v2.20.2v2.20.2

- **(Fix) Layers:**
   - Round properties before comparing to avoid the precision error
   - Prevent 'Wait time' properties from having negative values
   - The `RetractSpeed` or `RetractSpeed2` property wasn't setting the bottom speed for bottom layers, instead the normal retract speed was always used
   - Set the `RetractHeight2` or `RetractSpeed2` property was not notifing the timer to update the print time no
   - Propagate global settings to layers now identfies the bottom layers per height instead of layer index
- (Add) UVJ: Support TSMC for the file format
- (Fix) UVJ: Soft save was not updating the layer settings
- (Fix) CTB: TSMC not working properly due incorrect layer `LiftHeight` value calculation

15 files changed, 327 insertions, 151 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 56c9ea8..869dec1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,17 @@
 # Changelog
 
+## 27/08/2021 - v2.20.2
+
+- **(Fix) Layers:**
+   - Round properties before comparing to avoid the precision error
+   - Prevent 'Wait time' properties from having negative values
+   - The `RetractSpeed` or `RetractSpeed2` property wasn't setting the bottom speed for bottom layers, instead the normal retract speed was always used
+   - Set the `RetractHeight2` or `RetractSpeed2` property was not notifing the timer to update the print time no
+   - Propagate global settings to layers now identfies the bottom layers per height instead of layer index
+- (Add) UVJ: Support TSMC for the file format
+- (Fix) UVJ: Soft save was not updating the layer settings
+- (Fix) CTB: TSMC not working properly due incorrect layer `LiftHeight` value calculation
+
 ## 26/08/2021 - v2.20.1
 
 - **UI:**
diff --git a/Scripts/010 Editor/ctb_decrypted.bt b/Scripts/010 Editor/ctb_decrypted.bt
index f144886..b721b1b 100644
--- a/Scripts/010 Editor/ctb_decrypted.bt
+++ b/Scripts/010 Editor/ctb_decrypted.bt
@@ -31,8 +31,8 @@ struct DECRYPTED_HEADER {
     float DisplayWidth;
     float DisplayHeight;
     float MachineZ;
-    uint Padding1;
-	uint Padding2;
+    uint Unknown1;
+	uint Unknown2;
     float TotalHeightMilimeter;
     float LayerHeight;
     float ExposureTime;
@@ -55,7 +55,7 @@ struct DECRYPTED_HEADER {
     float ModelWeight;
     float Cost;
     float BottomLightOffDelay;
-    uint unknown9;
+    uint Unknown3;
     ushort LightPWM; /* these might be in the wrong order */
     ushort BottomLightPWM;
     uint LayerXorKey;
@@ -68,12 +68,12 @@ struct DECRYPTED_HEADER {
     float RestTimeAfterLift;
     uint PrinterNameOffset;
     uint PrinterNameSize;
-    uint unknown12;
-    uint unknown13;
-    uint unknown14;
+    uint Unknown4;
+    uint unknown5;
+    uint unknown6;
     float RestTimeAfterRetract;
     float RestTimeAfterLift;
-    uint unknown15;
+    uint TransitionLayerCount;
     float BottomRetractSpeed;
     float BottomRetractSpeed2;
     uint Padding1;
@@ -84,17 +84,20 @@ struct DECRYPTED_HEADER {
     float RestTimeAfterLift;
     float RestTimeBeforeLift;
     float BottomRetractHeight;
-    float unknown23;
-    uint unknown24;
-    uint unknown25;
+    float unknown7;
+    uint unknown8;
+    uint unknown9;
     uint LastLayerIndex;
-    uint unknown26[4];
-    uint DisclaimerOffset;
-    uint DisclaimerSize;
     uint Padding3;
     uint Padding4;
     uint Padding5;
     uint Padding6;
+    uint DisclaimerOffset;
+    uint DisclaimerSize;
+    uint Padding7;
+    uint Padding8;
+    uint Padding9;
+    uint Padding10;
 };
 
 
diff --git a/UVtools.Core/FileFormats/CTBEncryptedFile.cs b/UVtools.Core/FileFormats/CTBEncryptedFile.cs
index 5d6570d..667eea4 100644
--- a/UVtools.Core/FileFormats/CTBEncryptedFile.cs
+++ b/UVtools.Core/FileFormats/CTBEncryptedFile.cs
@@ -25,8 +25,9 @@ namespace UVtools.Core.FileFormats
         public const ushort RLE16EncodingLimit = 0xFFF;
         public const ushort RLEEncryptedMinimumLength = 512;
 
-        public const uint PERLAYER_SETTINGS_DISALLOW = 7; // 7 (This disallow per layer settings and follow global table only)
-        public const uint PERLAYER_SETTINGS_ALLOW    = 0x5000000F; // 1342177295 (This allow per layer settings)
+        public const uint PERLAYER_SETTINGS_DISALLOW_NO_AA = 7; // 7 (This disallow per layer settings and follow global table only) No AA
+        public const uint PERLAYER_SETTINGS_DISALLOW       = 15; // 15 (This disallow per layer settings and follow global table only) with AA
+        public const uint PERLAYER_SETTINGS_ALLOW          = 0x5000000F; // 1342177295 (This allow per layer settings)
 
         private const string CTB_DISCLAIMER = "Layout and record format for the ctb and cbddlp file types are the copyrighted programs or codes of CBD Technology (China) Inc..The Customer or User shall not in any manner reproduce, distribute, modify, decompile, disassemble, decrypt, extract, reverse engineer, lease, assign, or sublicense the said programs or codes.";
         private const ushort CTB_DISCLAIMER_SIZE = 320;
@@ -60,7 +61,7 @@ namespace UVtools.Core.FileFormats
             [FieldOrder(9)] public ushort Unknown5 { get; set; } = 1; // set to 1
             [FieldOrder(10)] public uint Unknown6 { get; set; } // set to 0
             [FieldOrder(11)] public uint Unknown7 { get; set; } = 42; // probably 0x2A
-            [FieldOrder(12)] public uint Unknown8 { get; set; } // probably 0
+            [FieldOrder(12)] public uint Unknown8 { get; set; } // probably 0 or 1
 
             public override string ToString()
             {
@@ -106,7 +107,7 @@ namespace UVtools.Core.FileFormats
             [FieldOrder(26)] public float MaterialGrams { get; set; }
             [FieldOrder(27)] public float MaterialCost { get; set; }
             [FieldOrder(28)] public float BottomLightOffDelay { get; set; }
-            [FieldOrder(29)] public uint Unknown9 { get; set; } = 1;
+            [FieldOrder(29)] public uint Unknown3 { get; set; } = 1;
             [FieldOrder(30)] public ushort LightPWM { get; set; }
             [FieldOrder(31)] public ushort BottomLightPWM { get; set; }
             [FieldOrder(32)] public uint LayerXorKey { get; set; }
@@ -120,11 +121,11 @@ namespace UVtools.Core.FileFormats
             [FieldOrder(40)] public uint MachineNameOffset { get; set; }
             [FieldOrder(41)] public uint MachineNameSize { get; set; }
             [FieldOrder(42)] public uint PerLayerSettings { get; set; } = PERLAYER_SETTINGS_DISALLOW;
-            [FieldOrder(43)] public uint Unknown13 { get; set; }
-            [FieldOrder(44)] public uint Unknown14 { get; set; } = 8;
+            [FieldOrder(43)] public uint Unknown4 { get; set; }
+            [FieldOrder(44)] public uint Unknown5 { get; set; } = 8; // Also 1
             [FieldOrder(45)] public float RestTimeAfterRetract { get; set; }
             [FieldOrder(46)] public float RestTimeAfterLift2 { get; set; }
-            [FieldOrder(47)] public uint Unknown15 { get; set; }
+            [FieldOrder(47)] public uint TransitionLayerCount { get; set; }
             [FieldOrder(48)] public float BottomRetractSpeed { get; set; }
             [FieldOrder(49)] public float BottomRetractSpeed2 { get; set; }
             [FieldOrder(50)] public uint Padding1 { get; set; }
@@ -135,9 +136,9 @@ namespace UVtools.Core.FileFormats
             [FieldOrder(55)] public float RestTimeAfterLift3 { get; set; }
             [FieldOrder(56)] public float RestTimeBeforeLift { get; set; }
             [FieldOrder(57)] public float BottomRetractHeight2 { get; set; }
-            [FieldOrder(58)] public float Unknown23 { get; set; } // Same as CTBv4.PrintParametersV4.Unknown1)
-            [FieldOrder(59)] public uint Unknown24 { get; set; } //  Same as  CTBv4.PrintParametersV4.Unknown2)
-            [FieldOrder(60)] public uint Unknown25 { get; set; } = 4; // Same as CTBv4.PrintParametersV4.Unknown3)
+            [FieldOrder(58)] public float Unknown6 { get; set; } // Same as CTBv4.PrintParametersV4.Unknown1)
+            [FieldOrder(59)] public uint Unknown7 { get; set; } //  Same as  CTBv4.PrintParametersV4.Unknown2)
+            [FieldOrder(60)] public uint Unknown8 { get; set; } = 4; // Same as CTBv4.PrintParametersV4.Unknown3)
             [FieldOrder(61)] public uint LastLayerIndex { get; set; }
             [FieldOrder(62)] public uint Padding3 { get; set; }
             [FieldOrder(63)] public uint Padding4 { get; set; }
@@ -163,7 +164,7 @@ namespace UVtools.Core.FileFormats
 
             public override string ToString()
             {
-                return $"{nameof(Unknown15)}: {Unknown15}, {nameof(ChecksumValue)}: {ChecksumValue}, {nameof(LayerPointersOffset)}: {LayerPointersOffset}, {nameof(DisplayWidth)}: {DisplayWidth}, {nameof(DisplayHeight)}: {DisplayHeight}, {nameof(MachineZ)}: {MachineZ}, {nameof(Unknown1)}: {Unknown1}, {nameof(Unknown2)}: {Unknown2}, {nameof(TotalHeightMillimeter)}: {TotalHeightMillimeter}, {nameof(LayerHeight)}: {LayerHeight}, {nameof(ExposureTime)}: {ExposureTime}, {nameof(BottomExposureTime)}: {BottomExposureTime}, {nameof(LightOffDelay)}: {LightOffDelay}, {nameof(BottomLayerCount)}: {BottomLayerCount}, {nameof(ResolutionX)}: {ResolutionX}, {nameof(ResolutionY)}: {ResolutionY}, {nameof(LayerCount)}: {LayerCount}, {nameof(LargePreviewOffset)}: {LargePreviewOffset}, {nameof(SmallPreviewOffset)}: {SmallPreviewOffset}, {nameof(PrintTime)}: {PrintTime}, {nameof(ProjectorType)}: {ProjectorType}, {nameof(BottomLiftHeight)}: {BottomLiftHeight}, {nameof(BottomLiftSpeed)}: {BottomLiftSpeed}, {nameof(LiftHeight)}: {LiftHeight}, {nameof(LiftSpeed)}: {LiftSpeed}, {nameof(RetractSpeed)}: {RetractSpeed}, {nameof(MaterialMilliliters)}: {MaterialMilliliters}, {nameof(MaterialGrams)}: {MaterialGrams}, {nameof(MaterialCost)}: {MaterialCost}, {nameof(BottomLightOffDelay)}: {BottomLightOffDelay}, {nameof(Unknown9)}: {Unknown9}, {nameof(LightPWM)}: {LightPWM}, {nameof(BottomLightPWM)}: {BottomLightPWM}, {nameof(LayerXorKey)}: {LayerXorKey}, {nameof(BottomLiftHeight2)}: {BottomLiftHeight2}, {nameof(BottomLiftSpeed2)}: {BottomLiftSpeed2}, {nameof(LiftHeight2)}: {LiftHeight2}, {nameof(LiftSpeed2)}: {LiftSpeed2}, {nameof(RetractHeight2)}: {RetractHeight2}, {nameof(RetractSpeed2)}: {RetractSpeed2}, {nameof(RestTimeAfterLift)}: {RestTimeAfterLift}, {nameof(MachineNameOffset)}: {MachineNameOffset}, {nameof(MachineNameSize)}: {MachineNameSize}, {nameof(PerLayerSettings)}: {PerLayerSettings}, {nameof(Unknown13)}: {Unknown13}, {nameof(Unknown14)}: {Unknown14}, {nameof(RestTimeAfterRetract)}: {RestTimeAfterRetract}, {nameof(RestTimeAfterLift2)}: {RestTimeAfterLift2}, {nameof(BottomRetractSpeed)}: {BottomRetractSpeed}, {nameof(BottomRetractSpeed2)}: {BottomRetractSpeed2}, {nameof(Four1)}: {Four1}, {nameof(Padding1)}: {Padding1}, {nameof(Four2)}: {Four2}, {nameof(Padding2)}: {Padding2}, {nameof(RestTimeAfterRetract2)}: {RestTimeAfterRetract2}, {nameof(RestTimeAfterLift3)}: {RestTimeAfterLift3}, {nameof(RestTimeBeforeLift)}: {RestTimeBeforeLift}, {nameof(BottomRetractHeight2)}: {BottomRetractHeight2}, {nameof(Unknown23)}: {Unknown23}, {nameof(Unknown24)}: {Unknown24}, {nameof(Unknown25)}: {Unknown25}, {nameof(LastLayerIndex)}: {LastLayerIndex}, {nameof(Padding3)}: {Padding3}, {nameof(Padding4)}: {Padding4}, {nameof(Padding5)}: {Padding5}, {nameof(Padding6)}: {Padding6}, {nameof(DisclaimerOffset)}: {DisclaimerOffset}, {nameof(DisclaimerSize)}: {DisclaimerSize}, {nameof(Padding7)}: {Padding7}, {nameof(Padding8)}: {Padding8}, {nameof(Padding9)}: {Padding9}, {nameof(Padding10)}: {Padding10}, {nameof(MachineName)}: {MachineName}";
+                return $"{nameof(ChecksumValue)}: {ChecksumValue}, {nameof(LayerPointersOffset)}: {LayerPointersOffset}, {nameof(DisplayWidth)}: {DisplayWidth}, {nameof(DisplayHeight)}: {DisplayHeight}, {nameof(MachineZ)}: {MachineZ}, {nameof(Unknown1)}: {Unknown1}, {nameof(Unknown2)}: {Unknown2}, {nameof(TotalHeightMillimeter)}: {TotalHeightMillimeter}, {nameof(LayerHeight)}: {LayerHeight}, {nameof(ExposureTime)}: {ExposureTime}, {nameof(BottomExposureTime)}: {BottomExposureTime}, {nameof(LightOffDelay)}: {LightOffDelay}, {nameof(BottomLayerCount)}: {BottomLayerCount}, {nameof(ResolutionX)}: {ResolutionX}, {nameof(ResolutionY)}: {ResolutionY}, {nameof(LayerCount)}: {LayerCount}, {nameof(LargePreviewOffset)}: {LargePreviewOffset}, {nameof(SmallPreviewOffset)}: {SmallPreviewOffset}, {nameof(PrintTime)}: {PrintTime}, {nameof(ProjectorType)}: {ProjectorType}, {nameof(BottomLiftHeight)}: {BottomLiftHeight}, {nameof(BottomLiftSpeed)}: {BottomLiftSpeed}, {nameof(LiftHeight)}: {LiftHeight}, {nameof(LiftSpeed)}: {LiftSpeed}, {nameof(RetractSpeed)}: {RetractSpeed}, {nameof(MaterialMilliliters)}: {MaterialMilliliters}, {nameof(MaterialGrams)}: {MaterialGrams}, {nameof(MaterialCost)}: {MaterialCost}, {nameof(BottomLightOffDelay)}: {BottomLightOffDelay}, {nameof(Unknown3)}: {Unknown3}, {nameof(LightPWM)}: {LightPWM}, {nameof(BottomLightPWM)}: {BottomLightPWM}, {nameof(LayerXorKey)}: {LayerXorKey}, {nameof(BottomLiftHeight2)}: {BottomLiftHeight2}, {nameof(BottomLiftSpeed2)}: {BottomLiftSpeed2}, {nameof(LiftHeight2)}: {LiftHeight2}, {nameof(LiftSpeed2)}: {LiftSpeed2}, {nameof(RetractHeight2)}: {RetractHeight2}, {nameof(RetractSpeed2)}: {RetractSpeed2}, {nameof(RestTimeAfterLift)}: {RestTimeAfterLift}, {nameof(MachineNameOffset)}: {MachineNameOffset}, {nameof(MachineNameSize)}: {MachineNameSize}, {nameof(PerLayerSettings)}: {PerLayerSettings}, {nameof(Unknown4)}: {Unknown4}, {nameof(Unknown5)}: {Unknown5}, {nameof(RestTimeAfterRetract)}: {RestTimeAfterRetract}, {nameof(RestTimeAfterLift2)}: {RestTimeAfterLift2}, {nameof(TransitionLayerCount)}: {TransitionLayerCount}, {nameof(BottomRetractSpeed)}: {BottomRetractSpeed}, {nameof(BottomRetractSpeed2)}: {BottomRetractSpeed2}, {nameof(Padding1)}: {Padding1}, {nameof(Four1)}: {Four1}, {nameof(Padding2)}: {Padding2}, {nameof(Four2)}: {Four2}, {nameof(RestTimeAfterRetract2)}: {RestTimeAfterRetract2}, {nameof(RestTimeAfterLift3)}: {RestTimeAfterLift3}, {nameof(RestTimeBeforeLift)}: {RestTimeBeforeLift}, {nameof(BottomRetractHeight2)}: {BottomRetractHeight2}, {nameof(Unknown6)}: {Unknown6}, {nameof(Unknown7)}: {Unknown7}, {nameof(Unknown8)}: {Unknown8}, {nameof(LastLayerIndex)}: {LastLayerIndex}, {nameof(Padding3)}: {Padding3}, {nameof(Padding4)}: {Padding4}, {nameof(Padding5)}: {Padding5}, {nameof(Padding6)}: {Padding6}, {nameof(DisclaimerOffset)}: {DisclaimerOffset}, {nameof(DisclaimerSize)}: {DisclaimerSize}, {nameof(Padding7)}: {Padding7}, {nameof(Padding8)}: {Padding8}, {nameof(Padding9)}: {Padding9}, {nameof(Padding10)}: {Padding10}, {nameof(MachineName)}: {MachineName}";
             }
         }
 
diff --git a/UVtools.Core/FileFormats/ChituboxFile.cs b/UVtools.Core/FileFormats/ChituboxFile.cs
index f0c5538..ed1d571 100644
--- a/UVtools.Core/FileFormats/ChituboxFile.cs
+++ b/UVtools.Core/FileFormats/ChituboxFile.cs
@@ -38,9 +38,10 @@ namespace UVtools.Core.FileFormats
         public const byte RLE8EncodingLimit = 0x7d; // 125;
         public const ushort RLE16EncodingLimit = 0xFFF;
 
-        public const uint PERLAYER_SETTINGS_CBDDLP =    0x8;  // 0 or 8 (This disallow per layer settings)
-        public const uint PERLAYER_SETTINGS_DISALLOW =  0x7; // 7 (This disallow per layer settings)
-        public const uint PERLAYER_SETTINGS_CTBv2 =     0xF; // 15 for ctb v2 files and others (This disallow per layer settings)
+        public const uint PERLAYER_SETTINGS_CBDDLP =    8;  // 0 or 8 (This disallow per layer settings)
+        public const uint PERLAYER_SETTINGS_DISALLOW_NO_AA =  7; // 7 (This disallow per layer settings) no AA
+        public const uint PERLAYER_SETTINGS_DISALLOW =  15; // 15 (This disallow per layer settings) with AA
+        public const uint PERLAYER_SETTINGS_CTBv2 =     15; // 15 for ctb v2 files and others (This disallow per layer settings)
         public const uint PERLAYER_SETTINGS_CTBv3 =     0x2000000F; // 536870927 for ctb v3 files (This allow per layer settings, while 15 don't)
         public const uint PERLAYER_SETTINGS_CTBv4 =     0x4000000F; // 1073741839 for ctb v4 files (This allow per layer settings, while 15 don't)
             
diff --git a/UVtools.Core/FileFormats/FileFormat.cs b/UVtools.Core/FileFormats/FileFormat.cs
index a43b4ce..7ff9433 100644
--- a/UVtools.Core/FileFormats/FileFormat.cs
+++ b/UVtools.Core/FileFormats/FileFormat.cs
@@ -2733,16 +2733,29 @@ namespace UVtools.Core.FileFormats
         }
 
         /// <summary>
-        /// Gets the value for initial layer or normal layers based on layer index
+        /// Gets the global value for bottom or normal layers based on layer index
         /// </summary>
         /// <typeparam name="T">Type of value</typeparam>
         /// <param name="layerIndex">Layer index</param>
-        /// <param name="initialLayerValue">Initial value</param>
-        /// <param name="normalLayerValue">Normal value</param>
+        /// <param name="bottomValue">Initial value</param>
+        /// <param name="normalValue">Normal value</param>
         /// <returns></returns>
-        public T GetInitialLayerValueOrNormal<T>(uint layerIndex, T initialLayerValue, T normalLayerValue)
+        public T GetBottomOrNormalValue<T>(uint layerIndex, T bottomValue, T normalValue)
         {
-            return layerIndex < BottomLayerCount ? initialLayerValue : normalLayerValue;
+            return layerIndex < BottomLayerCount ? bottomValue : normalValue;
+        }
+
+        /// <summary>
+        /// Gets the global value for bottom or normal layers based on layer
+        /// </summary>
+        /// <typeparam name="T">Type of value</typeparam>
+        /// <param name="layer">Layer</param>
+        /// <param name="bottomValue">Initial value</param>
+        /// <param name="normalValue">Normal value</param>
+        /// <returns></returns>
+        public T GetBottomOrNormalValue<T>(Layer layer, T bottomValue, T normalValue)
+        {
+            return layer.IsBottomLayer ? bottomValue : normalValue;
         }
 
         /// <summary>
diff --git a/UVtools.Core/FileFormats/UVJFile.cs b/UVtools.Core/FileFormats/UVJFile.cs
index 3712712..78e82a1 100644
--- a/UVtools.Core/FileFormats/UVJFile.cs
+++ b/UVtools.Core/FileFormats/UVJFile.cs
@@ -8,11 +8,11 @@
 
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.IO;
 using System.IO.Compression;
 using Emgu.CV;
 using Emgu.CV.CvEnum;
-using Emgu.CV.Util;
 using Newtonsoft.Json;
 using UVtools.Core.Extensions;
 using UVtools.Core.Operations;
@@ -43,7 +43,7 @@ namespace UVtools.Core.FileFormats
             public ushort X { get; set; }
             public ushort Y { get; set; }
 
-            public Millimeter Millimeter { get; set; } = new Millimeter();
+            public Millimeter Millimeter { get; set; } = new();
 
             public uint Layers { get; set; }
             public float LayerHeight { get; set; }
@@ -58,51 +58,97 @@ namespace UVtools.Core.FileFormats
         {
             public float LightOnTime { get; set; }
             public float LightOffTime { get; set; }
-            public byte LightPWM { get; set; } = 255;
-            public float LiftHeight { get; set; } = 5;
-            public float LiftSpeed { get; set; } = 100;
+            public byte LightPWM { get; set; } = DefaultLightPWM;
+            public float LiftHeight { get; set; } = DefaultLiftHeight;
+            public float LiftSpeed { get; set; } = DefaultLiftSpeed;
+            public float LiftHeight2 { get; set; } = DefaultLiftHeight2;
+            public float LiftSpeed2 { get; set; } = DefaultLiftSpeed2;
             public float RetractHeight { get; set; }
-            public float RetractSpeed { get; set; } = 100;
+            public float RetractSpeed { get; set; } = DefaultRetractSpeed;
+            public float RetractHeight2 { get; set; }
+            public float RetractSpeed2 { get; set; } = DefaultRetractSpeed2;
 
             public override string ToString()
             {
-                return $"{nameof(LightOnTime)}: {LightOnTime}, {nameof(LightOffTime)}: {LightOffTime}, {nameof(LightPWM)}: {LightPWM}, {nameof(LiftHeight)}: {LiftHeight}, {nameof(LiftSpeed)}: {LiftSpeed}, {nameof(RetractHeight)}: {RetractHeight}, {nameof(RetractSpeed)}: {RetractSpeed}";
+                return $"{nameof(LightOnTime)}: {LightOnTime}, {nameof(LightOffTime)}: {LightOffTime}, {nameof(LightPWM)}: {LightPWM}, {nameof(LiftHeight)}: {LiftHeight}, {nameof(LiftSpeed)}: {LiftSpeed}, {nameof(LiftHeight2)}: {LiftHeight2}, {nameof(LiftSpeed2)}: {LiftSpeed2}, {nameof(RetractHeight)}: {RetractHeight}, {nameof(RetractSpeed)}: {RetractSpeed}, {nameof(RetractHeight2)}: {RetractHeight2}, {nameof(RetractSpeed2)}: {RetractSpeed2}";
             }
         }
 
         public class Bottom
         {
-            public float LightOnTime { get; set; }
             public float LightOffTime { get; set; }
-            public byte LightPWM { get; set; } = 255;
-            public float LiftHeight { get; set; } = 5;
-            public float LiftSpeed { get; set; } = 100;
+            public float LightOnTime { get; set; }
+            public byte LightPWM { get; set; } = DefaultBottomLightPWM;
+            public float LiftHeight { get; set; } = DefaultBottomLiftHeight;
+            public float LiftSpeed { get; set; } = DefaultBottomLiftSpeed;
+            public float LiftHeight2 { get; set; } = DefaultBottomLiftHeight2;
+            public float LiftSpeed2 { get; set; } = DefaultBottomLiftSpeed2;
             public float RetractHeight { get; set; }
-            public float RetractSpeed { get; set; } = 100;
+            public float RetractSpeed { get; set; } = DefaultBottomRetractSpeed;
+            public float RetractHeight2 { get; set; }
+            public float RetractSpeed2 { get; set; } = DefaultBottomRetractSpeed2;
             public ushort Count { get; set; }
 
             public override string ToString()
             {
-                return $"{nameof(LightOnTime)}: {LightOnTime}, {nameof(LightOffTime)}: {LightOffTime}, {nameof(LightPWM)}: {LightPWM}, {nameof(LiftHeight)}: {LiftHeight}, {nameof(LiftSpeed)}: {LiftSpeed}, {nameof(RetractHeight)}: {RetractHeight}, {nameof(RetractSpeed)}: {RetractSpeed}, {nameof(Count)}: {Count}";
+                return $"{nameof(LightOffTime)}: {LightOffTime}, {nameof(LightOnTime)}: {LightOnTime}, {nameof(LightPWM)}: {LightPWM}, {nameof(LiftHeight)}: {LiftHeight}, {nameof(LiftSpeed)}: {LiftSpeed}, {nameof(LiftHeight2)}: {LiftHeight2}, {nameof(LiftSpeed2)}: {LiftSpeed2}, {nameof(RetractHeight)}: {RetractHeight}, {nameof(RetractSpeed)}: {RetractSpeed}, {nameof(RetractHeight2)}: {RetractHeight2}, {nameof(RetractSpeed2)}: {RetractSpeed2}, {nameof(Count)}: {Count}";
             }
         }
 
-        public class LayerData
+        public class LayerDef
         {
             public float Z { get; set; }
-            public Exposure Exposure { get; set; }
+            public Exposure Exposure { get; set; } = new();
+
+            public LayerDef() { }
+
+            public LayerDef(Layer layer)
+            {
+                SetFrom(layer);
+            }
 
             public override string ToString()
             {
                 return $"{nameof(Z)}: {Z}, {nameof(Exposure)}: {Exposure}";
             }
+
+            public void SetFrom(Layer layer)
+            {
+                Z = layer.PositionZ;
+                Exposure.LightOffTime = layer.LightOffDelay;
+                Exposure.LightOnTime = layer.ExposureTime;
+                Exposure.LiftHeight = layer.LiftHeight;
+                Exposure.LiftSpeed = layer.LiftSpeed;
+                Exposure.LiftHeight2 = layer.LiftHeight2;
+                Exposure.LiftSpeed2 = layer.LiftSpeed2;
+                Exposure.RetractHeight = layer.RetractHeight;
+                Exposure.RetractSpeed = layer.RetractSpeed;
+                Exposure.RetractHeight2 = layer.RetractHeight2;
+                Exposure.RetractSpeed2 = layer.RetractSpeed2;
+                Exposure.LightPWM = layer.LightPWM;
+            }
+
+            public void CopyTo(Layer layer)
+            {
+                layer.PositionZ = Z;
+                layer.LightOffDelay = Exposure.LightOffTime;
+                layer.ExposureTime = Exposure.LightOnTime;
+                layer.LiftHeight = Exposure.LiftHeight;
+                layer.LiftSpeed = Exposure.LiftSpeed;
+                layer.LiftHeight2 = Exposure.LiftHeight2;
+                layer.LiftSpeed2 = Exposure.LiftSpeed2;
+                layer.RetractSpeed = Exposure.RetractSpeed;
+                layer.RetractHeight2 = Exposure.RetractHeight2;
+                layer.RetractSpeed2 = Exposure.RetractSpeed2;
+                layer.LightPWM = Exposure.LightPWM;
+            }
         }
 
         public class Properties
         {
-            public Size Size { get; set; } = new Size();
-            public Exposure Exposure { get; set; } = new Exposure();
-            public Bottom Bottom { get; set; } = new Bottom();
+            public Size Size { get; set; } = new ();
+            public Exposure Exposure { get; set; } = new ();
+            public Bottom Bottom { get; set; } = new ();
             public byte AntiAliasLevel { get; set; } = 1;
 
             public override string ToString()
@@ -114,7 +160,7 @@ namespace UVtools.Core.FileFormats
         public class Settings
         {
             public Properties Properties { get; set; } = new();
-            public List<LayerData> Layers { get; set; } = new();
+            public List<LayerDef> Layers { get; set; } = new();
 
             public override string ToString()
             {
@@ -144,11 +190,25 @@ namespace UVtools.Core.FileFormats
 
             PrintParameterModifier.BottomLiftHeight,
             PrintParameterModifier.BottomLiftSpeed,
+
             PrintParameterModifier.LiftHeight,
             PrintParameterModifier.LiftSpeed,
+
+            PrintParameterModifier.BottomLiftHeight2,
+            PrintParameterModifier.BottomLiftSpeed2,
+
+            PrintParameterModifier.LiftHeight2,
+            PrintParameterModifier.LiftSpeed2,
+
             PrintParameterModifier.BottomRetractSpeed,
             PrintParameterModifier.RetractSpeed,
 
+            PrintParameterModifier.BottomRetractHeight2,
+            PrintParameterModifier.RetractHeight2,
+
+            PrintParameterModifier.BottomRetractSpeed2,
+            PrintParameterModifier.RetractSpeed2,
+
             PrintParameterModifier.BottomLightPWM,
             PrintParameterModifier.LightPWM,
         };
@@ -156,10 +216,15 @@ namespace UVtools.Core.FileFormats
         public override PrintParameterModifier[] PrintParameterPerLayerModifiers { get; } = {
             PrintParameterModifier.LightOffDelay,
             PrintParameterModifier.ExposureTime,
+
             PrintParameterModifier.LiftHeight,
             PrintParameterModifier.LiftSpeed,
+            PrintParameterModifier.LiftHeight2,
+            PrintParameterModifier.LiftSpeed2,
+
             PrintParameterModifier.RetractSpeed,
-            
+            PrintParameterModifier.RetractHeight2,
+            PrintParameterModifier.RetractSpeed2,
             
             PrintParameterModifier.BottomLightPWM,
             PrintParameterModifier.LightPWM,
@@ -241,6 +306,12 @@ namespace UVtools.Core.FileFormats
             set => base.BottomLayerCount = JsonSettings.Properties.Bottom.Count = value;
         }
 
+        public override float BottomLightOffDelay
+        {
+            get => JsonSettings.Properties.Bottom.LightOffTime;
+            set => base.BottomLightOffDelay = JsonSettings.Properties.Bottom.LightOffTime = (float)Math.Round(value, 2);
+        }
+
         public override float LightOffDelay
         {
             get => JsonSettings.Properties.Exposure.LightOffTime;
@@ -267,12 +338,6 @@ namespace UVtools.Core.FileFormats
             }
         }
 
-        public override float BottomLiftHeight
-        {
-            get => JsonSettings.Properties.Bottom.LiftHeight;
-            set => base.BottomLiftHeight = JsonSettings.Properties.Bottom.LiftHeight = (float)Math.Round(value, 2);
-        }
-
         public override float BottomExposureTime
         {
             get => JsonSettings.Properties.Bottom.LightOnTime;
@@ -285,16 +350,10 @@ namespace UVtools.Core.FileFormats
             set => base.ExposureTime = JsonSettings.Properties.Exposure.LightOnTime = (float)Math.Round(value, 2);
         }
 
-        public override float BottomLightOffDelay
-        {
-            get => JsonSettings.Properties.Bottom.LightOffTime;
-            set => base.BottomLightOffDelay = JsonSettings.Properties.Bottom.LightOffTime = (float)Math.Round(value, 2);
-        }
-
-        public override float LiftHeight
+        public override float BottomLiftHeight
         {
-            get => JsonSettings.Properties.Exposure.LiftHeight;
-            set => base.LiftHeight = JsonSettings.Properties.Exposure.LiftHeight = (float)Math.Round(value, 2);
+            get => JsonSettings.Properties.Bottom.LiftHeight;
+            set => base.BottomLiftHeight = JsonSettings.Properties.Bottom.LiftHeight = (float)Math.Round(value, 2);
         }
 
         public override float BottomLiftSpeed
@@ -303,12 +362,42 @@ namespace UVtools.Core.FileFormats
             set => base.BottomLiftSpeed = JsonSettings.Properties.Bottom.LiftSpeed = (float)Math.Round(value, 2);
         }
 
+        public override float LiftHeight
+        {
+            get => JsonSettings.Properties.Exposure.LiftHeight;
+            set => base.LiftHeight = JsonSettings.Properties.Exposure.LiftHeight = (float)Math.Round(value, 2);
+        }
+
         public override float LiftSpeed
         {
             get => JsonSettings.Properties.Exposure.LiftSpeed;
             set => base.LiftSpeed = JsonSettings.Properties.Exposure.LiftSpeed = (float)Math.Round(value, 2);
         }
 
+        public override float BottomLiftHeight2
+        {
+            get => JsonSettings.Properties.Bottom.LiftHeight2;
+            set => base.BottomLiftHeight2 = JsonSettings.Properties.Bottom.LiftHeight2 = (float)Math.Round(value, 2);
+        }
+
+        public override float BottomLiftSpeed2
+        {
+            get => JsonSettings.Properties.Bottom.LiftSpeed2;
+            set => base.BottomLiftSpeed2 = JsonSettings.Properties.Bottom.LiftSpeed2 = (float)Math.Round(value, 2);
+        }
+
+        public override float LiftHeight2
+        {
+            get => JsonSettings.Properties.Exposure.LiftHeight2;
+            set => base.LiftHeight2 = JsonSettings.Properties.Exposure.LiftHeight2 = (float)Math.Round(value, 2);
+        }
+
+        public override float LiftSpeed2
+        {
+            get => JsonSettings.Properties.Exposure.LiftSpeed2;
+            set => base.LiftSpeed2 = JsonSettings.Properties.Exposure.LiftSpeed2 = (float)Math.Round(value, 2);
+        }
+
         public override float BottomRetractSpeed
         {
             get => JsonSettings.Properties.Bottom.RetractSpeed;
@@ -321,6 +410,31 @@ namespace UVtools.Core.FileFormats
             set => base.RetractSpeed = JsonSettings.Properties.Exposure.RetractSpeed = (float)Math.Round(value, 2);
         }
 
+        public override float BottomRetractHeight2
+        {
+            get => JsonSettings.Properties.Bottom.RetractHeight2;
+            set => base.BottomRetractHeight2 = JsonSettings.Properties.Bottom.RetractHeight2 = (float)Math.Round(value, 2);
+        }
+
+        public override float BottomRetractSpeed2
+        {
+            get => JsonSettings.Properties.Bottom.RetractSpeed2;
+            set => base.BottomRetractSpeed2 = JsonSettings.Properties.Bottom.RetractSpeed2 = (float)Math.Round(value, 2);
+        }
+
+        public override float RetractHeight2
+        {
+            get => JsonSettings.Properties.Exposure.RetractHeight2;
+            set => base.RetractHeight2 = JsonSettings.Properties.Exposure.RetractHeight2 = (float)Math.Round(value, 2);
+        }
+
+        public override float RetractSpeed2
+        {
+            get => JsonSettings.Properties.Exposure.RetractSpeed2;
+            set => base.RetractSpeed2 = JsonSettings.Properties.Exposure.RetractSpeed2 = (float)Math.Round(value, 2);
+        }
+
+
         public override byte BottomLightPWM
         {
             get => JsonSettings.Properties.Bottom.LightPWM;
@@ -338,33 +452,35 @@ namespace UVtools.Core.FileFormats
 
         #region Methods
 
+        protected override void OnPropertyChanged(PropertyChangedEventArgs e)
+        {
+            if (e.PropertyName == nameof(BottomRetractHeight)) JsonSettings.Properties.Bottom.RetractHeight = BottomRetractHeight;
+            else if (e.PropertyName == nameof(RetractHeight)) JsonSettings.Properties.Exposure.RetractHeight = RetractHeight;
+
+            base.OnPropertyChanged(e);
+        }
+
         public override void Clear()
         {
             base.Clear();
-            JsonSettings.Layers = new List<LayerData>();
+            JsonSettings.Layers = new List<LayerDef>();
         }
 
         protected override void EncodeInternally(string fileFullPath, OperationProgress progress)
         {
             // Redo layer data
-            JsonSettings.Layers.Clear();
+            if (JsonSettings.Layers is null)
+            {
+                JsonSettings.Layers = new List<LayerDef>();
+            }
+            else
+            {
+                JsonSettings.Layers.Clear();
+            }
+            
             for (uint layerIndex = 0; layerIndex < LayerCount; layerIndex++)
             {
-                var layer = this[layerIndex];
-                JsonSettings.Layers.Add(new LayerData
-                {
-                    Z = layer.PositionZ,
-                    Exposure = new Exposure
-                    {
-                        LiftHeight = layer.LiftHeight,
-                        LiftSpeed = layer.LiftSpeed,
-                        RetractHeight = layer.LiftHeight,
-                        RetractSpeed = layer.RetractSpeed,
-                        LightOffTime = layer.LightOffDelay,
-                        LightOnTime = layer.ExposureTime,
-                        LightPWM = layer.LightPWM
-                    }
-                });
+                JsonSettings.Layers.Add(new LayerDef(this[layerIndex]));
             }
 
             using var outputFile = ZipFile.Open(fileFullPath, ZipArchiveMode.Create);
@@ -438,16 +554,14 @@ namespace UVtools.Core.FileFormats
                     if (entry is null) continue;
 
                     using var stream = entry.Open();
-                    this[layerIndex] = new Layer(layerIndex, stream, LayerManager)
+                    var layer = new Layer(layerIndex, stream, LayerManager);
+
+                    if (JsonSettings.Layers?.Count > layerIndex)
                     {
-                        PositionZ = JsonSettings.Layers?.Count > layerIndex ? JsonSettings.Layers[(int) layerIndex].Z : GetHeightFromLayer(layerIndex),
-                        LiftHeight = JsonSettings.Layers?.Count > layerIndex ? JsonSettings.Layers[(int)layerIndex].Exposure.LiftHeight : GetInitialLayerValueOrNormal(layerIndex, BottomLiftHeight, LiftHeight),
-                        LiftSpeed = JsonSettings.Layers?.Count > layerIndex ? JsonSettings.Layers[(int)layerIndex].Exposure.LiftSpeed : GetInitialLayerValueOrNormal(layerIndex, BottomLiftSpeed, LiftSpeed),
-                        RetractSpeed = JsonSettings.Layers?.Count > layerIndex ? JsonSettings.Layers[(int)layerIndex].Exposure.RetractSpeed : RetractSpeed,
-                        LightOffDelay = JsonSettings.Layers?.Count > layerIndex ? JsonSettings.Layers[(int)layerIndex].Exposure.LightOffTime : GetInitialLayerValueOrNormal(layerIndex, BottomLightOffDelay, LightOffDelay),
-                        ExposureTime = JsonSettings.Layers?.Count > layerIndex ? JsonSettings.Layers[(int)layerIndex].Exposure.LightOnTime : GetInitialLayerValueOrNormal(layerIndex, BottomExposureTime, ExposureTime),
-                        LightPWM = JsonSettings.Layers?.Count > layerIndex ? JsonSettings.Layers[(int)layerIndex].Exposure.LightPWM : GetInitialLayerValueOrNormal(layerIndex, BottomLightPWM, LightPWM),
-                    };
+                        JsonSettings.Layers[(int)layerIndex].CopyTo(layer);
+                    }
+
+                    this[layerIndex] = layer;
                 }
                 
                 progress.ProcessedItems++;
@@ -475,6 +589,20 @@ namespace UVtools.Core.FileFormats
 
             }
 
+            if (JsonSettings.Layers is null)
+            {
+                JsonSettings.Layers = new List<LayerDef>();
+            }
+            else
+            {
+                JsonSettings.Layers.Clear();
+            }
+
+            for (uint layerIndex = 0; layerIndex < LayerCount; layerIndex++)
+            {
+                JsonSettings.Layers.Add(new LayerDef(this[layerIndex]));
+            }
+
             using var outputFile = ZipFile.Open(FileFullPath, ZipArchiveMode.Update);
             outputFile.PutFileContent(FileConfigName, JsonConvert.SerializeObject(JsonSettings, Formatting.Indented), ZipArchiveMode.Update);
 
diff --git a/UVtools.Core/FileFormats/ZCodexFile.cs b/UVtools.Core/FileFormats/ZCodexFile.cs
index 35ff0b0..e0e3f0e 100644
--- a/UVtools.Core/FileFormats/ZCodexFile.cs
+++ b/UVtools.Core/FileFormats/ZCodexFile.cs
@@ -542,9 +542,9 @@ M106 S0
                             var stripGcode = gcode.Substring(gcode.IndexOf(startStr, StringComparison.InvariantCultureIgnoreCase) + startStr.Length).Trim(' ', '\n', '\r', '\t');
 
                             float liftHeight = 0;
-                            float liftSpeed = GetInitialLayerValueOrNormal((uint)layerIndex, BottomLiftSpeed, LiftSpeed);
+                            float liftSpeed = GetBottomOrNormalValue((uint)layerIndex, BottomLiftSpeed, LiftSpeed);
                             float retractSpeed = RetractSpeed;
-                            byte pwm = GetInitialLayerValueOrNormal((uint)layerIndex, BottomLightPWM, LightPWM); ;
+                            byte pwm = GetBottomOrNormalValue((uint)layerIndex, BottomLightPWM, LightPWM); ;
 
                             //var currPos = Regex.Match(stripGcode, "G1 Z([+-]?([0-9]*[.])?[0-9]+)", RegexOptions.IgnoreCase);
                             var moveG1Regex = Regex.Match(stripGcode, @"G1 Z([+-]?([0-9]*[.])?[0-9]+) F(\d+)", RegexOptions.IgnoreCase);
diff --git a/UVtools.Core/GCode/GCodeLayer.cs b/UVtools.Core/GCode/GCodeLayer.cs
index c9b6ae5..51989a9 100644
--- a/UVtools.Core/GCode/GCodeLayer.cs
+++ b/UVtools.Core/GCode/GCodeLayer.cs
@@ -259,20 +259,20 @@ namespace UVtools.Core.GCode
             if (!IsValid) return;
             uint layerIndex = LayerIndex.Value;
             var layer = SlicerFile[layerIndex];
-
+            
             PositionZ ??= PreviousPositionZ;
             layer.PositionZ = PositionZ.Value;
             layer.WaitTimeBeforeCure = WaitTimeBeforeCure ?? 0;
-            layer.ExposureTime = ExposureTime ?? SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomExposureTime, SlicerFile.ExposureTime);
+            layer.ExposureTime = ExposureTime ?? SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomExposureTime, SlicerFile.ExposureTime);
             layer.WaitTimeAfterCure = WaitTimeAfterCure ?? 0;
             layer.LiftHeight = LiftHeight ?? 0;
-            layer.LiftSpeed = LiftSpeed ?? SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomLiftSpeed, SlicerFile.LiftSpeed);
+            layer.LiftSpeed = LiftSpeed ?? SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomLiftSpeed, SlicerFile.LiftSpeed);
             layer.LiftHeight2 = LiftHeight2 ?? 0;
-            layer.LiftSpeed2 = LiftSpeed2 ?? SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomLiftSpeed2, SlicerFile.LiftSpeed2);
+            layer.LiftSpeed2 = LiftSpeed2 ?? SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomLiftSpeed2, SlicerFile.LiftSpeed2);
             layer.WaitTimeAfterLift = WaitTimeAfterLift ?? 0;
-            layer.RetractSpeed = RetractSpeed ?? SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomRetractSpeed, SlicerFile.RetractSpeed);
+            layer.RetractSpeed = RetractSpeed ?? SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomRetractSpeed, SlicerFile.RetractSpeed);
             layer.RetractHeight2 = RetractHeight2 ?? 0;
-            layer.RetractSpeed2 = RetractSpeed2 ?? SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomRetractSpeed2, SlicerFile.RetractSpeed2);
+            layer.RetractSpeed2 = RetractSpeed2 ?? SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomRetractSpeed2, SlicerFile.RetractSpeed2);
             layer.LightPWM = LightPWM ?? 0;//SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomLightPWM, SlicerFile.LightPWM);
 
             if (SlicerFile.GCode.SyncMovementsWithDelay) // Dirty fix of the value
diff --git a/UVtools.Core/Layer/Layer.cs b/UVtools.Core/Layer/Layer.cs
index 2939be4..1399440 100644
--- a/UVtools.Core/Layer/Layer.cs
+++ b/UVtools.Core/Layer/Layer.cs
@@ -170,7 +170,8 @@ namespace UVtools.Core
             get => _waitTimeBeforeCure;
             set
             {
-                if (!RaiseAndSetIfChanged(ref _waitTimeBeforeCure, (float)Math.Round(value, 2))) return;
+                value = Math.Max(0, (float)Math.Round(value, 2));
+                if (!RaiseAndSetIfChanged(ref _waitTimeBeforeCure, value)) return;
                 SlicerFile?.UpdatePrintTimeQueued();
             }
         }
@@ -183,8 +184,9 @@ namespace UVtools.Core
             get => _exposureTime;
             set
             {
-                if (value <= 0) value = SlicerFile.GetInitialLayerValueOrNormal(Index, SlicerFile.BottomExposureTime, SlicerFile.ExposureTime);
-                if(!RaiseAndSetIfChanged(ref _exposureTime, (float)Math.Round(value, 2))) return;
+                value = (float)Math.Round(value, 2);
+                if (value <= 0) value = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomExposureTime, SlicerFile.ExposureTime);
+                if(!RaiseAndSetIfChanged(ref _exposureTime, value)) return;
                 SlicerFile?.UpdatePrintTimeQueued();
             }
         }
@@ -199,7 +201,8 @@ namespace UVtools.Core
             get => _waitTimeAfterCure;
             set
             {
-                if (!RaiseAndSetIfChanged(ref _waitTimeAfterCure, (float)Math.Round(value, 2))) return;
+                value = Math.Max(0, (float)Math.Round(value, 2));
+                if (!RaiseAndSetIfChanged(ref _waitTimeAfterCure, value)) return;
                 SlicerFile?.UpdatePrintTimeQueued();
             }
         }
@@ -212,8 +215,9 @@ namespace UVtools.Core
             get => _lightOffDelay;
             set
             {
-                if (value < 0) value = SlicerFile.GetInitialLayerValueOrNormal(Index, SlicerFile.BottomLightOffDelay, SlicerFile.LightOffDelay);
-                if(!RaiseAndSetIfChanged(ref _lightOffDelay, (float)Math.Round(value, 2))) return;
+                value = (float)Math.Round(value, 2);
+                if (value < 0) value = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomLightOffDelay, SlicerFile.LightOffDelay);
+                if(!RaiseAndSetIfChanged(ref _lightOffDelay, value)) return;
                 SlicerFile?.UpdatePrintTimeQueued();
             }
         }
@@ -240,8 +244,9 @@ namespace UVtools.Core
             get => _liftHeight;
             set
             {
-                if (value < 0) value = SlicerFile.GetInitialLayerValueOrNormal(Index, SlicerFile.BottomLiftHeight, SlicerFile.LiftHeight);
-                if(!RaiseAndSetIfChanged(ref _liftHeight, (float)Math.Round(value, 2))) return;
+                value = (float)Math.Round(value, 2);
+                if (value < 0) value = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomLiftHeight, SlicerFile.LiftHeight);
+                if(!RaiseAndSetIfChanged(ref _liftHeight, value)) return;
                 RaisePropertyChanged(nameof(LiftHeightTotal));
                 RetractHeight2 = _retractHeight2; // Sanitize
                 SlicerFile?.UpdatePrintTimeQueued();
@@ -256,8 +261,9 @@ namespace UVtools.Core
             get => _liftSpeed;
             set
             {
-                if (value <= 0) value = SlicerFile.GetInitialLayerValueOrNormal(Index, SlicerFile.BottomLiftSpeed, SlicerFile.LiftSpeed);
-                if(!RaiseAndSetIfChanged(ref _liftSpeed, (float)Math.Round(value, 2))) return;
+                value = (float)Math.Round(value, 2);
+                if (value <= 0) value = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomLiftSpeed, SlicerFile.LiftSpeed);
+                if(!RaiseAndSetIfChanged(ref _liftSpeed, value)) return;
                 SlicerFile?.UpdatePrintTimeQueued();
             }
         }
@@ -270,8 +276,9 @@ namespace UVtools.Core
             get => _liftHeight2;
             set
             {
-                if (value < 0) value = SlicerFile.GetInitialLayerValueOrNormal(Index, SlicerFile.BottomLiftHeight2, SlicerFile.LiftHeight2);
-                if (!RaiseAndSetIfChanged(ref _liftHeight2, (float)Math.Round(value, 2))) return;
+                value = (float)Math.Round(value, 2);
+                if (value < 0) value = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomLiftHeight2, SlicerFile.LiftHeight2);
+                if (!RaiseAndSetIfChanged(ref _liftHeight2, value)) return;
                 RaisePropertyChanged(nameof(LiftHeightTotal));
                 RetractHeight2 = _retractHeight2; // Sanitize
                 SlicerFile?.UpdatePrintTimeQueued();
@@ -286,8 +293,9 @@ namespace UVtools.Core
             get => _liftSpeed2;
             set
             {
-                if (value <= 0) value = SlicerFile.GetInitialLayerValueOrNormal(Index, SlicerFile.BottomLiftSpeed2, SlicerFile.LiftSpeed2);
-                if (!RaiseAndSetIfChanged(ref _liftSpeed2, (float)Math.Round(value, 2))) return;
+                value = (float)Math.Round(value, 2);
+                if (value <= 0) value = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomLiftSpeed2, SlicerFile.LiftSpeed2);
+                if (!RaiseAndSetIfChanged(ref _liftSpeed2, value)) return;
                 SlicerFile?.UpdatePrintTimeQueued();
             }
         }
@@ -297,7 +305,8 @@ namespace UVtools.Core
             get => _waitTimeAfterLift;
             set
             {
-                if (!RaiseAndSetIfChanged(ref _waitTimeAfterLift, (float)Math.Round(value, 2))) return;
+                value = Math.Max(0, (float)Math.Round(value, 2));
+                if (!RaiseAndSetIfChanged(ref _waitTimeAfterLift, value)) return;
                 SlicerFile?.UpdatePrintTimeQueued();
             }
         }
@@ -320,8 +329,9 @@ namespace UVtools.Core
             get => _retractSpeed;
             set
             {
-                if (value <= 0) value = SlicerFile.RetractSpeed;
-                if(!RaiseAndSetIfChanged(ref _retractSpeed, (float)Math.Round(value, 2))) return;
+                value = (float)Math.Round(value, 2);
+                if (value <= 0) value = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomRetractSpeed, SlicerFile.RetractSpeed);
+                if (!RaiseAndSetIfChanged(ref _retractSpeed, value)) return;
                 SlicerFile?.UpdatePrintTimeQueued();
             }
         }
@@ -338,6 +348,7 @@ namespace UVtools.Core
                 RaiseAndSetIfChanged(ref _retractHeight2, value);
                 RaisePropertyChanged(nameof(RetractHeight));
                 RaisePropertyChanged(nameof(RetractHeightTotal));
+                SlicerFile?.UpdatePrintTimeQueued();
             }
         }
 
@@ -347,7 +358,13 @@ namespace UVtools.Core
         public virtual float RetractSpeed2
         {
             get => _retractSpeed2;
-            set => RaiseAndSetIfChanged(ref _retractSpeed2, (float)Math.Round(value, 2));
+            set
+            {
+                value = (float)Math.Round(value, 2);
+                if (value <= 0) value = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomRetractSpeed2, SlicerFile.RetractSpeed2);
+                if (!RaiseAndSetIfChanged(ref _retractSpeed2, value)) return;
+                SlicerFile?.UpdatePrintTimeQueued();
+            }
         }
 
         /// <summary>
@@ -560,19 +577,19 @@ namespace UVtools.Core
 
             if (parentLayerManager is null) return;
             _positionZ = SlicerFile.GetHeightFromLayer(index);
-            _lightOffDelay = SlicerFile.GetInitialLayerValueOrNormal(index, SlicerFile.BottomLightOffDelay, SlicerFile.LightOffDelay);
-            _waitTimeBeforeCure = SlicerFile.GetInitialLayerValueOrNormal(index, SlicerFile.BottomWaitTimeBeforeCure, SlicerFile.WaitTimeBeforeCure);
-            _exposureTime = SlicerFile.GetInitialLayerValueOrNormal(index, SlicerFile.BottomExposureTime, SlicerFile.ExposureTime);
-            _waitTimeAfterCure = SlicerFile.GetInitialLayerValueOrNormal(index, SlicerFile.BottomWaitTimeAfterCure, SlicerFile.WaitTimeAfterCure);
-            _liftHeight = SlicerFile.GetInitialLayerValueOrNormal(index, SlicerFile.BottomLiftHeight, SlicerFile.LiftHeight);
-            _liftSpeed = SlicerFile.GetInitialLayerValueOrNormal(index, SlicerFile.BottomLiftSpeed, SlicerFile.LiftSpeed);
-            _liftHeight2 = SlicerFile.GetInitialLayerValueOrNormal(index, SlicerFile.BottomLiftHeight2, SlicerFile.LiftHeight2);
-            _liftSpeed2 = SlicerFile.GetInitialLayerValueOrNormal(index, SlicerFile.BottomLiftSpeed2, SlicerFile.LiftSpeed2);
-            _waitTimeAfterLift = SlicerFile.GetInitialLayerValueOrNormal(index, SlicerFile.BottomWaitTimeAfterLift, SlicerFile.WaitTimeAfterLift);
-            _retractSpeed = SlicerFile.GetInitialLayerValueOrNormal(index, SlicerFile.BottomRetractSpeed, SlicerFile.RetractSpeed);
-            _retractHeight2 = SlicerFile.GetInitialLayerValueOrNormal(index, SlicerFile.BottomRetractHeight2, SlicerFile.RetractHeight2);
-            _retractSpeed2 = SlicerFile.GetInitialLayerValueOrNormal(index, SlicerFile.BottomRetractSpeed2, SlicerFile.RetractSpeed2);
-            _lightPWM = SlicerFile.GetInitialLayerValueOrNormal(index, SlicerFile.BottomLightPWM, SlicerFile.LightPWM);
+            _lightOffDelay = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomLightOffDelay, SlicerFile.LightOffDelay);
+            _waitTimeBeforeCure = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomWaitTimeBeforeCure, SlicerFile.WaitTimeBeforeCure);
+            _exposureTime = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomExposureTime, SlicerFile.ExposureTime);
+            _waitTimeAfterCure = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomWaitTimeAfterCure, SlicerFile.WaitTimeAfterCure);
+            _liftHeight = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomLiftHeight, SlicerFile.LiftHeight);
+            _liftSpeed = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomLiftSpeed, SlicerFile.LiftSpeed);
+            _liftHeight2 = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomLiftHeight2, SlicerFile.LiftHeight2);
+            _liftSpeed2 = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomLiftSpeed2, SlicerFile.LiftSpeed2);
+            _waitTimeAfterLift = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomWaitTimeAfterLift, SlicerFile.WaitTimeAfterLift);
+            _retractSpeed = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomRetractSpeed, SlicerFile.RetractSpeed);
+            _retractHeight2 = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomRetractHeight2, SlicerFile.RetractHeight2);
+            _retractSpeed2 = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomRetractSpeed2, SlicerFile.RetractSpeed2);
+            _lightPWM = SlicerFile.GetBottomOrNormalValue(this, SlicerFile.BottomLightPWM, SlicerFile.LightPWM);
         }
 
         public Layer(uint index, byte[] compressedBytes, LayerManager parentLayerManager) : this(index, parentLayerManager)
diff --git a/UVtools.Core/Layer/LayerManager.cs b/UVtools.Core/Layer/LayerManager.cs
index 01e6a36..47a8d10 100644
--- a/UVtools.Core/Layer/LayerManager.cs
+++ b/UVtools.Core/Layer/LayerManager.cs
@@ -505,19 +505,19 @@ namespace UVtools.Core
                 {
                     if (property is null or nameof(SlicerFile.BottomLayerCount))
                     {
-                        layer.LightOffDelay = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomLightOffDelay, SlicerFile.LightOffDelay);
-                        layer.WaitTimeBeforeCure = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomWaitTimeBeforeCure, SlicerFile.WaitTimeBeforeCure);
-                        layer.ExposureTime = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomExposureTime, SlicerFile.ExposureTime);
-                        layer.WaitTimeAfterCure = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomWaitTimeAfterCure, SlicerFile.WaitTimeAfterCure);
-                        layer.LiftHeight = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomLiftHeight, SlicerFile.LiftHeight);
-                        layer.LiftSpeed = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomLiftSpeed, SlicerFile.LiftSpeed);
-                        layer.LiftHeight2 = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomLiftHeight2, SlicerFile.LiftHeight2);
-                        layer.LiftSpeed2 = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomLiftSpeed2, SlicerFile.LiftSpeed2);
-                        layer.WaitTimeAfterLift = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomWaitTimeAfterLift, SlicerFile.WaitTimeAfterLift);
-                        layer.RetractSpeed = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomRetractSpeed, SlicerFile.RetractSpeed);
-                        layer.RetractHeight2 = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomRetractHeight2, SlicerFile.RetractHeight2);
-                        layer.RetractSpeed2 = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomRetractSpeed2, SlicerFile.RetractSpeed2);
-                        layer.LightPWM = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, SlicerFile.BottomLightPWM, SlicerFile.LightPWM);
+                        layer.LightOffDelay = SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomLightOffDelay, SlicerFile.LightOffDelay);
+                        layer.WaitTimeBeforeCure = SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomWaitTimeBeforeCure, SlicerFile.WaitTimeBeforeCure);
+                        layer.ExposureTime = SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomExposureTime, SlicerFile.ExposureTime);
+                        layer.WaitTimeAfterCure = SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomWaitTimeAfterCure, SlicerFile.WaitTimeAfterCure);
+                        layer.LiftHeight = SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomLiftHeight, SlicerFile.LiftHeight);
+                        layer.LiftSpeed = SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomLiftSpeed, SlicerFile.LiftSpeed);
+                        layer.LiftHeight2 = SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomLiftHeight2, SlicerFile.LiftHeight2);
+                        layer.LiftSpeed2 = SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomLiftSpeed2, SlicerFile.LiftSpeed2);
+                        layer.WaitTimeAfterLift = SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomWaitTimeAfterLift, SlicerFile.WaitTimeAfterLift);
+                        layer.RetractSpeed = SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomRetractSpeed, SlicerFile.RetractSpeed);
+                        layer.RetractHeight2 = SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomRetractHeight2, SlicerFile.RetractHeight2);
+                        layer.RetractSpeed2 = SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomRetractSpeed2, SlicerFile.RetractSpeed2);
+                        layer.LightPWM = SlicerFile.GetBottomOrNormalValue(layer, SlicerFile.BottomLightPWM, SlicerFile.LightPWM);
                     }
                     else
                     {
diff --git a/UVtools.Core/Operations/OperationCalibrateElephantFoot.cs b/UVtools.Core/Operations/OperationCalibrateElephantFoot.cs
index 8785c31..74da586 100644
--- a/UVtools.Core/Operations/OperationCalibrateElephantFoot.cs
+++ b/UVtools.Core/Operations/OperationCalibrateElephantFoot.cs
@@ -737,7 +737,7 @@ namespace UVtools.Core.Operations
                 layerIndex < _bottomLayers + _normalLayers;
                 layerIndex++)
             {
-                newLayers[layerIndex] = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, bottomLayer.Clone(), layer.Clone());
+                newLayers[layerIndex] = SlicerFile.GetBottomOrNormalValue(layerIndex, bottomLayer.Clone(), layer.Clone());
             }
 
             if (_extrudeText)
diff --git a/UVtools.Core/Operations/OperationCalibrateXYZAccuracy.cs b/UVtools.Core/Operations/OperationCalibrateXYZAccuracy.cs
index 9e98e24..92c0564 100644
--- a/UVtools.Core/Operations/OperationCalibrateXYZAccuracy.cs
+++ b/UVtools.Core/Operations/OperationCalibrateXYZAccuracy.cs
@@ -780,7 +780,7 @@ namespace UVtools.Core.Operations
 
             for (uint layerIndex = 0; layerIndex < LayerCount; layerIndex++)
             {
-                newLayers[layerIndex] = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, bottomLayer.Clone(),
+                newLayers[layerIndex] = SlicerFile.GetBottomOrNormalValue(layerIndex, bottomLayer.Clone(),
                     (_hollowModel || _centerHoleRelief) && _drainHoleArea > 0 && layerIndex <= _bottomLayers + (int)(_drainHoleArea / _layerHeight)
                         ? ventLayer.Clone() : layer.Clone());
 
diff --git a/UVtools.Core/Operations/OperationDynamicLayerHeight.cs b/UVtools.Core/Operations/OperationDynamicLayerHeight.cs
index 5733707..5016657 100644
--- a/UVtools.Core/Operations/OperationDynamicLayerHeight.cs
+++ b/UVtools.Core/Operations/OperationDynamicLayerHeight.cs
@@ -684,15 +684,16 @@ namespace UVtools.Core.Operations
             var exposureDictionary = ExposureTableDictionary;
             for (uint layerIndex = 0; layerIndex < SlicerFile.LayerCount; layerIndex++)
             {
+                var layer = SlicerFile[layerIndex];
                 float bottomExposure = SlicerFile.BottomExposureTime;
                 float exposure = SlicerFile.ExposureTime;
-                if(exposureDictionary.TryGetValue((decimal)SlicerFile[layerIndex].LayerHeight, out var item))
+                if(exposureDictionary.TryGetValue((decimal)layer.LayerHeight, out var item))
                 {
                     bottomExposure = (float) item.BottomExposure;
                     exposure = (float) item.Exposure;
                 }
 
-                SlicerFile[layerIndex].ExposureTime = SlicerFile.GetInitialLayerValueOrNormal(layerIndex, bottomExposure, exposure);
+                layer.ExposureTime = SlicerFile.GetBottomOrNormalValue(layer, bottomExposure, exposure);
             }
             //var layer = slicerFile.LayerManager.Layers[^1];
 
diff --git a/UVtools.Core/UVtools.Core.csproj b/UVtools.Core/UVtools.Core.csproj
index 9b1774c..50389f8 100644
--- a/UVtools.Core/UVtools.Core.csproj
+++ b/UVtools.Core/UVtools.Core.csproj
@@ -10,7 +10,7 @@
     <RepositoryUrl>https://github.com/sn4k3/UVtools</RepositoryUrl>
     <PackageProjectUrl>https://github.com/sn4k3/UVtools</PackageProjectUrl>
     <Description>MSLA/DLP, file analysis, calibration, repair, conversion and manipulation</Description>
-    <Version>2.20.1</Version>
+    <Version>2.20.2</Version>
     <Copyright>Copyright © 2020 PTRTECH</Copyright>
     <PackageIcon>UVtools.png</PackageIcon>
     <Platforms>AnyCPU;x64</Platforms>
diff --git a/UVtools.WPF/UVtools.WPF.csproj b/UVtools.WPF/UVtools.WPF.csproj
index 6b66cc3..e7dc131 100644
--- a/UVtools.WPF/UVtools.WPF.csproj
+++ b/UVtools.WPF/UVtools.WPF.csproj
@@ -12,7 +12,7 @@
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <RepositoryUrl>https://github.com/sn4k3/UVtools</RepositoryUrl>
     <RepositoryType>Git</RepositoryType>
-    <Version>2.20.1</Version>
+    <Version>2.20.2</Version>
   </PropertyGroup>
   
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">