Layer properties - Restored much functionality on the reworked VMs

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

@@ -9,10 +9,17 @@ namespace Artemis.Core.Models.Profile.LayerProperties
     /// </summary>
     public abstract class BaseLayerProperty
     {
+        private bool _keyframesEnabled;
+
         internal BaseLayerProperty()
         {
         }
 
+        /// <summary>
+        /// The layer this property applies to
+        /// </summary>
+        public Layer Layer { get; internal set; }
+
         /// <summary>
         ///     The parent group of this layer property, set after construction
         /// </summary>
@@ -21,13 +28,22 @@ namespace Artemis.Core.Models.Profile.LayerProperties
         /// <summary>
         ///     Gets whether keyframes are supported on this property
         /// </summary>
-        public bool KeyframesSupported { get; protected set; }
+        public bool KeyframesSupported { get; protected set; } = true;
 
         /// <summary>
         ///     Gets or sets whether keyframes are enabled on this property, has no effect if <see cref="KeyframesSupported" /> is
         ///     False
         /// </summary>
-        public bool KeyframesEnabled { get; set; }
+        public bool KeyframesEnabled
+        {
+            get => _keyframesEnabled;
+            set
+            {
+                if (_keyframesEnabled == value) return;
+                _keyframesEnabled = value;
+                OnKeyframesToggled();
+            }
+        }
 
         /// <summary>
         ///     Gets or sets whether the property is hidden in the UI
@@ -57,17 +73,73 @@ namespace Artemis.Core.Models.Profile.LayerProperties
         internal PropertyEntity PropertyEntity { get; set; }
         internal LayerPropertyGroup LayerPropertyGroup { get; set; }
 
+
         /// <summary>
         ///     Applies the provided property entity to the layer property by deserializing the JSON base value and keyframe values
         /// </summary>
         /// <param name="entity"></param>
         /// <param name="layerPropertyGroup"></param>
-        internal abstract void ApplyToLayerProperty(PropertyEntity entity, LayerPropertyGroup layerPropertyGroup);
+        /// <param name="fromStorage"></param>
+        internal abstract void ApplyToLayerProperty(PropertyEntity entity, LayerPropertyGroup layerPropertyGroup, bool fromStorage);
 
         /// <summary>
         ///     Saves the property to the underlying property entity that was configured when calling
         ///     <see cref="ApplyToLayerProperty" />
         /// </summary>
         internal abstract void ApplyToEntity();
+
+        #region Events
+
+        /// <summary>
+        ///     Occurs once every frame when the layer property is updated
+        /// </summary>
+        public event EventHandler Updated;
+
+        /// <summary>
+        ///     Occurs when the base value of the layer property was updated
+        /// </summary>
+        public event EventHandler BaseValueChanged;
+
+        /// <summary>
+        /// Occurs when keyframes are enabled/disabled
+        /// </summary>
+        public event EventHandler KeyframesToggled;
+
+        /// <summary>
+        ///     Occurs when a new keyframe was added to the layer property
+        /// </summary>
+        public event EventHandler KeyframeAdded;
+
+        /// <summary>
+        ///     Occurs when a keyframe was removed from the layer property
+        /// </summary>
+        public event EventHandler KeyframeRemoved;
+
+        protected virtual void OnUpdated()
+        {
+            Updated?.Invoke(this, EventArgs.Empty);
+        }
+
+        protected virtual void OnBaseValueChanged()
+        {
+            BaseValueChanged?.Invoke(this, EventArgs.Empty);
+        }
+
+        protected virtual void OnKeyframesToggled()
+        {
+            KeyframesToggled?.Invoke(this, EventArgs.Empty);
+        }
+
+        protected virtual void OnKeyframeAdded()
+        {
+            KeyframeAdded?.Invoke(this, EventArgs.Empty);
+        }
+
+        protected virtual void OnKeyframeRemoved()
+        {
+            KeyframeRemoved?.Invoke(this, EventArgs.Empty);
+        }
+
+        #endregion
     }
 }

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

@@ -180,12 +180,13 @@ namespace Artemis.Core.Models.Profile.LayerProperties
 
             // The current keyframe is the last keyframe before the current time
             CurrentKeyframe = _keyframes.LastOrDefault(k => k.Position <= TimelineProgress);
-            // The next keyframe is the first keyframe that's after the current time
-            NextKeyframe = _keyframes.FirstOrDefault(k => k.Position > TimelineProgress);
+            // Keyframes are sorted by position so we can safely assume the next keyframe's position is after the current 
+            var nextIndex = _keyframes.IndexOf(CurrentKeyframe) + 1;
+            NextKeyframe = _keyframes.Count > nextIndex ? _keyframes[nextIndex] : null;
 
             // No need to update the current value if either of the keyframes are null
             if (CurrentKeyframe == null)
-                CurrentValue = BaseValue;
+                CurrentValue = _keyframes.Any() ? _keyframes[0].Value : BaseValue;
             else if (NextKeyframe == null)
                 CurrentValue = CurrentKeyframe.Value;
             // Only determine progress and current value if both keyframes are present
@@ -218,7 +219,7 @@ namespace Artemis.Core.Models.Profile.LayerProperties
             _keyframes = _keyframes.OrderBy(k => k.Position).ToList();
         }
 
-        internal override void ApplyToLayerProperty(PropertyEntity entity, LayerPropertyGroup layerPropertyGroup)
+        internal override void ApplyToLayerProperty(PropertyEntity entity, LayerPropertyGroup layerPropertyGroup, bool fromStorage)
         {
             // Doubt this will happen but let's make sure
             if (_isInitialized)
@@ -231,8 +232,10 @@ namespace Artemis.Core.Models.Profile.LayerProperties
 
             try
             {
-                IsLoadedFromStorage = true;
-                BaseValue = JsonConvert.DeserializeObject<T>(entity.Value);
+                if (entity.Value != null)
+                    BaseValue = JsonConvert.DeserializeObject<T>(entity.Value);
+
+                IsLoadedFromStorage = fromStorage;
                 CurrentValue = BaseValue;
                 KeyframesEnabled = entity.KeyframesEnabled;
 
@@ -259,7 +262,7 @@ namespace Artemis.Core.Models.Profile.LayerProperties
 
         internal override void ApplyToEntity()
         {
-            if (_isInitialized)
+            if (!_isInitialized)
                 throw new ArtemisCoreException("Layer property is not yet initialized");
 
             PropertyEntity.Value = JsonConvert.SerializeObject(BaseValue);
@@ -272,49 +275,5 @@ namespace Artemis.Core.Models.Profile.LayerProperties
                 EasingFunction = (int) k.EasingFunction
             }));
         }
-
-        #region Events
-
-        /// <summary>
-        ///     Occurs once every frame when the layer property is updated
-        /// </summary>
-        public event EventHandler Updated;
-
-        /// <summary>
-        ///     Occurs when the base value of the layer property was updated
-        /// </summary>
-        public event EventHandler BaseValueChanged;
-
-        /// <summary>
-        ///     Occurs when a new keyframe was added to the layer property
-        /// </summary>
-        public event EventHandler KeyframeAdded;
-
-        /// <summary>
-        ///     Occurs when a keyframe was removed from the layer property
-        /// </summary>
-        public event EventHandler KeyframeRemoved;
-
-        protected virtual void OnUpdated()
-        {
-            Updated?.Invoke(this, EventArgs.Empty);
-        }
-
-        protected virtual void OnBaseValueChanged()
-        {
-            BaseValueChanged?.Invoke(this, EventArgs.Empty);
-        }
-
-        protected virtual void OnKeyframeAdded()
-        {
-            KeyframeAdded?.Invoke(this, EventArgs.Empty);
-        }
-
-        protected virtual void OnKeyframeRemoved()
-        {
-            KeyframeRemoved?.Invoke(this, EventArgs.Empty);
-        }
-
-        #endregion
     }
 }