Implemented layer elements

Added a brush layer element
Corsair - Added ST100 RGB layout

src/Artemis.Core/Artemis.Core.csproj

@@ -172,11 +172,14 @@
     <Compile Include="Plugins\Abstract\ProfileModule.cs" />
     <Compile Include="Plugins\Exceptions\ArtemisPluginException.cs" />
     <Compile Include="Plugins\Abstract\DataModelExpansion.cs" />
-    <Compile Include="Plugins\Abstract\Device.cs" />
-    <Compile Include="Plugins\Abstract\LayerType.cs" />
-    <Compile Include="Plugins\Interfaces\ILayerTypeConfiguration.cs" />
+    <Compile Include="Plugins\Abstract\DeviceProvider.cs" />
     <Compile Include="Plugins\Abstract\Module.cs" />
     <Compile Include="Plugins\Abstract\Plugin.cs" />
+    <Compile Include="Plugins\LayerElement\LayerElement.cs" />
+    <Compile Include="Plugins\LayerElement\LayerElementDescriptor.cs" />
+    <Compile Include="Plugins\LayerElement\LayerElementProvider.cs" />
+    <Compile Include="Plugins\LayerElement\LayerElementSettings.cs" />
+    <Compile Include="Plugins\LayerElement\LayerElementViewModel.cs" />
     <Compile Include="Plugins\Models\PluginInfo.cs" />
     <Compile Include="Plugins\Models\PluginSetting.cs" />
     <Compile Include="Plugins\Models\PluginSettings.cs" />
@@ -189,9 +192,11 @@
     <Compile Include="RGB.NET\DirectBitmap.cs" />
     <Compile Include="RGB.NET\GraphicsDecorator.cs" />
     <Compile Include="Services\DeviceService.cs" />
+    <Compile Include="Services\Interfaces\ILayerService.cs" />
     <Compile Include="Services\Interfaces\IProtectedArtemisService.cs" />
     <Compile Include="Services\Interfaces\IMainDataModelService.cs" />
     <Compile Include="Services\CoreService.cs" />
+    <Compile Include="Services\LayerService.cs" />
     <Compile Include="Services\MainDataModelService.cs" />
     <Compile Include="Services\RgbService.cs" />
     <Compile Include="Services\Interfaces\IRgbService.cs" />

src/Artemis.Core/Models/Profile/Abstract/ProfileElement.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Drawing;
 using System.Linq;
+using Artemis.Core.Models.Surface;
 using Stylet;
 
 namespace Artemis.Core.Models.Profile.Abstract
@@ -44,7 +45,7 @@ namespace Artemis.Core.Models.Profile.Abstract
         /// <summary>
         ///     Renders the element
         /// </summary>
-        public abstract void Render(double deltaTime, Surface.ArtemisSurface surface, Graphics graphics);
+        public abstract void Render(double deltaTime, ArtemisSurface surface, Graphics graphics);
 
         /// <summary>
         ///     Applies the profile element's properties to the underlying storage entity
@@ -73,7 +74,7 @@ namespace Artemis.Core.Models.Profile.Abstract
             layers.AddRange(Children.Where(c => c is Layer).Cast<Layer>());
 
             // Add all layers in folders inside this element
-            foreach (var childFolder in Children.Where(c => c is Folder).Cast<Folder>()) 
+            foreach (var childFolder in Children.Where(c => c is Folder).Cast<Folder>())
                 layers.AddRange(childFolder.GetAllLayers());
 
             return layers;

src/Artemis.Core/Models/Profile/Folder.cs

@@ -2,7 +2,7 @@ using System;
 using System.Drawing;
 using System.Linq;
 using Artemis.Core.Models.Profile.Abstract;
-using Artemis.Core.Services.Interfaces;
+using Artemis.Core.Models.Surface;
 using Artemis.Storage.Entities.Profile;
 
 namespace Artemis.Core.Models.Profile
@@ -19,7 +19,7 @@ namespace Artemis.Core.Models.Profile
             Name = name;
         }
 
-        public Folder(Profile profile, ProfileElement parent, FolderEntity folderEntity, IPluginService pluginService)
+        internal Folder(Profile profile, ProfileElement parent, FolderEntity folderEntity)
         {
             FolderEntity = folderEntity;
             EntityId = folderEntity.Id;
@@ -33,10 +33,10 @@ namespace Artemis.Core.Models.Profile
 
             // Load child folders
             foreach (var childFolder in Profile.ProfileEntity.Folders.Where(f => f.ParentId == EntityId))
-                _children.Add(new Folder(profile, this, childFolder, pluginService));
+                _children.Add(new Folder(profile, this, childFolder));
             // Load child layers
             foreach (var childLayer in Profile.ProfileEntity.Layers.Where(f => f.ParentId == EntityId))
-                _children.Add(new Layer(profile, this, childLayer, pluginService));
+                _children.Add(new Layer(profile, this, childLayer));
 
             // Ensure order integrity, should be unnecessary but no one is perfect specially me
             _children = _children.OrderBy(c => c.Order).ToList();
@@ -56,7 +56,7 @@ namespace Artemis.Core.Models.Profile
                 profileElement.Update(deltaTime);
         }
 
-        public override void Render(double deltaTime, Surface.ArtemisSurface surface, Graphics graphics)
+        public override void Render(double deltaTime, ArtemisSurface surface, Graphics graphics)
         {
             // Folders don't render but their children do
             foreach (var profileElement in Children)

src/Artemis.Core/Models/Profile/Layer.cs

@@ -7,15 +7,15 @@ using System.Linq;
 using Artemis.Core.Extensions;
 using Artemis.Core.Models.Profile.Abstract;
 using Artemis.Core.Models.Surface;
-using Artemis.Core.Plugins.Abstract;
-using Artemis.Core.Plugins.Interfaces;
-using Artemis.Core.Services.Interfaces;
+using Artemis.Core.Plugins.LayerElement;
 using Artemis.Storage.Entities.Profile;
+using Newtonsoft.Json;
 
 namespace Artemis.Core.Models.Profile
 {
     public sealed class Layer : ProfileElement
     {
+        private readonly List<LayerElement> _layerElements;
         private List<ArtemisLed> _leds;
 
         public Layer(Profile profile, ProfileElement parent, string name)
@@ -26,10 +26,12 @@ namespace Artemis.Core.Models.Profile
             Profile = profile;
             Parent = parent;
             Name = name;
+
             _leds = new List<ArtemisLed>();
+            _layerElements = new List<LayerElement>();
         }
 
-        internal Layer(Profile profile, ProfileElement parent, LayerEntity layerEntity, IPluginService pluginService)
+        internal Layer(Profile profile, ProfileElement parent, LayerEntity layerEntity)
         {
             LayerEntity = layerEntity;
             EntityId = layerEntity.Id;
@@ -39,46 +41,44 @@ namespace Artemis.Core.Models.Profile
             Name = layerEntity.Name;
             Order = layerEntity.Order;
 
-            LayerType = pluginService.GetLayerTypeByGuid(layerEntity.LayerTypeGuid);
             _leds = new List<ArtemisLed>();
+            _layerElements = new List<LayerElement>();
         }
 
         internal LayerEntity LayerEntity { get; set; }
 
         public ReadOnlyCollection<ArtemisLed> Leds => _leds.AsReadOnly();
-        public LayerType LayerType { get; private set; }
-        public ILayerTypeConfiguration LayerTypeConfiguration { get; set; }
+        public ReadOnlyCollection<LayerElement> LayerElements => _layerElements.AsReadOnly();
 
         public Rectangle RenderRectangle { get; set; }
         public GraphicsPath RenderPath { get; set; }
 
         public override void Update(double deltaTime)
         {
-            if (LayerType == null)
-                return;
-
-            lock (LayerType)
-            {
-                LayerType.Update(this);
-            }
+            foreach (var layerElement in LayerElements)
+                layerElement.Update(deltaTime);
         }
 
         public override void Render(double deltaTime, ArtemisSurface surface, Graphics graphics)
         {
-            if (LayerType == null)
-                return;
+            graphics.SetClip(RenderPath);
 
-            lock (LayerType)
-            {
-                LayerType.Render(this, surface, graphics);
-            }
+            foreach (var layerElement in LayerElements)
+                layerElement.RenderPreProcess(surface, graphics);
+
+            foreach (var layerElement in LayerElements)
+                layerElement.Render(surface, graphics);
+
+            foreach (var layerElement in LayerElements)
+                layerElement.RenderPostProcess(surface, graphics);
+
+            graphics.ResetClip();
         }
 
         internal override void ApplyToEntity()
         {
             LayerEntity.Id = EntityId;
             LayerEntity.ParentId = Parent?.EntityId ?? new Guid();
-            LayerEntity.LayerTypeGuid = LayerType?.PluginInfo.Guid ?? new Guid();
 
             LayerEntity.Order = Order;
             LayerEntity.Name = Name;
@@ -97,26 +97,18 @@ namespace Artemis.Core.Models.Profile
             }
 
             LayerEntity.Condition.Clear();
-            
+
             LayerEntity.Elements.Clear();
-        }
-
-        public void ApplySurface(ArtemisSurface surface)
-        {
-            var leds = new List<ArtemisLed>();
-
-            // Get the surface LEDs for this layer
-            var availableLeds = surface.Devices.SelectMany(d => d.Leds).ToList();
-            foreach (var ledEntity in LayerEntity.Leds)
+            foreach (var layerElement in LayerElements)
             {
-                var match = availableLeds.FirstOrDefault(a => a.Device.RgbDevice.GetDeviceHashCode() == ledEntity.DeviceHash &&
-                                                              a.RgbLed.Id.ToString() == ledEntity.LedName);
-                if (match != null)
-                    leds.Add(match);
+                var layerElementEntity = new LayerElementEntity
+                {
+                    PluginGuid = layerElement.Descriptor.LayerElementProvider.PluginInfo.Guid,
+                    LayerElementType = layerElement.GetType().Name,
+                    Configuration = JsonConvert.SerializeObject(layerElement.Settings)
+                };
+                LayerEntity.Elements.Add(layerElementEntity);
             }
-
-            _leds = leds;
-            CalculateRenderProperties();
         }
 
         public void AddLed(ArtemisLed led)
@@ -143,17 +135,27 @@ namespace Artemis.Core.Models.Profile
             CalculateRenderProperties();
         }
 
-        public void UpdateLayerType(LayerType layerType)
+        internal void AddLayerElement(LayerElement layerElement)
         {
-            if (LayerType != null)
+            _layerElements.Add(layerElement);
+        }
+
+        public void ApplySurface(ArtemisSurface surface)
+        {
+            var leds = new List<ArtemisLed>();
+
+            // Get the surface LEDs for this layer
+            var availableLeds = surface.Devices.SelectMany(d => d.Leds).ToList();
+            foreach (var ledEntity in LayerEntity.Leds)
             {
-                lock (LayerType)
-                {
-                    LayerType.Dispose();
-                }
+                var match = availableLeds.FirstOrDefault(a => a.Device.RgbDevice.GetDeviceHashCode() == ledEntity.DeviceHash &&
+                                                              a.RgbLed.Id.ToString() == ledEntity.LedName);
+                if (match != null)
+                    leds.Add(match);
             }
 
-            LayerType = layerType;
+            _leds = leds;
+            CalculateRenderProperties();
         }
 
         internal void CalculateRenderProperties()
@@ -167,8 +169,8 @@ namespace Artemis.Core.Models.Profile
             // Determine to top-left and bottom-right
             var minX = Leds.Min(l => l.AbsoluteRenderRectangle.X);
             var minY = Leds.Min(l => l.AbsoluteRenderRectangle.Y);
-            var maxX = Leds.Max(l => l.AbsoluteRenderRectangle.X);
-            var maxY = Leds.Max(l => l.AbsoluteRenderRectangle.Y);
+            var maxX = Leds.Max(l => l.AbsoluteRenderRectangle.X + l.AbsoluteRenderRectangle.Width);
+            var maxY = Leds.Max(l => l.AbsoluteRenderRectangle.Y + l.AbsoluteRenderRectangle.Height);
 
             RenderRectangle = new Rectangle(minX, minY, maxX - minX, maxY - minY);
 

src/Artemis.Core/Models/Profile/Profile.cs

@@ -3,8 +3,8 @@ using System.Drawing;
 using System.Linq;
 using Artemis.Core.Exceptions;
 using Artemis.Core.Models.Profile.Abstract;
+using Artemis.Core.Models.Surface;
 using Artemis.Core.Plugins.Models;
-using Artemis.Core.Services.Interfaces;
 using Artemis.Storage.Entities.Profile;
 
 namespace Artemis.Core.Models.Profile
@@ -23,7 +23,7 @@ namespace Artemis.Core.Models.Profile
             ApplyToEntity();
         }
 
-        internal Profile(PluginInfo pluginInfo, ProfileEntity profileEntity, IPluginService pluginService)
+        internal Profile(PluginInfo pluginInfo, ProfileEntity profileEntity)
         {
             ProfileEntity = profileEntity;
             EntityId = profileEntity.Id;
@@ -36,7 +36,7 @@ namespace Artemis.Core.Models.Profile
             if (rootFolder == null)
                 AddChild(new Folder(this, null, "Root folder"));
             else
-                AddChild(new Folder(this, null, rootFolder, pluginService));
+                AddChild(new Folder(this, null, rootFolder));
         }
 
         public PluginInfo PluginInfo { get; }
@@ -56,7 +56,7 @@ namespace Artemis.Core.Models.Profile
             }
         }
 
-        public override void Render(double deltaTime, Surface.ArtemisSurface surface, Graphics graphics)
+        public override void Render(double deltaTime, ArtemisSurface surface, Graphics graphics)
         {
             lock (this)
             {
@@ -86,12 +86,14 @@ namespace Artemis.Core.Models.Profile
         }
 
 
-        internal void Activate()
+        internal void Activate(ArtemisSurface surface)
         {
             lock (this)
             {
-                if (IsActivated) return;
+                if (IsActivated)
+                    return;
 
+                ApplySurface(surface);
                 OnActivated();
                 IsActivated = true;
             }
@@ -113,7 +115,7 @@ namespace Artemis.Core.Models.Profile
             return $"{nameof(Order)}: {Order}, {nameof(Name)}: {Name}, {nameof(PluginInfo)}: {PluginInfo}";
         }
 
-        public void ApplySurface(Surface.ArtemisSurface surface)
+        public void ApplySurface(ArtemisSurface surface)
         {
             foreach (var layer in GetAllLayers())
                 layer.ApplySurface(surface);
@@ -140,7 +142,7 @@ namespace Artemis.Core.Models.Profile
         {
             Deactivated?.Invoke(this, EventArgs.Empty);
         }
-        
+
         #endregion
     }
 }

src/Artemis.Core/Models/Surface/ArtemisSurface.cs

@@ -36,7 +36,7 @@ namespace Artemis.Core.Models.Surface
             IsActive = surfaceEntity.IsActive;
 
             // Devices are not populated here but as they are detected
-            Devices = new List<ArtemisDevice>(); 
+            Devices = new List<ArtemisDevice>();
         }
 
         public RGBSurface RgbSurface { get; }

src/Artemis.Core/Plugins/Abstract/DeviceProvider.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using System.IO;
 using Artemis.Core.Extensions;
 using Artemis.Core.Plugins.Models;
@@ -8,22 +9,24 @@ namespace Artemis.Core.Plugins.Abstract
 {
     /// <inheritdoc />
     /// <summary>
-    ///     Allows you to implement your own RGB device
+    ///     Allows you to implement and register your own device provider
     /// </summary>
-    public abstract class Device : Plugin
+    public abstract class DeviceProvider : Plugin
     {
-        protected Device(PluginInfo pluginInfo, IRGBDeviceProvider deviceProvider) : base(pluginInfo)
+        protected DeviceProvider(PluginInfo pluginInfo, IRGBDeviceProvider rgbDeviceProvider) : base(pluginInfo)
         {
-            DeviceProvider = deviceProvider ?? throw new ArgumentNullException(nameof(deviceProvider));
+            RgbDeviceProvider = rgbDeviceProvider ?? throw new ArgumentNullException(nameof(rgbDeviceProvider));
         }
 
-        public IRGBDeviceProvider DeviceProvider { get; }
+        public IRGBDeviceProvider RgbDeviceProvider { get; }
 
 
         protected void ResolveAbsolutePath(Type type, object sender, ResolvePathEventArgs e)
         {
             if (sender.GetType().IsGenericType(type))
             {
+                Debug.WriteLine(e.RelativePart);
+                Debug.WriteLine(e.FileName);
                 // Start from the plugin directory
                 if (e.RelativePart != null && e.FileName != null)
                     e.FinalPath = Path.Combine(PluginInfo.Directory.FullName, e.RelativePart, e.FileName);

src/Artemis.Core/Plugins/Abstract/LayerType.cs

@@ -1,29 +0,0 @@
-using System.Drawing;
-using Artemis.Core.Models.Profile;
-using Artemis.Core.Models.Surface;
-using Artemis.Core.Plugins.Models;
-
-namespace Artemis.Core.Plugins.Abstract
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Allows you to create your own layer type
-    /// </summary>
-    public abstract class LayerType : Plugin
-    {
-        protected LayerType(PluginInfo pluginInfo) : base(pluginInfo)
-        {
-        }
-
-        /// <summary>
-        ///     Updates the layer type
-        /// </summary>
-        /// <param name="layer"></param>
-        public abstract void Update(Layer layer);
-
-        /// <summary>
-        ///     Renders the layer type
-        /// </summary>
-        public abstract void Render(Layer device, ArtemisSurface surface, Graphics graphics);
-    }
-}

src/Artemis.Core/Plugins/Abstract/ModuleViewModel.cs

@@ -9,7 +9,7 @@ namespace Artemis.Core.Plugins.Abstract
             Module = module;
             DisplayName = displayName;
         }
-        
+
         public Module Module { get; }
     }
 }

src/Artemis.Core/Plugins/Abstract/ProfileModule.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Drawing;
+using Artemis.Core.Exceptions;
 using Artemis.Core.Models.Profile;
 using Artemis.Core.Models.Surface;
 using Artemis.Core.Plugins.Models;
@@ -34,8 +35,10 @@ namespace Artemis.Core.Plugins.Abstract
             }
         }
 
-        public void ChangeActiveProfile(Profile profile)
+        internal void ChangeActiveProfile(Profile profile, ArtemisSurface surface)
         {
+            if (profile != null && profile.PluginInfo != PluginInfo)
+                throw new ArtemisCoreException($"Cannot activate a profile of plugin {profile.PluginInfo} on a module of plugin {PluginInfo}.");
             lock (this)
             {
                 if (profile == ActiveProfile)
@@ -44,7 +47,7 @@ namespace Artemis.Core.Plugins.Abstract
                 ActiveProfile?.Deactivate();
 
                 ActiveProfile = profile;
-                ActiveProfile?.Activate();
+                ActiveProfile?.Activate(surface);
             }
 
             OnActiveProfileChanged();
@@ -53,7 +56,7 @@ namespace Artemis.Core.Plugins.Abstract
         #region Events
 
         public event EventHandler ActiveProfileChanged;
-        
+
         protected virtual void OnActiveProfileChanged()
         {
             ActiveProfileChanged?.Invoke(this, EventArgs.Empty);

src/Artemis.Core/Plugins/Interfaces/ILayerTypeConfiguration.cs

@@ -1,6 +0,0 @@
-namespace Artemis.Core.Plugins.Interfaces
-{
-    public interface ILayerTypeConfiguration
-    {
-    }
-}

src/Artemis.Core/Plugins/LayerElement/LayerElement.cs

@@ -0,0 +1,47 @@
+using System.Drawing;
+using Artemis.Core.Models.Profile;
+using Artemis.Core.Models.Surface;
+
+namespace Artemis.Core.Plugins.LayerElement
+{
+    public abstract class LayerElement
+    {
+        protected LayerElement(Layer layer, LayerElementSettings settings, LayerElementDescriptor descriptor)
+        {
+            Layer = layer;
+            Settings = settings;
+            Descriptor = descriptor;
+        }
+
+        public Layer Layer { get; }
+        public LayerElementSettings Settings { get; }
+        public LayerElementDescriptor Descriptor { get; }
+
+        /// <summary>
+        ///     Called by the profile editor to populate the layer element properties panel
+        /// </summary>
+        /// <returns></returns>
+        public abstract LayerElementViewModel GetViewModel();
+
+        /// <summary>
+        ///     Called before rendering every frame, write your update logic here
+        /// </summary>
+        /// <param name="deltaTime"></param>
+        public abstract void Update(double deltaTime);
+
+        /// <summary>
+        ///     Called before rendering, in the order configured on the layer
+        /// </summary>
+        public abstract void RenderPreProcess(ArtemisSurface surface, Graphics graphics);
+
+        /// <summary>
+        ///     Called during rendering, in the order configured on the layer
+        /// </summary>
+        public abstract void Render(ArtemisSurface surface, Graphics graphics);
+
+        /// <summary>
+        ///     Called after rendering, in the order configured on the layer
+        /// </summary>
+        public abstract void RenderPostProcess(ArtemisSurface surface, Graphics graphics);
+    }
+}

src/Artemis.Core/Plugins/LayerElement/LayerElementDescriptor.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace Artemis.Core.Plugins.LayerElement
+{
+    public class LayerElementDescriptor
+    {
+        internal LayerElementDescriptor(string displayName, string description, string icon, Type layerElementType, LayerElementProvider layerElementProvider)
+        {
+            DisplayName = displayName;
+            Description = description;
+            Icon = icon;
+            LayerElementType = layerElementType;
+            LayerElementProvider = layerElementProvider;
+        }
+
+        public string DisplayName { get; }
+        public string Description { get; }
+        public string Icon { get; }
+        public Type LayerElementType { get; }
+        public LayerElementProvider LayerElementProvider { get; }
+    }
+}

src/Artemis.Core/Plugins/LayerElement/LayerElementProvider.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Artemis.Core.Plugins.Abstract;
+using Artemis.Core.Plugins.Models;
+
+namespace Artemis.Core.Plugins.LayerElement
+{
+    /// <inheritdoc />
+    /// <summary>
+    ///     Allows you to create one or more <see cref="LayerElement" />s usable by profile layers.
+    /// </summary>
+    public abstract class LayerElementProvider : Plugin
+    {
+        private readonly List<LayerElementDescriptor> _layerElementDescriptors;
+
+        protected LayerElementProvider(PluginInfo pluginInfo) : base(pluginInfo)
+        {
+            _layerElementDescriptors = new List<LayerElementDescriptor>();
+        }
+
+        public ReadOnlyCollection<LayerElementDescriptor> LayerElementDescriptors => _layerElementDescriptors.AsReadOnly();
+
+        protected void AddLayerElementDescriptor<T>(string displayName, string description, string icon) where T : LayerElement
+        {
+            _layerElementDescriptors.Add(new LayerElementDescriptor(displayName, description, icon, typeof(T), this));
+        }
+    }
+}

src/Artemis.Core/Plugins/LayerElement/LayerElementSettings.cs

@@ -0,0 +1,8 @@
+using Stylet;
+
+namespace Artemis.Core.Plugins.LayerElement
+{
+    public abstract class LayerElementSettings : PropertyChangedBase
+    {
+    }
+}

src/Artemis.Core/Plugins/LayerElement/LayerElementViewModel.cs

@@ -0,0 +1,14 @@
+using Stylet;
+
+namespace Artemis.Core.Plugins.LayerElement
+{
+    public abstract class LayerElementViewModel : PropertyChangedBase
+    {
+        protected LayerElementViewModel(LayerElement layerElement)
+        {
+            LayerElement = layerElement;
+        }
+
+        public LayerElement LayerElement { get; }
+    }
+}

src/Artemis.Core/RGB.NET/GraphicsDecorator.cs

@@ -54,7 +54,16 @@ namespace Artemis.Core.RGB.NET
 
         public Graphics GetGraphics()
         {
-            return _bitmap == null ? null : Graphics.FromImage(_bitmap.Bitmap);
+            try
+            {
+                return _bitmap == null ? null : Graphics.FromImage(_bitmap.Bitmap);
+            }
+            catch (AccessViolationException)
+            {
+                // ignored
+            }
+
+            return null;
         }
 
         public Bitmap GetBitmap()

src/Artemis.Core/Services/CoreService.cs

@@ -5,7 +5,6 @@ using Artemis.Core.Events;
 using Artemis.Core.Exceptions;
 using Artemis.Core.Plugins.Abstract;
 using Artemis.Core.Services.Interfaces;
-using Artemis.Core.Services.Storage;
 using Artemis.Core.Services.Storage.Interfaces;
 using RGB.NET.Core;
 using Serilog;

src/Artemis.Core/Services/DeviceService.cs

@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Drawing;
-using System.Linq;
-using System.Text;
+using System.Drawing;
 using System.Threading.Tasks;
 using Artemis.Core.Events;
 using Artemis.Core.Models.Surface;
@@ -56,9 +52,9 @@ namespace Artemis.Core.Services
     public interface IDeviceService : IArtemisService
     {
         /// <summary>
-        /// Identifies the device by making it blink white 5 times
+        ///     Identifies the device by making it blink white 5 times
         /// </summary>
         /// <param name="device"></param>
         void IdentifyDevice(ArtemisDevice device);
     }
-}
+}

src/Artemis.Core/Services/Interfaces/ILayerService.cs

@@ -0,0 +1,18 @@
+using Artemis.Core.Models.Profile;
+using Artemis.Core.Plugins.LayerElement;
+
+namespace Artemis.Core.Services.Interfaces
+{
+    public interface ILayerService : IArtemisService
+    {
+        /// <summary>
+        ///     Instantiates and adds the <see cref="LayerElement" /> described by the provided
+        ///     <see cref="LayerElementDescriptor" /> to the provided <see cref="Layer" />.
+        /// </summary>
+        /// <param name="layer">The layer to add the new layer element to</param>
+        /// <param name="layerElementDescriptor">The descriptor of the new layer element</param>
+        /// <param name="settings">JSON settings to be deserialized and injected into the layer element</param>
+        /// <returns></returns>
+        LayerElement InstantiateLayerElement(Layer layer, LayerElementDescriptor layerElementDescriptor, string settings = null);
+    }
+}

src/Artemis.Core/Services/Interfaces/IPluginService.cs

@@ -55,13 +55,6 @@ namespace Artemis.Core.Services.Interfaces
         /// <returns>A list containing all the plugin info</returns>
         List<PluginInfo> GetAllPluginInfo();
 
-        /// <summary>
-        ///     Finds an instance of the layer type matching the given GUID
-        /// </summary>
-        /// <param name="layerTypeGuid">The GUID of the layer type to find</param>
-        /// <returns>An instance of the layer type</returns>
-        LayerType GetLayerTypeByGuid(Guid layerTypeGuid);
-
         /// <summary>
         ///     Finds all enabled <see cref="Plugin" /> instances of type <see cref="T" />
         /// </summary>

src/Artemis.Core/Services/LayerService.cs

@@ -0,0 +1,50 @@
+using Artemis.Core.Models.Profile;
+using Artemis.Core.Plugins.Exceptions;
+using Artemis.Core.Plugins.LayerElement;
+using Artemis.Core.Services.Interfaces;
+using Newtonsoft.Json;
+using Ninject;
+using Ninject.Parameters;
+
+namespace Artemis.Core.Services
+{
+    public class LayerService : ILayerService
+    {
+        private readonly IKernel _kernel;
+
+        public LayerService(IKernel kernel)
+        {
+            _kernel = kernel;
+        }
+
+        public LayerElement InstantiateLayerElement(Layer layer, LayerElementDescriptor layerElementDescriptor, string settings)
+        {
+            // Deserialize the settings, if provided
+            object deserializedSettings = null;
+            if (settings != null)
+            {
+                var settingsType = layerElementDescriptor.LayerElementType.GetProperty(nameof(LayerElement.Settings))?.PropertyType;
+                if (settingsType == null)
+                {
+                    throw new ArtemisPluginException(
+                        layerElementDescriptor.LayerElementProvider.PluginInfo,
+                        $"Layer element of type {layerElementDescriptor.LayerElementType} has no Settings property."
+                    );
+                }
+
+                deserializedSettings = JsonConvert.DeserializeObject(settings, settingsType);
+            }
+
+            var arguments = new IParameter[]
+            {
+                new ConstructorArgument("layer", layer),
+                new ConstructorArgument("settings", deserializedSettings),
+                new ConstructorArgument("descriptor", layerElementDescriptor)
+            };
+            var layerElement = (LayerElement) _kernel.Get(layerElementDescriptor.LayerElementType, arguments);
+            layer.AddLayerElement(layerElement);
+
+            return layerElement;
+        }
+    }
+}

src/Artemis.Core/Services/PluginService.cs

@@ -285,19 +285,6 @@ namespace Artemis.Core.Services
             return new List<PluginInfo>(_plugins);
         }
 
-        /// <inheritdoc />
-        public LayerType GetLayerTypeByGuid(Guid layerTypeGuid)
-        {
-            var pluginInfo = _plugins.FirstOrDefault(p => p.Guid == layerTypeGuid);
-            if (pluginInfo == null)
-                return null;
-
-            if (!(pluginInfo.Instance is LayerType layerType))
-                throw new ArtemisPluginException(pluginInfo, "Plugin is expected to implement exactly one LayerType");
-
-            return layerType;
-        }
-
         /// <inheritdoc />
         public List<T> GetPluginsOfType<T>() where T : Plugin
         {
@@ -309,7 +296,7 @@ namespace Artemis.Core.Services
 
         public Plugin GetDevicePlugin(IRGBDevice rgbDevice)
         {
-            return GetPluginsOfType<Device>().First(d => d.DeviceProvider.Devices.Contains(rgbDevice));
+            return GetPluginsOfType<DeviceProvider>().First(d => d.RgbDeviceProvider.Devices.Contains(rgbDevice));
         }
 
         public void Dispose()

src/Artemis.Core/Services/Storage/Interfaces/IProfileService.cs

@@ -12,5 +12,12 @@ namespace Artemis.Core.Services.Storage.Interfaces
         Profile GetActiveProfile(ProfileModule module);
         void UpdateProfile(Profile profile, bool includeChildren);
         void DeleteProfile(Profile profile);
+
+        /// <summary>
+        ///     Activates the profile for the given <see cref="ProfileModule" /> with the currently active surface
+        /// </summary>
+        /// <param name="module">The module to activate the profile for</param>
+        /// <param name="profile">The profile to activate</param>
+        void ActivateProfile(ProfileModule module, Profile profile);
     }
 }

src/Artemis.Core/Services/Storage/ProfileService.cs

@@ -16,8 +16,8 @@ namespace Artemis.Core.Services.Storage
     public class ProfileService : IProfileService
     {
         private readonly IPluginService _pluginService;
-        private readonly ISurfaceService _surfaceService;
         private readonly IProfileRepository _profileRepository;
+        private readonly ISurfaceService _surfaceService;
 
         internal ProfileService(IPluginService pluginService, ISurfaceService surfaceService, IProfileRepository profileRepository)
         {
@@ -29,6 +29,73 @@ namespace Artemis.Core.Services.Storage
             _surfaceService.SurfaceConfigurationUpdated += SurfaceServiceOnSurfaceConfigurationUpdated;
         }
 
+        public List<Profile> GetProfiles(ProfileModule module)
+        {
+            var profileEntities = _profileRepository.GetByPluginGuid(module.PluginInfo.Guid);
+            var profiles = new List<Profile>();
+            foreach (var profileEntity in profileEntities)
+            {
+                // If the profile entity matches the module's currently active profile, use that instead
+                if (module.ActiveProfile != null && module.ActiveProfile.EntityId == profileEntity.Id)
+                    profiles.Add(module.ActiveProfile);
+                else
+                    profiles.Add(new Profile(module.PluginInfo, profileEntity));
+            }
+
+            return profiles;
+        }
+
+        public Profile GetActiveProfile(ProfileModule module)
+        {
+            if (module.ActiveProfile != null)
+                return module.ActiveProfile;
+
+            var moduleProfiles = _profileRepository.GetByPluginGuid(module.PluginInfo.Guid);
+            var profileEntity = moduleProfiles.FirstOrDefault(p => p.IsActive) ?? moduleProfiles.FirstOrDefault();
+            if (profileEntity == null)
+                return null;
+
+            return new Profile(module.PluginInfo, profileEntity);
+        }
+
+        public Profile CreateProfile(ProfileModule module, string name)
+        {
+            var profile = new Profile(module.PluginInfo, name);
+            _profileRepository.Add(profile.ProfileEntity);
+
+            if (_surfaceService.ActiveSurface != null)
+                profile.ApplySurface(_surfaceService.ActiveSurface);
+            return profile;
+        }
+
+
+        public void ActivateProfile(ProfileModule module, Profile profile)
+        {
+            module.ChangeActiveProfile(profile, _surfaceService.ActiveSurface);
+        }
+
+        public void DeleteProfile(Profile profile)
+        {
+            _profileRepository.Remove(profile.ProfileEntity);
+        }
+
+        public void UpdateProfile(Profile profile, bool includeChildren)
+        {
+            profile.ApplyToEntity();
+            if (includeChildren)
+            {
+                foreach (var folder in profile.GetAllFolders())
+                    folder.ApplyToEntity();
+                foreach (var layer in profile.GetAllLayers())
+                    layer.ApplyToEntity();
+
+                if (_surfaceService.ActiveSurface != null)
+                    profile.ApplySurface(_surfaceService.ActiveSurface);
+            }
+
+            _profileRepository.Save(profile.ProfileEntity);
+        }
+
         private void SurfaceServiceOnActiveSurfaceConfigurationChanged(object sender, SurfaceConfigurationEventArgs e)
         {
             ApplySurfaceToProfiles(e.Surface);
@@ -47,66 +114,5 @@ namespace Artemis.Core.Services.Storage
             foreach (var profileModule in profileModules.Where(p => p.ActiveProfile != null).ToList())
                 profileModule.ActiveProfile.ApplySurface(surface);
         }
-
-        public List<Profile> GetProfiles(ProfileModule module)
-        {
-            var profileEntities = _profileRepository.GetByPluginGuid(module.PluginInfo.Guid);
-            var profiles = new List<Profile>();
-            foreach (var profileEntity in profileEntities)
-            {
-                // If the profile entity matches the module's currently active profile, use that instead
-                if (module.ActiveProfile != null && module.ActiveProfile.EntityId == profileEntity.Id)
-                    profiles.Add(module.ActiveProfile);
-                else
-                    profiles.Add(new Profile(module.PluginInfo, profileEntity, _pluginService));
-            }
-
-            return profiles;
-        }
-
-        public Profile GetActiveProfile(ProfileModule module)
-        {
-            if (module.ActiveProfile != null)
-                return module.ActiveProfile;
-
-            var moduleProfiles = _profileRepository.GetByPluginGuid(module.PluginInfo.Guid);
-            var profileEntity = moduleProfiles.FirstOrDefault(p => p.IsActive) ?? moduleProfiles.FirstOrDefault();
-            if (profileEntity == null)
-                return null;
-
-            return new Profile(module.PluginInfo, profileEntity, _pluginService);
-        }
-
-        public Profile CreateProfile(ProfileModule module, string name)
-        {
-            var profile = new Profile(module.PluginInfo, name);
-            _profileRepository.Add(profile.ProfileEntity);
-
-            if (_surfaceService.ActiveSurface != null)
-                profile.ApplySurface(_surfaceService.ActiveSurface);
-            return profile;
-        }
-
-        public void DeleteProfile(Profile profile)
-        {
-            _profileRepository.Remove(profile.ProfileEntity);
-        }
-
-        public void UpdateProfile(Profile profile, bool includeChildren)
-        {
-            profile.ApplyToEntity();
-            if (includeChildren)
-            {
-                foreach (var folder in profile.GetAllFolders()) 
-                    folder.ApplyToEntity();
-                foreach (var layer in profile.GetAllLayers()) 
-                    layer.ApplyToEntity();
-                
-                if (_surfaceService.ActiveSurface != null)
-                    profile.ApplySurface(_surfaceService.ActiveSurface);
-            }
-
-            _profileRepository.Save(profile.ProfileEntity);
-        }
     }
 }

src/Artemis.Core/packages.config

@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
+
 <packages>
   <package id="AppDomainToolkit" version="1.0.4.3" targetFramework="net461" />
   <package id="Ben.Demystifier" version="0.1.4" targetFramework="net472" />