Merge branch 'master' into RGB.NET_update

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

@@ -11,9 +11,8 @@ namespace Artemis.Core
     public class DataModelConditionEvent : DataModelConditionPart
     {
         private bool _disposed;
-        private IDataModelEvent? _event;
-        private bool _eventTriggered;
         private bool _reinitializing;
+        private DateTime _lastTrigger;
 
         /// <summary>
         ///     Creates a new instance of the <see cref="DataModelConditionEvent" /> class
@@ -53,22 +52,21 @@ namespace Artemis.Core
             if (_disposed)
                 throw new ObjectDisposedException("DataModelConditionEvent");
 
-            // Ensure the event has not been replaced
-            if (EventPath?.GetValue() is IDataModelEvent dataModelEvent && _event != dataModelEvent)
-                SubscribeToDataModelEvent(dataModelEvent);
-
-            // Only evaluate to true once every time the event has been triggered
-            if (!_eventTriggered)
+            if (EventPath?.GetValue() is not IDataModelEvent dataModelEvent) 
+                return false;
+            // Only evaluate to true once every time the event has been triggered since the last evaluation
+            if (dataModelEvent.LastTrigger <= _lastTrigger)
                 return false;
 
-            _eventTriggered = false;
+            _lastTrigger = DateTime.Now;
 
             // If there is a child (root group), it must evaluate to true whenever the event triggered
             if (Children.Any())
-                return Children[0].EvaluateObject(_event?.LastEventArgumentsUntyped);
+                return Children[0].EvaluateObject(dataModelEvent.LastEventArgumentsUntyped);
 
             // If there are no children, we always evaluate to true whenever the event triggered
             return true;
+
         }
 
         /// <summary>
@@ -132,7 +130,7 @@ namespace Artemis.Core
             // Target list
             EventPath?.Save();
             Entity.EventPath = EventPath?.Entity;
-
+            
             // Children
             Entity.Children.Clear();
             Entity.Children.AddRange(Children.Select(c => c.GetEntity()));
@@ -172,16 +170,9 @@ namespace Artemis.Core
                 Entity.Children.Clear();
                 AddChild(new DataModelConditionGroup(this));
             }
-        }
 
-        private void SubscribeToDataModelEvent(IDataModelEvent dataModelEvent)
-        {
-            if (_event != null)
-                _event.EventTriggered -= OnEventTriggered;
-
-            _event = dataModelEvent;
-            if (_event != null)
-                _event.EventTriggered += OnEventTriggered;
+            if (EventPath?.GetValue() is IDataModelEvent dataModelEvent) 
+                _lastTrigger = dataModelEvent.LastTrigger;
         }
 
         private Type? GetEventArgumentType()
@@ -212,11 +203,6 @@ namespace Artemis.Core
 
         #region Event handlers
 
-        private void OnEventTriggered(object? sender, EventArgs e)
-        {
-            _eventTriggered = true;
-        }
-
         private void EventPathOnPathValidated(object? sender, EventArgs e)
         {
             if (_reinitializing)

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

@@ -97,7 +97,7 @@ namespace Artemis.Core
         /// </summary>
         public Type? GetTargetType()
         {
-            return Registration?.PropertyExpression.ReturnType;
+            return Registration?.Getter.Method.ReturnType;
         }
 
         private void ResetEasing(TProperty value)
@@ -272,7 +272,7 @@ namespace Artemis.Core
                 throw new ObjectDisposedException("DataBinding");
 
             // General
-            DataBindingRegistration<TLayerProperty, TProperty>? registration = LayerProperty.GetDataBindingRegistration<TProperty>(Entity.TargetExpression);
+            DataBindingRegistration<TLayerProperty, TProperty>? registration = LayerProperty.GetDataBindingRegistration<TProperty>(Entity.Identifier);
             if (registration != null)
                 ApplyRegistration(registration);
 
@@ -293,7 +293,7 @@ namespace Artemis.Core
 
             // Don't save an invalid state
             if (Registration != null)
-                Entity.TargetExpression = Registration.PropertyExpression.ToString();
+                Entity.Identifier = Registration.DisplayName;
 
             Entity.EasingTime = EasingTime;
             Entity.EasingFunction = (int) EasingFunction;

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

@@ -1,6 +1,4 @@
 using System;
-using System.Linq.Expressions;
-using System.Reflection;
 
 namespace Artemis.Core
 {
@@ -10,21 +8,6 @@ namespace Artemis.Core
     /// </summary>
     public abstract class DataBindingConverter<TLayerProperty, TProperty> : IDataBindingConverter
     {
-        /// <summary>
-        ///     Gets a dynamically compiled getter pointing to the data bound property
-        /// </summary>
-        public Func<TLayerProperty, TProperty>? GetExpression { get; private set; }
-
-        /// <summary>
-        ///     Gets a dynamically compiled setter pointing to the data bound property used for value types
-        /// </summary>
-        public Action<TProperty>? ValueTypeSetExpression { get; private set; }
-
-        /// <summary>
-        ///     Gets a dynamically compiled setter pointing to the data bound property used for reference types
-        /// </summary>
-        public Action<TLayerProperty, TProperty>? ReferenceTypeSetExpression { get; private set; }
-
         /// <summary>
         ///     Gets the data binding this converter is applied to
         /// </summary>
@@ -40,9 +23,6 @@ namespace Artemis.Core
         /// </summary>
         public bool SupportsInterpolate { get; protected set; }
 
-        /// <inheritdoc />
-        public Type SupportedType => typeof(TProperty);
-
         /// <summary>
         ///     Returns the sum of <paramref name="a" /> and <paramref name="b" />
         /// </summary>
@@ -65,12 +45,9 @@ namespace Artemis.Core
         /// <param name="value"></param>
         public virtual void ApplyValue(TProperty value)
         {
-            if (DataBinding == null)
+            if (DataBinding?.Registration == null)
                 throw new ArtemisCoreException("Data binding converter is not yet initialized");
-            if (ReferenceTypeSetExpression != null)
-                ReferenceTypeSetExpression(DataBinding.LayerProperty.CurrentValue, value);
-            else if (ValueTypeSetExpression != null)
-                ValueTypeSetExpression(value);
+            DataBinding.Registration.Setter(value);
         }
 
         /// <summary>
@@ -78,9 +55,9 @@ namespace Artemis.Core
         /// </summary>
         public virtual TProperty GetValue()
         {
-            if (DataBinding == null || GetExpression == null)
+            if (DataBinding?.Registration == null)
                 throw new ArtemisCoreException("Data binding converter is not yet initialized");
-            return GetExpression(DataBinding.LayerProperty.CurrentValue);
+            return DataBinding.Registration.Getter();
         }
 
         /// <summary>
@@ -104,83 +81,10 @@ namespace Artemis.Core
                 throw new ArtemisCoreException("Cannot initialize a data binding converter for a data binding without a registration");
 
             DataBinding = dataBinding;
-            GetExpression = dataBinding.Registration.PropertyExpression.Compile();
-            CreateSetExpression();
-
             OnInitialized();
         }
 
-        private void CreateSetExpression()
-        {
-            // If the registration does not point towards a member of LayerProperty<T>.CurrentValue, assign directly to LayerProperty<T>.CurrentValue
-            if (DataBinding!.Registration?.Member == null)
-            {
-                CreateSetCurrentValueExpression();
-                return;
-            }
-
-            // Ensure the member of LayerProperty<T>.CurrentValue has a setter
-            MethodInfo? setterMethod = null;
-            if (DataBinding.Registration.Member is PropertyInfo propertyInfo)
-                setterMethod = propertyInfo.GetSetMethod();
-            // If there is no setter, the built-in data binding cannot do its job, stay null
-            if (setterMethod == null)
-                return;
-
-            // If LayerProperty<T>.CurrentValue is a value type, assign it directly to LayerProperty<T>.CurrentValue after applying the changes
-            if (typeof(TLayerProperty).IsValueType)
-                CreateSetValueTypeExpression();
-            // If it is a reference type it can safely be updated by its reference
-            else
-                CreateSetReferenceTypeExpression();
-        }
-
-        private void CreateSetReferenceTypeExpression()
-        {
-            if (DataBinding!.Registration?.Member == null)
-                throw new ArtemisCoreException("Cannot create value setter for data binding without a registration");
-
-            ParameterExpression propertyValue = Expression.Parameter(typeof(TProperty), "propertyValue");
-            ParameterExpression parameter = Expression.Parameter(typeof(TLayerProperty), "currentValue");
-            MemberExpression memberAccess = Expression.MakeMemberAccess(parameter, DataBinding.Registration.Member);
-            BinaryExpression assignment = Expression.Assign(memberAccess, propertyValue);
-            Expression<Action<TLayerProperty, TProperty>> referenceTypeLambda = Expression.Lambda<Action<TLayerProperty, TProperty>>(assignment, parameter, propertyValue);
-
-            ReferenceTypeSetExpression = referenceTypeLambda.Compile();
-        }
-
-        private void CreateSetValueTypeExpression()
-        {
-            if (DataBinding!.Registration?.Member == null)
-                throw new ArtemisCoreException("Cannot create value setter for data binding without a registration");
-
-            ParameterExpression propertyValue = Expression.Parameter(typeof(TProperty), "propertyValue");
-            ParameterExpression variableCurrent = Expression.Variable(typeof(TLayerProperty), "current");
-            ConstantExpression layerProperty = Expression.Constant(DataBinding.LayerProperty);
-            MemberExpression layerPropertyMemberAccess = Expression.MakeMemberAccess(layerProperty,
-                DataBinding.LayerProperty.GetType().GetMember(nameof(DataBinding.LayerProperty.CurrentValue))[0]);
-
-            BlockExpression body = Expression.Block(
-                new[] {variableCurrent},
-                Expression.Assign(variableCurrent, layerPropertyMemberAccess),
-                Expression.Assign(Expression.MakeMemberAccess(variableCurrent, DataBinding.Registration.Member), propertyValue),
-                Expression.Assign(layerPropertyMemberAccess, variableCurrent)
-            );
-
-            Expression<Action<TProperty>> valueTypeLambda = Expression.Lambda<Action<TProperty>>(body, propertyValue);
-            ValueTypeSetExpression = valueTypeLambda.Compile();
-        }
-
-        private void CreateSetCurrentValueExpression()
-        {
-            ParameterExpression propertyValue = Expression.Parameter(typeof(TProperty), "propertyValue");
-            ConstantExpression layerProperty = Expression.Constant(DataBinding!.LayerProperty);
-            MemberExpression layerPropertyMemberAccess = Expression.MakeMemberAccess(layerProperty,
-                DataBinding.LayerProperty.GetType().GetMember(nameof(DataBinding.LayerProperty.CurrentValue))[0]);
-
-            BinaryExpression body = Expression.Assign(layerPropertyMemberAccess, propertyValue);
-            Expression<Action<TProperty>> lambda = Expression.Lambda<Action<TProperty>>(body, propertyValue);
-            ValueTypeSetExpression = lambda.Compile();
-        }
+        /// <inheritdoc />
+        public Type SupportedType => typeof(TProperty);
     }
 }

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

@@ -1,7 +1,5 @@
 using System;
 using System.Linq;
-using System.Linq.Expressions;
-using System.Reflection;
 using Artemis.Storage.Entities.Profile.DataBindings;
 
 namespace Artemis.Core
@@ -9,16 +7,14 @@ namespace Artemis.Core
     /// <inheritdoc />
     public class DataBindingRegistration<TLayerProperty, TProperty> : IDataBindingRegistration
     {
-        internal DataBindingRegistration(LayerProperty<TLayerProperty> layerProperty,
-            DataBindingConverter<TLayerProperty, TProperty> converter,
-            Expression<Func<TLayerProperty, TProperty>> propertyExpression)
+        internal DataBindingRegistration(LayerProperty<TLayerProperty> layerProperty, DataBindingConverter<TLayerProperty, TProperty> converter,
+            Func<TProperty> getter, Action<TProperty> setter, string displayName)
         {
             LayerProperty = layerProperty ?? throw new ArgumentNullException(nameof(layerProperty));
             Converter = converter ?? throw new ArgumentNullException(nameof(converter));
-            PropertyExpression = propertyExpression ?? throw new ArgumentNullException(nameof(propertyExpression));
-
-            if (propertyExpression.Body is MemberExpression memberExpression)
-                Member = memberExpression.Member;
+            Getter = getter ?? throw new ArgumentNullException(nameof(getter));
+            Setter = setter ?? throw new ArgumentNullException(nameof(setter));
+            DisplayName = displayName ?? throw new ArgumentNullException(nameof(displayName));
         }
 
         /// <summary>
@@ -32,15 +28,17 @@ namespace Artemis.Core
         public DataBindingConverter<TLayerProperty, TProperty> Converter { get; }
 
         /// <summary>
-        ///     Gets the expression that that accesses the property
+        ///     Gets the function to call to get the value of the property
         /// </summary>
-        public Expression<Func<TLayerProperty, TProperty>> PropertyExpression { get; }
+        public Func<TProperty> Getter { get; }
 
         /// <summary>
-        ///     Gets the member the <see cref="PropertyExpression" /> targets
-        ///     <para><see langword="null"/> if the <see cref="PropertyExpression" /> is not a member expression</para>
+        ///     Gets the action to call to set the value of the property
         /// </summary>
-        public MemberInfo? Member { get; }
+        public Action<TProperty> Setter { get; }
+
+        /// <inheritdoc />
+        public string DisplayName { get; }
 
         /// <summary>
         ///     Gets the data binding created using this registration
@@ -59,7 +57,7 @@ namespace Artemis.Core
             if (DataBinding != null)
                 return DataBinding;
 
-            DataBindingEntity? dataBinding = LayerProperty.Entity.DataBindingEntities.FirstOrDefault(e => e.TargetExpression == PropertyExpression.ToString());
+            DataBindingEntity? dataBinding = LayerProperty.Entity.DataBindingEntities.FirstOrDefault(e => e.Identifier == DisplayName);
             if (dataBinding == null)
                 return null;
 

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

@@ -5,6 +5,11 @@
     /// </summary>
     public interface IDataBindingRegistration
     {
+        /// <summary>
+        ///     Gets or sets the display name of the data binding registration
+        /// </summary>
+        string DisplayName { get; }
+
         /// <summary>
         ///     Returns the data binding applied using this registration
         /// </summary>

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

@@ -213,9 +213,25 @@ namespace Artemis.Core
             Expression? expression = Expression.Convert(parameter, Target.GetType());
             Expression? nullCondition = null;
 
+            MethodInfo equals = typeof(object).GetMethod("Equals", BindingFlags.Static | BindingFlags.Public)!;
             foreach (DataModelPathSegment segment in _segments)
             {
-                BinaryExpression notNull = Expression.NotEqual(expression, Expression.Default(expression.Type));
+                BinaryExpression notNull;
+                try
+                {
+                    notNull = Expression.NotEqual(expression, Expression.Default(expression.Type));
+                }
+                catch (InvalidOperationException)
+                {
+                    notNull = Expression.NotEqual(
+                        Expression.Call(
+                            null,
+                            equals,
+                            Expression.Convert(expression, typeof(object)),
+                            Expression.Convert(Expression.Default(expression.Type), typeof(object))),
+                        Expression.Constant(true));
+                }
+
                 nullCondition = nullCondition != null ? Expression.AndAlso(nullCondition, notNull) : notNull;
                 expression = segment.Initialize(parameter, expression, nullCondition);
                 if (expression == null)

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

@@ -97,6 +97,16 @@ namespace Artemis.Core
         /// </summary>
         public event EventHandler<LayerPropertyEventArgs>? KeyframeRemoved;
 
+        /// <summary>
+        ///     Occurs when a data binding property has been added
+        /// </summary>
+        public event EventHandler<LayerPropertyEventArgs>? DataBindingPropertyRegistered;
+
+        /// <summary>
+        ///     Occurs when all data binding properties have been removed
+        /// </summary>
+        public event EventHandler<LayerPropertyEventArgs>? DataBindingPropertiesCleared;
+
         /// <summary>
         ///     Occurs when a data binding has been enabled
         /// </summary>

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

@@ -379,21 +379,16 @@ namespace Artemis.Core
         public bool HasDataBinding => GetAllDataBindingRegistrations().Any(r => r.GetDataBinding() != null);
 
         /// <summary>
-        ///     Gets a data binding registration by the expression used to register it
+        ///     Gets a data binding registration by the display name used to register it
         ///     <para>Note: The expression must exactly match the one used to register the data binding</para>
         /// </summary>
-        public DataBindingRegistration<T, TProperty>? GetDataBindingRegistration<TProperty>(Expression<Func<T, TProperty>> propertyExpression)
-        {
-            return GetDataBindingRegistration<TProperty>(propertyExpression.ToString());
-        }
-
-        internal DataBindingRegistration<T, TProperty>? GetDataBindingRegistration<TProperty>(string expression)
+        public DataBindingRegistration<T, TProperty>? GetDataBindingRegistration<TProperty>(string identifier)
         {
             if (_disposed)
                 throw new ObjectDisposedException("LayerProperty");
 
             IDataBindingRegistration? match = _dataBindingRegistrations.FirstOrDefault(r => r is DataBindingRegistration<T, TProperty> registration &&
-                                                                                            registration.PropertyExpression.ToString() == expression);
+                                                                                            registration.DisplayName == identifier);
             return (DataBindingRegistration<T, TProperty>?) match;
         }
 
@@ -410,21 +405,35 @@ namespace Artemis.Core
         ///     Registers a data binding property so that is available to the data binding system
         /// </summary>
         /// <typeparam name="TProperty">The type of the layer property</typeparam>
-        /// <param name="propertyExpression">The expression pointing to the value to register</param>
+        /// <param name="getter">The function to call to get the value of the property</param>
+        /// <param name="setter">The action to call to set the value of the property</param>
         /// <param name="converter">The converter to use while applying the data binding</param>
-        public void RegisterDataBindingProperty<TProperty>(Expression<Func<T, TProperty>> propertyExpression, DataBindingConverter<T, TProperty> converter)
+        /// <param name="displayName">The display name of the data binding property</param>
+        public DataBindingRegistration<T, TProperty> RegisterDataBindingProperty<TProperty>(Func<TProperty> getter, Action<TProperty> setter, DataBindingConverter<T, TProperty> converter,
+            string displayName)
+        {
+            if (_disposed)
+                throw new ObjectDisposedException("LayerProperty");
+            if (_dataBindingRegistrations.Any(d => d.DisplayName == displayName))
+                throw new ArtemisCoreException($"A databinding property named '{displayName}' is already registered.");
+
+            DataBindingRegistration<T, TProperty> registration = new(this, converter, getter, setter, displayName);
+            _dataBindingRegistrations.Add(registration);
+
+            OnDataBindingPropertyRegistered();
+            return registration;
+        }
+
+        /// <summary>
+        ///     Removes all data binding properties so they are no longer available to the data binding system
+        /// </summary>
+        public void ClearDataBindingProperties()
         {
             if (_disposed)
                 throw new ObjectDisposedException("LayerProperty");
 
-            if (propertyExpression.Body.NodeType != ExpressionType.MemberAccess && propertyExpression.Body.NodeType != ExpressionType.Parameter)
-                throw new ArtemisCoreException("Provided expression is invalid, it must be 'value => value' or 'value => value.Property'");
-
-            if (converter.SupportedType != propertyExpression.ReturnType)
-                throw new ArtemisCoreException($"Cannot register data binding property for property {PropertyDescription.Name} " +
-                                               "because the provided converter does not support the property's type");
-
-            _dataBindingRegistrations.Add(new DataBindingRegistration<T, TProperty>(this, converter, propertyExpression));
+            _dataBindingRegistrations.Clear();
+            OnDataBindingPropertiesCleared();
         }
 
         /// <summary>
@@ -661,6 +670,12 @@ namespace Artemis.Core
         /// <inheritdoc />
         public event EventHandler<LayerPropertyEventArgs>? KeyframeRemoved;
 
+        /// <inheritdoc />
+        public event EventHandler<LayerPropertyEventArgs>? DataBindingPropertyRegistered;
+        
+        /// <inheritdoc />
+        public event EventHandler<LayerPropertyEventArgs>? DataBindingPropertiesCleared;
+
         /// <inheritdoc />
         public event EventHandler<LayerPropertyEventArgs>? DataBindingEnabled;
 
@@ -716,6 +731,22 @@ namespace Artemis.Core
             KeyframeRemoved?.Invoke(this, new LayerPropertyEventArgs(this));
         }
 
+        /// <summary>
+        ///     Invokes the <see cref="DataBindingPropertyRegistered" /> event
+        /// </summary>
+        protected virtual void OnDataBindingPropertyRegistered()
+        {
+            DataBindingPropertyRegistered?.Invoke(this, new LayerPropertyEventArgs(this));
+        }
+
+        /// <summary>
+        ///     Invokes the <see cref="DataBindingDisabled" /> event
+        /// </summary>
+        protected virtual void OnDataBindingPropertiesCleared()
+        {
+            DataBindingPropertiesCleared?.Invoke(this, new LayerPropertyEventArgs(this));
+        }
+
         /// <summary>
         ///     Invokes the <see cref="DataBindingEnabled" /> event
         /// </summary>