UI VM factories - Shortened names for readibility

Layer properties - Ensure only LayerBrushes can add properties and make sure that method instantiates a keyframe engine
Layer properties UI - Respond to properties being added/removed

src/Artemis.UI/Screens/Module/ModuleRootViewModel.cs

@@ -8,14 +8,14 @@ namespace Artemis.UI.Screens.Module
 {
     public class ModuleRootViewModel : Conductor<Screen>.Collection.OneActive
     {
-        private readonly IProfileEditorViewModelFactory _profileEditorViewModelFactory;
+        private readonly IProfileEditorVmFactory _profileEditorVmFactory;
 
-        public ModuleRootViewModel(Core.Plugins.Abstract.Module module, IProfileEditorViewModelFactory profileEditorViewModelFactory)
+        public ModuleRootViewModel(Core.Plugins.Abstract.Module module, IProfileEditorVmFactory profileEditorVmFactory)
         {
             DisplayName = module?.DisplayName;
             Module = module;
 
-            _profileEditorViewModelFactory = profileEditorViewModelFactory;
+            _profileEditorVmFactory = profileEditorVmFactory;
 
             Task.Run(AddTabsAsync);
         }
@@ -30,7 +30,7 @@ namespace Artemis.UI.Screens.Module
             // Create the profile editor and module VMs
             if (Module is ProfileModule profileModule)
             {
-                var profileEditor = _profileEditorViewModelFactory.Create(profileModule);
+                var profileEditor = _profileEditorVmFactory.Create(profileModule);
                 Items.Add(profileEditor);
             }
 

src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/LayerPropertiesViewModel.cs

@@ -1,10 +1,12 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Windows;
 using System.Windows.Input;
 using System.Windows.Media;
 using Artemis.Core.Events;
 using Artemis.Core.Models.Profile;
+using Artemis.Core.Models.Profile.LayerProperties;
 using Artemis.Core.Services;
 using Artemis.Core.Services.Interfaces;
 using Artemis.UI.Ninject.Factories;
@@ -18,30 +20,32 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties
     public class LayerPropertiesViewModel : ProfileEditorPanelViewModel
     {
         private readonly ICoreService _coreService;
-        private readonly ILayerPropertyViewModelFactory _layerPropertyViewModelFactory;
+        private readonly ILayerPropertyVmFactory _layerPropertyVmFactory;
         private readonly IProfileEditorService _profileEditorService;
         private readonly ISettingsService _settingsService;
+        private readonly List<LayerPropertyViewModel> _layerPropertyViewModels;
 
         public LayerPropertiesViewModel(IProfileEditorService profileEditorService,
             ICoreService coreService,
             ISettingsService settingsService,
-            ILayerPropertyViewModelFactory layerPropertyViewModelFactory,
-            IPropertyTreeViewModelFactory propertyTreeViewModelFactory,
-            IPropertyTimelineViewModelFactory propertyTimelineViewModelFactory)
+            ILayerPropertyVmFactory layerPropertyVmFactory,
+            IPropertyTreeVmFactory propertyTreeVmFactory,
+            IPropertyTimelineVmFactory propertyTimelineVmFactory)
         {
             _profileEditorService = profileEditorService;
             _coreService = coreService;
             _settingsService = settingsService;
-            _layerPropertyViewModelFactory = layerPropertyViewModelFactory;
+            _layerPropertyVmFactory = layerPropertyVmFactory;
 
             PixelsPerSecond = 31;
-            PropertyTree = propertyTreeViewModelFactory.Create(this);
-            PropertyTimeline = propertyTimelineViewModelFactory.Create(this);
+            PropertyTree = propertyTreeVmFactory.Create(this);
+            PropertyTimeline = propertyTimelineVmFactory.Create(this);
 
-            PopulateProperties();
+            PopulateProperties(_profileEditorService.SelectedProfileElement, null);
 
-            _profileEditorService.SelectedProfileElementChanged += (sender, args) => PopulateProperties();
-            _profileEditorService.SelectedProfileChanged += (sender, args) => PopulateProperties();
+            _layerPropertyViewModels = new List<LayerPropertyViewModel>();
+            _profileEditorService.SelectedProfileElementChanged += (sender, args) => PopulateProperties(args.ProfileElement, args.PreviousProfileElement);
+            _profileEditorService.SelectedProfileChanged += (sender, args) => PopulateProperties(_profileEditorService.SelectedProfileElement, null);
             _profileEditorService.CurrentTimeChanged += ProfileEditorServiceOnCurrentTimeChanged;
         }
 
@@ -68,26 +72,6 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties
         public PropertyTreeViewModel PropertyTree { get; set; }
         public PropertyTimelineViewModel PropertyTimeline { get; set; }
 
-        private void PopulateProperties()
-        {
-            if (_profileEditorService.SelectedProfileElement is Layer selectedLayer)
-            {
-                // Only create VMs for top-level parents, let parents populate their own children recursively
-                var propertyViewModels = selectedLayer.Properties
-                    .Where(p => p.Children.Any())
-                    .Select(p => _layerPropertyViewModelFactory.Create(p, null))
-                    .ToList();
-
-                PropertyTree.PopulateProperties(propertyViewModels);
-                PropertyTimeline.PopulateProperties(propertyViewModels);
-            }
-            else
-            {
-                PropertyTree.ClearProperties();
-                PropertyTimeline.ClearProperties();
-            }
-        }
-
         private void ProfileEditorServiceOnCurrentTimeChanged(object sender, EventArgs e)
         {
             NotifyOfPropertyChange(() => FormattedCurrentTime);
@@ -100,6 +84,77 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties
             base.OnDeactivate();
         }
 
+        #region View model managament
+
+        private void PopulateProperties(ProfileElement profileElement, ProfileElement previousProfileElement)
+        {
+            if (previousProfileElement is Layer previousLayer)
+            {
+                previousLayer.LayerPropertyRegistered -= LayerOnPropertyRegistered;
+                previousLayer.LayerPropertyRemoved -= LayerOnPropertyRemoved;
+            }
+            if (profileElement is Layer layer)
+            {
+                // Create VMs for missing properties
+                foreach (var baseLayerProperty in layer.Properties)
+                {
+                    if (_layerPropertyViewModels.All(vm => vm.LayerProperty != baseLayerProperty))
+                        CreatePropertyViewModel(baseLayerProperty);
+                }
+
+                // Remove VMs for extra properties
+                foreach (var layerPropertyViewModel in _layerPropertyViewModels.ToList())
+                {
+                    if (layer.Properties.All(p => p != layerPropertyViewModel.LayerProperty))
+                        RemovePropertyViewModel(layerPropertyViewModel);
+                }
+
+                layer.LayerPropertyRegistered += LayerOnPropertyRegistered;
+                layer.LayerPropertyRemoved += LayerOnPropertyRemoved;
+            }
+        }
+
+        private void LayerOnPropertyRegistered(object sender, LayerPropertyEventArgs e)
+        {
+            Console.WriteLine("LayerOnPropertyRegistered");
+            PopulateProperties(e.LayerProperty.Layer, e.LayerProperty.Layer);
+        }
+
+        private void LayerOnPropertyRemoved(object sender, LayerPropertyEventArgs e)
+        {
+            Console.WriteLine("LayerOnPropertyRemoved");
+            PopulateProperties(e.LayerProperty.Layer, e.LayerProperty.Layer);
+        }
+
+        private LayerPropertyViewModel CreatePropertyViewModel(BaseLayerProperty layerProperty)
+        {
+            LayerPropertyViewModel parent = null;
+            // If the property has a parent, find it's VM
+            if (layerProperty.Parent != null)
+            {
+                parent = _layerPropertyViewModels.FirstOrDefault(vm => vm.LayerProperty == layerProperty.Parent);
+                // If no VM is found, create it
+                if (parent == null)
+                    parent = CreatePropertyViewModel(layerProperty.Parent);
+            }
+
+            var createdViewModel = _layerPropertyVmFactory.Create(layerProperty, parent);
+            _layerPropertyViewModels.Add(createdViewModel);
+            PropertyTree.AddLayerProperty(createdViewModel);
+            PropertyTimeline.AddLayerProperty(createdViewModel);
+
+            return createdViewModel;
+        }
+
+        private void RemovePropertyViewModel(LayerPropertyViewModel layerPropertyViewModel)
+        {
+            PropertyTree.RemoveLayerProperty(layerPropertyViewModel);
+            PropertyTimeline.RemoveLayerProperty(layerPropertyViewModel);
+            _layerPropertyViewModels.Remove(layerPropertyViewModel);
+        }
+
+        #endregion
+
         #region Controls
 
         public void PlayFromStart()

src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/LayerPropertyViewModel.cs

@@ -16,8 +16,7 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties
         private readonly IProfileEditorService _profileEditorService;
         private bool _keyframesEnabled;
 
-        public LayerPropertyViewModel(BaseLayerProperty layerProperty, LayerPropertyViewModel parent, ILayerPropertyViewModelFactory layerPropertyViewModelFactory, IKernel kernel,
-            IProfileEditorService profileEditorService)
+        public LayerPropertyViewModel(BaseLayerProperty layerProperty, LayerPropertyViewModel parent, IKernel kernel, IProfileEditorService profileEditorService)
         {
             _kernel = kernel;
             _profileEditorService = profileEditorService;
@@ -28,8 +27,7 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties
             Children = new List<LayerPropertyViewModel>();
             IsExpanded = layerProperty.ExpandByDefault;
 
-            foreach (var child in layerProperty.Children)
-                Children.Add(layerPropertyViewModelFactory.Create(child, this));
+            Parent?.Children.Add(this);
         }
 
         public BaseLayerProperty LayerProperty { get; }
@@ -78,15 +76,5 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties
             match.Initialize(this);
             return match;
         }
-
-        public IEnumerable<LayerPropertyViewModel> GetAllChildren()
-        {
-            var children = new List<LayerPropertyViewModel>();
-            children.AddRange(Children);
-            foreach (var layerPropertyViewModel in children) 
-                children.AddRange(layerPropertyViewModel.GetAllChildren());
-
-            return children;
-        }
     }
 }

src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/PropertyTree/PropertyTreeChildViewModel.cs

@@ -22,5 +22,13 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree
                     PropertyInputViewModel?.Update();
             }
         }
+
+        public override void RemoveLayerProperty(LayerPropertyViewModel layerPropertyViewModel)
+        {
+        }
+
+        public override void AddLayerProperty(LayerPropertyViewModel layerPropertyViewModel)
+        {
+        }
     }
 }

src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/PropertyTree/PropertyTreeItemViewModel.cs

@@ -16,5 +16,18 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree
         /// </summary>
         /// <param name="forceUpdate">Force update regardless of visibility and keyframes</param>
         public abstract void Update(bool forceUpdate);
+
+        /// <summary>
+        /// Removes the layer property recursively
+        /// </summary>
+        /// <param name="layerPropertyViewModel"></param>
+        public abstract void RemoveLayerProperty(LayerPropertyViewModel layerPropertyViewModel);
+
+        /// <summary>
+        /// Adds the layer property recursively
+        /// </summary>
+        /// <param name="layerPropertyViewModel"></param>
+        public abstract void AddLayerProperty(LayerPropertyViewModel layerPropertyViewModel);
+
     }
 }

src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/PropertyTree/PropertyTreeParentViewModel.cs

@@ -9,43 +9,6 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree
         public PropertyTreeParentViewModel(LayerPropertyViewModel layerPropertyViewModel) : base(layerPropertyViewModel)
         {
             Children = new BindableCollection<PropertyTreeItemViewModel>();
-
-            foreach (var childProperty in layerPropertyViewModel.Children)
-            {
-                if (childProperty.Children.Any())
-                    Children.Add(new PropertyTreeParentViewModel(childProperty));
-                else
-                    Children.Add(new PropertyTreeChildViewModel(childProperty));
-            }
-
-            LayerPropertyViewModel.LayerProperty.Layer.LayerPropertyRegistered += LayerOnLayerPropertyRegistered;
-            LayerPropertyViewModel.LayerProperty.Layer.LayerPropertyRemoved += LayerOnLayerPropertyRemoved;
-        }
-
-        private void LayerOnLayerPropertyRegistered(object sender, LayerPropertyEventArgs e)
-        {
-            if (e.LayerProperty.Parent == LayerPropertyViewModel.LayerProperty)
-            {
-                // Problem is we don't have a LayerPropertyViewModel here..
-            }
-        }
-
-        private void LayerOnLayerPropertyRemoved(object sender, LayerPropertyEventArgs e)
-        {
-            // Remove self
-            if (e.LayerProperty == LayerPropertyViewModel.LayerProperty)
-            {
-                LayerPropertyViewModel.LayerProperty.Layer.LayerPropertyRemoved -= LayerOnLayerPropertyRegistered;
-                LayerPropertyViewModel.LayerProperty.Layer.LayerPropertyRemoved -= LayerOnLayerPropertyRemoved;
-            }
-
-            // Remove child
-            if (e.LayerProperty.Parent == LayerPropertyViewModel.LayerProperty)
-            {
-                var child = Children.FirstOrDefault(c => c.LayerPropertyViewModel.LayerProperty == e.LayerProperty);
-                if (child != null)
-                    Children.Remove(child);
-            }
         }
 
         public BindableCollection<PropertyTreeItemViewModel> Children { get; set; }
@@ -55,5 +18,38 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree
             foreach (var child in Children)
                 child.Update(forceUpdate);
         }
+
+        public override void AddLayerProperty(LayerPropertyViewModel layerPropertyViewModel)
+        {
+            if (layerPropertyViewModel.Parent == LayerPropertyViewModel)
+            {
+                lock (Children)
+                {
+                    var index = layerPropertyViewModel.LayerProperty.Parent.Children.IndexOf(layerPropertyViewModel.LayerProperty);
+                    if (index > Children.Count)
+                        index = Children.Count;
+                    if (layerPropertyViewModel.Children.Any())
+                        Children.Insert(index, new PropertyTreeParentViewModel(layerPropertyViewModel));
+                    else
+                        Children.Insert(index, new PropertyTreeChildViewModel(layerPropertyViewModel));
+                }
+            }
+            else
+            {
+                foreach (var propertyTreeItemViewModel in Children)
+                    propertyTreeItemViewModel.AddLayerProperty(layerPropertyViewModel);
+            }
+        }
+
+        public override void RemoveLayerProperty(LayerPropertyViewModel layerPropertyViewModel)
+        {
+            foreach (var child in Children.ToList())
+            {
+                if (child.LayerPropertyViewModel == layerPropertyViewModel)
+                    Children.Remove(child);
+                else
+                    child.RemoveLayerProperty(layerPropertyViewModel);
+            }
+        }
     }
 }

src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/PropertyTree/PropertyTreeViewModel.cs

@@ -1,9 +1,7 @@
-using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
-using Artemis.Core.Models.Profile.LayerProperties;
 using Artemis.UI.Services.Interfaces;
 using Stylet;
 
@@ -27,26 +25,31 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.PropertyTree
         public LayerPropertiesViewModel LayerPropertiesViewModel { get; }
         public BindableCollection<PropertyTreeItemViewModel> PropertyTreeItemViewModels { get; set; }
 
-        public void PopulateProperties(List<LayerPropertyViewModel> properties)
+        public void AddLayerProperty(LayerPropertyViewModel layerPropertyViewModel)
         {
-            PropertyTreeItemViewModels.Clear();
-
-            // Only put parents on the top-level, let parents populate their own children recursively
-            foreach (var property in properties)
+            // Add as a root VM
+            if (layerPropertyViewModel.Parent == null)
+                PropertyTreeItemViewModels.Add(new PropertyTreeParentViewModel(layerPropertyViewModel));
+            // Add recursively to one of the child VMs
+            else
             {
-                if (property.Children.Any())
-                    PropertyTreeItemViewModels.Add(new PropertyTreeParentViewModel(property));
+                foreach (var propertyTreeItemViewModel in PropertyTreeItemViewModels)
+                    propertyTreeItemViewModel.AddLayerProperty(layerPropertyViewModel);
             }
         }
 
-        public void ClearProperties()
+        public void RemoveLayerProperty(LayerPropertyViewModel layerPropertyViewModel)
         {
-            PropertyTreeItemViewModels.Clear();
-        }
-
-        public void AddLayerProperty(BaseLayerProperty layerProperty)
-        {
-            
+            // Remove a root VM
+            var rootVm = PropertyTreeItemViewModels.FirstOrDefault(vm => vm.LayerPropertyViewModel == layerPropertyViewModel);
+            if (rootVm != null)
+                PropertyTreeItemViewModels.Remove(rootVm);
+            // Remove recursively from one of the child VMs
+            else
+            {
+                foreach (var propertyTreeItemViewModel in PropertyTreeItemViewModels)
+                    propertyTreeItemViewModel.RemoveLayerProperty(layerPropertyViewModel);
+            }
         }
 
         /// <summary>

src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/Timeline/PropertyTimelineViewModel.cs

@@ -11,14 +11,14 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.Timeline
     public class PropertyTimelineViewModel : PropertyChangedBase
     {
         private readonly IProfileEditorService _profileEditorService;
-        private readonly IPropertyTrackViewModelFactory _propertyTrackViewModelFactory;
+        private readonly IPropertyTrackVmFactory _propertyTrackVmFactory;
 
         public PropertyTimelineViewModel(LayerPropertiesViewModel layerPropertiesViewModel,
             IProfileEditorService profileEditorService,
-            IPropertyTrackViewModelFactory propertyTrackViewModelFactory)
+            IPropertyTrackVmFactory propertyTrackVmFactory)
         {
             _profileEditorService = profileEditorService;
-            _propertyTrackViewModelFactory = propertyTrackViewModelFactory;
+            _propertyTrackVmFactory = propertyTrackVmFactory;
 
             LayerPropertiesViewModel = layerPropertiesViewModel;
             PropertyTrackViewModels = new BindableCollection<PropertyTrackViewModel>();
@@ -54,23 +54,29 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.Timeline
             UpdateEndTime();
         }
 
+        public void AddLayerProperty(LayerPropertyViewModel layerPropertyViewModel)
+        {
+            // Determine the index by flattening all the layer's properties
+            var index = layerPropertyViewModel.LayerProperty.GetFlattenedIndex();
+            if (index > PropertyTrackViewModels.Count)
+                index = PropertyTrackViewModels.Count;
+            PropertyTrackViewModels.Insert(index, _propertyTrackVmFactory.Create(this, layerPropertyViewModel));
+        }
+
+        public void RemoveLayerProperty(LayerPropertyViewModel layerPropertyViewModel)
+        {
+            var vm = PropertyTrackViewModels.FirstOrDefault(v => v.LayerPropertyViewModel == layerPropertyViewModel);
+            if (vm != null)
+                PropertyTrackViewModels.Remove(vm);
+        }
+
         private void CreateViewModels(LayerPropertyViewModel property)
         {
-            PropertyTrackViewModels.Add(_propertyTrackViewModelFactory.Create(this, property));
+            PropertyTrackViewModels.Add(_propertyTrackVmFactory.Create(this, property));
             foreach (var child in property.Children)
                 CreateViewModels(child);
         }
-
-        public void AddLayerProperty(BaseLayerProperty layerProperty)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void ClearProperties()
-        {
-            PropertyTrackViewModels.Clear();
-        }
-
+        
         public void UpdateKeyframePositions()
         {
             foreach (var viewModel in PropertyTrackViewModels)

src/Artemis.UI/Screens/Module/ProfileEditor/LayerProperties/Timeline/PropertyTrackViewModel.cs

@@ -7,13 +7,11 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.Timeline
 {
     public class PropertyTrackViewModel : Screen
     {
-        private readonly IPropertyTrackKeyframeViewModelFactory _propertyTrackKeyframeViewModelFactory;
+        private readonly IPropertyTrackKeyframeVmFactory _propertyTrackKeyframeVmFactory;
 
-        public PropertyTrackViewModel(PropertyTimelineViewModel propertyTimelineViewModel,
-            LayerPropertyViewModel layerPropertyViewModel,
-            IPropertyTrackKeyframeViewModelFactory propertyTrackKeyframeViewModelFactory)
+        public PropertyTrackViewModel(PropertyTimelineViewModel propertyTimelineViewModel, LayerPropertyViewModel layerPropertyViewModel, IPropertyTrackKeyframeVmFactory propertyTrackKeyframeVmFactory)
         {
-            _propertyTrackKeyframeViewModelFactory = propertyTrackKeyframeViewModelFactory;
+            _propertyTrackKeyframeVmFactory = propertyTrackKeyframeVmFactory;
             PropertyTimelineViewModel = propertyTimelineViewModel;
             LayerPropertyViewModel = layerPropertyViewModel;
             KeyframeViewModels = new BindableCollection<PropertyTrackKeyframeViewModel>();
@@ -41,7 +39,7 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.LayerProperties.Timeline
             {
                 if (KeyframeViewModels.Any(k => k.Keyframe == keyframe))
                     continue;
-                KeyframeViewModels.Add(_propertyTrackKeyframeViewModelFactory.Create(this, keyframe));
+                KeyframeViewModels.Add(_propertyTrackKeyframeVmFactory.Create(this, keyframe));
             }
 
             UpdateKeyframes(PropertyTimelineViewModel.LayerPropertiesViewModel.PixelsPerSecond);

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

@@ -11,18 +11,18 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.ProfileTree
 {
     public class ProfileTreeViewModel : ProfileEditorPanelViewModel, IDropTarget
     {
-        private readonly IFolderViewModelFactory _folderViewModelFactory;
+        private readonly IFolderVmFactory _folderVmFactory;
         private readonly IProfileEditorService _profileEditorService;
         private TreeItemViewModel _selectedTreeItem;
         private bool _updatingTree;
 
 
         public ProfileTreeViewModel(IProfileEditorService profileEditorService,
-            IFolderViewModelFactory folderViewModelFactory,
-            ILayerViewModelFactory layerViewModelFactory)
+            IFolderVmFactory folderVmFactory,
+            ILayerVmFactory layerVmFactory)
         {
             _profileEditorService = profileEditorService;
-            _folderViewModelFactory = folderViewModelFactory;
+            _folderVmFactory = folderVmFactory;
 
             CreateRootFolderViewModel();
             _profileEditorService.SelectedProfileChanged += OnSelectedProfileChanged;
@@ -105,7 +105,7 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.ProfileTree
                 return;
             }
 
-            RootFolder = _folderViewModelFactory.Create(folder);
+            RootFolder = _folderVmFactory.Create(folder);
             _updatingTree = false;
         }
 

src/Artemis.UI/Screens/Module/ProfileEditor/ProfileTree/TreeItem/FolderViewModel.cs

@@ -12,9 +12,9 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.ProfileTree.TreeItem
             IProfileEditorService profileEditorService,
             IDialogService dialogService,
             ILayerService layerService,
-            IFolderViewModelFactory folderViewModelFactory,
-            ILayerViewModelFactory layerViewModelFactory) :
-            base(null, folder, profileEditorService, dialogService, layerService, folderViewModelFactory, layerViewModelFactory)
+            IFolderVmFactory folderVmFactory,
+            ILayerVmFactory layerVmFactory) :
+            base(null, folder, profileEditorService, dialogService, layerService, folderVmFactory, layerVmFactory)
         {
         }
 
@@ -23,9 +23,9 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.ProfileTree.TreeItem
             IProfileEditorService profileEditorService,
             IDialogService dialogService,
             ILayerService layerService,
-            IFolderViewModelFactory folderViewModelFactory,
-            ILayerViewModelFactory layerViewModelFactory) :
-            base(parent, folder, profileEditorService, dialogService, layerService, folderViewModelFactory, layerViewModelFactory)
+            IFolderVmFactory folderVmFactory,
+            ILayerVmFactory layerVmFactory) :
+            base(parent, folder, profileEditorService, dialogService, layerService, folderVmFactory, layerVmFactory)
         {
         }
 

src/Artemis.UI/Screens/Module/ProfileEditor/ProfileTree/TreeItem/LayerViewModel.cs

@@ -12,9 +12,9 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.ProfileTree.TreeItem
             IProfileEditorService profileEditorService,
             IDialogService dialogService,
             ILayerService layerService,
-            IFolderViewModelFactory folderViewModelFactory,
-            ILayerViewModelFactory layerViewModelFactory) :
-            base(parent, folder, profileEditorService, dialogService, layerService, folderViewModelFactory, layerViewModelFactory)
+            IFolderVmFactory folderVmFactory,
+            ILayerVmFactory layerVmFactory) :
+            base(parent, folder, profileEditorService, dialogService, layerService, folderVmFactory, layerVmFactory)
         {
         }
 

src/Artemis.UI/Screens/Module/ProfileEditor/ProfileTree/TreeItem/TreeItemViewModel.cs

@@ -14,9 +14,9 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.ProfileTree.TreeItem
     public abstract class TreeItemViewModel : PropertyChangedBase
     {
         private readonly IDialogService _dialogService;
-        private readonly IFolderViewModelFactory _folderViewModelFactory;
+        private readonly IFolderVmFactory _folderVmFactory;
         private readonly ILayerService _layerService;
-        private readonly ILayerViewModelFactory _layerViewModelFactory;
+        private readonly ILayerVmFactory _layerVmFactory;
         private readonly IProfileEditorService _profileEditorService;
 
         protected TreeItemViewModel(TreeItemViewModel parent,
@@ -24,14 +24,14 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.ProfileTree.TreeItem
             IProfileEditorService profileEditorService,
             IDialogService dialogService,
             ILayerService layerService,
-            IFolderViewModelFactory folderViewModelFactory,
-            ILayerViewModelFactory layerViewModelFactory)
+            IFolderVmFactory folderVmFactory,
+            ILayerVmFactory layerVmFactory)
         {
             _profileEditorService = profileEditorService;
             _dialogService = dialogService;
             _layerService = layerService;
-            _folderViewModelFactory = folderViewModelFactory;
-            _layerViewModelFactory = layerViewModelFactory;
+            _folderVmFactory = folderVmFactory;
+            _layerVmFactory = layerVmFactory;
 
             Parent = parent;
             ProfileElement = profileElement;
@@ -182,13 +182,13 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.ProfileTree.TreeItem
                     {
                         existing = Children.FirstOrDefault(p => p is FolderViewModel vm && vm.ProfileElement == folder);
                         if (existing == null)
-                            Children.Add(_folderViewModelFactory.Create((FolderViewModel) this, folder));
+                            Children.Add(_folderVmFactory.Create((FolderViewModel) this, folder));
                     }
                     else if (profileElement is Layer layer)
                     {
                         existing = Children.FirstOrDefault(p => p is LayerViewModel vm && vm.ProfileElement == layer);
                         if (existing == null)
-                            Children.Add(_layerViewModelFactory.Create((FolderViewModel) this, layer));
+                            Children.Add(_layerVmFactory.Create((FolderViewModel) this, layer));
                     }
 
                     existing?.UpdateProfileElements();

src/Artemis.UI/Screens/Module/ProfileEditor/Visualization/ProfileViewModel.cs

@@ -24,7 +24,7 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.Visualization
     {
         private readonly ILayerEditorService _layerEditorService;
         private readonly IProfileEditorService _profileEditorService;
-        private readonly IProfileLayerViewModelFactory _profileLayerViewModelFactory;
+        private readonly IProfileLayerVmFactory _profileLayerVmFactory;
         private readonly ISettingsService _settingsService;
         private readonly ISurfaceService _surfaceService;
         private int _activeToolIndex;
@@ -37,13 +37,13 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.Visualization
             ISurfaceService surfaceService,
             ISettingsService settingsService,
             IEventAggregator eventAggregator,
-            IProfileLayerViewModelFactory profileLayerViewModelFactory)
+            IProfileLayerVmFactory profileLayerVmFactory)
         {
             _profileEditorService = profileEditorService;
             _layerEditorService = layerEditorService;
             _surfaceService = surfaceService;
             _settingsService = settingsService;
-            _profileLayerViewModelFactory = profileLayerViewModelFactory;
+            _profileLayerVmFactory = profileLayerVmFactory;
 
             Execute.OnUIThreadSync(() =>
             {
@@ -144,7 +144,7 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.Visualization
                     foreach (var layer in layers)
                     {
                         if (layerViewModels.All(vm => vm.Layer != layer))
-                            CanvasViewModels.Add(_profileLayerViewModelFactory.Create(layer));
+                            CanvasViewModels.Add(_profileLayerVmFactory.Create(layer));
                     }
 
                     // Remove layers that no longer exist

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

@@ -20,7 +20,7 @@ namespace Artemis.UI.Screens.Settings
 {
     public class SettingsViewModel : MainScreenViewModel
     {
-        private readonly IDeviceSettingsViewModelFactory _deviceSettingsViewModelFactory;
+        private readonly IDeviceSettingsVmFactory _deviceSettingsVmFactory;
         private readonly IKernel _kernel;
         private readonly IPluginService _pluginService;
         private readonly ISettingsService _settingsService;
@@ -32,7 +32,7 @@ namespace Artemis.UI.Screens.Settings
             IPluginService pluginService,
             IWindowManager windowManager,
             ISettingsService settingsService,
-            IDeviceSettingsViewModelFactory deviceSettingsViewModelFactory)
+            IDeviceSettingsVmFactory deviceSettingsVmFactory)
         {
             DisplayName = "Settings";
             DisplayIcon = PackIconKind.Settings;
@@ -43,7 +43,7 @@ namespace Artemis.UI.Screens.Settings
             _pluginService = pluginService;
             _windowManager = windowManager;
             _settingsService = settingsService;
-            _deviceSettingsViewModelFactory = deviceSettingsViewModelFactory;
+            _deviceSettingsVmFactory = deviceSettingsVmFactory;
 
             DeviceSettingsViewModels = new BindableCollection<DeviceSettingsViewModel>();
             Plugins = new BindableCollection<PluginSettingsViewModel>();
@@ -112,7 +112,7 @@ namespace Artemis.UI.Screens.Settings
         {
             DeviceSettingsViewModels.Clear();
             foreach (var device in _surfaceService.ActiveSurface.Devices)
-                DeviceSettingsViewModels.Add(_deviceSettingsViewModelFactory.Create(device));
+                DeviceSettingsViewModels.Add(_deviceSettingsVmFactory.Create(device));
 
             // TODO: GetPluginsOfType isn't ideal here as it doesn't include disabled plugins
             Plugins.Clear();

src/Artemis.UI/Screens/Sidebar/SidebarViewModel.cs

@@ -13,12 +13,12 @@ namespace Artemis.UI.Screens.Sidebar
 {
     public class SidebarViewModel : PropertyChangedBase
     {
-        private readonly IModuleViewModelFactory _moduleViewModelFactory;
+        private readonly IModuleVmFactory _moduleVmFactory;
         private readonly IPluginService _pluginService;
 
-        public SidebarViewModel(List<MainScreenViewModel> defaultSidebarItems, IModuleViewModelFactory moduleViewModelFactory, IPluginService pluginService)
+        public SidebarViewModel(List<MainScreenViewModel> defaultSidebarItems, IModuleVmFactory moduleVmFactory, IPluginService pluginService)
         {
-            _moduleViewModelFactory = moduleViewModelFactory;
+            _moduleVmFactory = moduleVmFactory;
             _pluginService = pluginService;
 
             DefaultSidebarItems = defaultSidebarItems;
@@ -76,7 +76,7 @@ namespace Artemis.UI.Screens.Sidebar
                 SelectedItem = screen;
             // Modules have a VM that must be created, use a factory and set the result as the selected item
             else if (sidebarItemObject is Core.Plugins.Abstract.Module module)
-                SelectedItem = _moduleViewModelFactory.Create(module);
+                SelectedItem = _moduleVmFactory.Create(module);
         }
 
         public void AddModule(Core.Plugins.Abstract.Module module)