UI - Centralized default editors registration into a service

Display conditions - Added more test operators 
Display conditions - Implemented operator selection
Display conditions - Implemented property selection and rules

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

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 using Artemis.Core.Plugins.Models;
 using Artemis.Core.Services.Interfaces;
@@ -8,6 +9,24 @@ namespace Artemis.Core.Models.Profile.Conditions
 {
     public abstract class DisplayConditionOperator
     {
+        /// <summary>
+        ///     A read-only collection containing all primitive number types
+        /// </summary>
+        protected static IReadOnlyCollection<Type> NumberTypes = new List<Type>
+        {
+            typeof(sbyte),
+            typeof(byte),
+            typeof(short),
+            typeof(ushort),
+            typeof(int),
+            typeof(uint),
+            typeof(long),
+            typeof(ulong),
+            typeof(float),
+            typeof(double),
+            typeof(decimal)
+        };
+
         private IDataModelService _dataModelService;
         private bool _registered;
 
@@ -25,12 +44,12 @@ namespace Artemis.Core.Models.Profile.Conditions
         /// <summary>
         ///     Gets or sets the description of this logical operator
         /// </summary>
-        public string Description { get; set; }
+        public abstract string Description { get; }
 
         /// <summary>
         ///     Gets or sets the icon of this logical operator
         /// </summary>
-        public string Icon { get; set; }
+        public abstract string Icon { get; }
 
         /// <summary>
         ///     Creates a binary expression comparing two types
@@ -69,5 +88,12 @@ namespace Artemis.Core.Models.Profile.Conditions
             // Profile editor service will call Unsubscribe
             _dataModelService.RemoveConditionOperator(this);
         }
+
+        public bool SupportsType(Type type)
+        {
+            if (type == null)
+                return true;
+            return CompatibleTypes.Any(t => t.IsAssignableFrom(type));
+        }
     }
 }

src/Artemis.Core/Models/Profile/Conditions/Operators/EqualsConditionOperator.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+
+namespace Artemis.Core.Models.Profile.Conditions.Operators
+{
+    public class EqualsConditionOperator : DisplayConditionOperator
+    {
+        public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> {typeof(object)};
+
+        public override string Description => "Equals";
+        public override string Icon => "Equal";
+
+        public override BinaryExpression CreateExpression(Type leftSideType, Type rightSideType)
+        {
+            var leftSideParameter = Expression.Parameter(leftSideType, "a");
+            var rightSideParameter = Expression.Parameter(rightSideType, "b");
+            return Expression.Equal(leftSideParameter, rightSideParameter);
+        }
+    }
+}

src/Artemis.Core/Models/Profile/Conditions/Operators/GreaterThanConditionOperator.cs

@@ -6,20 +6,10 @@ namespace Artemis.Core.Models.Profile.Conditions.Operators
 {
     public class GreaterThanConditionOperator : DisplayConditionOperator
     {
-        public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type>
+        public override IReadOnlyCollection<Type> CompatibleTypes => NumberTypes;
-        {
+
-            typeof(sbyte),
+        public override string Description => "Is greater than";
-            typeof(byte),
+        public override string Icon => "GreaterThan";
-            typeof(short),
-            typeof(ushort),
-            typeof(int),
-            typeof(uint),
-            typeof(long),
-            typeof(ulong),
-            typeof(float),
-            typeof(double),
-            typeof(decimal)
-        };
 
         public override BinaryExpression CreateExpression(Type leftSideType, Type rightSideType)
         {

src/Artemis.Core/Models/Profile/Conditions/Operators/GreaterThanOrEqualConditionOperator.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+
+namespace Artemis.Core.Models.Profile.Conditions.Operators
+{
+    public class GreaterThanOrEqualConditionOperator : DisplayConditionOperator
+    {
+        public override IReadOnlyCollection<Type> CompatibleTypes => NumberTypes;
+
+        public override string Description => "Is greater than or equal to";
+        public override string Icon => "GreaterThanOrEqual";
+
+        public override BinaryExpression CreateExpression(Type leftSideType, Type rightSideType)
+        {
+            var leftSideParameter = Expression.Parameter(leftSideType, "a");
+            var rightSideParameter = Expression.Parameter(rightSideType, "b");
+            return Expression.GreaterThanOrEqual(leftSideParameter, rightSideParameter);
+        }
+    }
+}

src/Artemis.Core/Models/Profile/Conditions/Operators/LessThanConditionOperator.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+
+namespace Artemis.Core.Models.Profile.Conditions.Operators
+{
+    public class LessThanConditionOperator : DisplayConditionOperator
+    {
+        public override IReadOnlyCollection<Type> CompatibleTypes => NumberTypes;
+
+        public override string Description => "Is less than";
+        public override string Icon => "LessThan";
+
+        public override BinaryExpression CreateExpression(Type leftSideType, Type rightSideType)
+        {
+            var leftSideParameter = Expression.Parameter(leftSideType, "a");
+            var rightSideParameter = Expression.Parameter(rightSideType, "b");
+            return Expression.LessThan(leftSideParameter, rightSideParameter);
+        }
+    }
+}

src/Artemis.Core/Models/Profile/Conditions/Operators/LessThanOrEqualConditionOperator.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+
+namespace Artemis.Core.Models.Profile.Conditions.Operators
+{
+    public class LessThanOrEqualConditionOperator : DisplayConditionOperator
+    {
+        public override IReadOnlyCollection<Type> CompatibleTypes => NumberTypes;
+
+        public override string Description => "Is less than or equal to";
+        public override string Icon => "LessThanOrEqual";
+
+        public override BinaryExpression CreateExpression(Type leftSideType, Type rightSideType)
+        {
+            var leftSideParameter = Expression.Parameter(leftSideType, "a");
+            var rightSideParameter = Expression.Parameter(rightSideType, "b");
+            return Expression.LessThanOrEqual(leftSideParameter, rightSideParameter);
+        }
+    }
+}

src/Artemis.Core/Models/Profile/Conditions/Operators/NotEqualConditionOperator.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+
+namespace Artemis.Core.Models.Profile.Conditions.Operators
+{
+    public class NotEqualConditionOperator : DisplayConditionOperator
+    {
+        public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> { typeof(object) };
+
+        public override string Description => "Does not equal";
+        public override string Icon => "NotEqualVariant";
+
+        public override BinaryExpression CreateExpression(Type leftSideType, Type rightSideType)
+        {
+            var leftSideParameter = Expression.Parameter(leftSideType, "a");
+            var rightSideParameter = Expression.Parameter(rightSideType, "b");
+            return Expression.NotEqual(leftSideParameter, rightSideParameter);
+        }
+    }
+}

src/Artemis.Core/Services/DataModelService.cs

@@ -40,7 +40,18 @@ namespace Artemis.Core.Services
                 AddDataModelExpansionDataModel(dataModelExpansion);
         }
 
-        public ReadOnlyCollection<DataModel> DataModelExpansions
+        public IReadOnlyCollection<DisplayConditionOperator> RegisteredConditionOperators
+        {
+            get
+            {
+                lock (_registeredConditionOperators)
+                {
+                    return _registeredConditionOperators.AsReadOnly();
+                }
+            }
+        }
+
+        public IReadOnlyCollection<DataModel> DataModelExpansions
         {
             get
             {
@@ -128,13 +139,20 @@ namespace Artemis.Core.Services
         {
             lock (_registeredConditionOperators)
             {
-                return _registeredConditionOperators.Where(c => c.CompatibleTypes.Contains(type)).ToList();
+                if (type == null)
+                    return new List<DisplayConditionOperator>(_registeredConditionOperators);
+                return _registeredConditionOperators.Where(c => c.CompatibleTypes.Any(t => t.IsAssignableFrom(type))).ToList();
             }
         }
 
         private void RegisterBuiltInConditionOperators()
         {
+            RegisterConditionOperator(Constants.CorePluginInfo, new EqualsConditionOperator());
+            RegisterConditionOperator(Constants.CorePluginInfo, new NotEqualConditionOperator());
+            RegisterConditionOperator(Constants.CorePluginInfo, new LessThanConditionOperator());
             RegisterConditionOperator(Constants.CorePluginInfo, new GreaterThanConditionOperator());
+            RegisterConditionOperator(Constants.CorePluginInfo, new LessThanOrEqualConditionOperator());
+            RegisterConditionOperator(Constants.CorePluginInfo, new GreaterThanOrEqualConditionOperator());
         }
 
         private void PluginServiceOnPluginEnabled(object sender, PluginEventArgs e)

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

@@ -1,4 +1,5 @@
-using System.Collections.ObjectModel;
+using System;
+using System.Collections.Generic;
 using Artemis.Core.Annotations;
 using Artemis.Core.Models.Profile.Conditions;
 using Artemis.Core.Plugins.Abstract;
@@ -9,7 +10,8 @@ namespace Artemis.Core.Services.Interfaces
 {
     public interface IDataModelService : IArtemisService
     {
-        ReadOnlyCollection<DataModel> DataModelExpansions { get; }
+        IReadOnlyCollection<DisplayConditionOperator> RegisteredConditionOperators { get; }
+        IReadOnlyCollection<DataModel> DataModelExpansions { get; }
 
         /// <summary>
         ///     Add an expansion to the datamodel to be available for use after the next update
@@ -48,5 +50,7 @@ namespace Artemis.Core.Services.Interfaces
         /// </summary>
         /// <param name="displayConditionOperator">The layer condition operator to remove</param>
         void RemoveConditionOperator([NotNull] DisplayConditionOperator displayConditionOperator);
+
+        List<DisplayConditionOperator> GetCompatibleConditionOperators(Type type);
     }
 }

src/Artemis.UI.Shared/DataModelVisualization/DataModelInputViewModel.cs

@@ -5,13 +5,26 @@ namespace Artemis.UI.Shared.DataModelVisualization
 {
     public abstract class DataModelInputViewModel<T> : DataModelInputViewModel
     {
-        protected DataModelInputViewModel(DataModelPropertyAttribute description)
+        private T _inputValue;
+
+        protected DataModelInputViewModel(DataModelPropertyAttribute description, T initialValue)
         {
             Description = description;
+            InputValue = initialValue;
+        }
+
+        public T InputValue
+        {
+            get => _inputValue;
+            set => SetAndNotify(ref _inputValue, value);
         }
 
         public DataModelPropertyAttribute Description { get; }
         internal override object InternalGuard { get; } = null;
+
+        protected void Submit()
+        {
+        }
     }
 
     /// <summary>

src/Artemis.UI.Shared/DataModelVisualization/Shared/DataModelVisualizationViewModel.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using Artemis.Core.Extensions;
@@ -19,6 +20,7 @@ namespace Artemis.UI.Shared.DataModelVisualization.Shared
         private DataModelVisualizationViewModel _parent;
         private DataModelPropertyAttribute _propertyDescription;
         private PropertyInfo _propertyInfo;
+        private bool _isMatchingFilteredTypes;
 
         internal DataModelVisualizationViewModel(DataModel dataModel, DataModelVisualizationViewModel parent, PropertyInfo propertyInfo)
         {
@@ -26,6 +28,7 @@ namespace Artemis.UI.Shared.DataModelVisualization.Shared
             PropertyInfo = propertyInfo;
             Parent = parent;
             Children = new BindableCollection<DataModelVisualizationViewModel>();
+            IsMatchingFilteredTypes = true;
 
             if (dataModel == null && parent == null && propertyInfo == null)
                 IsRootViewModel = true;
@@ -65,6 +68,12 @@ namespace Artemis.UI.Shared.DataModelVisualization.Shared
             set => SetAndNotify(ref _children, value);
         }
 
+        public bool IsMatchingFilteredTypes
+        {
+            get => _isMatchingFilteredTypes;
+            set => SetAndNotify(ref _isMatchingFilteredTypes, value);
+        }
+
         public abstract void Update(IDataModelVisualizationService dataModelVisualizationService);
 
         public virtual object GetCurrentValue()
@@ -72,6 +81,34 @@ namespace Artemis.UI.Shared.DataModelVisualization.Shared
             return Parent == null ? null : PropertyInfo.GetValue(Parent.GetCurrentValue());
         }
 
+        public void ApplyTypeFilter(params Type[] filteredTypes)
+        {
+            // If the VM has children, its own type is not relevant
+            if (Children.Any())
+            {
+                foreach (var child in Children)
+                    child.ApplyTypeFilter(filteredTypes);
+
+                IsMatchingFilteredTypes = true;
+                return;
+            }
+
+            // If null is passed, clear the type filter
+            if (filteredTypes == null || filteredTypes.Length == 0)
+            {
+                IsMatchingFilteredTypes = true;
+                return;
+            }
+            // If this VM has no property info, assume it does not match
+            if (PropertyInfo == null)
+            {
+                IsMatchingFilteredTypes = false;
+                return;
+            }
+
+            IsMatchingFilteredTypes = filteredTypes.Any(t => t.IsAssignableFrom(PropertyInfo.PropertyType));
+        }
+
         public DataModelVisualizationViewModel GetChildByPath(Guid dataModelGuid, string propertyPath)
         {
             var path = propertyPath.Split(".");

src/Artemis.UI.Shared/Services/DataModelVisualizationService.cs

@@ -18,8 +18,6 @@ namespace Artemis.UI.Shared.Services
         private readonly IKernel _kernel;
         private readonly List<DataModelVisualizationRegistration> _registeredDataModelDisplays;
         private readonly List<DataModelVisualizationRegistration> _registeredDataModelEditors;
-        private DataModelPropertiesViewModel _cachedMainDataModel;
-        private Dictionary<Plugin, DataModelPropertiesViewModel> _cachedDataModels;
 
         public DataModelVisualizationService(IDataModelService dataModelService, IKernel kernel)
         {
@@ -27,38 +25,24 @@ namespace Artemis.UI.Shared.Services
             _kernel = kernel;
             _registeredDataModelEditors = new List<DataModelVisualizationRegistration>();
             _registeredDataModelDisplays = new List<DataModelVisualizationRegistration>();
-            _cachedDataModels = new Dictionary<Plugin, DataModelPropertiesViewModel>();
         }
 
         public IReadOnlyCollection<DataModelVisualizationRegistration> RegisteredDataModelEditors => _registeredDataModelEditors.AsReadOnly();
         public IReadOnlyCollection<DataModelVisualizationRegistration> RegisteredDataModelDisplays => _registeredDataModelDisplays.AsReadOnly();
 
-        public DataModelPropertiesViewModel GetMainDataModelVisualization(bool useCache)
+        public DataModelPropertiesViewModel GetMainDataModelVisualization()
         {
-            // Return from cache if found
-            if (useCache && _cachedMainDataModel != null)
-                return _cachedMainDataModel;
-
             var viewModel = new DataModelPropertiesViewModel(null, null, null);
             foreach (var dataModelExpansion in _dataModelService.DataModelExpansions)
                 viewModel.Children.Add(new DataModelPropertiesViewModel(dataModelExpansion, viewModel, null));
 
             // Update to populate children
             viewModel.Update(this);
-
-            // Add to cache
-            _cachedMainDataModel = viewModel;
-
             return viewModel;
         }
 
-        public DataModelPropertiesViewModel GetPluginDataModelVisualization(Plugin plugin, bool useCache)
+        public DataModelPropertiesViewModel GetPluginDataModelVisualization(Plugin plugin)
         {
-            // Return from cache if found
-            var isCached = _cachedDataModels.TryGetValue(plugin, out var cachedMainDataModel);
-            if (useCache && isCached)
-                return cachedMainDataModel;
-
             var dataModel = _dataModelService.GetPluginDataModel(plugin);
             if (dataModel == null)
                 return null;
@@ -68,11 +52,6 @@ namespace Artemis.UI.Shared.Services
 
             // Update to populate children
             viewModel.Update(this);
-
-            // Add to cache
-            if (!isCached)
-                _cachedDataModels.Add(plugin, viewModel);
-
             return viewModel;
         }
 
@@ -81,12 +60,6 @@ namespace Artemis.UI.Shared.Services
             return _dataModelService.GetPluginExtendsDataModel(plugin);
         }
 
-        public void BustCache()
-        {
-            _cachedMainDataModel = null;
-            _cachedDataModels.Clear();
-        }
-
         public DataModelVisualizationRegistration RegisterDataModelInput<T>(PluginInfo pluginInfo) where T : DataModelInputViewModel
         {
             var viewModelType = typeof(T);
@@ -173,8 +146,8 @@ namespace Artemis.UI.Shared.Services
 
     public interface IDataModelVisualizationService : IArtemisSharedUIService
     {
-        DataModelPropertiesViewModel GetMainDataModelVisualization(bool useCached);
+        DataModelPropertiesViewModel GetMainDataModelVisualization();
-        DataModelPropertiesViewModel GetPluginDataModelVisualization(Plugin plugin, bool useCached);
+        DataModelPropertiesViewModel GetPluginDataModelVisualization(Plugin plugin);
 
         /// <summary>
         ///     Determines whether the given plugin expands the main data model
@@ -183,8 +156,6 @@ namespace Artemis.UI.Shared.Services
         /// <returns></returns>
         bool GetPluginExtendsDataModel(Plugin plugin);
 
-        void BustCache();
-
         DataModelVisualizationRegistration RegisterDataModelInput<T>(PluginInfo pluginInfo) where T : DataModelInputViewModel;
         DataModelVisualizationRegistration RegisterDataModelDisplay<T>(PluginInfo pluginInfo) where T : DataModelDisplayViewModel;
         void RemoveDataModelInput(DataModelVisualizationRegistration registration);

src/Artemis.UI.Shared/Services/Dialog/DialogService.cs

@@ -22,6 +22,8 @@ namespace Artemis.UI.Shared.Services.Dialog
             _viewManager = viewManager;
         }
 
+        public bool IsExceptionDialogOpen { get; private set; }
+
         public async Task<bool> ShowConfirmDialog(string header, string text, string confirmText = "Confirm", string cancelText = "Cancel")
         {
             var arguments = new IParameter[]
@@ -90,31 +92,28 @@ namespace Artemis.UI.Shared.Services.Dialog
 
         public async Task ShowExceptionDialog(string message, Exception exception)
         {
+            if (IsExceptionDialogOpen)
+                return;
+
+            IsExceptionDialogOpen = true;
             var arguments = new IParameter[]
             {
                 new ConstructorArgument("message", message),
                 new ConstructorArgument("exception", exception)
             };
-
+            
-            try
+            await Execute.OnUIThreadAsync(async () =>
             {
-                await Execute.OnUIThreadAsync(async () =>
+                try
                 {
-                    try
+                    DialogHost.CloseDialogCommand.Execute(new object(), null);
-                    {
+                    await ShowDialog<ExceptionDialogViewModel>(arguments);
-                        DialogHost.CloseDialogCommand.Execute(new object(), null);
+                }
-                        await ShowDialog<ExceptionDialogViewModel>(arguments);
+                finally
-                    }
+                {
-                    catch (Exception)
+                    IsExceptionDialogOpen = false;
-                    {
+                }
-                        // ignored
+            });
-                    }
-                });
-            }
-            catch (Exception)
-            {
-                // ignored
-            }
         }
 
         private async Task<object> ShowDialog(string identifier, DialogViewModelBase viewModel)

src/Artemis.UI.Shared/Services/Interfaces/IDialogService.cs

@@ -102,5 +102,7 @@ namespace Artemis.UI.Shared.Services.Interfaces
         /// <param name="exception">The exception to display. The exception message and stacktrace will be shown.</param>
         /// <returns>A task resolving when the dialog is closed</returns>
         Task ShowExceptionDialog(string message, Exception exception);
+
+        bool IsExceptionDialogOpen { get; }
     }
 }

src/Artemis.UI/DataModelVisualization/Display/SKColorDataModelDisplayView.xaml

@@ -1,13 +1,14 @@
-<UserControl x:Class="Artemis.UI.DataModelVisualization.SKColorDataModelDisplayView"
+<UserControl x:Class="Artemis.UI.DataModelVisualization.Display.SKColorDataModelDisplayView"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              xmlns:local="clr-namespace:Artemis.UI.DataModelVisualization"
              xmlns:converters="clr-namespace:Artemis.UI.Shared.Converters;assembly=Artemis.UI.Shared"
+             xmlns:display="clr-namespace:Artemis.UI.DataModelVisualization.Display"
              mc:Ignorable="d"
              d:DesignHeight="450" d:DesignWidth="800"
-             d:DataContext="{d:DesignInstance {x:Type local:SKColorDataModelDisplayViewModel}}">
+             d:DataContext="{d:DesignInstance {x:Type display:SKColorDataModelDisplayViewModel}}">
     <UserControl.Resources>
         <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>

src/Artemis.UI/DataModelVisualization/Display/SKColorDataModelDisplayViewModel.cs

@@ -1,7 +1,7 @@
 using Artemis.UI.Shared.DataModelVisualization;
 using SkiaSharp;
 
-namespace Artemis.UI.DataModelVisualization
+namespace Artemis.UI.DataModelVisualization.Display
 {
     public class SKColorDataModelDisplayViewModel : DataModelDisplayViewModel<SKColor>
     {

src/Artemis.UI/DataModelVisualization/Input/StringDataModelInputView.xaml

@@ -0,0 +1,10 @@
+<UserControl x:Class="Artemis.UI.DataModelVisualization.Input.StringDataModelInputView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:local="clr-namespace:Artemis.UI.DataModelVisualization.Input"
+             mc:Ignorable="d" 
+             d:DesignHeight="450" d:DesignWidth="800">
+    <TextBox VerticalAlignment="Center" Text="{Binding InputValue}"/>
+</UserControl>

src/Artemis.UI/DataModelVisualization/Input/StringDataModelInputViewModel.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Artemis.Core.Plugins.Abstract.DataModels.Attributes;
+using Artemis.UI.Shared.DataModelVisualization;
+
+namespace Artemis.UI.DataModelVisualization.Input
+{
+    public class StringDataModelInputViewModel : DataModelInputViewModel<string>
+    {
+        public StringDataModelInputViewModel(DataModelPropertyAttribute description, string initialValue) : base(description, initialValue)
+        {
+        }
+    }
+}

src/Artemis.UI/Screens/Module/ProfileEditor/DisplayConditions/DisplayConditionPredicateView.xaml

@@ -48,9 +48,10 @@
                 Background="#ab47bc"
                 BorderBrush="#ab47bc"
                 Style="{StaticResource DisplayConditionButton}"
+                ToolTip="{Binding DisplayConditionPredicate.LeftPropertyPath}"
                 Click="PropertyButton_OnClick">
             <Button.ContextMenu>
-                <ContextMenu ItemsSource="{Binding DataModel.Children}">
+                <ContextMenu ItemsSource="{Binding LeftSideDataModel.Children}">
                     <ContextMenu.ItemContainerStyle>
                         <Style TargetType="{x:Type MenuItem}" BasedOn="{StaticResource MaterialDesignMenuItem}">
                             <Setter Property="ItemsSource" Value="{Binding Children}" />
@@ -59,14 +60,13 @@
                             <Setter Property="Command" Value="{Binding Data.SelectLeftPropertyCommand, Source={StaticResource DataContextProxy}}" />
                             <Setter Property="CommandParameter" Value="{Binding}" />
                             <Setter Property="CommandTarget" Value="{Binding}" />
-
+                            <Setter Property="IsEnabled" Value="{Binding IsMatchingFilteredTypes}" />
                         </Style>
                     </ContextMenu.ItemContainerStyle>
                 </ContextMenu>
             </Button.ContextMenu>
             <Grid>
                 <TextBlock Text="{Binding SelectedLeftSideProperty.PropertyDescription.Name}"
-                           ToolTip="{Binding SelectedLeftSideProperty.PropertyDescription.Description}"
                            Visibility="{Binding SelectedLeftSideProperty, Converter={StaticResource NullToVisibilityConverter}}" />
                 <TextBlock Text="« Select a property »"
                            FontStyle="Italic"
@@ -79,44 +79,26 @@
                 Grid.Column="2"
                 Style="{StaticResource DisplayConditionButtonLeftClickMenu}"
                 Background="#7B7B7B"
-                BorderBrush="#7B7B7B" Content="Equals">
+                BorderBrush="#7B7B7B" 
+                Content="{Binding DisplayConditionPredicate.Operator.Description}"
+                Click="PropertyButton_OnClick">
             <Button.ContextMenu>
-                <ContextMenu>
+                <ContextMenu ItemsSource="{Binding Operators}">
-                    <MenuItem Header="Equals">
+                    <ContextMenu.ItemTemplate>
-                        <MenuItem.Icon>
+                        <DataTemplate>
-                            <materialDesign:PackIcon Kind="Equal" />
+                            <StackPanel Orientation="Horizontal">
-                        </MenuItem.Icon>
+                                <materialDesign:PackIcon Kind="{Binding Icon}" VerticalAlignment="Center" Margin="0 0 15 0"/>
-                    </MenuItem>
+                                <TextBlock Text="{Binding Description}" VerticalAlignment="Center"/>
-                    <MenuItem Header="Does not equal">
+                            </StackPanel>
-                        <MenuItem.Icon>
+                        </DataTemplate>
-                            <materialDesign:PackIcon Kind="NotEqualVariant" />
+                    </ContextMenu.ItemTemplate>
-                        </MenuItem.Icon>
+                    <ContextMenu.ItemContainerStyle>
-                    </MenuItem>
+                        <Style TargetType="{x:Type MenuItem}" BasedOn="{StaticResource MaterialDesignMenuItem}">
-                    <MenuItem Header="Is less than">
+                            <Setter Property="Command" Value="{Binding Data.SelectOperatorCommand, Source={StaticResource DataContextProxy}}" />
-                        <MenuItem.Icon>
+                            <Setter Property="CommandParameter" Value="{Binding}" />
-                            <materialDesign:PackIcon Kind="LessThan" />
+                            <Setter Property="CommandTarget" Value="{Binding}" />
-                        </MenuItem.Icon>
+                        </Style>
-                    </MenuItem>
+                    </ContextMenu.ItemContainerStyle>
-                    <MenuItem Header="Is greater than">
-                        <MenuItem.Icon>
-                            <materialDesign:PackIcon Kind="GreaterThan" />
-                        </MenuItem.Icon>
-                    </MenuItem>
-                    <MenuItem Header="Is less than or equal to">
-                        <MenuItem.Icon>
-                            <materialDesign:PackIcon Kind="LessThanOrEqual" />
-                        </MenuItem.Icon>
-                    </MenuItem>
-                    <MenuItem Header="Is greater than or equal to">
-                        <MenuItem.Icon>
-                            <materialDesign:PackIcon Kind="GreaterThanOrEqual" />
-                        </MenuItem.Icon>
-                    </MenuItem>
-                    <MenuItem Header="Is null">
-                        <MenuItem.Icon>
-                            <materialDesign:PackIcon Kind="Null" />
-                        </MenuItem.Icon>
-                    </MenuItem>
                 </ContextMenu>
             </Button.ContextMenu>
         </Button>
@@ -127,10 +109,11 @@
                 Background="{DynamicResource PrimaryHueMidBrush}"
                 BorderBrush="{DynamicResource PrimaryHueMidBrush}"
                 Style="{StaticResource DisplayConditionButton}"
+                ToolTip="{Binding DisplayConditionPredicate.RightPropertyPath}"
                 Click="PropertyButton_OnClick"
                 Visibility="{Binding ShowRightSidePropertySelection, Converter={x:Static s:BoolToVisibilityConverter.Instance}, Mode=OneWay}">
             <Button.ContextMenu>
-                <ContextMenu ItemsSource="{Binding DataModel.Children}">
+                <ContextMenu ItemsSource="{Binding RightSideDataModel.Children}">
                     <ContextMenu.ItemContainerStyle>
                         <Style TargetType="{x:Type MenuItem}" BasedOn="{StaticResource MaterialDesignMenuItem}">
                             <Setter Property="ItemsSource" Value="{Binding Children}" />
@@ -139,14 +122,13 @@
                             <Setter Property="Command" Value="{Binding Data.SelectRightPropertyCommand, Source={StaticResource DataContextProxy}}" />
                             <Setter Property="CommandParameter" Value="{Binding}" />
                             <Setter Property="CommandTarget" Value="{Binding}" />
-
+                            <Setter Property="IsEnabled" Value="{Binding IsMatchingFilteredTypes}" />
                         </Style>
                     </ContextMenu.ItemContainerStyle>
                 </ContextMenu>
             </Button.ContextMenu>
             <Grid>
                 <TextBlock Text="{Binding SelectedRightSideProperty.PropertyDescription.Name}"
-                           ToolTip="{Binding SelectedRightSideProperty.PropertyDescription.Description}"
                            Visibility="{Binding SelectedRightSideProperty, Converter={StaticResource NullToVisibilityConverter}}" />
                 <TextBlock Text="« Select a property »"
                            FontStyle="Italic"

src/Artemis.UI/Screens/Module/ProfileEditor/DisplayConditions/DisplayConditionPredicateViewModel.cs

@@ -1,4 +1,9 @@
-using Artemis.Core.Models.Profile.Conditions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Artemis.Core.Models.Profile.Conditions;
+using Artemis.Core.Services.Interfaces;
 using Artemis.UI.Screens.Module.ProfileEditor.DisplayConditions.Abstract;
 using Artemis.UI.Shared.DataModelVisualization;
 using Artemis.UI.Shared.DataModelVisualization.Shared;
@@ -10,35 +15,52 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.DisplayConditions
 {
     public class DisplayConditionPredicateViewModel : DisplayConditionViewModel
     {
+        private readonly IDataModelService _dataModelService;
         private readonly IDataModelVisualizationService _dataModelVisualizationService;
         private readonly IProfileEditorService _profileEditorService;
-        private DataModelPropertiesViewModel _dataModel;
+        private DataModelPropertiesViewModel _leftSideDataModel;
+        private List<DisplayConditionOperator> _operators;
+        private DataModelPropertiesViewModel _rightSideDataModel;
+        private DataModelInputViewModel _rightSideInputViewModel;
+        private int _rightSideTransitionIndex;
         private DataModelVisualizationViewModel _selectedLeftSideProperty;
         private DataModelVisualizationViewModel _selectedRightSideProperty;
-        private int _rightSideTransitionIndex;
+
-        private DataModelInputViewModel _rightSideInputViewModel;
+        private List<Type> _supportedInputTypes;
 
         public DisplayConditionPredicateViewModel(DisplayConditionPredicate displayConditionPredicate, DisplayConditionViewModel parent,
-            IProfileEditorService profileEditorService, IDataModelVisualizationService dataModelVisualizationService) : base(displayConditionPredicate, parent)
+            IProfileEditorService profileEditorService, IDataModelVisualizationService dataModelVisualizationService, IDataModelService dataModelService)
+            : base(displayConditionPredicate, parent)
         {
             _profileEditorService = profileEditorService;
             _dataModelVisualizationService = dataModelVisualizationService;
+            _dataModelService = dataModelService;
 
             SelectLeftPropertyCommand = new DelegateCommand(ExecuteSelectLeftProperty);
             SelectRightPropertyCommand = new DelegateCommand(ExecuteSelectRightProperty);
+            SelectOperatorCommand = new DelegateCommand(ExecuteSelectOperatorCommand);
 
-            GetDataModel();
+            Initialize();
         }
 
         public DisplayConditionPredicate DisplayConditionPredicate => (DisplayConditionPredicate) Model;
         public DelegateCommand SelectLeftPropertyCommand { get; }
         public DelegateCommand SelectRightPropertyCommand { get; }
+        public DelegateCommand SelectOperatorCommand { get; }
         public bool ShowRightSidePropertySelection => DisplayConditionPredicate.PredicateType == PredicateType.Dynamic;
 
-        public DataModelPropertiesViewModel DataModel
+        public bool IsInitialized { get; private set; }
+
+        public DataModelPropertiesViewModel LeftSideDataModel
         {
-            get => _dataModel;
+            get => _leftSideDataModel;
-            set => SetAndNotify(ref _dataModel, value);
+            set => SetAndNotify(ref _leftSideDataModel, value);
+        }
+
+        public DataModelPropertiesViewModel RightSideDataModel
+        {
+            get => _rightSideDataModel;
+            set => SetAndNotify(ref _rightSideDataModel, value);
         }
 
         public DataModelVisualizationViewModel SelectedLeftSideProperty
@@ -65,26 +87,70 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.DisplayConditions
             set => SetAndNotify(ref _rightSideInputViewModel, value);
         }
 
-        public void GetDataModel()
+        public List<DisplayConditionOperator> Operators
         {
-            var mainDataModel = _dataModelVisualizationService.GetMainDataModelVisualization(true);
+            get => _operators;
-            if (!_dataModelVisualizationService.GetPluginExtendsDataModel(_profileEditorService.GetCurrentModule()))
+            set => SetAndNotify(ref _operators, value);
-                mainDataModel.Children.Add(_dataModelVisualizationService.GetPluginDataModelVisualization(_profileEditorService.GetCurrentModule(), true));
+        }
 
-            DataModel = mainDataModel;
+        public void Initialize()
+        {
+            Task.Run(() =>
+            {
+                // Get the data models
+                LeftSideDataModel = _dataModelVisualizationService.GetMainDataModelVisualization();
+                RightSideDataModel = _dataModelVisualizationService.GetMainDataModelVisualization();
+                if (!_dataModelVisualizationService.GetPluginExtendsDataModel(_profileEditorService.GetCurrentModule()))
+                {
+                    LeftSideDataModel.Children.Add(_dataModelVisualizationService.GetPluginDataModelVisualization(_profileEditorService.GetCurrentModule()));
+                    RightSideDataModel.Children.Add(_dataModelVisualizationService.GetPluginDataModelVisualization(_profileEditorService.GetCurrentModule()));
+                }
 
-            Update();
+                // Determine which types are currently supported
+                _supportedInputTypes = _dataModelVisualizationService.RegisteredDataModelEditors.Select(e => e.SupportedType).ToList();
+
+                IsInitialized = true;
+                Update();
+            });
         }
 
         public override void Update()
         {
-            SelectedLeftSideProperty = DisplayConditionPredicate.LeftPropertyPath != null 
+            if (!IsInitialized)
-                ? DataModel.GetChildByPath(DisplayConditionPredicate.LeftDataModelGuid, DisplayConditionPredicate.LeftPropertyPath) 
+                return;
-                : null;
 
-            SelectedRightSideProperty = DisplayConditionPredicate.RightPropertyPath != null 
+            // If static, only allow selecting properties also supported by input
-                ? DataModel.GetChildByPath(DisplayConditionPredicate.RightDataModelGuid, DisplayConditionPredicate.RightPropertyPath) 
+            if (DisplayConditionPredicate.PredicateType == PredicateType.Static)
+                LeftSideDataModel.ApplyTypeFilter(_supportedInputTypes.ToArray());
+
+            // Determine the left side property first
+            SelectedLeftSideProperty = DisplayConditionPredicate.LeftPropertyPath != null
+                ? LeftSideDataModel.GetChildByPath(DisplayConditionPredicate.LeftDataModelGuid, DisplayConditionPredicate.LeftPropertyPath)
                 : null;
+            var leftSideType = SelectedLeftSideProperty?.PropertyInfo?.PropertyType;
+
+            // Right side may only select properties matching the left side
+            if (SelectedLeftSideProperty != null)
+                RightSideDataModel.ApplyTypeFilter(leftSideType);
+            else
+                RightSideDataModel.ApplyTypeFilter();
+
+            // Determine the right side property first
+            if (DisplayConditionPredicate.RightPropertyPath != null)
+            {
+                // Ensure the right side property still matches the left side type, else set it to null
+                var selectedProperty = RightSideDataModel.GetChildByPath(DisplayConditionPredicate.RightDataModelGuid, DisplayConditionPredicate.RightPropertyPath);
+                SelectedRightSideProperty = selectedProperty.IsMatchingFilteredTypes ? selectedProperty : null;
+            }
+            else
+                SelectedRightSideProperty = null;
+
+            // Get the supported operators
+            Operators = _dataModelService.GetCompatibleConditionOperators(leftSideType);
+            if (DisplayConditionPredicate.Operator == null || !DisplayConditionPredicate.Operator.SupportsType(leftSideType))
+                DisplayConditionPredicate.Operator = Operators.FirstOrDefault(o => o.SupportsType(leftSideType));
+
+            NotifyOfPropertyChange(nameof(DisplayConditionPredicate));
         }
 
         public void ActivateRightSideInputViewModel()
@@ -111,5 +177,14 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.DisplayConditions
             DisplayConditionPredicate.RightDataModelGuid = vm.DataModel.PluginInfo.Guid;
             Update();
         }
+
+        private void ExecuteSelectOperatorCommand(object context)
+        {
+            if (!(context is DisplayConditionOperator displayConditionOperator))
+                return;
+
+            DisplayConditionPredicate.Operator = displayConditionOperator;
+            Update();
+        }
     }
 }

src/Artemis.UI/Screens/Module/ProfileEditor/DisplayConditions/DisplayConditionsViewModel.cs

@@ -1,10 +1,7 @@
-using System.Linq;
+using Artemis.Core.Models.Profile;
-using Artemis.Core.Models.Profile;
 using Artemis.Core.Models.Profile.Conditions;
 using Artemis.UI.Ninject.Factories;
-using Artemis.UI.Shared.DataModelVisualization.Shared;
 using Artemis.UI.Shared.Events;
-using Artemis.UI.Shared.Services;
 using Artemis.UI.Shared.Services.Interfaces;
 
 namespace Artemis.UI.Screens.Module.ProfileEditor.DisplayConditions
@@ -12,13 +9,10 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.DisplayConditions
     public class DisplayConditionsViewModel : ProfileEditorPanelViewModel
     {
         private readonly IDisplayConditionsVmFactory _displayConditionsVmFactory;
-        private readonly IDataModelVisualizationService _dataModelVisualizationService;
         private DisplayConditionGroupViewModel _rootGroup;
 
-        public DisplayConditionsViewModel(IProfileEditorService profileEditorService, IDataModelVisualizationService dataModelVisualizationService,
+        public DisplayConditionsViewModel(IProfileEditorService profileEditorService, IDisplayConditionsVmFactory displayConditionsVmFactory)
-            IDisplayConditionsVmFactory displayConditionsVmFactory)
         {
-            _dataModelVisualizationService = dataModelVisualizationService;
             _displayConditionsVmFactory = displayConditionsVmFactory;
             profileEditorService.ProfileElementSelected += ProfileEditorServiceOnProfileElementSelected;
         }
@@ -31,8 +25,6 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.DisplayConditions
 
         private void ProfileEditorServiceOnProfileElementSelected(object sender, ProfileElementEventArgs e)
         {
-            _dataModelVisualizationService.BustCache();
-
             if (e.ProfileElement is Layer layer)
             {
                 // Ensure the layer has a root display condition group
@@ -41,6 +33,7 @@ namespace Artemis.UI.Screens.Module.ProfileEditor.DisplayConditions
 
                 RootGroup = _displayConditionsVmFactory.DisplayConditionGroupViewModel(layer.DisplayConditionGroup, null);
                 RootGroup.IsRootGroup = true;
+                RootGroup.Update();
             }
             else
                 RootGroup = null;

src/Artemis.UI/Screens/RootViewModel.cs

@@ -10,6 +10,7 @@ using Artemis.Core.Services.Interfaces;
 using Artemis.UI.Events;
 using Artemis.UI.Screens.Settings;
 using Artemis.UI.Screens.Sidebar;
+using Artemis.UI.Services;
 using Artemis.UI.Services.Interfaces;
 using Artemis.UI.Utilities;
 using MaterialDesignExtensions.Controls;
@@ -23,6 +24,7 @@ namespace Artemis.UI.Screens
         private readonly PluginSetting<ApplicationColorScheme> _colorScheme;
         private readonly ICoreService _coreService;
         private readonly IDebugService _debugService;
+        private readonly IRegistrationService _builtInRegistrationService;
         private readonly IEventAggregator _eventAggregator;
         private readonly ThemeWatcher _themeWatcher;
         private readonly Timer _titleUpdateTimer;
@@ -33,13 +35,14 @@ namespace Artemis.UI.Screens
         private string _windowTitle;
 
         public RootViewModel(IEventAggregator eventAggregator, SidebarViewModel sidebarViewModel, ISettingsService settingsService, ICoreService coreService,
-            IDebugService debugService, ISnackbarMessageQueue snackbarMessageQueue)
+            IDebugService debugService, IRegistrationService builtInRegistrationService, ISnackbarMessageQueue snackbarMessageQueue)
         {
             SidebarViewModel = sidebarViewModel;
             MainMessageQueue = snackbarMessageQueue;
             _eventAggregator = eventAggregator;
             _coreService = coreService;
             _debugService = debugService;
+            _builtInRegistrationService = builtInRegistrationService;
 
             _titleUpdateTimer = new Timer(500);
             _titleUpdateTimer.Elapsed += (sender, args) => UpdateWindowTitle();
@@ -56,7 +59,7 @@ namespace Artemis.UI.Screens
         }
 
         public SidebarViewModel SidebarViewModel { get; }
-        public ISnackbarMessageQueue MainMessageQueue { get;  }
+        public ISnackbarMessageQueue MainMessageQueue { get; }
 
         public bool IsSidebarVisible
         {
@@ -184,6 +187,10 @@ namespace Artemis.UI.Screens
         {
             UpdateWindowTitle();
             _titleUpdateTimer.Start();
+
+            _builtInRegistrationService.RegisterBuiltInDataModelDisplays();
+            _builtInRegistrationService.RegisterBuiltInDataModelInputs();
+            _builtInRegistrationService.RegisterBuiltInPropertyEditors();
         }
 
         protected override void OnDeactivate()

src/Artemis.UI/Screens/Settings/Debug/Tabs/DataModelDebugViewModel.cs

@@ -93,8 +93,8 @@ namespace Artemis.UI.Screens.Settings.Debug.Tabs
         private void GetDataModel()
         {
             MainDataModel = SelectedModule != null
-                ? _dataModelVisualizationService.GetPluginDataModelVisualization(SelectedModule, false)
+                ? _dataModelVisualizationService.GetPluginDataModelVisualization(SelectedModule)
-                : _dataModelVisualizationService.GetMainDataModelVisualization(false);
+                : _dataModelVisualizationService.GetMainDataModelVisualization();
         }
 
         private void PluginServiceOnPluginToggled(object? sender, PluginEventArgs e)

src/Artemis.UI/Services/DebugService.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Windows;
 using Artemis.Core;
-using Artemis.UI.DataModelVisualization;
+using Artemis.UI.DataModelVisualization.Display;
 using Artemis.UI.Screens.Settings.Debug;
 using Artemis.UI.Services.Interfaces;
 using Artemis.UI.Shared.Services;
@@ -15,21 +15,12 @@ namespace Artemis.UI.Services
     {
         private readonly IKernel _kernel;
         private readonly IWindowManager _windowManager;
-        private readonly IDataModelVisualizationService _dataModelVisualizationService;
         private DebugViewModel _debugViewModel;
 
-        public DebugService(IKernel kernel, IWindowManager windowManager, IDataModelVisualizationService dataModelVisualizationService)
+        public DebugService(IKernel kernel, IWindowManager windowManager)
         {
             _kernel = kernel;
             _windowManager = windowManager;
-            _dataModelVisualizationService = dataModelVisualizationService;
-
-            RegisterBuiltInDataModelDisplays();
-        }
-
-        private void RegisterBuiltInDataModelDisplays()
-        {
-            _dataModelVisualizationService.RegisterDataModelDisplay<SKColorDataModelDisplayViewModel>(Constants.CorePluginInfo);
         }
 
         public void ShowDebugger()

src/Artemis.UI/Services/LayerEditorService.cs

@@ -1,10 +1,8 @@
 using System;
 using System.Windows;
 using System.Windows.Media;
-using Artemis.Core;
 using Artemis.Core.Models.Profile;
 using Artemis.Core.Services;
-using Artemis.UI.PropertyInput;
 using Artemis.UI.Services.Interfaces;
 using Artemis.UI.Shared.Services.Interfaces;
 using SkiaSharp;
@@ -14,14 +12,11 @@ namespace Artemis.UI.Services
 {
     public class LayerEditorService : ILayerEditorService
     {
-        private readonly IProfileEditorService _profileEditorService;
         private readonly ISettingsService _settingsService;
 
         public LayerEditorService(ISettingsService settingsService, IProfileEditorService profileEditorService)
         {
             _settingsService = settingsService;
-            _profileEditorService = profileEditorService;
-            RegisterBuiltInPropertyEditors();
         }
 
         /// <inheritdoc />
@@ -138,16 +133,5 @@ namespace Artemis.UI.Services
             // The difference between the two is the offset
             return topLeft - tempTopLeft;
         }
-
-        private void RegisterBuiltInPropertyEditors()
-        {
-            _profileEditorService.RegisterPropertyInput<BrushPropertyInputViewModel>(Constants.CorePluginInfo);
-            _profileEditorService.RegisterPropertyInput<ColorGradientPropertyInputViewModel>(Constants.CorePluginInfo);
-            _profileEditorService.RegisterPropertyInput<FloatPropertyInputViewModel>(Constants.CorePluginInfo);
-            _profileEditorService.RegisterPropertyInput<IntPropertyInputViewModel>(Constants.CorePluginInfo);
-            _profileEditorService.RegisterPropertyInput<SKColorPropertyInputViewModel>(Constants.CorePluginInfo);
-            _profileEditorService.RegisterPropertyInput<SKPointPropertyInputViewModel>(Constants.CorePluginInfo);
-            _profileEditorService.RegisterPropertyInput<SKSizePropertyInputViewModel>(Constants.CorePluginInfo);
-        }
     }
 }

src/Artemis.UI/Services/RegistrationService.cs

@@ -0,0 +1,68 @@
+using Artemis.Core;
+using Artemis.UI.DataModelVisualization.Display;
+using Artemis.UI.DataModelVisualization.Input;
+using Artemis.UI.PropertyInput;
+using Artemis.UI.Services.Interfaces;
+using Artemis.UI.Shared.Services;
+using Artemis.UI.Shared.Services.Interfaces;
+
+namespace Artemis.UI.Services
+{
+    public class RegistrationService : IRegistrationService
+    {
+        private readonly IDataModelVisualizationService _dataModelVisualizationService;
+        private readonly IProfileEditorService _profileEditorService;
+        private bool _registeredBuiltInDataModelDisplays;
+        private bool _registeredBuiltInDataModelInputs;
+        private bool _registeredBuiltInPropertyEditors;
+
+        public RegistrationService(IDataModelVisualizationService dataModelVisualizationService, IProfileEditorService profileEditorService)
+        {
+            _dataModelVisualizationService = dataModelVisualizationService;
+            _profileEditorService = profileEditorService;
+        }
+
+        public void RegisterBuiltInDataModelDisplays()
+        {
+            if (_registeredBuiltInDataModelDisplays)
+                return;
+
+            _dataModelVisualizationService.RegisterDataModelDisplay<SKColorDataModelDisplayViewModel>(Constants.CorePluginInfo);
+
+            _registeredBuiltInDataModelDisplays = true;
+        }
+
+        public void RegisterBuiltInDataModelInputs()
+        {
+            if (_registeredBuiltInDataModelInputs)
+                return;
+
+            _dataModelVisualizationService.RegisterDataModelInput<StringDataModelInputViewModel>(Constants.CorePluginInfo);
+
+            _registeredBuiltInDataModelInputs = true;
+        }
+
+        public void RegisterBuiltInPropertyEditors()
+        {
+            if (_registeredBuiltInPropertyEditors)
+                return;
+
+            _profileEditorService.RegisterPropertyInput<BrushPropertyInputViewModel>(Constants.CorePluginInfo);
+            _profileEditorService.RegisterPropertyInput<ColorGradientPropertyInputViewModel>(Constants.CorePluginInfo);
+            _profileEditorService.RegisterPropertyInput<FloatPropertyInputViewModel>(Constants.CorePluginInfo);
+            _profileEditorService.RegisterPropertyInput<IntPropertyInputViewModel>(Constants.CorePluginInfo);
+            _profileEditorService.RegisterPropertyInput<SKColorPropertyInputViewModel>(Constants.CorePluginInfo);
+            _profileEditorService.RegisterPropertyInput<SKPointPropertyInputViewModel>(Constants.CorePluginInfo);
+            _profileEditorService.RegisterPropertyInput<SKSizePropertyInputViewModel>(Constants.CorePluginInfo);
+
+            _registeredBuiltInPropertyEditors = true;
+        }
+    }
+
+    public interface IRegistrationService : IArtemisUIService
+    {
+        void RegisterBuiltInDataModelDisplays();
+        void RegisterBuiltInDataModelInputs();
+        void RegisterBuiltInPropertyEditors();
+    }
+}