Merge branch 'development'

src/Artemis.Core/Events/DynamicDataModelChildEventArgs.cs

@@ -4,20 +4,20 @@ using Artemis.Core.DataModelExpansions;
 namespace Artemis.Core
 {
     /// <summary>
-    ///     Provides data about dynamic data model related events
+    ///     Provides data about dynamic data model child related events
     /// </summary>
-    public class DynamicDataModelEventArgs : EventArgs
+    public class DynamicDataModelChildEventArgs : EventArgs
     {
-        internal DynamicDataModelEventArgs(DataModel dynamicDataModel, string key)
+        internal DynamicDataModelChildEventArgs(DynamicChild dynamicChild, string key)
         {
-            DynamicDataModel = dynamicDataModel;
+            DynamicChild = dynamicChild;
             Key = key;
         }
 
         /// <summary>
-        ///     Gets the dynamic data model
+        ///     Gets the dynamic data model child
         /// </summary>
-        public DataModel DynamicDataModel { get; }
+        public DynamicChild DynamicChild { get; }
 
         /// <summary>
         ///     Gets the key of the dynamic data model on the parent <see cref="DataModel" />

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

@@ -15,6 +15,8 @@ namespace Artemis.Core
     {
         private Expression<Func<object, object>>? _accessorLambda;
         private DataModel? _dynamicDataModel;
+        private Type? _dynamicDataModelType;
+        private DataModelPropertyAttribute? _dynamicDataModelAttribute;
 
         internal DataModelPathSegment(DataModelPath dataModelPath, string identifier, string path)
         {
@@ -49,12 +51,6 @@ namespace Artemis.Core
         /// </summary>
         public DataModelPathSegmentType Type { get; private set; }
 
-        /// <summary>
-        ///     Gets the type of dynamic data model this path points to
-        ///     <para>Not used if the <see cref="Type" /> is <see cref="DataModelPathSegmentType.Static" /></para>
-        /// </summary>
-        public Type? DynamicDataModelType { get; private set; }
-
         /// <summary>
         ///     Gets the previous segment in the path
         /// </summary>
@@ -114,7 +110,7 @@ namespace Artemis.Core
         {
             // Dynamic types have a data model description
             if (Type == DataModelPathSegmentType.Dynamic)
-                return (GetValue() as DataModel)?.DataModelDescription;
+                return _dynamicDataModelAttribute;
             if (IsStartSegment && DataModelPath.Target != null)
                 return DataModelPath.Target.DataModelDescription;
             if (IsStartSegment)
@@ -187,12 +183,12 @@ namespace Artemis.Core
                     return CreateExpression(parameter, expression, nullCondition);
 
                 // If a dynamic data model is found the use that
-                bool hasDynamicDataModel = _dynamicDataModel.DynamicDataModels.TryGetValue(Identifier, out DataModel? dynamicDataModel);
-                if (hasDynamicDataModel && dynamicDataModel != null)
-                    DetermineDynamicType(dynamicDataModel);
+                bool hasDynamicChild = _dynamicDataModel.DynamicChildren.TryGetValue(Identifier, out DynamicChild? dynamicChild);
+                if (hasDynamicChild && dynamicChild?.BaseValue != null)
+                    DetermineDynamicType(dynamicChild.BaseValue, dynamicChild.Attribute);
 
-                _dynamicDataModel.DynamicDataModelAdded += DynamicDataModelOnDynamicDataModelAdded;
-                _dynamicDataModel.DynamicDataModelRemoved += DynamicDataModelOnDynamicDataModelRemoved;
+                _dynamicDataModel.DynamicChildAdded += DynamicChildOnDynamicChildAdded;
+                _dynamicDataModel.DynamicChildRemoved += DynamicChildOnDynamicChildRemoved;
             }
 
             return CreateExpression(parameter, expression, nullCondition);
@@ -216,12 +212,14 @@ namespace Artemis.Core
                 accessorExpression = Expression.PropertyOrField(expression, Identifier);
             // A dynamic segment calls the generic method DataModel.DynamicChild<T> and provides the identifier as an argument
             else
+            {
                 accessorExpression = Expression.Call(
                     expression,
-                    nameof(DataModel.DynamicChild),
-                    DynamicDataModelType != null ? new[] {DynamicDataModelType} : null,
+                    nameof(DataModel.GetDynamicChildValue),
+                    _dynamicDataModelType != null ? new[] { _dynamicDataModelType } : null,
                     Expression.Constant(Identifier)
                 );
+            }
 
             _accessorLambda = Expression.Lambda<Func<object, object>>(
                 // Wrap with a null check
@@ -236,10 +234,11 @@ namespace Artemis.Core
             return accessorExpression;
         }
 
-        private void DetermineDynamicType(DataModel dynamicDataModel)
+        private void DetermineDynamicType(object dynamicDataModel, DataModelPropertyAttribute attribute)
         {
             Type = DataModelPathSegmentType.Dynamic;
-            DynamicDataModelType = dynamicDataModel.GetType();
+            _dynamicDataModelType = dynamicDataModel.GetType();
+            _dynamicDataModelAttribute = attribute;
         }
 
         private void DetermineStaticType(Type previousType)
@@ -263,8 +262,8 @@ namespace Artemis.Core
             {
                 if (_dynamicDataModel != null)
                 {
-                    _dynamicDataModel.DynamicDataModelAdded -= DynamicDataModelOnDynamicDataModelAdded;
-                    _dynamicDataModel.DynamicDataModelRemoved -= DynamicDataModelOnDynamicDataModelRemoved;
+                    _dynamicDataModel.DynamicChildAdded -= DynamicChildOnDynamicChildAdded;
+                    _dynamicDataModel.DynamicChildRemoved -= DynamicChildOnDynamicChildRemoved;
                 }
 
                 Type = DataModelPathSegmentType.Invalid;
@@ -285,15 +284,15 @@ namespace Artemis.Core
 
         #region Event handlers
 
-        private void DynamicDataModelOnDynamicDataModelAdded(object? sender, DynamicDataModelEventArgs e)
+        private void DynamicChildOnDynamicChildAdded(object? sender, DynamicDataModelChildEventArgs e)
         {
             if (e.Key == Identifier)
                 DataModelPath.Initialize();
         }
 
-        private void DynamicDataModelOnDynamicDataModelRemoved(object? sender, DynamicDataModelEventArgs e)
+        private void DynamicChildOnDynamicChildRemoved(object? sender, DynamicDataModelChildEventArgs e)
         {
-            if (e.DynamicDataModel == _dynamicDataModel)
+            if (e.DynamicChild.BaseValue == _dynamicDataModel)
                 DataModelPath.Initialize();
         }
 

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

@@ -195,7 +195,7 @@ namespace Artemis.Core
                     baseLayerEffect.Update(Timeline.Delta.TotalSeconds);
                 }
 
-                SKPaint layerPaint = new();
+                SKPaint layerPaint = new() {FilterQuality = SKFilterQuality.Low};
                 try
                 {
                     SKRectI rendererBounds = SKRectI.Create(0, 0, Bounds.Width, Bounds.Height);

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

@@ -364,7 +364,7 @@ namespace Artemis.Core
             if (LayerBrush?.BrushType != LayerBrushType.Regular)
                 return;
 
-            SKPaint layerPaint = new();
+            SKPaint layerPaint = new() {FilterQuality = SKFilterQuality.Low};
             try
             {
                 canvas.Save();

src/Artemis.Core/Plugins/DataModelExpansions/DataModel.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
 using Artemis.Core.Modules;
@@ -14,7 +15,7 @@ namespace Artemis.Core.DataModelExpansions
     /// </summary>
     public abstract class DataModel
     {
-        private readonly Dictionary<string, DataModel> _dynamicDataModels = new();
+        private readonly Dictionary<string, DynamicChild> _dynamicChildren = new();
 
         /// <summary>
         ///     Creates a new instance of the <see cref="DataModel" /> class
@@ -47,10 +48,10 @@ namespace Artemis.Core.DataModelExpansions
         public bool IsExpansion { get; internal set; }
 
         /// <summary>
-        ///     Gets an read-only dictionary of all dynamic data models
+        ///     Gets an read-only dictionary of all dynamic children
         /// </summary>
         [DataModelIgnore]
-        public ReadOnlyDictionary<string, DataModel> DynamicDataModels => new(_dynamicDataModels);
+        public ReadOnlyDictionary<string, DynamicChild> DynamicChildren => new(_dynamicChildren);
 
         /// <summary>
         ///     Returns a read-only collection of all properties in this datamodel that are to be ignored
@@ -67,122 +68,213 @@ namespace Artemis.Core.DataModelExpansions
         }
 
         /// <summary>
-        ///     Adds a dynamic data model to this data model
+        ///     Occurs when a dynamic child has been added to this data model
         /// </summary>
-        /// <param name="dynamicDataModel">The dynamic data model to add</param>
-        /// <param name="key">The key of the child, must be unique to this data model</param>
-        /// <param name="name">An optional name, if not provided the key will be used in a humanized form</param>
-        /// <param name="description">An optional description</param>
-        public T AddDynamicChild<T>(T dynamicDataModel, string key, string? name = null, string? description = null) where T : DataModel
+        public event EventHandler<DynamicDataModelChildEventArgs>? DynamicChildAdded;
+
+        /// <summary>
+        ///     Occurs when a dynamic child has been removed from this data model
+        /// </summary>
+        public event EventHandler<DynamicDataModelChildEventArgs>? DynamicChildRemoved;
+
+        /// <summary>
+        ///     Invokes the <see cref="DynamicChildAdded" /> event
+        /// </summary>
+        protected virtual void OnDynamicDataModelAdded(DynamicDataModelChildEventArgs e)
         {
-            if (dynamicDataModel == null)
-                throw new ArgumentNullException(nameof(dynamicDataModel));
-            if (key == null)
-                throw new ArgumentNullException(nameof(key));
+            DynamicChildAdded?.Invoke(this, e);
+        }
+
+        /// <summary>
+        ///     Invokes the <see cref="DynamicChildRemoved" /> event
+        /// </summary>
+        protected virtual void OnDynamicDataModelRemoved(DynamicDataModelChildEventArgs e)
+        {
+            DynamicChildRemoved?.Invoke(this, e);
+        }
+
+        #region Dynamic children
+
+        /// <summary>
+        ///     Adds a dynamic child to this data model
+        /// </summary>
+        /// <param name="key">The key of the child, must be unique to this data model</param>
+        /// <param name="initialValue">The initial value of the dynamic child</param>
+        /// <returns>The resulting dynamic child which can be used to further update the value</returns>
+        public DynamicChild<T> AddDynamicChild<T>(string key, T initialValue)
+        {
+            return AddDynamicChild(key, initialValue, new DataModelPropertyAttribute());
+        }
+
+        /// <summary>
+        ///     Adds a dynamic child to this data model
+        /// </summary>
+        /// <param name="key">The key of the child, must be unique to this data model</param>
+        /// <param name="initialValue">The initial value of the dynamic child</param>
+        /// <param name="name">A human readable name for your dynamic child, shown in the UI</param>
+        /// <param name="description">An optional description, shown in the UI</param>
+        /// <returns>The resulting dynamic child which can be used to further update the value</returns>
+        public DynamicChild<T> AddDynamicChild<T>(string key, T initialValue, string name, string? description = null)
+        {
+            return AddDynamicChild(key, initialValue, new DataModelPropertyAttribute {Name = name, Description = description});
+        }
+
+        /// <summary>
+        ///     Adds a dynamic child to this data model
+        /// </summary>
+        /// <param name="key">The key of the child, must be unique to this data model</param>
+        /// <param name="initialValue">The initial value of the dynamic child</param>
+        /// <param name="attribute">A data model property attribute describing the dynamic child</param>
+        /// <returns>The resulting dynamic child which can be used to further update the value</returns>
+        public DynamicChild<T> AddDynamicChild<T>(string key, T initialValue, DataModelPropertyAttribute attribute)
+        {
+            if (key == null) throw new ArgumentNullException(nameof(key));
+            if (initialValue == null) throw new ArgumentNullException(nameof(initialValue));
+            if (attribute == null) throw new ArgumentNullException(nameof(attribute));
             if (key.Contains('.'))
                 throw new ArtemisCoreException("The provided key contains an illegal character (.)");
-            if (_dynamicDataModels.ContainsKey(key))
-                throw new ArtemisCoreException($"Cannot add a dynamic data model with key '{key}' " +
-                                               "because the key is already in use on by another dynamic property this data model.");
-
-            if (_dynamicDataModels.ContainsValue(dynamicDataModel))
+            if (_dynamicChildren.ContainsKey(key))
             {
-                string existingKey = _dynamicDataModels.First(kvp => kvp.Value == dynamicDataModel).Key;
-                throw new ArtemisCoreException($"Cannot add a dynamic data model with key '{key}' " +
-                                               $"because the dynamic data model is already added with key '{existingKey}.");
+                throw new ArtemisCoreException($"Cannot add a dynamic child with key '{key}' " +
+                                               "because the key is already in use on by another dynamic property this data model.");
             }
 
             if (GetType().GetProperty(key) != null)
-                throw new ArtemisCoreException($"Cannot add a dynamic data model with key '{key}' " +
-                                               "because the key is already in use by a static property on this data model.");
-
-            dynamicDataModel.Feature = Feature;
-            dynamicDataModel.DataModelDescription = new DataModelPropertyAttribute
             {
-                Name = string.IsNullOrWhiteSpace(name) ? key.Humanize() : name,
-                Description = description
-            };
-            _dynamicDataModels.Add(key, dynamicDataModel);
+                throw new ArtemisCoreException($"Cannot add a dynamic child with key '{key}' " +
+                                               "because the key is already in use by a static property on this data model.");
+            }
 
-            OnDynamicDataModelAdded(new DynamicDataModelEventArgs(dynamicDataModel, key));
-            return dynamicDataModel;
+            // Make sure a name is on the attribute or funny things might happen
+            attribute.Name ??= key.Humanize();
+            if (initialValue is DataModel dynamicDataModel)
+            {
+                dynamicDataModel.Feature = Feature;
+                dynamicDataModel.DataModelDescription = attribute;
+            }
+
+            DynamicChild<T> dynamicChild = new(initialValue, key, attribute);
+            _dynamicChildren.Add(key, dynamicChild);
+
+            OnDynamicDataModelAdded(new DynamicDataModelChildEventArgs(dynamicChild, key));
+            return dynamicChild;
         }
 
         /// <summary>
-        ///     Removes a dynamic data model from the data model by its key
+        ///     Gets a previously added dynamic child by its key
         /// </summary>
-        /// <param name="key">The key of the dynamic data model to remove</param>
+        /// <param name="key">The key of the dynamic child</param>
+        public DynamicChild GetDynamicChild(string key)
+        {
+            if (key == null) throw new ArgumentNullException(nameof(key));
+            return DynamicChildren[key];
+        }
+
+        /// <summary>
+        ///     Gets a previously added dynamic child by its key
+        /// </summary>
+        /// <typeparam name="T">The typer of dynamic child you are expecting</typeparam>
+        /// <param name="key">The key of the dynamic child</param>
+        /// <returns></returns>
+        public DynamicChild<T> GetDynamicChild<T>(string key)
+        {
+            if (key == null) throw new ArgumentNullException(nameof(key));
+            return (DynamicChild<T>) DynamicChildren[key];
+        }
+
+        /// <summary>
+        ///     Gets a previously added dynamic child by its key
+        /// </summary>
+        /// <param name="key">The key of the dynamic child</param>
+        /// <param name="dynamicChild">
+        ///     When this method returns, the <see cref="DynamicChild" /> associated with the specified key,
+        ///     if the key is found; otherwise, <see langword="null" />. This parameter is passed uninitialized.
+        /// </param>
+        /// <returns>
+        ///     <see langword="true" /> if the data model contains the dynamic child; otherwise <see langword="false" />
+        /// </returns>
+        public bool TryGetDynamicChild(string key, [MaybeNullWhen(false)] out DynamicChild dynamicChild)
+        {
+            if (key == null) throw new ArgumentNullException(nameof(key));
+
+            dynamicChild = null;
+            if (!DynamicChildren.TryGetValue(key, out DynamicChild? value))
+                return false;
+
+            dynamicChild = value;
+            return true;
+        }
+
+        /// <summary>
+        ///     Gets a previously added dynamic child by its key
+        /// </summary>
+        /// <typeparam name="T">The typer of dynamic child you are expecting</typeparam>
+        /// <param name="key">The key of the dynamic child</param>
+        /// <param name="dynamicChild">
+        ///     When this method returns, the <see cref="DynamicChild{T}" /> associated with the specified
+        ///     key, if the key is found and the type matches; otherwise, <see langword="null" />. This parameter is passed
+        ///     uninitialized.
+        /// </param>
+        /// <returns>
+        ///     <see langword="true" /> if the data model contains the dynamic child; otherwise <see langword="false" />
+        /// </returns>
+        public bool TryGetDynamicChild<T>(string key, [MaybeNullWhen(false)] out DynamicChild<T> dynamicChild)
+        {
+            if (key == null) throw new ArgumentNullException(nameof(key));
+
+            dynamicChild = null;
+            if (!DynamicChildren.TryGetValue(key, out DynamicChild? value))
+                return false;
+            if (value is not DynamicChild<T> typedDynamicChild)
+                return false;
+            dynamicChild = typedDynamicChild;
+            return true;
+        }
+
+        /// <summary>
+        ///     Removes a dynamic child from the data model by its key
+        /// </summary>
+        /// <param name="key">The key of the dynamic child to remove</param>
         public void RemoveDynamicChildByKey(string key)
         {
-            _dynamicDataModels.TryGetValue(key, out DataModel? childDataModel);
-            if (childDataModel == null)
+            if (key == null) throw new ArgumentNullException(nameof(key));
+            if (!_dynamicChildren.TryGetValue(key, out DynamicChild? dynamicChild))
                 return;
 
-            _dynamicDataModels.Remove(key);
-            OnDynamicDataModelRemoved(new DynamicDataModelEventArgs(childDataModel, key));
+            _dynamicChildren.Remove(key);
+            OnDynamicDataModelRemoved(new DynamicDataModelChildEventArgs(dynamicChild, key));
         }
 
         /// <summary>
-        ///     Removes a dynamic data model from this data model
+        ///     Removes a dynamic child from this data model
         /// </summary>
-        /// <param name="dynamicDataModel">The dynamic data model to remove</param>
-        public void RemoveDynamicChild(DataModel dynamicDataModel)
+        /// <param name="dynamicChild">The dynamic data child to remove</param>
+        public void RemoveDynamicChild(DynamicChild dynamicChild)
         {
-            List<string> keys = _dynamicDataModels.Where(kvp => kvp.Value == dynamicDataModel).Select(kvp => kvp.Key).ToList();
+            if (dynamicChild == null) throw new ArgumentNullException(nameof(dynamicChild));
+            List<string> keys = _dynamicChildren.Where(kvp => kvp.Value.BaseValue == dynamicChild).Select(kvp => kvp.Key).ToList();
             foreach (string key in keys)
             {
-                _dynamicDataModels.Remove(key);
-                OnDynamicDataModelRemoved(new DynamicDataModelEventArgs(dynamicDataModel, key));
+                _dynamicChildren.Remove(key);
+                OnDynamicDataModelRemoved(new DynamicDataModelChildEventArgs(dynamicChild, key));
             }
         }
 
         /// <summary>
-        ///     Removes all dynamic data models from this data model
+        ///     Removes all dynamic children from this data model
         /// </summary>
         public void ClearDynamicChildren()
         {
-            while (_dynamicDataModels.Any())
-                RemoveDynamicChildByKey(_dynamicDataModels.First().Key);
+            while (_dynamicChildren.Any())
+                RemoveDynamicChildByKey(_dynamicChildren.First().Key);
         }
 
-        /// <summary>
-        ///     Gets a dynamic data model of type <typeparamref name="T" /> by its key
-        /// </summary>
-        /// <typeparam name="T">The type of data model you expect</typeparam>
-        /// <param name="key">The unique key of the dynamic data model</param>
-        /// <returns>If found, the dynamic data model otherwise <c>null</c></returns>
-        public T? DynamicChild<T>(string key) where T : DataModel
+        // Used a runtime by data model paths only
+        internal T? GetDynamicChildValue<T>(string key)
         {
-            _dynamicDataModels.TryGetValue(key, out DataModel? value);
-            return value as T;
-        }
-
-        #region Events
-
-        /// <summary>
-        ///     Occurs when a dynamic data model has been added to this data model
-        /// </summary>
-        public event EventHandler<DynamicDataModelEventArgs>? DynamicDataModelAdded;
-
-        /// <summary>
-        ///     Occurs when a dynamic data model has been removed from this data model
-        /// </summary>
-        public event EventHandler<DynamicDataModelEventArgs>? DynamicDataModelRemoved;
-
-        /// <summary>
-        ///     Invokes the <see cref="DynamicDataModelAdded" /> event
-        /// </summary>
-        protected virtual void OnDynamicDataModelAdded(DynamicDataModelEventArgs e)
-        {
-            DynamicDataModelAdded?.Invoke(this, e);
-        }
-
-        /// <summary>
-        ///     Invokes the <see cref="DynamicDataModelRemoved" /> event
-        /// </summary>
-        protected virtual void OnDynamicDataModelRemoved(DynamicDataModelEventArgs e)
-        {
-            DynamicDataModelRemoved?.Invoke(this, e);
+            if (TryGetDynamicChild(key, out DynamicChild? dynamicChild) && dynamicChild.BaseValue != null)
+                return (T) dynamicChild.BaseValue;
+            return default;
         }
 
         #endregion

src/Artemis.Core/Plugins/DataModelExpansions/DynamicChild.cs

@@ -0,0 +1,66 @@
+using System;
+
+namespace Artemis.Core.DataModelExpansions
+{
+    /// <summary>
+    ///     Represents a dynamic child value with its property attribute
+    /// </summary>
+    public class DynamicChild<T> : DynamicChild
+    {
+        internal DynamicChild(T value, string key, DataModelPropertyAttribute attribute) : base(key, attribute, typeof(T))
+        {
+            Value = value;
+        }
+
+        /// <summary>
+        ///     Gets or sets the current value of the dynamic child
+        /// </summary>
+        public new T Value { get; set; }
+
+        /// <inheritdoc />
+        protected override object? GetValue()
+        {
+            return Value;
+        }
+    }
+
+    /// <summary>
+    ///     Represents a dynamic child value with its property attribute
+    /// </summary>
+    public abstract class DynamicChild
+    {
+        internal DynamicChild(string key, DataModelPropertyAttribute attribute, Type type)
+        {
+            if (type == null) throw new ArgumentNullException(nameof(type));
+            Key = key ?? throw new ArgumentNullException(nameof(key));
+            Attribute = attribute ?? throw new ArgumentNullException(nameof(attribute));
+            Type = type;
+        }
+
+        /// <summary>
+        ///     Gets the key of the dynamic child
+        /// </summary>
+        public string Key { get; }
+
+        /// <summary>
+        ///     Gets the attribute describing the dynamic child
+        /// </summary>
+        public DataModelPropertyAttribute Attribute { get; }
+
+        /// <summary>
+        ///     Gets the type of <see cref="BaseValue" />
+        /// </summary>
+        public Type Type { get; }
+
+        /// <summary>
+        ///     Gets the current value of the dynamic child
+        /// </summary>
+        public object? BaseValue => GetValue();
+
+        /// <summary>
+        ///     Gets the current value of the dynamic child
+        /// </summary>
+        /// <returns>The current value of the dynamic child</returns>
+        protected abstract object? GetValue();
+    }
+}

src/Artemis.Core/Services/RgbService.cs

@@ -113,7 +113,7 @@ namespace Artemis.Core.Services
 
         private void SurfaceOnException(ExceptionEventArgs args)
         {
-            _logger.Warning("Surface threw e");
+            _logger.Warning(args.Exception, "Surface caught exception");
             throw args.Exception;
         }
 

src/Artemis.UI.Shared/Controls/DeviceVisualizer.cs

@@ -314,6 +314,7 @@ namespace Artemis.UI.Shared
             ImageBrush bitmapBrush = new(bitmap);
             bitmapBrush.Freeze();
             _backingStore.OpacityMask = bitmapBrush;
+            _backingStore.Children.Clear();
 
             InvalidateMeasure();
         }
@@ -331,14 +332,19 @@ namespace Artemis.UI.Shared
         private void Render()
         {
             DrawingContext drawingContext = _backingStore.Append();
-            // DrawingContext drawingContext = _backingStore.Open();
 
             if (HighlightedLeds != null && HighlightedLeds.Any())
+            {
+                // Faster on large devices, maybe a bit slower on smaller ones but that's ok
+                ILookup<ArtemisLed, ArtemisLed> toHighlight = HighlightedLeds.ToLookup(l => l);
                 foreach (DeviceVisualizerLed deviceVisualizerLed in _deviceVisualizerLeds)
-                    deviceVisualizerLed.RenderColor(_backingStore, drawingContext, !HighlightedLeds.Contains(deviceVisualizerLed.Led));
+                    deviceVisualizerLed.RenderColor(_backingStore, drawingContext, !toHighlight.Contains(deviceVisualizerLed.Led));
+            }
             else
+            {
                 foreach (DeviceVisualizerLed deviceVisualizerLed in _deviceVisualizerLeds)
                     deviceVisualizerLed.RenderColor(_backingStore, drawingContext, false);
+            }
 
             drawingContext.Close();
         }

src/Artemis.UI.Shared/Controls/DeviceVisualizerLed.cs

@@ -14,10 +14,10 @@ namespace Artemis.UI.Shared
     {
         private const byte Dimmed = 100;
         private const byte NonDimmed = 255;
-        private GeometryDrawing? _geometryDrawing;
         private Color _renderColor;
-
+        private GeometryDrawing? _geometryDrawing;
         private SolidColorBrush? _renderColorBrush;
+        private DrawingGroup? _lastBackingStore;
 
         public DeviceVisualizerLed(ArtemisLed led)
         {
@@ -43,12 +43,12 @@ namespace Artemis.UI.Shared
 
         public void RenderColor(DrawingGroup backingStore, DrawingContext drawingContext, bool isDimmed)
         {
-            if (DisplayGeometry == null)
+            if (DisplayGeometry == null || backingStore == null)
                 return;
 
             _renderColorBrush ??= new SolidColorBrush();
             _geometryDrawing ??= new GeometryDrawing(_renderColorBrush, null, new RectangleGeometry(LedRect));
-
+            
             byte r = Led.RgbLed.Color.GetR();
             byte g = Led.RgbLed.Color.GetG();
             byte b = Led.RgbLed.Color.GetB();
@@ -59,9 +59,12 @@ namespace Artemis.UI.Shared
             _renderColor.B = b;
             _renderColorBrush.Color = _renderColor;
 
-
-            if (!backingStore.Children.Contains(_geometryDrawing))
+            if (_lastBackingStore != backingStore)
+            {
                 backingStore.Children.Add(_geometryDrawing);
+                _lastBackingStore = backingStore;
+            }
+            
         }
 
         public void RenderImage(DrawingContext drawingContext)

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

@@ -239,9 +239,10 @@ namespace Artemis.UI.Shared
             // Add missing dynamic children
             object? value = Parent == null || Parent.IsRootViewModel ? DataModel : DataModelPath?.GetValue();
             if (value is DataModel dataModel)
-                foreach (KeyValuePair<string, DataModel> kvp in dataModel.DynamicDataModels)
+            {
+                foreach (var (key, dynamicChild) in dataModel.DynamicChildren)
                 {
-                    string childPath = AppendToPath(kvp.Key);
+                    string childPath = AppendToPath(key);
                     if (Children.Any(c => c.Path != null && c.Path.Equals(childPath)))
                         continue;
 
@@ -249,6 +250,7 @@ namespace Artemis.UI.Shared
                     if (child != null)
                         Children.Add(child);
                 }
+            }
 
             // Remove dynamic children that have been removed from the data model
             List<DataModelVisualizationViewModel> toRemoveDynamic = Children.Where(c => c.DataModelPath != null && !c.DataModelPath.IsValid).ToList();

src/Artemis.UI.Shared/DefaultTypes/DataModel/Display/DefaultDataModelDisplayView.xaml

@@ -14,16 +14,19 @@
     </UserControl.Resources>
     <Grid>
         <Grid.ColumnDefinitions>
-            <ColumnDefinition Width="Auto" />
-            <ColumnDefinition />
+            <ColumnDefinition Width="*" />
+            <ColumnDefinition Width="Auto"/>
             <ColumnDefinition Width="Auto"/>
         </Grid.ColumnDefinitions>
 
+        <!-- Prefix -->
         <TextBlock Grid.Column="0" 
                    Text="{Binding PropertyDescription.Prefix}"
                    Visibility="{Binding PropertyDescription.Prefix, Converter={StaticResource NullToVisibilityConverter}}" 
+                   TextAlignment="Right"
                    Margin="0 0 5 0" />
-        <!-- Value display -->
+
+        <!-- Value -->
         <TextBlock Grid.Column="1"
                    Text="{Binding DisplayValue, Mode=OneWay}"
                    HorizontalAlignment="Right"
@@ -35,6 +38,7 @@
                    Foreground="{DynamicResource MaterialDesignCheckBoxDisabled}"
                    Visibility="{Binding ShowNull, Converter={x:Static s:BoolToVisibilityConverter.Instance}, Mode=OneWay}" />
 
+        <!-- Affix -->
         <TextBlock Grid.Column="2" 
                    Text="{Binding PropertyDescription.Affix}"
                    Visibility="{Binding PropertyDescription.Affix, Converter={StaticResource NullToVisibilityConverter}}" 

src/Artemis.UI/DefaultTypes/DataModel/Display/SKColorDataModelDisplayView.xaml

@@ -5,6 +5,7 @@
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              xmlns:shared="clr-namespace:Artemis.UI.Shared;assembly=Artemis.UI.Shared"
              xmlns:display="clr-namespace:Artemis.UI.DefaultTypes.DataModel.Display"
+             xmlns:s="https://github.com/canton7/Stylet"
              mc:Ignorable="d"
              d:DesignHeight="450" d:DesignWidth="800"
              d:DataContext="{d:DesignInstance {x:Type display:SKColorDataModelDisplayViewModel}}">
@@ -15,25 +16,49 @@
             </ResourceDictionary.MergedDictionaries>
             <shared:ColorToStringConverter x:Key="SKColorToStringConverter" />
             <shared:SKColorToColorConverter x:Key="SKColorToColorConverter" />
+            <shared:NullToVisibilityConverter x:Key="NullToVisibilityConverter" />
         </ResourceDictionary>
     </UserControl.Resources>
-    <StackPanel Orientation="Horizontal" HorizontalAlignment="Right">
-        <TextBlock x:Name="HexDisplay"
-                   Text="{Binding DisplayValue, Converter={StaticResource SKColorToStringConverter}}"
-                   VerticalAlignment="Center"
-                   HorizontalAlignment="Stretch" />
-        <Border Width="{Binding ActualHeight, ElementName=HexDisplay}"
-                Height="{Binding ActualHeight, ElementName=HexDisplay}"
-                CornerRadius="{Binding ActualHeight, ElementName=HexDisplay}"
-                Margin="5 0 0 0"
-                VerticalAlignment="Center"
-                HorizontalAlignment="Right"
-                Background="{StaticResource Checkerboard}">
-            <Ellipse Stroke="{DynamicResource NormalBorderBrush}">
-                <Ellipse.Fill>
-                    <SolidColorBrush Color="{Binding DisplayValue, Converter={StaticResource SKColorToColorConverter}}" />
-                </Ellipse.Fill>
-            </Ellipse>
-        </Border>
-    </StackPanel>
+
+    <Grid>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="*" />
+            <ColumnDefinition Width="Auto"/>
+            <ColumnDefinition Width="Auto"/>
+        </Grid.ColumnDefinitions>
+
+        <!-- Prefix -->
+        <TextBlock Grid.Column="0" 
+                   Text="{Binding PropertyDescription.Prefix}"
+                   Visibility="{Binding PropertyDescription.Prefix, Converter={StaticResource NullToVisibilityConverter}}" 
+                   TextAlignment="Right"
+                   Margin="0 0 5 0" />
+
+        <!-- Value -->
+        <StackPanel Grid.Column="1" Orientation="Horizontal" HorizontalAlignment="Right">
+            <TextBlock x:Name="HexDisplay"
+                       Text="{Binding DisplayValue, Converter={StaticResource SKColorToStringConverter}}"
+                       VerticalAlignment="Center"
+                       HorizontalAlignment="Stretch" />
+            <Border Width="{Binding ActualHeight, ElementName=HexDisplay}"
+                    Height="{Binding ActualHeight, ElementName=HexDisplay}"
+                    CornerRadius="{Binding ActualHeight, ElementName=HexDisplay}"
+                    Margin="5 0 0 0"
+                    VerticalAlignment="Center"
+                    HorizontalAlignment="Right"
+                    Background="{StaticResource Checkerboard}">
+                <Ellipse Stroke="{DynamicResource NormalBorderBrush}">
+                    <Ellipse.Fill>
+                        <SolidColorBrush Color="{Binding DisplayValue, Converter={StaticResource SKColorToColorConverter}}" />
+                    </Ellipse.Fill>
+                </Ellipse>
+            </Border>
+        </StackPanel>
+
+        <!-- Affix -->
+        <TextBlock Grid.Column="2" 
+                   Text="{Binding PropertyDescription.Affix}"
+                   Visibility="{Binding PropertyDescription.Affix, Converter={StaticResource NullToVisibilityConverter}}" 
+                   Margin="5 0 0 0" />
+    </Grid>
 </UserControl>