Made devices aware of the plugin that loaded them

Fixed Corsair LL Fans layout
Expanded render events
Added identify option to device settings, must move this to be reusable though

src/Artemis.UI/ViewModels/Controls/Settings/DeviceSettingsViewModel.cs

@@ -0,0 +1,76 @@
+using System.Diagnostics;
+using System.Drawing;
+using System.Threading.Tasks;
+using Artemis.Core.Events;
+using Artemis.Core.Models.Surface;
+using Artemis.Core.Services.Interfaces;
+using Humanizer;
+
+namespace Artemis.UI.ViewModels.Controls.Settings
+{
+    public class DeviceSettingsViewModel
+    {
+        private readonly ICoreService _coreService;
+
+        public DeviceSettingsViewModel(Device device, ICoreService coreService)
+        {
+            _coreService = coreService;
+
+            Device = device;
+
+            Type = Device.RgbDevice.DeviceInfo.DeviceType.ToString().Humanize();
+            Name = Device.RgbDevice.DeviceInfo.Model;
+            Manufacturer = Device.RgbDevice.DeviceInfo.Manufacturer;
+            IsDeviceEnabled = true;
+        }
+
+        public Device Device { get; }
+
+        public string Type { get; set; }
+        public string Name { get; set; }
+        public string Manufacturer { get; set; }
+        public bool IsDeviceEnabled { get; set; }
+
+        public void Identify()
+        {
+            BlinkDevice(0);
+        }
+
+        private void BlinkDevice(int blinkCount)
+        {
+            // Draw a white overlay over the device
+            void DrawOverlay(object sender, FrameRenderingEventArgs args)
+            {
+                using (var g = Graphics.FromImage(args.Bitmap))
+                {
+                    g.FillPath(new SolidBrush(Color.White), Device.RenderPath);
+                }
+            }
+
+            _coreService.FrameRendering += DrawOverlay;
+
+            // After 200ms, stop drawing the overlay
+            Task.Run(async () =>
+            {
+                await Task.Delay(200);
+                _coreService.FrameRendering -= DrawOverlay;
+
+                if (blinkCount < 5)
+                {
+                    // After another 200ms, draw the overlay again, repeat six times
+                    await Task.Delay(200);
+                    BlinkDevice(blinkCount + 1);
+                }
+            });
+        }
+
+        public void ShowDeviceDebugger()
+        {
+        }
+
+        public void OpenPluginDirectory()
+        {
+            Process.Start(Device.Plugin.PluginInfo.Directory.FullName);
+        }
+    }
+}

src/Artemis.UI/ViewModels/Controls/Settings/RgbDeviceSettingsViewModel.cs

@@ -1,25 +0,0 @@
-using Humanizer;
-using RGB.NET.Core;
-
-namespace Artemis.UI.ViewModels.Controls.Settings
-{
-    public class RgbDeviceSettingsViewModel
-    {
-        public IRGBDevice Device { get; }
-
-        public RgbDeviceSettingsViewModel(IRGBDevice device)
-        {
-            Device = device;
-
-            Type = Device.DeviceInfo.DeviceType.ToString().Humanize();
-            Name = Device.DeviceInfo.Model;
-            Manufacturer = Device.DeviceInfo.Manufacturer;
-            Enabled = true;
-        }
-
-        public string Type { get; set; }
-        public string Name { get; set; }
-        public string Manufacturer { get; set; }
-        public bool Enabled { get; set; }
-    }
-}

src/Artemis.UI/ViewModels/Screens/DebugViewModel.cs

@@ -22,6 +22,7 @@ namespace Artemis.UI.ViewModels.Screens
             _rgbService = rgbService;
 
             _coreService.FrameRendered += CoreServiceOnFrameRendered;
+            _coreService.FrameRendering += CoreServiceOnFrameRendering;
         }
 
         public ImageSource CurrentFrame { get; set; }
@@ -33,20 +34,25 @@ namespace Artemis.UI.ViewModels.Screens
             GC.WaitForPendingFinalizers();
         }
 
-        private void CoreServiceOnFrameRendered(object sender, FrameEventArgs e)
+        private void CoreServiceOnFrameRendered(object sender, FrameRenderedEventArgs e)
         {
             var imageSource = ImageSourceFromBitmap(e.Bitmap);
             imageSource.Freeze();
-            CurrentFps = Math.Round(1.0 / e.DeltaTime, 2);
             Execute.OnUIThread(() =>
             {
                 CurrentFrame = imageSource;
             });
         }
-        
+
+        private void CoreServiceOnFrameRendering(object sender, FrameRenderingEventArgs e)
+        {
+            CurrentFps = Math.Round(1.0 / e.DeltaTime, 2);
+        }
+
         protected override void OnClose()
         {
             _coreService.FrameRendered -= CoreServiceOnFrameRendered;
+            _coreService.FrameRendering -= CoreServiceOnFrameRendering;
             base.OnClose();
         }
 

src/Artemis.UI/ViewModels/Screens/SettingsViewModel.cs

@@ -1,6 +1,7 @@
-using Artemis.Core.Events;
+using System.Windows.Media;
 using Artemis.Core.Services;
 using Artemis.Core.Services.Interfaces;
+using Artemis.Core.Services.Storage;
 using Artemis.UI.ViewModels.Controls.Settings;
 using Artemis.UI.ViewModels.Interfaces;
 using Ninject;
@@ -11,30 +12,42 @@ namespace Artemis.UI.ViewModels.Screens
     public class SettingsViewModel : Screen, ISettingsViewModel
     {
         private readonly IKernel _kernel;
+        private readonly ICoreService _coreService;
+        private readonly ISurfaceService _surfaceService;
         private readonly IWindowManager _windowManager;
+        private readonly ISettingsService _settingsService;
 
-        public SettingsViewModel(IKernel kernel, IRgbService rgbService, IWindowManager windowManager, ISettingsService settingsService)
+        public SettingsViewModel(IKernel kernel, ICoreService coreService, ISurfaceService surfaceService, IWindowManager windowManager, ISettingsService settingsService)
         {
             _kernel = kernel;
+            _coreService = coreService;
+            _surfaceService = surfaceService;
             _windowManager = windowManager;
-            DeviceSettingsViewModels = new BindableCollection<RgbDeviceSettingsViewModel>();
-            foreach (var device in rgbService.LoadedDevices)
-                DeviceSettingsViewModels.Add(new RgbDeviceSettingsViewModel(device));
+            _settingsService = settingsService;
 
-            rgbService.DeviceLoaded += UpdateDevices;
+            DeviceSettingsViewModels = new BindableCollection<DeviceSettingsViewModel>();
+            RenderScale = _settingsService.GetSetting("RenderScale", 1.0).Value;
+            TargetFrameRate = _settingsService.GetSetting("FrameRate", 25).Value;
         }
 
-        public BindableCollection<RgbDeviceSettingsViewModel> DeviceSettingsViewModels { get; set; }
+        public BindableCollection<DeviceSettingsViewModel> DeviceSettingsViewModels { get; set; }
         public string Title => "Settings";
 
+        public double RenderScale { get; set; }
+        public int TargetFrameRate { get; set; }
+
+        protected override void OnActivate()
+        {
+            DeviceSettingsViewModels.Clear();
+            foreach (var device in _surfaceService.ActiveSurface.Devices)
+                DeviceSettingsViewModels.Add(new DeviceSettingsViewModel(device, _coreService));
+
+            base.OnActivate();
+        }
+
         public void ShowDebugger()
         {
             _windowManager.ShowWindow(_kernel.Get<DebugViewModel>());
         }
-
-        private void UpdateDevices(object sender, DeviceEventArgs deviceEventArgs)
-        {
-            DeviceSettingsViewModels.Add(new RgbDeviceSettingsViewModel(deviceEventArgs.Device));
-        }
     }
 }