v0.6.4.1v0.6.4.1

* (Add) Partial update islands from current working layer and next layer when using pixel editor or island remove
* (Add) Setting: To enable or disable partial update islands
* (Change) Properties, Issues, Pixel Editor: ListView upgraded to a FastObjectListView, resulting in faster renders, sorting capabilities, column order, groups with counter, selection, hot tracking, filtering and empty list message
* (Change) Log: ObjectListView upgraded to a FastObjectListView
* (Change) Bunch of icons

50 files changed, 2006 insertions, 959 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d1b8a0f..5e68efd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+## 04/07/2020 - v0.6.4.1
+
+* (Add) Partial update islands from current working layer and next layer when using pixel editor or island remove
+* (Add) Setting: To enable or disable partial update islands
+* (Change) Properties, Issues, Pixel Editor: ListView upgraded to a FastObjectListView, resulting in faster renders, sorting capabilities, column order, groups with counter, selection, hot tracking, filtering and empty list message
+* (Change) Log: ObjectListView upgraded to a FastObjectListView
+* (Change) Bunch of icons
+
 ## 30/07/2020 - v0.6.4.0
 
 * (Add) Tool: Change resolution
diff --git a/UVtools.Cmd/Program.cs b/UVtools.Cmd/Program.cs
index 405411b..909b31c 100644
--- a/UVtools.Cmd/Program.cs
+++ b/UVtools.Cmd/Program.cs
@@ -187,13 +187,18 @@ namespace UVtools.Cmd
                 {
                     Console.WriteLine("Computing Issues, please wait.");
                     sw.Restart();
-                    var issuesDict = fileFormat.LayerManager.GetAllIssues(null, null, progress);
+                    var issueList = fileFormat.LayerManager.GetAllIssues(null, null, null, progress);
                     sw.Stop();
                     
                     Console.WriteLine("Issues:");
                     Console.WriteLine("----------------------");
                     count = 0;
-                    for (uint layerIndex = 0; layerIndex < fileFormat.LayerCount; layerIndex++)
+                    foreach (var issue in issueList)
+                    {
+                        Console.WriteLine(issue);
+                        count++;
+                    }
+                    /*for (uint layerIndex = 0; layerIndex < fileFormat.LayerCount; layerIndex++)
                     {
                         if(!issuesDict.TryGetValue(layerIndex, out var list)) continue;
                         foreach (var issue in list)
@@ -201,7 +206,7 @@ namespace UVtools.Cmd
                             Console.WriteLine(issue);
                             count++;
                         }
-                    }
+                    }*/
 
                     Console.WriteLine("----------------------");
                     Console.WriteLine($"Total Issues: {count} in {sw.ElapsedMilliseconds}ms");
diff --git a/UVtools.Core/FileFormats/FileFormat.cs b/UVtools.Core/FileFormats/FileFormat.cs
index 75fd714..1eaabe1 100644
--- a/UVtools.Core/FileFormats/FileFormat.cs
+++ b/UVtools.Core/FileFormats/FileFormat.cs
@@ -137,6 +137,7 @@ namespace UVtools.Core.FileFormats
             new PWSFile(),   // PSW
             new ZCodexFile(),   // zcodex
             new CWSFile(),   // CWS
+            //new MakerbaseFile(),   // MKS
             new UVJFile(),   // UVJ
             new ImageFile(),   // images
         };
diff --git a/UVtools.Core/FileFormats/MakerbaseFile.cs b/UVtools.Core/FileFormats/MakerbaseFile.cs
new file mode 100644
index 0000000..9f86a6b
--- /dev/null
+++ b/UVtools.Core/FileFormats/MakerbaseFile.cs
@@ -0,0 +1,646 @@
+/*
+ *                     GNU AFFERO GENERAL PUBLIC LICENSE
+ *                       Version 3, 19 November 2007
+ *  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ *  Everyone is permitted to copy and distribute verbatim copies
+ *  of this license document, but changing it is not allowed.
+ */
+
+// https://github.com/cbiffle/catibo/blob/master/doc/cbddlp-ctb.adoc
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Drawing;
+using System.IO;
+using System.Linq;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using BinarySerialization;
+using Emgu.CV;
+using Emgu.CV.CvEnum;
+using UVtools.Core.Extensions;
+using UVtools.Core.Operations;
+
+namespace UVtools.Core.FileFormats
+{
+    public class MakerbaseFile : FileFormat
+    {
+        #region Constants
+        private const uint MAGIC_CBDDLP = 0x12FD0019;
+        private const uint MAGIC_CBT = 0x12FD0086;
+        private const ushort REPEATRGB15MASK = 0x20;
+
+        private const byte RLE8EncodingLimit = 0x7d; // 125;
+        private const ushort RLE16EncodingLimit = 0xFFF;
+        #endregion
+
+        #region Sub Classes
+
+        #region Header
+        public class Header
+        {
+            public const string TagValue = "MKSDLP";
+            //[FieldOrder(0)]  public uint Offset1     { get; set; }
+
+            /// <summary>
+            /// Gets the file tag = MKSDLP
+            /// </summary>
+            [FieldOrder(0)] [FieldOffset(4)] [FieldLength(6)] public string Tag { get; set; } = TagValue;
+            [FieldOrder(1)] [FieldOffset(1)] public ushort MaxSize { get; set; }
+            [FieldOrder(2)] public ushort ResolutionX { get; set; }
+            [FieldOrder(3)] public ushort ResolutionY { get; set; }
+
+            
+        }
+        #endregion
+
+        #endregion
+
+        #region Properties
+
+        public Header HeaderSettings { get; protected internal set; } = new Header();
+        private int temp = 0;
+        public override FileFormatType FileType => FileFormatType.Binary;
+
+        public override FileExtension[] FileExtensions { get; } = {
+            new FileExtension("mdlp", "Makerbase MDLP Files"),
+            new FileExtension("gr1", "GR1 Workshop GR1 Files"),
+        };
+
+        public override Type[] ConvertToFormats { get; } =
+        {
+            typeof(UVJFile),
+        };
+
+        public override PrintParameterModifier[] PrintParameterModifiers { get; } =
+        {
+            PrintParameterModifier.InitialLayerCount,
+            PrintParameterModifier.InitialExposureSeconds,
+            PrintParameterModifier.ExposureSeconds,
+
+            PrintParameterModifier.BottomLayerOffTime,
+            PrintParameterModifier.LayerOffTime,
+            PrintParameterModifier.BottomLiftHeight,
+            PrintParameterModifier.BottomLiftSpeed,
+            PrintParameterModifier.LiftHeight,
+            PrintParameterModifier.LiftSpeed,
+            PrintParameterModifier.RetractSpeed,
+
+            PrintParameterModifier.BottomLightPWM,
+            PrintParameterModifier.LightPWM,
+        };
+
+        public override byte ThumbnailsCount { get; } = 0;
+
+        public override Size[] ThumbnailsOriginalSize { get; } = {new Size(400, 300), new Size(200, 125)};
+
+        public override uint ResolutionX
+        {
+            get => 0;
+            set => temp = 0;
+        }
+
+        public override uint ResolutionY
+        {
+            get => 0;
+            set => temp = 0;
+        }
+
+        public override byte AntiAliasing => 1;
+
+        public override float LayerHeight
+        {
+            get => 0;
+            set => temp = 0;
+        }
+
+        public override uint LayerCount
+        {
+            set
+            {
+                temp = 0;
+                /*HeaderSettings.LayerCount = LayerCount;
+                HeaderSettings.OverallHeightMilimeter = TotalHeight;*/
+            }
+        }
+
+        public override ushort InitialLayerCount => 0;
+
+        public override float InitialExposureTime => 0;
+
+        public override float LayerExposureTime => 0;
+        public override float LiftHeight => 0;
+        public override float LiftSpeed => 0;
+        public override float RetractSpeed => 0;
+
+        public override float PrintTime => 0;
+
+        public override float UsedMaterial => 0;
+
+        public override float MaterialCost => 0;
+
+        public override string MaterialName => "Unknown";
+        public override string MachineName => null;
+        
+        public override object[] Configs => new[] { (object)HeaderSettings };
+
+        #endregion
+
+        #region Constructors
+        public MakerbaseFile()
+        {
+        }
+        #endregion
+
+        #region Methods
+        public override void Encode(string fileFullPath, OperationProgress progress = null)
+        {
+            base.Encode(fileFullPath, progress);
+            
+            uint currentOffset = (uint)Helpers.Serializer.SizeOf(HeaderSettings);
+            using (var outputFile = new FileStream(fileFullPath, FileMode.Create, FileAccess.Write))
+            {
+
+                outputFile.Seek((int) currentOffset, SeekOrigin.Begin);
+
+
+                
+            }
+
+            AfterEncode();
+
+            Debug.WriteLine("Encode Results:");
+            Debug.WriteLine(HeaderSettings);
+            Debug.WriteLine("-End-");
+        }
+
+        
+
+        public override void Decode(string fileFullPath, OperationProgress progress = null)
+        {
+            base.Decode(fileFullPath, progress);
+
+            using (var inputFile = new FileStream(fileFullPath, FileMode.Open, FileAccess.Read))
+            {
+                //HeaderSettings = Helpers.ByteToType<CbddlpFile.Header>(InputFile);
+                //HeaderSettings = Helpers.Serializer.Deserialize<Header>(InputFile.ReadBytes(Helpers.Serializer.SizeOf(typeof(Header))));
+                HeaderSettings = Helpers.Deserialize<Header>(inputFile);
+                if (HeaderSettings.Tag != Header.TagValue)
+                {
+                    throw new FileLoadException("Not a valid Makerfile file!", fileFullPath);
+                }
+
+
+                FileFullPath = fileFullPath;
+
+            }
+
+            progress.Token.ThrowIfCancellationRequested();
+        }
+
+        public override object GetValueFromPrintParameterModifier(PrintParameterModifier modifier)
+        {
+            var baseValue = base.GetValueFromPrintParameterModifier(modifier);
+            if (!ReferenceEquals(baseValue, null)) return baseValue;
+            /*if (ReferenceEquals(modifier, PrintParameterModifier.BottomLayerOffTime)) return PrintParametersSettings.BottomLightOffDelay;
+            if (ReferenceEquals(modifier, PrintParameterModifier.LayerOffTime)) return PrintParametersSettings.LightOffDelay;
+            if (ReferenceEquals(modifier, PrintParameterModifier.BottomLiftHeight)) return PrintParametersSettings.BottomLiftHeight;
+            if (ReferenceEquals(modifier, PrintParameterModifier.BottomLiftSpeed)) return PrintParametersSettings.BottomLiftSpeed;*/
+            /*if (ReferenceEquals(modifier, PrintParameterModifier.LiftHeight)) return PrintParametersSettings.LiftHeight;
+            if (ReferenceEquals(modifier, PrintParameterModifier.LiftSpeed)) return PrintParametersSettings.LiftingSpeed;
+            if (ReferenceEquals(modifier, PrintParameterModifier.RetractSpeed)) return PrintParametersSettings.RetractSpeed;*/
+
+            /*if (ReferenceEquals(modifier, PrintParameterModifier.BottomLightPWM)) return HeaderSettings.BottomLightPWM;
+            if (ReferenceEquals(modifier, PrintParameterModifier.LightPWM)) return HeaderSettings.LightPWM;*/
+
+
+
+            return null;
+        }
+
+        public override bool SetValueFromPrintParameterModifier(PrintParameterModifier modifier, string value)
+        {
+            return false;
+        }
+
+        public override void SaveAs(string filePath = null, OperationProgress progress = null)
+        {
+            if (RequireFullEncode)
+            {
+                if (!string.IsNullOrEmpty(filePath))
+                {
+                    FileFullPath = filePath;
+                }
+                Encode(FileFullPath, progress);
+                return;
+            }
+
+
+            if (!string.IsNullOrEmpty(filePath))
+            {
+                File.Copy(FileFullPath, filePath, true);
+                FileFullPath = filePath;
+            }
+
+            /*using (var outputFile = new FileStream(FileFullPath, FileMode.Open, FileAccess.Write))
+            {
+
+                outputFile.Seek(0, SeekOrigin.Begin);
+                Helpers.SerializeWriteFileStream(outputFile, HeaderSettings);
+
+                if (HeaderSettings.Version >= 2 && HeaderSettings.PrintParametersOffsetAddress > 0)
+                {
+                    outputFile.Seek(HeaderSettings.PrintParametersOffsetAddress, SeekOrigin.Begin);
+                    Helpers.SerializeWriteFileStream(outputFile, PrintParametersSettings);
+                    Helpers.SerializeWriteFileStream(outputFile, SlicerInfoSettings);
+                }
+
+                uint layerOffset = HeaderSettings.LayersDefinitionOffsetAddress;
+                for (byte aaIndex = 0; aaIndex < HeaderSettings.AntiAliasLevel; aaIndex++)
+                {
+                    for (uint layerIndex = 0; layerIndex < HeaderSettings.LayerCount; layerIndex++)
+                    {
+                        outputFile.Seek(layerOffset, SeekOrigin.Begin);
+                        layerOffset += Helpers.SerializeWriteFileStream(outputFile, LayersDefinitions[aaIndex, layerIndex]);
+                    }
+                }
+            }*/
+
+            //Decode(FileFullPath, progress);
+        }
+
+        public override bool Convert(Type to, string fileFullPath, OperationProgress progress = null)
+        {
+            /*if (to == typeof(ChituboxFile))
+            {
+                if (Path.GetExtension(FileFullPath).Equals(Path.GetExtension(fileFullPath)))
+                {
+                    return false;
+                }
+                ChituboxFile file = new ChituboxFile
+                {
+                    LayerManager = LayerManager,
+                    HeaderSettings =
+                    {
+                        ResolutionX = ResolutionX,
+                        ResolutionY = ResolutionY,
+                        BedSizeX = HeaderSettings.BedSizeX,
+                        BedSizeY = HeaderSettings.BedSizeY,
+                        BedSizeZ = HeaderSettings.BedSizeZ,
+                        ProjectorType = HeaderSettings.ProjectorType,
+                        LayerCount = LayerCount,
+                        AntiAliasLevel = ValidateAntiAliasingLevel(),
+                        BottomLightPWM = (byte) HeaderSettings.BottomLightPWM,
+                        LightPWM = (byte) HeaderSettings.LightPWM,
+                        LayerOffTime = HeaderSettings.LayerOffTime,
+                        PrintTime = HeaderSettings.PrintTime,
+                        BottomExposureSeconds = HeaderSettings.BottomExposureSeconds,
+                        BottomLayersCount = HeaderSettings.BottomLayersCount,
+                        //EncryptionKey = HeaderSettings.EncryptionKey,
+                        LayerExposureSeconds = HeaderSettings.LayerExposureSeconds,
+                        LayerHeightMilimeter = HeaderSettings.LayerHeightMilimeter,
+                        OverallHeightMilimeter = HeaderSettings.OverallHeightMilimeter,
+                    },
+                    PrintParametersSettings =
+                    {
+                        LiftSpeed = PrintParametersSettings.LiftSpeed,
+                        LiftHeight = PrintParametersSettings.LiftHeight,
+                        BottomLiftSpeed = PrintParametersSettings.BottomLiftSpeed,
+                        RetractSpeed = PrintParametersSettings.RetractSpeed,
+                        BottomLightOffDelay = PrintParametersSettings.BottomLightOffDelay,
+                        LightOffDelay = PrintParametersSettings.BottomLightOffDelay,
+                        BottomLayerCount = PrintParametersSettings.BottomLayerCount,
+                        VolumeMl = PrintParametersSettings.VolumeMl,
+                        BottomLiftHeight = PrintParametersSettings.BottomLiftHeight,
+                        CostDollars = PrintParametersSettings.CostDollars,
+                        WeightG = PrintParametersSettings.WeightG
+                    },
+                    SlicerInfoSettings =
+                    {
+                        AntiAliasLevel = SlicerInfoSettings.AntiAliasLevel,
+                        MachineName = SlicerInfoSettings.MachineName,
+                        //EncryptionMode = SlicerInfoSettings.EncryptionMode,
+                        MachineNameSize = SlicerInfoSettings.MachineNameSize,
+                    },
+                    Thumbnails = Thumbnails,
+                };
+
+                //file.SetThumbnails(Thumbnails);
+                file.Encode(fileFullPath, progress);
+
+                return true;
+            }
+
+            if (to == typeof(ChituboxZipFile))
+            {
+                ChituboxZipFile file = new ChituboxZipFile
+                {
+                    LayerManager = LayerManager,
+                    HeaderSettings =
+                    {
+                        Filename = Path.GetFileName(FileFullPath),
+
+                        ResolutionX = ResolutionX,
+                        ResolutionY = ResolutionY,
+                        MachineX = HeaderSettings.BedSizeX,
+                        MachineY = HeaderSettings.BedSizeY,
+                        MachineZ = HeaderSettings.BedSizeZ,
+                        MachineType = MachineName,
+                        ProjectType = HeaderSettings.ProjectorType == 0 ? "Normal" : "LCD_mirror",
+
+                        Resin = MaterialName,
+                        Price = MaterialCost,
+                        Weight = PrintParametersSettings.WeightG,
+                        Volume = UsedMaterial,
+                        Mirror = (byte)  (HeaderSettings.ProjectorType == 0 ? 0 : 1),
+
+
+                        BottomLiftHeight = PrintParametersSettings.BottomLiftHeight,
+                        LiftHeight = PrintParametersSettings.LiftHeight,
+                        BottomLiftSpeed = PrintParametersSettings.BottomLiftSpeed,
+                        LiftSpeed = PrintParametersSettings.LiftSpeed,
+                        RetractSpeed = PrintParametersSettings.RetractSpeed,
+                        BottomLayCount = InitialLayerCount,
+                        BottomLayerCount = InitialLayerCount,
+                        BottomLightOffTime = PrintParametersSettings.BottomLightOffDelay,
+                        LightOffTime = PrintParametersSettings.LightOffDelay,
+                        BottomLayExposureTime = InitialExposureTime,
+                        BottomLayerExposureTime = InitialExposureTime,
+                        LayerExposureTime = LayerExposureTime,
+                        LayerHeight = LayerHeight,
+                        LayerCount = LayerCount,
+                        AntiAliasing = ValidateAntiAliasingLevel(),
+                        BottomLightPWM = (byte) HeaderSettings.BottomLightPWM,
+                        LayerLightPWM = (byte) HeaderSettings.LightPWM,
+
+                        EstimatedPrintTime = PrintTime
+                    },
+                };
+
+                file.SetThumbnails(Thumbnails);
+                file.Encode(fileFullPath, progress);
+
+                return true;
+            }
+
+            if (to == typeof(PWSFile))
+            {
+                PWSFile file = new PWSFile
+                {
+                    LayerManager = LayerManager,
+                    HeaderSettings =
+                    {
+                        ResolutionX = ResolutionX,
+                        ResolutionY = ResolutionY,
+                        LayerHeight = LayerHeight,
+                        LayerExposureTime = LayerExposureTime,
+                        LiftHeight = LiftHeight,
+                        LiftSpeed = LiftSpeed / 60,
+                        RetractSpeed = RetractSpeed / 60,
+                        LayerOffTime = HeaderSettings.LayerOffTime,
+                        BottomLayersCount = InitialLayerCount,
+                        BottomExposureSeconds = InitialExposureTime,
+                        Price = MaterialCost,
+                        Volume = UsedMaterial,
+                        Weight = PrintParametersSettings.WeightG,
+                        AntiAliasing = ValidateAntiAliasingLevel()
+                    }
+                };
+
+                file.SetThumbnails(Thumbnails);
+                file.Encode(fileFullPath, progress);
+
+                return true;
+            }
+
+            if (to == typeof(PHZFile))
+            {
+                PHZFile file = new PHZFile
+                {
+                    LayerManager = LayerManager,
+                    HeaderSettings =
+                    {
+                        Version = 2,
+                        BedSizeX = HeaderSettings.BedSizeX,
+                        BedSizeY = HeaderSettings.BedSizeY,
+                        BedSizeZ = HeaderSettings.BedSizeZ,
+                        OverallHeightMilimeter = TotalHeight,
+                        BottomExposureSeconds = InitialExposureTime,
+                        BottomLayersCount = InitialLayerCount,
+                        BottomLightPWM = HeaderSettings.BottomLightPWM,
+                        LayerCount = LayerCount,
+                        LayerExposureSeconds = LayerExposureTime,
+                        LayerHeightMilimeter = LayerHeight,
+                        LayerOffTime = HeaderSettings.LayerOffTime,
+                        LightPWM = HeaderSettings.LightPWM,
+                        PrintTime = HeaderSettings.PrintTime,
+                        ProjectorType = HeaderSettings.ProjectorType,
+                        ResolutionX = ResolutionX,
+                        ResolutionY = ResolutionY,
+                        BottomLayerCount = InitialLayerCount,
+                        BottomLiftHeight = PrintParametersSettings.BottomLiftHeight,
+                        BottomLiftSpeed = PrintParametersSettings.BottomLiftSpeed,
+                        BottomLightOffDelay = PrintParametersSettings.BottomLightOffDelay,
+                        CostDollars = MaterialCost,
+                        LiftHeight = PrintParametersSettings.LiftHeight,
+                        LiftSpeed = PrintParametersSettings.LiftSpeed,
+                        RetractSpeed = PrintParametersSettings.RetractSpeed,
+                        VolumeMl = UsedMaterial,
+                        AntiAliasLevelInfo = ValidateAntiAliasingLevel(),
+                        WeightG = PrintParametersSettings.WeightG,
+                        MachineName = MachineName,
+                        MachineNameSize = (uint)MachineName.Length
+                    }
+                };
+
+                
+
+                file.SetThumbnails(Thumbnails);
+                file.Encode(fileFullPath, progress);
+
+                return true;
+            }
+
+            if (to == typeof(ZCodexFile))
+            {
+                TimeSpan ts = new TimeSpan(0, 0, (int)PrintTime);
+                ZCodexFile file = new ZCodexFile
+                {
+                    ResinMetadataSettings = new ZCodexFile.ResinMetadata
+                    {
+                        MaterialId = 2,
+                        Material = MaterialName,
+                        AdditionalSupportLayerTime = 0,
+                        BottomLayersNumber = InitialLayerCount,
+                        BottomLayersTime = (uint)(InitialExposureTime * 1000),
+                        LayerTime = (uint)(LayerExposureTime * 1000),
+                        DisableSettingsChanges = false,
+                        LayerThickness = LayerHeight,
+                        PrintTime = (uint)PrintTime,
+                        TotalLayersCount = LayerCount,
+                        TotalMaterialVolumeUsed = UsedMaterial,
+                        TotalMaterialWeightUsed = UsedMaterial,
+                    },
+                    UserSettings = new ZCodexFile.UserSettingsdata
+                    {
+                        Printer = MachineName,
+                        BottomLayersCount = InitialLayerCount,
+                        PrintTime = $"{ts.Hours}h {ts.Minutes}m",
+                        LayerExposureTime = (uint)(LayerExposureTime * 1000),
+                        BottomLayerExposureTime = (uint)(InitialExposureTime * 1000),
+                        MaterialId = 2,
+                        LayerThickness = $"{LayerHeight} mm",
+                        AntiAliasing = (byte)(ValidateAntiAliasingLevel() > 1 ? 1 : 0),
+                        CrossSupportEnabled = 1,
+                        ExposureOffTime = (uint) HeaderSettings.LayerOffTime,
+                        HollowEnabled = 0,
+                        HollowThickness = 0,
+                        InfillDensity = 0,
+                        IsAdvanced = 0,
+                        MaterialType = MaterialName,
+                        MaterialVolume = UsedMaterial,
+                        MaxLayer = LayerCount - 1,
+                        ModelLiftEnabled = 0,
+                        ModelLiftHeight = 0,
+                        RaftEnabled = 0,
+                        RaftHeight = 0,
+                        RaftOffset = 0,
+                        SupportAdditionalExposureEnabled = 0,
+                        SupportAdditionalExposureTime = 0,
+                        XCorrection = 0,
+                        YCorrection = 0,
+                        ZLiftDistance = PrintParametersSettings.LiftHeight,
+                        ZLiftFeedRate = PrintParametersSettings.LiftSpeed,
+                        ZLiftRetractRate = PrintParametersSettings.RetractSpeed,
+                    },
+                    ZCodeMetadataSettings = new ZCodexFile.ZCodeMetadata
+                    {
+                        PrintTime = (uint)PrintTime,
+                        PrinterName = MachineName,
+                        Materials = new List<ZCodexFile.ZCodeMetadata.MaterialsData>
+                        {
+                            new ZCodexFile.ZCodeMetadata.MaterialsData
+                            {
+                                Name = MaterialName,
+                                ExtruderType = "MAIN",
+                                Id = 0,
+                                Usage = 0,
+                                Temperature = 0
+                            }
+                        },
+                    },
+                    LayerManager = LayerManager
+                };
+
+                float usedMaterial = UsedMaterial / LayerCount;
+                for (uint layerIndex = 0; layerIndex < LayerCount; layerIndex++)
+                {
+                    file.ResinMetadataSettings.Layers.Add(new ZCodexFile.ResinMetadata.LayerData
+                    {
+                        Layer = layerIndex,
+                        UsedMaterialVolume = usedMaterial
+                    });
+                }
+
+                file.SetThumbnails(Thumbnails);
+                file.Encode(fileFullPath, progress);
+                return true;
+            }
+
+            if (to == typeof(CWSFile))
+            {
+                CWSFile defaultFormat = (CWSFile)FindByType(typeof(CWSFile));
+                CWSFile file = new CWSFile { LayerManager = LayerManager };
+
+                file.SliceSettings.Xppm = file.OutputSettings.PixPermmX = (float)Math.Round(ResolutionX / HeaderSettings.BedSizeX, 3);
+                file.SliceSettings.Yppm = file.OutputSettings.PixPermmY = (float)Math.Round(ResolutionY / HeaderSettings.BedSizeY, 3);
+                file.SliceSettings.Xres = file.OutputSettings.XResolution = (ushort)ResolutionX;
+                file.SliceSettings.Yres = file.OutputSettings.YResolution = (ushort)ResolutionY;
+                file.SliceSettings.Thickness = file.OutputSettings.LayerThickness = LayerHeight;
+                file.SliceSettings.LayersNum = file.OutputSettings.LayersNum = LayerCount;
+                file.SliceSettings.HeadLayersNum = file.OutputSettings.NumberBottomLayers = InitialLayerCount;
+                file.SliceSettings.LayersExpoMs = file.OutputSettings.LayerTime = (uint)LayerExposureTime * 1000;
+                file.SliceSettings.HeadLayersExpoMs = file.OutputSettings.BottomLayersTime = (uint)InitialExposureTime * 1000;
+                file.SliceSettings.WaitBeforeExpoMs = (uint)(PrintParametersSettings.LightOffDelay * 1000);
+                file.SliceSettings.LiftDistance = file.OutputSettings.LiftDistance = LiftHeight;
+                file.SliceSettings.LiftUpSpeed = file.OutputSettings.ZLiftFeedRate = LiftSpeed;
+                file.SliceSettings.LiftDownSpeed = file.OutputSettings.ZLiftRetractRate = RetractSpeed;
+                file.SliceSettings.LiftWhenFinished = defaultFormat.SliceSettings.LiftWhenFinished;
+
+                file.OutputSettings.BlankingLayerTime = (uint) (PrintParametersSettings.LightOffDelay * 1000);
+                //file.OutputSettings.RenderOutlines = false;
+                //file.OutputSettings.OutlineWidthInset = 0;
+                //file.OutputSettings.OutlineWidthOutset = 0;
+                file.OutputSettings.RenderOutlines = false;
+                //file.OutputSettings.TiltValue = 0;
+                //file.OutputSettings.UseMainliftGCodeTab = false;
+                //file.OutputSettings.AntiAliasing = 0;
+                //file.OutputSettings.AntiAliasingValue = 0;
+                file.OutputSettings.FlipX = HeaderSettings.ProjectorType != 0;
+                file.OutputSettings.FlipY = file.OutputSettings.FlipX;
+                file.OutputSettings.AntiAliasingValue = ValidateAntiAliasingLevel();
+                file.OutputSettings.AntiAliasing = file.OutputSettings.AntiAliasingValue > 1;
+
+                file.Encode(fileFullPath, progress);
+
+                return true;
+            }
+
+            /*if (to == typeof(UVJFile))
+            {
+                UVJFile file = new UVJFile
+                {
+                    LayerManager = LayerManager,
+                    JsonSettings = new UVJFile.Settings
+                    {
+                        Properties = new UVJFile.Properties
+                        {
+                            Size = new UVJFile.Size
+                            {
+                                X = (ushort)ResolutionX,
+                                Y = (ushort)ResolutionY,
+                                Millimeter = new UVJFile.Millimeter
+                                {
+                                    X = HeaderSettings.BedSizeX,
+                                    Y = HeaderSettings.BedSizeY,
+                                },
+                                LayerHeight = LayerHeight,
+                                Layers = LayerCount
+                            },
+                            Bottom = new UVJFile.Bottom
+                            {
+                                LiftHeight = PrintParametersSettings.BottomLiftHeight,
+                                LiftSpeed = PrintParametersSettings.BottomLiftSpeed,
+                                LightOnTime = InitialExposureTime,
+                                LightOffTime = PrintParametersSettings.BottomLightOffDelay,
+                                LightPWM = (byte) HeaderSettings.BottomLightPWM,
+                                RetractSpeed = PrintParametersSettings.RetractSpeed,
+                                Count = InitialLayerCount
+                                //RetractHeight = LookupCustomValue<float>(Keyword_LiftHeight, defaultFormat.JsonSettings.Properties.Bottom.RetractHeight),
+                            },
+                            Exposure = new UVJFile.Exposure
+                            {
+                                LiftHeight = PrintParametersSettings.LiftHeight,
+                                LiftSpeed = PrintParametersSettings.LiftSpeed,
+                                LightOnTime = LayerExposureTime,
+                                LightOffTime = PrintParametersSettings.LightOffDelay,
+                                LightPWM = (byte) HeaderSettings.LightPWM,
+                                RetractSpeed = PrintParametersSettings.RetractSpeed,
+                            },
+                            AntiAliasLevel = ValidateAntiAliasingLevel()
+                        }
+                    }
+                };
+
+                file.SetThumbnails(Thumbnails);
+                file.Encode(fileFullPath, progress);
+
+                return true;
+            }*/
+
+            return false;
+        }
+        #endregion
+    }
+}
diff --git a/UVtools.Core/Layer/LayerIssue.cs b/UVtools.Core/Layer/LayerIssue.cs
index 0a28c56..c41d896 100644
--- a/UVtools.Core/Layer/LayerIssue.cs
+++ b/UVtools.Core/Layer/LayerIssue.cs
@@ -8,7 +8,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Drawing;
-using System.Text;
+using System.Runtime.CompilerServices;
 
 namespace UVtools.Core
 {
@@ -22,6 +22,12 @@ namespace UVtools.Core
         public bool Enabled { get; set; } = true;
 
         /// <summary>
+        /// Gets or sets a list of layers to check for islands, absent layers will not be checked.
+        /// Set to null to check every layer
+        /// </summary>
+        public List<uint> WhiteListLayers { get; set; } = null;
+
+        /// <summary>
         /// Gets or sets the binary threshold, all pixels below this value will turn in black, otherwise white
         /// Set to 0 to disable this operation 
         /// </summary>
@@ -77,6 +83,19 @@ namespace UVtools.Core
         public byte MaximumPixelBrightnessToDrain { get; set; } = 30;
     }
 
+    public class TouchingBoundDetectionConfiguration
+    {
+        /// <summary>
+        /// Gets if the detection is enabled
+        /// </summary>
+        public bool Enabled { get; set; } = true;
+
+        /// <summary>
+        /// Gets the maximum pixel brightness to be a touching bound
+        /// </summary>
+        public byte MaximumPixelBrightness { get; set; } = 200;
+    }
+
 
     public class LayerIssue : IEnumerable<Point>
     {
@@ -95,15 +114,22 @@ namespace UVtools.Core
         public Layer Layer { get; }
 
         /// <summary>
+        /// Gets the layer index
+        /// </summary>
+        public uint LayerIndex => Layer.Index;
+
+        /// <summary>
         /// Gets the issue type associated
         /// </summary>
         public IssueType Type { get; }
 
         /// <summary>
-        /// Gets the pixels containing the issue
+        /// Gets the pixels points containing the issue
         /// </summary>
         public Point[] Pixels { get; }
 
+        public int PixelsCount => Pixels?.Length ?? 0;
+
         /// <summary>
         /// Gets the bounding rectangle of the pixel area
         /// </summary>
@@ -122,7 +148,8 @@ namespace UVtools.Core
         /// <summary>
         /// Gets the XY point for first point
         /// </summary>
-        public Point Point => HaveValidPoint ? Pixels[0] : new Point(-1, -1);
+        public Point FirstPoint => HaveValidPoint ? Pixels[0] : new Point(-1, -1);
+        public string FirstPointStr => $"{FirstPoint.X}, {FirstPoint.Y}";
 
         /// <summary>
         /// Gets the number of pixels on this issue
diff --git a/UVtools.Core/Layer/LayerManager.cs b/UVtools.Core/Layer/LayerManager.cs
index ccf95be..a3379c4 100644
--- a/UVtools.Core/Layer/LayerManager.cs
+++ b/UVtools.Core/Layer/LayerManager.cs
@@ -684,17 +684,19 @@ namespace UVtools.Core
             progress.Token.ThrowIfCancellationRequested();
         }
 
-        public ConcurrentDictionary<uint, List<LayerIssue>> GetAllIssues(
+        public List<LayerIssue> GetAllIssues(
             IslandDetectionConfiguration islandConfig = null, ResinTrapDetectionConfiguration resinTrapConfig = null,
+            TouchingBoundDetectionConfiguration touchBoundConfig = null,
             OperationProgress progress = null)
         {
             if(ReferenceEquals(islandConfig, null)) islandConfig = new IslandDetectionConfiguration();
             if(ReferenceEquals(resinTrapConfig, null)) resinTrapConfig = new ResinTrapDetectionConfiguration();
+            if(ReferenceEquals(touchBoundConfig, null)) touchBoundConfig = new TouchingBoundDetectionConfiguration();
             if(ReferenceEquals(progress, null)) progress = new OperationProgress();
 
             const byte minTouchingBondsPixelColor = 200;
 
-            var result = new ConcurrentDictionary<uint, List<LayerIssue>>();
+            var result = new ConcurrentBag<LayerIssue>();
             var layerHollowAreas = new ConcurrentDictionary<uint, List<LayerHollowArea>>();
 
             bool islandsFinished = false;
@@ -703,7 +705,7 @@ namespace UVtools.Core
 
             Parallel.Invoke(() =>
             {
-                if (!islandConfig.Enabled)
+                if (!islandConfig.Enabled && !resinTrapConfig.Enabled)
                 {
                     islandsFinished = true;
                     return;
@@ -722,44 +724,54 @@ namespace UVtools.Core
                                 int step = image.Step;
                                 var span = image.GetPixelSpan<byte>();
 
-                                // TouchingBounds Checker
-                                List<Point> pixels = new List<Point>();
-                                for (int x = 0; x < image.Width; x++) // Check Top and Bottom bounds
+                                if (resinTrapConfig.Enabled)
                                 {
-                                    if (span[x] >= minTouchingBondsPixelColor) // Top
+                                    // TouchingBounds Checker
+                                    List<Point> pixels = new List<Point>();
+                                    for (int x = 0; x < image.Width; x++) // Check Top and Bottom bounds
                                     {
-                                        pixels.Add(new Point(x, 0));
-                                    }
+                                        if (span[x] >= minTouchingBondsPixelColor) // Top
+                                        {
+                                            pixels.Add(new Point(x, 0));
+                                        }
 
-                                    if (span[step * image.Height - step + x] >= minTouchingBondsPixelColor) // Bottom
-                                    {
-                                        pixels.Add(new Point(x, image.Height - 1));
+                                        if (span[step * image.Height - step + x] >=
+                                            minTouchingBondsPixelColor) // Bottom
+                                        {
+                                            pixels.Add(new Point(x, image.Height - 1));
+                                        }
                                     }
-                                }
 
-                                for (int y = 0; y < image.Height; y++) // Check Left and Right bounds
-                                {
-                                    if (span[y * step] >= minTouchingBondsPixelColor) // Left
+                                    for (int y = 0; y < image.Height; y++) // Check Left and Right bounds
                                     {
-                                        pixels.Add(new Point(0, y));
+                                        if (span[y * step] >= minTouchingBondsPixelColor) // Left
+                                        {
+                                            pixels.Add(new Point(0, y));
+                                        }
+
+                                        if (span[y * step + step - 1] >= minTouchingBondsPixelColor) // Right
+                                        {
+                                            pixels.Add(new Point(step - 1, y));
+                                        }
                                     }
 
-                                    if (span[y * step + step - 1] >= minTouchingBondsPixelColor) // Right
+                                    if (pixels.Count > 0)
                                     {
-                                        pixels.Add(new Point(step - 1, y));
+                                        result.Add(new LayerIssue(layer, LayerIssue.IssueType.TouchingBound, pixels.ToArray()));
+                                        /*result.TryAdd(layer.Index, new List<LayerIssue>
+                                        {
+                                            new LayerIssue(layer, LayerIssue.IssueType.TouchingBound, pixels.ToArray())
+                                        });*/
                                     }
                                 }
 
-                                if (pixels.Count > 0)
+                                if (layer.Index == 0 || !islandConfig.Enabled) return; // No islands for layer 0
+
+                                if (!ReferenceEquals(islandConfig.WhiteListLayers, null)) // Check white list
                                 {
-                                    result.TryAdd(layer.Index, new List<LayerIssue>
-                                    {
-                                        new LayerIssue(layer, LayerIssue.IssueType.TouchingBound, pixels.ToArray())
-                                    });
+                                    if (!islandConfig.WhiteListLayers.Contains(layer.Index)) return;
                                 }
 
-                                if (layer.Index == 0) return; // No islands for layer 0
-
                                 VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint();
                                 Mat hierarchy = new Mat();
 
@@ -846,12 +858,13 @@ namespace UVtools.Core
 
                                     var issue = new LayerIssue(layer, LayerIssue.IssueType.Island, points.ToArray(),
                                         rect);
-                                    result.AddOrUpdate(layer.Index, new List<LayerIssue> {issue},
+                                    result.Add(issue);
+                                    /*result.AddOrUpdate(layer.Index, new List<LayerIssue> {issue},
                                         (layerIndex, list) =>
                                         {
                                             list.Add(issue);
                                             return list;
-                                        });
+                                        });*/
                                 }
 
                                 contours.Dispose();
@@ -861,17 +874,18 @@ namespace UVtools.Core
                         }
                         else
                         {
-                            result.TryAdd(layer.Index, new List<LayerIssue>
+                            result.Add(new LayerIssue(layer, LayerIssue.IssueType.EmptyLayer));
+                            /*result.TryAdd(layer.Index, new List<LayerIssue>
                             {
                                 new LayerIssue(layer, LayerIssue.IssueType.EmptyLayer)
-                            });
+                            });*/
                         }
 
                         lock (progress.Mutex)
                         {
                             progress++;
                         }
-                    });
+                    }); // Parallel end
                 islandsFinished = true;
             }, () =>
             {
@@ -1113,7 +1127,13 @@ namespace UVtools.Core
                 }
             });
 
-            if (progress.Token.IsCancellationRequested) return result;
+            /*var resultSorted = result.ToList();
+            resultSorted.Sort((issue, layerIssue) =>
+            {
+                int ret = issue.Type.CompareTo(layerIssue.Type);
+                return ret != 0 ? ret : issue.LayerIndex.CompareTo(layerIssue.LayerIndex);
+            });*/
+            if (progress.Token.IsCancellationRequested) return result.OrderBy(issue => issue.Type).ThenBy(issue => issue.LayerIndex).ThenBy(issue => issue.PixelsCount).ToList();
 
             for (uint layerIndex = 0; layerIndex < Count; layerIndex++)
             {
@@ -1125,19 +1145,26 @@ namespace UVtools.Core
                         where area.Type == LayerHollowArea.AreaType.Trap 
                         select new LayerIssue(this[layerIndex], LayerIssue.IssueType.ResinTrap, area.Contour, area.BoundingRectangle))
                 {
-                    result.AddOrUpdate(layerIndex, new List<LayerIssue> {issue}, (u, listIssues) =>
+                    result.Add(issue);
+                    /*result.AddOrUpdate(layerIndex, new List<LayerIssue> {issue}, (u, listIssues) =>
                     {
                         listIssues.Add(issue);
                         return listIssues;
-                    });
+                    });*/
                 }
             }
 
-            return result;
+            //resultSorted = resultSorted.OrderBy(issue => issue.Type).ThenBy(issue => issue.LayerIndex);
+            /*resultSorted.Sort((issue, layerIssue) =>
+            {
+                int ret = issue.Type.CompareTo(layerIssue.Type);
+                return ret != 0 ? ret : issue.LayerIndex.CompareTo(layerIssue.LayerIndex);
+            });*/
+            return result.OrderBy(issue => issue.Type).ThenBy(issue => issue.LayerIndex).ThenBy(issue => issue.PixelsCount).ToList();
         }
 
         public void RepairLayers(uint layerStart, uint layerEnd, uint closingIterations = 1, uint openingIterations = 1, byte removeIslandsBelowEqualPixels = 4,
-            bool repairIslands = true, bool removeEmptyLayers = true, bool repairResinTraps = true, Dictionary<uint, List<LayerIssue>> issues = null,
+            bool repairIslands = true, bool removeEmptyLayers = true, bool repairResinTraps = true, List<LayerIssue> issues = null,
             OperationProgress progress = null)
         {
             if(ReferenceEquals(progress, null)) progress = new OperationProgress();
@@ -1155,7 +1182,20 @@ namespace UVtools.Core
                         {
                             if (repairIslands && removeIslandsBelowEqualPixels > 0)
                             {
-                                if (issues.TryGetValue((uint)layerIndex, out var issueList))
+                                var bytes = image.GetPixelSpan<byte>();
+                                foreach (var issue in issues)
+                                {
+                                    if (
+                                        issue.LayerIndex != layerIndex ||
+                                        issue.Type != LayerIssue.IssueType.Island ||
+                                        issue.Pixels.Length > removeIslandsBelowEqualPixels) continue;
+
+                                    foreach (var issuePixel in issue.Pixels)
+                                    {
+                                        bytes[image.GetPixelPos(issuePixel)] = 0;
+                                    }
+                                }
+                                /*if (issues.TryGetValue((uint)layerIndex, out var issueList))
                                 {
                                     var bytes = image.GetPixelSpan<byte>();
                                     foreach (var issue in issueList.Where(issue =>
@@ -1166,30 +1206,20 @@ namespace UVtools.Core
                                             bytes[image.GetPixelPos(issuePixel)] = 0;
                                         }
                                     }
-                                }
+                                }*/
                             }
 
                             if (repairResinTraps)
                             {
-                                if (issues.TryGetValue((uint) layerIndex, out var issueList))
+                                foreach (var issue in issues.Where(issue => issue.LayerIndex == layerIndex && issue.Type == LayerIssue.IssueType.ResinTrap))
                                 {
-                                    foreach (var issue in issueList.Where(issue =>
-                                        issue.Type == LayerIssue.IssueType.ResinTrap))
+                                    using (var vec = new VectorOfVectorOfPoint(new VectorOfPoint(issue.Pixels)))
                                     {
-                                        using (var vec = new VectorOfVectorOfPoint(new VectorOfPoint(issue.Pixels)))
-                                        {
-                                            CvInvoke.DrawContours(image,
-                                                vec,
-                                                -1,
-                                                new MCvScalar(255),
-                                                -1);
-                                        }
-
-                                        /*CvInvoke.DrawContours(image,
-                                            new VectorOfVectorOfPoint(new VectorOfPoint(issue.Pixels)),
+                                        CvInvoke.DrawContours(image,
+                                            vec,
                                             -1,
                                             new MCvScalar(255),
-                                            2);*/
+                                            -1);
                                     }
                                 }
                             }
@@ -1386,7 +1416,7 @@ namespace UVtools.Core
                 progress++;
             }
 
-            pixelHistory.Clear();
+            //pixelHistory.Clear();
         }
 
         /// <summary>
diff --git a/UVtools.Core/PixelEditor/PixelHistory.cs b/UVtools.Core/PixelEditor/PixelHistory.cs
index 73f11ed..2953d77 100644
--- a/UVtools.Core/PixelEditor/PixelHistory.cs
+++ b/UVtools.Core/PixelEditor/PixelHistory.cs
@@ -5,6 +5,8 @@
  *  Everyone is permitted to copy and distribute verbatim copies
  *  of this license document, but changing it is not allowed.
  */
+
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Text;
@@ -57,5 +59,12 @@ namespace UVtools.Core.PixelEditor
 
         #endregion
 
+        public void Renumber()
+        {
+            for (int i = 0; i < Count; i++)
+            {
+                Items[i].Index = (uint) (i + 1);
+            }
+        }
     }
 }
diff --git a/UVtools.Core/PixelEditor/PixelOperation.cs b/UVtools.Core/PixelEditor/PixelOperation.cs
index 5173ba2..c4b6c93 100644
--- a/UVtools.Core/PixelEditor/PixelOperation.cs
+++ b/UVtools.Core/PixelEditor/PixelOperation.cs
@@ -18,11 +18,29 @@ namespace UVtools.Core.PixelEditor
             DrainHole,
         }
 
+        /// <summary>
+        /// Gets or sets the index number to show on GUI
+        /// </summary>
+        public uint Index { get; set; }
+
+        /// <summary>
+        /// Gets the <see cref="PixelOperationType"/>
+        /// </summary>
         public PixelOperationType OperationType { get; }
+
+        /// <summary>
+        /// Gets the layer index
+        /// </summary>
         public uint LayerIndex { get; }
 
+        /// <summary>
+        /// Gets the location of the operation
+        /// </summary>
         public Point Location { get; }
 
+        /// <summary>
+        /// Gets the total size of the operation
+        /// </summary>
         public Size Size { get; private protected set; } = Size.Empty;
 
 
diff --git a/UVtools.Core/UVtools.Core.csproj b/UVtools.Core/UVtools.Core.csproj
index 2a8efae..e3a2ef8 100644
--- a/UVtools.Core/UVtools.Core.csproj
+++ b/UVtools.Core/UVtools.Core.csproj
@@ -10,12 +10,12 @@
     <RepositoryUrl>https://github.com/sn4k3/UVtools</RepositoryUrl>
     <PackageProjectUrl>https://github.com/sn4k3/UVtools</PackageProjectUrl>
     <Description>MSLA/DLP, file analysis, repair, conversion and manipulation</Description>
-    <Version>0.6.4.0</Version>
+    <Version>0.6.4.1</Version>
     <Copyright>Copyright © 2020 PTRTECH</Copyright>
     <PackageIcon>UVtools.png</PackageIcon>
     <Platforms>AnyCPU;x64</Platforms>
-    <AssemblyVersion>0.6.4.0</AssemblyVersion>
-    <FileVersion>0.6.4.0</FileVersion>
+    <AssemblyVersion>0.6.4.1</AssemblyVersion>
+    <FileVersion>0.6.4.1</FileVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
@@ -46,7 +46,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="BinarySerializer" Version="8.5.1" />
+    <PackageReference Include="BinarySerializer" Version="8.5.2" />
     <PackageReference Include="Emgu.CV" Version="4.3.0.3890" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
     <PackageReference Include="System.Memory" Version="4.5.4" />
diff --git a/UVtools.GUI/App.config b/UVtools.GUI/App.config
index 6f53367..3631139 100644
--- a/UVtools.GUI/App.config
+++ b/UVtools.GUI/App.config
@@ -189,9 +189,13 @@
       <setting name="LayerRepairRemoveEmptyLayers" serializeAs="String">
         <value>True</value>
       </setting>
-      <setting name="LayerRepairRemoveIslandsBelowEqualPixelsDefault" serializeAs="String">
+      <setting name="LayerRepairRemoveIslandsBelowEqualPixelsDefault"
+        serializeAs="String">
         <value>10</value>
       </setting>
+      <setting name="PartialUpdateIslandsOnEditing" serializeAs="String">
+        <value>True</value>
+      </setting>
     </UVtools.GUI.Properties.Settings>
   </userSettings>
 </configuration>
diff --git a/UVtools.GUI/Controls/ListViewColumnSorter.cs b/UVtools.GUI/Controls/ListViewColumnSorter.cs
deleted file mode 100644
index de0d344..0000000
--- a/UVtools.GUI/Controls/ListViewColumnSorter.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Windows.Forms;
-
-namespace UVtools.GUI.Controls
-{
-    /// <summary>
-    /// This class is an implementation of the 'IComparer' interface.
-    /// </summary>
-    public class ListViewColumnSorter : IComparer
-    {
-        /// <summary>
-        /// Case insensitive comparer object
-        /// </summary>
-        private readonly CaseInsensitiveComparer _objectCompare;
-
-        /// <summary>
-        /// Gets or sets the number of the column to which to apply the sorting operation (Defaults to '0').
-        /// </summary>
-        public int SortColumn { set; get; }
-
-        /// <summary>
-        /// Gets or sets the order of sorting to apply (for example, 'Ascending' or 'Descending').
-        /// </summary>
-        public SortOrder Order { set; get; }
-
-        /// <summary>
-        /// Class constructor. Initializes various elements
-        /// </summary>
-        public ListViewColumnSorter()
-        {
-            // Initialize the column to '0'
-            SortColumn = 0;
-
-            // Initialize the sort order to 'none'
-            Order = SortOrder.None;
-
-            // Initialize the CaseInsensitiveComparer object
-            _objectCompare = new CaseInsensitiveComparer();
-        }
-
-        /// <summary>
-        /// This method is inherited from the IComparer interface. It compares the two objects passed using a case insensitive comparison.
-        /// </summary>
-        /// <param name="x">First object to be compared</param>
-        /// <param name="y">Second object to be compared</param>
-        /// <returns>The result of the comparison. "0" if equal, negative if 'x' is less than 'y' and positive if 'x' is greater than 'y'</returns>
-        public int Compare(object x, object y)
-        {
-            // Cast the objects to be compared to ListViewItem objects
-            var listviewX = (ListViewItem)x;
-            var listviewY = (ListViewItem)y;
-
-            // Compare the two items
-            var compareResult = _objectCompare.Compare(listviewX.SubItems[SortColumn].Text, listviewY.SubItems[SortColumn].Text);
-
-            switch (Order)
-            {
-                // Calculate correct return value based on object comparison
-                case SortOrder.Ascending:
-                    // Ascending sort is selected, return normal result of compare operation
-                    return compareResult;
-                case SortOrder.Descending:
-                    // Descending sort is selected, return negative result of compare operation
-                    return (-compareResult);
-                default:
-                    // Return '0' to indicate they are equal
-                    return 0;
-            }
-        }
-    }
-}
diff --git a/UVtools.GUI/Controls/Log.cs b/UVtools.GUI/Controls/Log.cs
index 3f8c7be..80836f7 100644
--- a/UVtools.GUI/Controls/Log.cs
+++ b/UVtools.GUI/Controls/Log.cs
@@ -47,7 +47,7 @@ namespace UVtools.GUI.Controls
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
         }
 
-        protected bool SetField<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
+        private bool SetField<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
         {
             if (EqualityComparer<T>.Default.Equals(field, value)) return false;
             field = value;
diff --git a/UVtools.GUI/Controls/SlicerPropertyItem.cs b/UVtools.GUI/Controls/SlicerPropertyItem.cs
new file mode 100644
index 0000000..21d046a
--- /dev/null
+++ b/UVtools.GUI/Controls/SlicerPropertyItem.cs
@@ -0,0 +1,23 @@
+using BrightIdeasSoftware;
+
+namespace UVtools.GUI.Controls
+{
+    public sealed class SlicerPropertyItem
+    {
+        [OLVColumn(Width = 185)]
+        public string Key { get; set; }
+
+        [OLVColumn(Width = 0)]
+        public string Value { get; set; }
+
+        [OLVColumn(IsVisible = false)]
+        public string Group { get; set; }
+
+        public SlicerPropertyItem(string key, string value, string group)
+        {
+            Key = key;
+            Value = value;
+            Group = group;
+        }
+    }
+}
diff --git a/UVtools.GUI/Forms/FrmSettings.Designer.cs b/UVtools.GUI/Forms/FrmSettings.Designer.cs
index 31e0430..af30674 100644
--- a/UVtools.GUI/Forms/FrmSettings.Designer.cs
+++ b/UVtools.GUI/Forms/FrmSettings.Designer.cs
@@ -131,6 +131,8 @@
             this.label23 = new System.Windows.Forms.Label();
             this.btnPixelEditorAddPixelColor = new System.Windows.Forms.Button();
             this.tabPage5 = new System.Windows.Forms.TabPage();
+            this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault = new System.Windows.Forms.NumericUpDown();
+            this.label35 = new System.Windows.Forms.Label();
             this.nmLayerRepairDefaultOpeningIterations = new System.Windows.Forms.NumericUpDown();
             this.label34 = new System.Windows.Forms.Label();
             this.nmLayerRepairDefaultClosingIterations = new System.Windows.Forms.NumericUpDown();
@@ -139,8 +141,7 @@
             this.cbLayerRepairRemoveEmptyLayers = new System.Windows.Forms.CheckBox();
             this.cbLayerRepairLayersIslands = new System.Windows.Forms.CheckBox();
             this.panel1 = new System.Windows.Forms.Panel();
-            this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault = new System.Windows.Forms.NumericUpDown();
-            this.label35 = new System.Windows.Forms.Label();
+            this.cbPartialUpdateIslandsOnEditing = new System.Windows.Forms.CheckBox();
             ((System.ComponentModel.ISupportInitialize)(this.nmOutlineHollowAreasLineThickness)).BeginInit();
             ((System.ComponentModel.ISupportInitialize)(this.nmOutlineLayerBoundsLineThickness)).BeginInit();
             ((System.ComponentModel.ISupportInitialize)(this.nmOutlinePrintVolumeBoundsLineThickness)).BeginInit();
@@ -164,10 +165,10 @@
             this.tabPage3.SuspendLayout();
             this.tabPage4.SuspendLayout();
             this.tabPage5.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)(this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault)).BeginInit();
             ((System.ComponentModel.ISupportInitialize)(this.nmLayerRepairDefaultOpeningIterations)).BeginInit();
             ((System.ComponentModel.ISupportInitialize)(this.nmLayerRepairDefaultClosingIterations)).BeginInit();
             this.panel1.SuspendLayout();
-            ((System.ComponentModel.ISupportInitialize)(this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault)).BeginInit();
             this.SuspendLayout();
             // 
             // label1
@@ -1333,6 +1334,7 @@
             // 
             // tabPage4
             // 
+            this.tabPage4.Controls.Add(this.cbPartialUpdateIslandsOnEditing);
             this.tabPage4.Controls.Add(this.btnPixelEditorDrainHoleColor);
             this.tabPage4.Controls.Add(this.label26);
             this.tabPage4.Controls.Add(this.btnPixelEditorSupportColor);
@@ -1464,6 +1466,32 @@
             this.tabPage5.Text = "Layer Repair";
             this.tabPage5.UseVisualStyleBackColor = true;
             // 
+            // nmLayerRepairRemoveIslandsBelowEqualPixelsDefault
+            // 
+            this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault.Location = new System.Drawing.Point(6, 66);
+            this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault.Maximum = new decimal(new int[] {
+            255,
+            0,
+            0,
+            0});
+            this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault.Name = "nmLayerRepairRemoveIslandsBelowEqualPixelsDefault";
+            this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault.Size = new System.Drawing.Size(57, 24);
+            this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault.TabIndex = 34;
+            this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault.Value = new decimal(new int[] {
+            1,
+            0,
+            0,
+            0});
+            // 
+            // label35
+            // 
+            this.label35.AutoSize = true;
+            this.label35.Location = new System.Drawing.Point(69, 69);
+            this.label35.Name = "label35";
+            this.label35.Size = new System.Drawing.Size(357, 18);
+            this.label35.TabIndex = 35;
+            this.label35.Text = "Remove islands below or equal to pixels default value";
+            // 
             // nmLayerRepairDefaultOpeningIterations
             // 
             this.nmLayerRepairDefaultOpeningIterations.Location = new System.Drawing.Point(6, 36);
@@ -1557,31 +1585,16 @@
             this.panel1.Size = new System.Drawing.Size(624, 77);
             this.panel1.TabIndex = 19;
             // 
-            // nmLayerRepairRemoveIslandsBelowEqualPixelsDefault
+            // cbPartialUpdateIslandsOnEditing
             // 
-            this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault.Location = new System.Drawing.Point(6, 66);
-            this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault.Maximum = new decimal(new int[] {
-            255,
-            0,
-            0,
-            0});
-            this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault.Name = "nmLayerRepairRemoveIslandsBelowEqualPixelsDefault";
-            this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault.Size = new System.Drawing.Size(57, 24);
-            this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault.TabIndex = 34;
-            this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault.Value = new decimal(new int[] {
-            1,
-            0,
-            0,
-            0});
-            // 
-            // label35
-            // 
-            this.label35.AutoSize = true;
-            this.label35.Location = new System.Drawing.Point(69, 69);
-            this.label35.Name = "label35";
-            this.label35.Size = new System.Drawing.Size(357, 18);
-            this.label35.TabIndex = 35;
-            this.label35.Text = "Remove islands below or equal to pixels default value";
+            this.cbPartialUpdateIslandsOnEditing.AutoSize = true;
+            this.cbPartialUpdateIslandsOnEditing.Location = new System.Drawing.Point(9, 170);
+            this.cbPartialUpdateIslandsOnEditing.Name = "cbPartialUpdateIslandsOnEditing";
+            this.cbPartialUpdateIslandsOnEditing.Size = new System.Drawing.Size(565, 40);
+            this.cbPartialUpdateIslandsOnEditing.TabIndex = 19;
+            this.cbPartialUpdateIslandsOnEditing.Text = "Partial update islands for the affected layers after apply the modifications and " +
+    "when\r\nremove a island";
+            this.cbPartialUpdateIslandsOnEditing.UseVisualStyleBackColor = true;
             // 
             // FrmSettings
             // 
@@ -1631,10 +1644,10 @@
             this.tabPage4.PerformLayout();
             this.tabPage5.ResumeLayout(false);
             this.tabPage5.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)(this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault)).EndInit();
             ((System.ComponentModel.ISupportInitialize)(this.nmLayerRepairDefaultOpeningIterations)).EndInit();
             ((System.ComponentModel.ISupportInitialize)(this.nmLayerRepairDefaultClosingIterations)).EndInit();
             this.panel1.ResumeLayout(false);
-            ((System.ComponentModel.ISupportInitialize)(this.nmLayerRepairRemoveIslandsBelowEqualPixelsDefault)).EndInit();
             this.ResumeLayout(false);
 
         }
@@ -1753,5 +1766,6 @@
         private System.Windows.Forms.Label label34;
         private System.Windows.Forms.NumericUpDown nmLayerRepairRemoveIslandsBelowEqualPixelsDefault;
         private System.Windows.Forms.Label label35;
+        private System.Windows.Forms.CheckBox cbPartialUpdateIslandsOnEditing;
     }
 }
\ No newline at end of file
diff --git a/UVtools.GUI/Forms/FrmSettings.cs b/UVtools.GUI/Forms/FrmSettings.cs
index 4e0f7f1..499a2bf 100644
--- a/UVtools.GUI/Forms/FrmSettings.cs
+++ b/UVtools.GUI/Forms/FrmSettings.cs
@@ -84,6 +84,7 @@ namespace UVtools.GUI.Forms
                 btnPixelEditorRemovePixelColor.BackColor = Settings.Default.PixelEditorRemovePixelColor;
                 btnPixelEditorSupportColor.BackColor = Settings.Default.PixelEditorSupportColor;
                 btnPixelEditorDrainHoleColor.BackColor = Settings.Default.PixelEditorDrainHoleColor;
+                cbPartialUpdateIslandsOnEditing.Checked = Settings.Default.PartialUpdateIslandsOnEditing;
 
                 nmLayerRepairDefaultClosingIterations.Value = Settings.Default.LayerRepairDefaultClosingIterations;
                 nmLayerRepairDefaultOpeningIterations.Value = Settings.Default.LayerRepairDefaultOpeningIterations;
@@ -234,6 +235,7 @@ namespace UVtools.GUI.Forms
                 Settings.Default.PixelEditorRemovePixelColor = btnPixelEditorRemovePixelColor.BackColor;
                 Settings.Default.PixelEditorSupportColor = btnPixelEditorSupportColor.BackColor;
                 Settings.Default.PixelEditorDrainHoleColor = btnPixelEditorDrainHoleColor.BackColor;
+                Settings.Default.PartialUpdateIslandsOnEditing = cbPartialUpdateIslandsOnEditing.Checked;
 
                 Settings.Default.LayerRepairDefaultClosingIterations = (byte) nmLayerRepairDefaultClosingIterations.Value;
                 Settings.Default.LayerRepairDefaultOpeningIterations = (byte) nmLayerRepairDefaultOpeningIterations.Value;
diff --git a/UVtools.GUI/FrmMain.Designer.cs b/UVtools.GUI/FrmMain.Designer.cs
index 4a66af2..3ee4fe7 100644
--- a/UVtools.GUI/FrmMain.Designer.cs
+++ b/UVtools.GUI/FrmMain.Designer.cs
@@ -53,13 +53,13 @@
             this.menuToolsLayerReHeight = new System.Windows.Forms.ToolStripMenuItem();
             this.menuToolsLayerRemoval = new System.Windows.Forms.ToolStripMenuItem();
             this.menuToolsPattern = new System.Windows.Forms.ToolStripMenuItem();
-            this.viewToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
             this.helpToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
             this.menuHelpWebsite = new System.Windows.Forms.ToolStripMenuItem();
             this.menuHelpDonate = new System.Windows.Forms.ToolStripMenuItem();
             this.menuHelpAbout = new System.Windows.Forms.ToolStripMenuItem();
             this.toolStripSeparator10 = new System.Windows.Forms.ToolStripSeparator();
             this.menuHelpInstallPrinters = new System.Windows.Forms.ToolStripMenuItem();
+            this.viewToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
             this.menuNewVersion = new System.Windows.Forms.ToolStripMenuItem();
             this.statusBar = new System.Windows.Forms.StatusStrip();
             this.mainTable = new System.Windows.Forms.TableLayoutPanel();
@@ -113,9 +113,7 @@
             this.tsThumbnailsImport = new System.Windows.Forms.ToolStripButton();
             this.toolStripSeparator22 = new System.Windows.Forms.ToolStripSeparator();
             this.tsThumbnailsResolution = new System.Windows.Forms.ToolStripLabel();
-            this.lvProperties = new System.Windows.Forms.ListView();
-            this.lvChKey = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
-            this.lvChValue = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
+            this.flvProperties = new BrightIdeasSoftware.FastObjectListView();
             this.tsProperties = new System.Windows.Forms.ToolStrip();
             this.tsPropertiesLabelCount = new System.Windows.Forms.ToolStripLabel();
             this.toolStripSeparator4 = new System.Windows.Forms.ToolStripSeparator();
@@ -131,29 +129,32 @@
             this.tsGcodeLabelChars = new System.Windows.Forms.ToolStripLabel();
             this.tsGCodeButtonSave = new System.Windows.Forms.ToolStripButton();
             this.tabPageIssues = new System.Windows.Forms.TabPage();
-            this.lvIssues = new System.Windows.Forms.ListView();
-            this.lvIssuesType = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
-            this.lvIssuesCount = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
-            this.lvIssuesLayerHeader = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
-            this.lvIssuesXY = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
-            this.lvIssuesPixels = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
+            this.flvIssues = new BrightIdeasSoftware.FastObjectListView();
+            this.flvIssuesColType = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn()));
+            this.flvIssuesColLayerIndex = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn()));
+            this.flvIssuesColPosition = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn()));
+            this.flvIssuesColPixels = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn()));
+            this.tsIssuesLv = new System.Windows.Forms.ToolStrip();
+            this.btnIssueGroup = new System.Windows.Forms.ToolStripButton();
+            this.toolStripSeparator23 = new System.Windows.Forms.ToolStripSeparator();
+            this.btnIssueResort = new System.Windows.Forms.ToolStripButton();
             this.tsIssues = new System.Windows.Forms.ToolStrip();
             this.tsIssuePrevious = new System.Windows.Forms.ToolStripButton();
             this.tsIssueCount = new System.Windows.Forms.ToolStripLabel();
             this.tsIssueNext = new System.Windows.Forms.ToolStripButton();
             this.toolStripSeparator13 = new System.Windows.Forms.ToolStripSeparator();
             this.tsIssueRemove = new System.Windows.Forms.ToolStripButton();
-            this.tsIsuesRefresh = new System.Windows.Forms.ToolStripSplitButton();
-            this.tsIsuesRefreshIslands = new System.Windows.Forms.ToolStripMenuItem();
-            this.tsIsuesRefreshResinTraps = new System.Windows.Forms.ToolStripMenuItem();
+            this.tsIssuesRefresh = new System.Windows.Forms.ToolStripSplitButton();
+            this.tsIssuesRefreshIslands = new System.Windows.Forms.ToolStripMenuItem();
+            this.tsIssuesRefreshResinTraps = new System.Windows.Forms.ToolStripMenuItem();
             this.toolStripSeparator12 = new System.Windows.Forms.ToolStripSeparator();
             this.tsIssuesRepair = new System.Windows.Forms.ToolStripButton();
             this.tabPagePixelEditor = new System.Windows.Forms.TabPage();
-            this.lvPixelHistory = new System.Windows.Forms.ListView();
-            this.columnHeader5 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
-            this.columnHeader1 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
-            this.columnHeader2 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
-            this.columnHeader3 = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
+            this.flvPixelHistory = new BrightIdeasSoftware.FastObjectListView();
+            this.flvPixelHistoryColNumber = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn()));
+            this.flvPixelHistoryColOperation = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn()));
+            this.olvColumn3 = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn()));
+            this.olvColumn4 = ((BrightIdeasSoftware.OLVColumn)(new BrightIdeasSoftware.OLVColumn()));
             this.tsPixelEditorHistory = new System.Windows.Forms.ToolStrip();
             this.lbPixelHistoryOperations = new System.Windows.Forms.ToolStripLabel();
             this.btnPixelHistoryRemove = new System.Windows.Forms.ToolStripButton();
@@ -189,8 +190,8 @@
             this.panel5 = new System.Windows.Forms.Panel();
             this.label12 = new System.Windows.Forms.Label();
             this.tabPageLog = new System.Windows.Forms.TabPage();
-            this.lvLog = new BrightIdeasSoftware.ObjectListView();
-            this.toolStrip1 = new System.Windows.Forms.ToolStrip();
+            this.lvLog = new BrightIdeasSoftware.FastObjectListView();
+            this.tsLog = new System.Windows.Forms.ToolStrip();
             this.btnLogClear = new System.Windows.Forms.ToolStripButton();
             this.lbLogOperations = new System.Windows.Forms.ToolStripLabel();
             this.imageList16x16 = new System.Windows.Forms.ImageList(this.components);
@@ -224,12 +225,16 @@
             this.scLeft.SuspendLayout();
             ((System.ComponentModel.ISupportInitialize)(this.pbThumbnail)).BeginInit();
             this.tsThumbnails.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)(this.flvProperties)).BeginInit();
             this.tsProperties.SuspendLayout();
             this.tabPageGCode.SuspendLayout();
             this.tsGCode.SuspendLayout();
             this.tabPageIssues.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)(this.flvIssues)).BeginInit();
+            this.tsIssuesLv.SuspendLayout();
             this.tsIssues.SuspendLayout();
             this.tabPagePixelEditor.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)(this.flvPixelHistory)).BeginInit();
             this.tsPixelEditorHistory.SuspendLayout();
             this.tabControlPixelEditor.SuspendLayout();
             this.tabPage1.SuspendLayout();
@@ -245,7 +250,7 @@
             this.panel5.SuspendLayout();
             this.tabPageLog.SuspendLayout();
             ((System.ComponentModel.ISupportInitialize)(this.lvLog)).BeginInit();
-            this.toolStrip1.SuspendLayout();
+            this.tsLog.SuspendLayout();
             this.tlRight.SuspendLayout();
             this.panel1.SuspendLayout();
             ((System.ComponentModel.ISupportInitialize)(this.tbLayer)).BeginInit();
@@ -259,8 +264,8 @@
             this.menuEdit,
             this.menuMutate,
             this.menuTools,
-            this.viewToolStripMenuItem,
             this.helpToolStripMenuItem,
+            this.viewToolStripMenuItem,
             this.menuNewVersion});
             this.menu.Location = new System.Drawing.Point(0, 0);
             this.menu.Name = "menu";
@@ -428,7 +433,7 @@
             // menuToolsRepairLayers
             // 
             this.menuToolsRepairLayers.Enabled = false;
-            this.menuToolsRepairLayers.Image = global::UVtools.GUI.Properties.Resources.Wrench_16x16;
+            this.menuToolsRepairLayers.Image = global::UVtools.GUI.Properties.Resources.toolbox_16x16;
             this.menuToolsRepairLayers.Name = "menuToolsRepairLayers";
             this.menuToolsRepairLayers.ShortcutKeys = ((System.Windows.Forms.Keys)(((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.Alt) 
             | System.Windows.Forms.Keys.R)));
@@ -457,7 +462,7 @@
             // menuToolsLayerRemoval
             // 
             this.menuToolsLayerRemoval.Enabled = false;
-            this.menuToolsLayerRemoval.Image = global::UVtools.GUI.Properties.Resources.delete_16x16;
+            this.menuToolsLayerRemoval.Image = global::UVtools.GUI.Properties.Resources.layers_alt_16x16;
             this.menuToolsLayerRemoval.Name = "menuToolsLayerRemoval";
             this.menuToolsLayerRemoval.Size = new System.Drawing.Size(261, 22);
             this.menuToolsLayerRemoval.Text = "Layer Re&moval";
@@ -474,13 +479,6 @@
             this.menuToolsPattern.Text = "&Pattern";
             this.menuToolsPattern.Click += new System.EventHandler(this.EventClick);
             // 
-            // viewToolStripMenuItem
-            // 
-            this.viewToolStripMenuItem.Name = "viewToolStripMenuItem";
-            this.viewToolStripMenuItem.Size = new System.Drawing.Size(44, 20);
-            this.viewToolStripMenuItem.Text = "&View";
-            this.viewToolStripMenuItem.Visible = false;
-            // 
             // helpToolStripMenuItem
             // 
             this.helpToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
@@ -495,7 +493,7 @@
             // 
             // menuHelpWebsite
             // 
-            this.menuHelpWebsite.Image = global::UVtools.GUI.Properties.Resources.Global_Network_icon_16x16;
+            this.menuHelpWebsite.Image = global::UVtools.GUI.Properties.Resources.internet_explorer_16x16;
             this.menuHelpWebsite.Name = "menuHelpWebsite";
             this.menuHelpWebsite.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.F1)));
             this.menuHelpWebsite.Size = new System.Drawing.Size(231, 22);
@@ -534,6 +532,13 @@
             this.menuHelpInstallPrinters.Text = "Install profiles into PrusaSlicer";
             this.menuHelpInstallPrinters.Click += new System.EventHandler(this.EventClick);
             // 
+            // viewToolStripMenuItem
+            // 
+            this.viewToolStripMenuItem.Name = "viewToolStripMenuItem";
+            this.viewToolStripMenuItem.Size = new System.Drawing.Size(44, 20);
+            this.viewToolStripMenuItem.Text = "&View";
+            this.viewToolStripMenuItem.Visible = false;
+            // 
             // menuNewVersion
             // 
             this.menuNewVersion.BackColor = System.Drawing.Color.Lime;
@@ -647,7 +652,7 @@
             // tsLayerResolution
             // 
             this.tsLayerResolution.Alignment = System.Windows.Forms.ToolStripItemAlignment.Right;
-            this.tsLayerResolution.Image = global::UVtools.GUI.Properties.Resources.resize_16x16;
+            this.tsLayerResolution.Image = global::UVtools.GUI.Properties.Resources.expand_16x16;
             this.tsLayerResolution.Name = "tsLayerResolution";
             this.tsLayerResolution.Size = new System.Drawing.Size(79, 22);
             this.tsLayerResolution.Text = "Resolution";
@@ -679,7 +684,7 @@
             // tsLayerImagePanLocation
             // 
             this.tsLayerImagePanLocation.Alignment = System.Windows.Forms.ToolStripItemAlignment.Right;
-            this.tsLayerImagePanLocation.Image = global::UVtools.GUI.Properties.Resources.cursor_16x16;
+            this.tsLayerImagePanLocation.Image = global::UVtools.GUI.Properties.Resources.map_marker_16x16;
             this.tsLayerImagePanLocation.Name = "tsLayerImagePanLocation";
             this.tsLayerImagePanLocation.Size = new System.Drawing.Size(79, 22);
             this.tsLayerImagePanLocation.Text = "{X=0, Y=0}";
@@ -695,7 +700,7 @@
             // tsLayerImageMouseLocation
             // 
             this.tsLayerImageMouseLocation.Alignment = System.Windows.Forms.ToolStripItemAlignment.Right;
-            this.tsLayerImageMouseLocation.Image = global::UVtools.GUI.Properties.Resources.pointer_16x16;
+            this.tsLayerImageMouseLocation.Image = global::UVtools.GUI.Properties.Resources.map_marker_16x16;
             this.tsLayerImageMouseLocation.Name = "tsLayerImageMouseLocation";
             this.tsLayerImageMouseLocation.Size = new System.Drawing.Size(79, 22);
             this.tsLayerImageMouseLocation.Text = "{X=0, Y=0}";
@@ -717,7 +722,7 @@
             // 
             // tsLayerBounds
             // 
-            this.tsLayerBounds.Image = global::UVtools.GUI.Properties.Resources.resize_16x16;
+            this.tsLayerBounds.Image = global::UVtools.GUI.Properties.Resources.expand_16x16;
             this.tsLayerBounds.Name = "tsLayerBounds";
             this.tsLayerBounds.Size = new System.Drawing.Size(66, 22);
             this.tsLayerBounds.Text = "Bounds:";
@@ -901,7 +906,7 @@
             // tsLayerRmove
             // 
             this.tsLayerRmove.Alignment = System.Windows.Forms.ToolStripItemAlignment.Right;
-            this.tsLayerRmove.Image = global::UVtools.GUI.Properties.Resources.delete_16x16;
+            this.tsLayerRmove.Image = global::UVtools.GUI.Properties.Resources.trash_16x16;
             this.tsLayerRmove.ImageTransparentColor = System.Drawing.Color.Magenta;
             this.tsLayerRmove.Name = "tsLayerRmove";
             this.tsLayerRmove.Size = new System.Drawing.Size(101, 22);
@@ -939,7 +944,7 @@
             // tbpThumbnailsAndInfo
             // 
             this.tbpThumbnailsAndInfo.Controls.Add(this.scLeft);
-            this.tbpThumbnailsAndInfo.ImageKey = "PhotoInfo-16x16.png";
+            this.tbpThumbnailsAndInfo.ImageKey = "Button-Info-16x16.png";
             this.tbpThumbnailsAndInfo.Location = new System.Drawing.Point(4, 42);
             this.tbpThumbnailsAndInfo.Name = "tbpThumbnailsAndInfo";
             this.tbpThumbnailsAndInfo.Padding = new System.Windows.Forms.Padding(3);
@@ -964,7 +969,7 @@
             // 
             // scLeft.Panel2
             // 
-            this.scLeft.Panel2.Controls.Add(this.lvProperties);
+            this.scLeft.Panel2.Controls.Add(this.flvProperties);
             this.scLeft.Panel2.Controls.Add(this.tsProperties);
             this.scLeft.Size = new System.Drawing.Size(380, 707);
             this.scLeft.SplitterDistance = 425;
@@ -1075,7 +1080,7 @@
             this.tsThumbnailsImport.ImageTransparentColor = System.Drawing.Color.Magenta;
             this.tsThumbnailsImport.Name = "tsThumbnailsImport";
             this.tsThumbnailsImport.Size = new System.Drawing.Size(23, 22);
-            this.tsThumbnailsImport.Text = "toolStripButton1";
+            this.tsThumbnailsImport.Text = "Change Preview";
             this.tsThumbnailsImport.ToolTipText = "Replace the current preview image";
             this.tsThumbnailsImport.Click += new System.EventHandler(this.EventClick);
             // 
@@ -1093,32 +1098,30 @@
             this.tsThumbnailsResolution.Text = "Resolution";
             this.tsThumbnailsResolution.ToolTipText = "Thumbnail Resolution";
             // 
-            // lvProperties
-            // 
-            this.lvProperties.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
-            this.lvChKey,
-            this.lvChValue});
-            this.lvProperties.Dock = System.Windows.Forms.DockStyle.Fill;
-            this.lvProperties.FullRowSelect = true;
-            this.lvProperties.GridLines = true;
-            this.lvProperties.HideSelection = false;
-            this.lvProperties.Location = new System.Drawing.Point(0, 25);
-            this.lvProperties.Name = "lvProperties";
-            this.lvProperties.Size = new System.Drawing.Size(380, 253);
-            this.lvProperties.TabIndex = 1;
-            this.lvProperties.UseCompatibleStateImageBehavior = false;
-            this.lvProperties.View = System.Windows.Forms.View.Details;
-            this.lvProperties.KeyUp += new System.Windows.Forms.KeyEventHandler(this.EventKeyUp);
-            // 
-            // lvChKey
-            // 
-            this.lvChKey.Text = "Key";
-            this.lvChKey.Width = 183;
-            // 
-            // lvChValue
-            // 
-            this.lvChValue.Text = "Value";
-            this.lvChValue.Width = 205;
+            // flvProperties
+            // 
+            this.flvProperties.AllowColumnReorder = true;
+            this.flvProperties.Cursor = System.Windows.Forms.Cursors.Default;
+            this.flvProperties.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.flvProperties.EmptyListMsg = "No properties";
+            this.flvProperties.FullRowSelect = true;
+            this.flvProperties.GridLines = true;
+            this.flvProperties.HideSelection = false;
+            this.flvProperties.IncludeColumnHeadersInCopy = true;
+            this.flvProperties.Location = new System.Drawing.Point(0, 25);
+            this.flvProperties.Name = "flvProperties";
+            this.flvProperties.ShowGroups = false;
+            this.flvProperties.ShowItemCountOnGroups = true;
+            this.flvProperties.Size = new System.Drawing.Size(380, 253);
+            this.flvProperties.TabIndex = 9;
+            this.flvProperties.UseCompatibleStateImageBehavior = false;
+            this.flvProperties.UseExplorerTheme = true;
+            this.flvProperties.UseFilterIndicator = true;
+            this.flvProperties.UseFiltering = true;
+            this.flvProperties.UseHotItem = true;
+            this.flvProperties.View = System.Windows.Forms.View.Details;
+            this.flvProperties.VirtualMode = true;
+            this.flvProperties.KeyUp += new System.Windows.Forms.KeyEventHandler(this.EventKeyUp);
             // 
             // tsProperties
             // 
@@ -1187,7 +1190,7 @@
             // 
             this.tabPageGCode.Controls.Add(this.tbGCode);
             this.tabPageGCode.Controls.Add(this.tsGCode);
-            this.tabPageGCode.ImageKey = "GCode-16x16.png";
+            this.tabPageGCode.ImageKey = "code-16x16.png";
             this.tabPageGCode.Location = new System.Drawing.Point(4, 42);
             this.tabPageGCode.Name = "tabPageGCode";
             this.tabPageGCode.Size = new System.Drawing.Size(386, 713);
@@ -1250,7 +1253,8 @@
             // 
             // tabPageIssues
             // 
-            this.tabPageIssues.Controls.Add(this.lvIssues);
+            this.tabPageIssues.Controls.Add(this.flvIssues);
+            this.tabPageIssues.Controls.Add(this.tsIssuesLv);
             this.tabPageIssues.Controls.Add(this.tsIssues);
             this.tabPageIssues.ImageKey = "warning-16x16.png";
             this.tabPageIssues.Location = new System.Drawing.Point(4, 42);
@@ -1261,55 +1265,104 @@
             this.tabPageIssues.Text = "Issues";
             this.tabPageIssues.UseVisualStyleBackColor = true;
             // 
-            // lvIssues
-            // 
-            this.lvIssues.Activation = System.Windows.Forms.ItemActivation.TwoClick;
-            this.lvIssues.AllowColumnReorder = true;
-            this.lvIssues.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
-            this.lvIssuesType,
-            this.lvIssuesCount,
-            this.lvIssuesLayerHeader,
-            this.lvIssuesXY,
-            this.lvIssuesPixels});
-            this.lvIssues.Dock = System.Windows.Forms.DockStyle.Fill;
-            this.lvIssues.FullRowSelect = true;
-            this.lvIssues.GridLines = true;
-            this.lvIssues.HideSelection = false;
-            this.lvIssues.Location = new System.Drawing.Point(3, 28);
-            this.lvIssues.Name = "lvIssues";
-            this.lvIssues.Size = new System.Drawing.Size(380, 682);
-            this.lvIssues.TabIndex = 8;
-            this.lvIssues.UseCompatibleStateImageBehavior = false;
-            this.lvIssues.View = System.Windows.Forms.View.Details;
-            this.lvIssues.ColumnClick += new System.Windows.Forms.ColumnClickEventHandler(this.EventColumnClick);
-            this.lvIssues.ItemActivate += new System.EventHandler(this.EventItemActivate);
-            this.lvIssues.SelectedIndexChanged += new System.EventHandler(this.EventSelectedIndexChanged);
-            this.lvIssues.KeyUp += new System.Windows.Forms.KeyEventHandler(this.EventKeyUp);
-            // 
-            // lvIssuesType
-            // 
-            this.lvIssuesType.Text = "Type";
-            this.lvIssuesType.Width = 100;
-            // 
-            // lvIssuesCount
-            // 
-            this.lvIssuesCount.Text = "#";
-            this.lvIssuesCount.Width = 50;
-            // 
-            // lvIssuesLayerHeader
-            // 
-            this.lvIssuesLayerHeader.Text = "Layer";
-            this.lvIssuesLayerHeader.Width = 50;
-            // 
-            // lvIssuesXY
-            // 
-            this.lvIssuesXY.Text = "X, Y";
-            this.lvIssuesXY.Width = 100;
-            // 
-            // lvIssuesPixels
-            // 
-            this.lvIssuesPixels.Text = "Pixels";
-            this.lvIssuesPixels.Width = 70;
+            // flvIssues
+            // 
+            this.flvIssues.AllColumns.Add(this.flvIssuesColType);
+            this.flvIssues.AllColumns.Add(this.flvIssuesColLayerIndex);
+            this.flvIssues.AllColumns.Add(this.flvIssuesColPosition);
+            this.flvIssues.AllColumns.Add(this.flvIssuesColPixels);
+            this.flvIssues.AllowColumnReorder = true;
+            this.flvIssues.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
+            this.flvIssuesColType,
+            this.flvIssuesColLayerIndex,
+            this.flvIssuesColPosition,
+            this.flvIssuesColPixels});
+            this.flvIssues.Cursor = System.Windows.Forms.Cursors.Default;
+            this.flvIssues.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.flvIssues.EmptyListMsg = "No issues";
+            this.flvIssues.FullRowSelect = true;
+            this.flvIssues.GridLines = true;
+            this.flvIssues.HideSelection = false;
+            this.flvIssues.IncludeColumnHeadersInCopy = true;
+            this.flvIssues.Location = new System.Drawing.Point(3, 53);
+            this.flvIssues.Name = "flvIssues";
+            this.flvIssues.ShowGroups = false;
+            this.flvIssues.ShowItemCountOnGroups = true;
+            this.flvIssues.Size = new System.Drawing.Size(380, 657);
+            this.flvIssues.TabIndex = 9;
+            this.flvIssues.UseCompatibleStateImageBehavior = false;
+            this.flvIssues.UseExplorerTheme = true;
+            this.flvIssues.UseFilterIndicator = true;
+            this.flvIssues.UseFiltering = true;
+            this.flvIssues.UseHotItem = true;
+            this.flvIssues.View = System.Windows.Forms.View.Details;
+            this.flvIssues.VirtualMode = true;
+            this.flvIssues.SelectionChanged += new System.EventHandler(this.EventSelectedIndexChanged);
+            this.flvIssues.ItemActivate += new System.EventHandler(this.EventItemActivate);
+            this.flvIssues.KeyUp += new System.Windows.Forms.KeyEventHandler(this.EventKeyUp);
+            // 
+            // flvIssuesColType
+            // 
+            this.flvIssuesColType.AspectName = "Type";
+            this.flvIssuesColType.Text = "Type";
+            this.flvIssuesColType.Width = 100;
+            // 
+            // flvIssuesColLayerIndex
+            // 
+            this.flvIssuesColLayerIndex.AspectName = "LayerIndex";
+            this.flvIssuesColLayerIndex.Text = "Layer";
+            this.flvIssuesColLayerIndex.Width = 56;
+            // 
+            // flvIssuesColPosition
+            // 
+            this.flvIssuesColPosition.AspectName = "FirstPointStr";
+            this.flvIssuesColPosition.Text = "Position (X,Y)";
+            this.flvIssuesColPosition.Width = 110;
+            // 
+            // flvIssuesColPixels
+            // 
+            this.flvIssuesColPixels.AspectName = "PixelsCount";
+            this.flvIssuesColPixels.Text = "Pixels";
+            this.flvIssuesColPixels.Width = 100;
+            // 
+            // tsIssuesLv
+            // 
+            this.tsIssuesLv.GripStyle = System.Windows.Forms.ToolStripGripStyle.Hidden;
+            this.tsIssuesLv.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
+            this.btnIssueGroup,
+            this.toolStripSeparator23,
+            this.btnIssueResort});
+            this.tsIssuesLv.Location = new System.Drawing.Point(3, 28);
+            this.tsIssuesLv.Name = "tsIssuesLv";
+            this.tsIssuesLv.Size = new System.Drawing.Size(380, 25);
+            this.tsIssuesLv.TabIndex = 10;
+            this.tsIssuesLv.Text = "Thumbnail Menu";
+            // 
+            // btnIssueGroup
+            // 
+            this.btnIssueGroup.CheckOnClick = true;
+            this.btnIssueGroup.Image = global::UVtools.GUI.Properties.Resources.list_16x16;
+            this.btnIssueGroup.ImageTransparentColor = System.Drawing.Color.Magenta;
+            this.btnIssueGroup.Name = "btnIssueGroup";
+            this.btnIssueGroup.Size = new System.Drawing.Size(60, 22);
+            this.btnIssueGroup.Text = "Group";
+            this.btnIssueGroup.ToolTipText = "Group items by issue type";
+            this.btnIssueGroup.Click += new System.EventHandler(this.EventClick);
+            // 
+            // toolStripSeparator23
+            // 
+            this.toolStripSeparator23.Name = "toolStripSeparator23";
+            this.toolStripSeparator23.Size = new System.Drawing.Size(6, 25);
+            // 
+            // btnIssueResort
+            // 
+            this.btnIssueResort.Image = global::UVtools.GUI.Properties.Resources.sort_alpha_up_16x16;
+            this.btnIssueResort.ImageTransparentColor = System.Drawing.Color.Magenta;
+            this.btnIssueResort.Name = "btnIssueResort";
+            this.btnIssueResort.Size = new System.Drawing.Size(60, 22);
+            this.btnIssueResort.Text = "Resort";
+            this.btnIssueResort.ToolTipText = "Reset sorting on issues";
+            this.btnIssueResort.Click += new System.EventHandler(this.EventClick);
             // 
             // tsIssues
             // 
@@ -1320,7 +1373,7 @@
             this.tsIssueNext,
             this.toolStripSeparator13,
             this.tsIssueRemove,
-            this.tsIsuesRefresh,
+            this.tsIssuesRefresh,
             this.toolStripSeparator12,
             this.tsIssuesRepair});
             this.tsIssues.Location = new System.Drawing.Point(3, 3);
@@ -1368,7 +1421,7 @@
             // tsIssueRemove
             // 
             this.tsIssueRemove.Enabled = false;
-            this.tsIssueRemove.Image = global::UVtools.GUI.Properties.Resources.delete_16x16;
+            this.tsIssueRemove.Image = global::UVtools.GUI.Properties.Resources.trash_16x16;
             this.tsIssueRemove.ImageTransparentColor = System.Drawing.Color.Magenta;
             this.tsIssueRemove.Name = "tsIssueRemove";
             this.tsIssueRemove.Size = new System.Drawing.Size(70, 22);
@@ -1378,37 +1431,37 @@
     "tion, need reslice.";
             this.tsIssueRemove.Click += new System.EventHandler(this.EventClick);
             // 
-            // tsIsuesRefresh
-            // 
-            this.tsIsuesRefresh.Alignment = System.Windows.Forms.ToolStripItemAlignment.Right;
-            this.tsIsuesRefresh.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-            this.tsIsuesRefreshIslands,
-            this.tsIsuesRefreshResinTraps});
-            this.tsIsuesRefresh.Image = global::UVtools.GUI.Properties.Resources.refresh_16x16;
-            this.tsIsuesRefresh.ImageTransparentColor = System.Drawing.Color.Magenta;
-            this.tsIsuesRefresh.Name = "tsIsuesRefresh";
-            this.tsIsuesRefresh.Size = new System.Drawing.Size(73, 22);
-            this.tsIsuesRefresh.Text = "&Detect";
-            this.tsIsuesRefresh.ToolTipText = "Compute Issues";
-            this.tsIsuesRefresh.ButtonClick += new System.EventHandler(this.EventClick);
-            // 
-            // tsIsuesRefreshIslands
-            // 
-            this.tsIsuesRefreshIslands.Checked = true;
-            this.tsIsuesRefreshIslands.CheckOnClick = true;
-            this.tsIsuesRefreshIslands.CheckState = System.Windows.Forms.CheckState.Checked;
-            this.tsIsuesRefreshIslands.Name = "tsIsuesRefreshIslands";
-            this.tsIsuesRefreshIslands.Size = new System.Drawing.Size(211, 22);
-            this.tsIsuesRefreshIslands.Text = "Islands && Touching Bonds";
-            // 
-            // tsIsuesRefreshResinTraps
-            // 
-            this.tsIsuesRefreshResinTraps.Checked = true;
-            this.tsIsuesRefreshResinTraps.CheckOnClick = true;
-            this.tsIsuesRefreshResinTraps.CheckState = System.Windows.Forms.CheckState.Checked;
-            this.tsIsuesRefreshResinTraps.Name = "tsIsuesRefreshResinTraps";
-            this.tsIsuesRefreshResinTraps.Size = new System.Drawing.Size(211, 22);
-            this.tsIsuesRefreshResinTraps.Text = "Resin traps";
+            // tsIssuesRefresh
+            // 
+            this.tsIssuesRefresh.Alignment = System.Windows.Forms.ToolStripItemAlignment.Right;
+            this.tsIssuesRefresh.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
+            this.tsIssuesRefreshIslands,
+            this.tsIssuesRefreshResinTraps});
+            this.tsIssuesRefresh.Image = global::UVtools.GUI.Properties.Resources.refresh_16x16;
+            this.tsIssuesRefresh.ImageTransparentColor = System.Drawing.Color.Magenta;
+            this.tsIssuesRefresh.Name = "tsIssuesRefresh";
+            this.tsIssuesRefresh.Size = new System.Drawing.Size(73, 22);
+            this.tsIssuesRefresh.Text = "&Detect";
+            this.tsIssuesRefresh.ToolTipText = "Compute Issues";
+            this.tsIssuesRefresh.ButtonClick += new System.EventHandler(this.EventClick);
+            // 
+            // tsIssuesRefreshIslands
+            // 
+            this.tsIssuesRefreshIslands.Checked = true;
+            this.tsIssuesRefreshIslands.CheckOnClick = true;
+            this.tsIssuesRefreshIslands.CheckState = System.Windows.Forms.CheckState.Checked;
+            this.tsIssuesRefreshIslands.Name = "tsIssuesRefreshIslands";
+            this.tsIssuesRefreshIslands.Size = new System.Drawing.Size(211, 22);
+            this.tsIssuesRefreshIslands.Text = "Islands && Touching Bonds";
+            // 
+            // tsIssuesRefreshResinTraps
+            // 
+            this.tsIssuesRefreshResinTraps.Checked = true;
+            this.tsIssuesRefreshResinTraps.CheckOnClick = true;
+            this.tsIssuesRefreshResinTraps.CheckState = System.Windows.Forms.CheckState.Checked;
+            this.tsIssuesRefreshResinTraps.Name = "tsIssuesRefreshResinTraps";
+            this.tsIssuesRefreshResinTraps.Size = new System.Drawing.Size(211, 22);
+            this.tsIssuesRefreshResinTraps.Text = "Resin traps";
             // 
             // toolStripSeparator12
             // 
@@ -1430,7 +1483,7 @@
             // 
             // tabPagePixelEditor
             // 
-            this.tabPagePixelEditor.Controls.Add(this.lvPixelHistory);
+            this.tabPagePixelEditor.Controls.Add(this.flvPixelHistory);
             this.tabPagePixelEditor.Controls.Add(this.tsPixelEditorHistory);
             this.tabPagePixelEditor.Controls.Add(this.tabControlPixelEditor);
             this.tabPagePixelEditor.ImageKey = "pixel-16x16.png";
@@ -1442,46 +1495,64 @@
             this.tabPagePixelEditor.Text = "Pixel Editor";
             this.tabPagePixelEditor.UseVisualStyleBackColor = true;
             // 
-            // lvPixelHistory
-            // 
-            this.lvPixelHistory.AllowColumnReorder = true;
-            this.lvPixelHistory.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
-            this.columnHeader5,
-            this.columnHeader1,
-            this.columnHeader2,
-            this.columnHeader3});
-            this.lvPixelHistory.Dock = System.Windows.Forms.DockStyle.Fill;
-            this.lvPixelHistory.FullRowSelect = true;
-            this.lvPixelHistory.GridLines = true;
-            this.lvPixelHistory.HideSelection = false;
-            this.lvPixelHistory.Location = new System.Drawing.Point(3, 350);
-            this.lvPixelHistory.Name = "lvPixelHistory";
-            this.lvPixelHistory.Size = new System.Drawing.Size(380, 360);
-            this.lvPixelHistory.TabIndex = 1;
-            this.lvPixelHistory.UseCompatibleStateImageBehavior = false;
-            this.lvPixelHistory.View = System.Windows.Forms.View.Details;
-            this.lvPixelHistory.ItemActivate += new System.EventHandler(this.EventItemActivate);
-            this.lvPixelHistory.SelectedIndexChanged += new System.EventHandler(this.EventSelectedIndexChanged);
-            this.lvPixelHistory.KeyUp += new System.Windows.Forms.KeyEventHandler(this.EventKeyUp);
-            // 
-            // columnHeader5
-            // 
-            this.columnHeader5.Text = "#";
-            this.columnHeader5.Width = 50;
-            // 
-            // columnHeader1
-            // 
-            this.columnHeader1.Text = "Operation";
-            this.columnHeader1.Width = 100;
-            // 
-            // columnHeader2
-            // 
-            this.columnHeader2.Text = "Layer";
-            // 
-            // columnHeader3
-            // 
-            this.columnHeader3.Text = "Position";
-            this.columnHeader3.Width = 130;
+            // flvPixelHistory
+            // 
+            this.flvPixelHistory.AllColumns.Add(this.flvPixelHistoryColNumber);
+            this.flvPixelHistory.AllColumns.Add(this.flvPixelHistoryColOperation);
+            this.flvPixelHistory.AllColumns.Add(this.olvColumn3);
+            this.flvPixelHistory.AllColumns.Add(this.olvColumn4);
+            this.flvPixelHistory.AllowColumnReorder = true;
+            this.flvPixelHistory.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
+            this.flvPixelHistoryColNumber,
+            this.flvPixelHistoryColOperation,
+            this.olvColumn3,
+            this.olvColumn4});
+            this.flvPixelHistory.Cursor = System.Windows.Forms.Cursors.Default;
+            this.flvPixelHistory.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.flvPixelHistory.EmptyListMsg = "No operations";
+            this.flvPixelHistory.FullRowSelect = true;
+            this.flvPixelHistory.GridLines = true;
+            this.flvPixelHistory.HideSelection = false;
+            this.flvPixelHistory.IncludeColumnHeadersInCopy = true;
+            this.flvPixelHistory.Location = new System.Drawing.Point(3, 350);
+            this.flvPixelHistory.Name = "flvPixelHistory";
+            this.flvPixelHistory.ShowGroups = false;
+            this.flvPixelHistory.ShowItemCountOnGroups = true;
+            this.flvPixelHistory.Size = new System.Drawing.Size(380, 360);
+            this.flvPixelHistory.TabIndex = 8;
+            this.flvPixelHistory.UseCompatibleStateImageBehavior = false;
+            this.flvPixelHistory.UseExplorerTheme = true;
+            this.flvPixelHistory.UseFilterIndicator = true;
+            this.flvPixelHistory.UseFiltering = true;
+            this.flvPixelHistory.UseHotItem = true;
+            this.flvPixelHistory.View = System.Windows.Forms.View.Details;
+            this.flvPixelHistory.VirtualMode = true;
+            this.flvPixelHistory.SelectionChanged += new System.EventHandler(this.EventSelectedIndexChanged);
+            this.flvPixelHistory.ItemActivate += new System.EventHandler(this.EventItemActivate);
+            this.flvPixelHistory.KeyUp += new System.Windows.Forms.KeyEventHandler(this.EventKeyUp);
+            // 
+            // flvPixelHistoryColNumber
+            // 
+            this.flvPixelHistoryColNumber.AspectName = "Index";
+            this.flvPixelHistoryColNumber.Text = "#";
+            this.flvPixelHistoryColNumber.Width = 46;
+            // 
+            // flvPixelHistoryColOperation
+            // 
+            this.flvPixelHistoryColOperation.AspectName = "OperationType";
+            this.flvPixelHistoryColOperation.Text = "Operation";
+            this.flvPixelHistoryColOperation.Width = 98;
+            // 
+            // olvColumn3
+            // 
+            this.olvColumn3.AspectName = "LayerIndex";
+            this.olvColumn3.Text = "Layer";
+            // 
+            // olvColumn4
+            // 
+            this.olvColumn4.AspectName = "Location";
+            this.olvColumn4.Text = "Position";
+            this.olvColumn4.Width = 149;
             // 
             // tsPixelEditorHistory
             // 
@@ -1913,7 +1984,7 @@
             // tabPageLog
             // 
             this.tabPageLog.Controls.Add(this.lvLog);
-            this.tabPageLog.Controls.Add(this.toolStrip1);
+            this.tabPageLog.Controls.Add(this.tsLog);
             this.tabPageLog.ImageKey = "log-16x16.png";
             this.tabPageLog.Location = new System.Drawing.Point(4, 42);
             this.tabPageLog.Name = "tabPageLog";
@@ -1928,32 +1999,40 @@
             this.lvLog.AllowColumnReorder = true;
             this.lvLog.Cursor = System.Windows.Forms.Cursors.Default;
             this.lvLog.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.lvLog.EmptyListMsg = "No operations";
             this.lvLog.FullRowSelect = true;
             this.lvLog.GridLines = true;
             this.lvLog.HideSelection = false;
+            this.lvLog.IncludeColumnHeadersInCopy = true;
             this.lvLog.Location = new System.Drawing.Point(3, 28);
             this.lvLog.Name = "lvLog";
             this.lvLog.ShowGroups = false;
+            this.lvLog.ShowItemCountOnGroups = true;
             this.lvLog.Size = new System.Drawing.Size(380, 682);
             this.lvLog.TabIndex = 1;
             this.lvLog.UseCompatibleStateImageBehavior = false;
+            this.lvLog.UseExplorerTheme = true;
+            this.lvLog.UseFilterIndicator = true;
+            this.lvLog.UseFiltering = true;
+            this.lvLog.UseHotItem = true;
             this.lvLog.View = System.Windows.Forms.View.Details;
+            this.lvLog.VirtualMode = true;
             // 
-            // toolStrip1
+            // tsLog
             // 
-            this.toolStrip1.GripStyle = System.Windows.Forms.ToolStripGripStyle.Hidden;
-            this.toolStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
+            this.tsLog.GripStyle = System.Windows.Forms.ToolStripGripStyle.Hidden;
+            this.tsLog.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
             this.btnLogClear,
             this.lbLogOperations});
-            this.toolStrip1.Location = new System.Drawing.Point(3, 3);
-            this.toolStrip1.Name = "toolStrip1";
-            this.toolStrip1.Size = new System.Drawing.Size(380, 25);
-            this.toolStrip1.TabIndex = 0;
-            this.toolStrip1.Text = "toolStrip1";
+            this.tsLog.Location = new System.Drawing.Point(3, 3);
+            this.tsLog.Name = "tsLog";
+            this.tsLog.Size = new System.Drawing.Size(380, 25);
+            this.tsLog.TabIndex = 0;
+            this.tsLog.Text = "Log";
             // 
             // btnLogClear
             // 
-            this.btnLogClear.Image = global::UVtools.GUI.Properties.Resources.delete_16x16;
+            this.btnLogClear.Image = global::UVtools.GUI.Properties.Resources.trash_16x16;
             this.btnLogClear.ImageTransparentColor = System.Drawing.Color.Magenta;
             this.btnLogClear.Name = "btnLogClear";
             this.btnLogClear.Size = new System.Drawing.Size(54, 22);
@@ -1972,9 +2051,9 @@
             // 
             this.imageList16x16.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList16x16.ImageStream")));
             this.imageList16x16.TransparentColor = System.Drawing.Color.Transparent;
-            this.imageList16x16.Images.SetKeyName(0, "DataList-16x16.png");
+            this.imageList16x16.Images.SetKeyName(0, "Button-Info-16x16.png");
             this.imageList16x16.Images.SetKeyName(1, "PhotoInfo-16x16.png");
-            this.imageList16x16.Images.SetKeyName(2, "GCode-16x16.png");
+            this.imageList16x16.Images.SetKeyName(2, "code-16x16.png");
             this.imageList16x16.Images.SetKeyName(3, "warning-16x16.png");
             this.imageList16x16.Images.SetKeyName(4, "pixel-16x16.png");
             this.imageList16x16.Images.SetKeyName(5, "log-16x16.png");
@@ -2189,6 +2268,7 @@
             ((System.ComponentModel.ISupportInitialize)(this.pbThumbnail)).EndInit();
             this.tsThumbnails.ResumeLayout(false);
             this.tsThumbnails.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)(this.flvProperties)).EndInit();
             this.tsProperties.ResumeLayout(false);
             this.tsProperties.PerformLayout();
             this.tabPageGCode.ResumeLayout(false);
@@ -2197,10 +2277,14 @@
             this.tsGCode.PerformLayout();
             this.tabPageIssues.ResumeLayout(false);
             this.tabPageIssues.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)(this.flvIssues)).EndInit();
+            this.tsIssuesLv.ResumeLayout(false);
+            this.tsIssuesLv.PerformLayout();
             this.tsIssues.ResumeLayout(false);
             this.tsIssues.PerformLayout();
             this.tabPagePixelEditor.ResumeLayout(false);
             this.tabPagePixelEditor.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)(this.flvPixelHistory)).EndInit();
             this.tsPixelEditorHistory.ResumeLayout(false);
             this.tsPixelEditorHistory.PerformLayout();
             this.tabControlPixelEditor.ResumeLayout(false);
@@ -2224,8 +2308,8 @@
             this.tabPageLog.ResumeLayout(false);
             this.tabPageLog.PerformLayout();
             ((System.ComponentModel.ISupportInitialize)(this.lvLog)).EndInit();
-            this.toolStrip1.ResumeLayout(false);
-            this.toolStrip1.PerformLayout();
+            this.tsLog.ResumeLayout(false);
+            this.tsLog.PerformLayout();
             this.tlRight.ResumeLayout(false);
             this.panel1.ResumeLayout(false);
             this.panel1.PerformLayout();
@@ -2278,9 +2362,6 @@
         private System.Windows.Forms.ToolStripSeparator toolStripSeparator3;
         private System.Windows.Forms.ToolStripLabel tsGcodeLabelChars;
         private System.Windows.Forms.ToolStripButton tsGCodeButtonSave;
-        private System.Windows.Forms.ListView lvProperties;
-        private System.Windows.Forms.ColumnHeader lvChKey;
-        private System.Windows.Forms.ColumnHeader lvChValue;
         private System.Windows.Forms.ToolStrip tsProperties;
         private System.Windows.Forms.ToolStripLabel tsPropertiesLabelCount;
         private System.Windows.Forms.ToolStripSeparator toolStripSeparator4;
@@ -2301,11 +2382,6 @@
         private System.Windows.Forms.ToolStripButton tsIssuePrevious;
         private System.Windows.Forms.ToolStripButton tsIssueNext;
         private System.Windows.Forms.ToolStripLabel tsIssueCount;
-        private System.Windows.Forms.ListView lvIssues;
-        private System.Windows.Forms.ColumnHeader lvIssuesCount;
-        private System.Windows.Forms.ColumnHeader lvIssuesXY;
-        private System.Windows.Forms.ColumnHeader lvIssuesPixels;
-        private System.Windows.Forms.ColumnHeader lvIssuesLayerHeader;
         private System.Windows.Forms.ToolStripSeparator toolStripSeparator12;
         private System.Windows.Forms.ToolStripButton tsIssueRemove;
         private System.Windows.Forms.ToolStripMenuItem menuTools;
@@ -2327,7 +2403,6 @@
         private System.Windows.Forms.Button btnLastLayer;
         private System.Windows.Forms.Button btnFindLayer;
         private System.Windows.Forms.ToolTip toolTipInformation;
-        private System.Windows.Forms.ColumnHeader lvIssuesType;
         private System.Windows.Forms.Timer layerScrollTimer;
         private System.Windows.Forms.ToolStripSplitButton tsLayerImageExport;
         private System.Windows.Forms.ToolStripMenuItem tsLayerImageExportFile;
@@ -2335,9 +2410,9 @@
         private System.Windows.Forms.ToolStripMenuItem menuNewVersion;
         private System.Windows.Forms.ToolStripMenuItem menuFileSettings;
         private System.Windows.Forms.ToolStripSeparator toolStripSeparator15;
-        private System.Windows.Forms.ToolStripSplitButton tsIsuesRefresh;
-        private System.Windows.Forms.ToolStripMenuItem tsIsuesRefreshIslands;
-        private System.Windows.Forms.ToolStripMenuItem tsIsuesRefreshResinTraps;
+        private System.Windows.Forms.ToolStripSplitButton tsIssuesRefresh;
+        private System.Windows.Forms.ToolStripMenuItem tsIssuesRefreshIslands;
+        private System.Windows.Forms.ToolStripMenuItem tsIssuesRefreshResinTraps;
         private System.Windows.Forms.ToolStripSplitButton tsLayerImageLayerOutline;
         private System.Windows.Forms.ToolStripMenuItem tsLayerImageLayerOutlineEdgeDetection;
         private System.Windows.Forms.ToolStripMenuItem tsLayerImageLayerOutlinePrintVolumeBounds;
@@ -2351,7 +2426,6 @@
         private System.Windows.Forms.TabControl tabControlPixelEditor;
         private System.Windows.Forms.TabPage tabPage1;
         private System.Windows.Forms.TabPage tabPage2;
-        private System.Windows.Forms.ListView lvPixelHistory;
         private System.Windows.Forms.ToolStrip tsPixelEditorHistory;
         private System.Windows.Forms.Label label1;
         private System.Windows.Forms.ComboBox cbPixelEditorBrushShape;
@@ -2359,10 +2433,6 @@
         private System.Windows.Forms.Label label2;
         private System.Windows.Forms.Label label3;
         private System.Windows.Forms.NumericUpDown nmPixelEditorBrushSize;
-        private System.Windows.Forms.ColumnHeader columnHeader5;
-        private System.Windows.Forms.ColumnHeader columnHeader1;
-        private System.Windows.Forms.ColumnHeader columnHeader2;
-        private System.Windows.Forms.ColumnHeader columnHeader3;
         private System.Windows.Forms.ToolStripLabel lbPixelHistoryOperations;
         private System.Windows.Forms.Panel panel4;
         private System.Windows.Forms.Label label4;
@@ -2412,10 +2482,25 @@
         private System.Windows.Forms.ToolStripMenuItem tsPropertiesExportClipboard;
         private System.Windows.Forms.ToolStripMenuItem menuToolsChangeResolution;
         private System.Windows.Forms.TabPage tabPageLog;
-        private BrightIdeasSoftware.ObjectListView lvLog;
-        private System.Windows.Forms.ToolStrip toolStrip1;
+        private BrightIdeasSoftware.FastObjectListView lvLog;
+        private System.Windows.Forms.ToolStrip tsLog;
         private System.Windows.Forms.ToolStripButton btnLogClear;
         private System.Windows.Forms.ToolStripLabel lbLogOperations;
+        private BrightIdeasSoftware.FastObjectListView flvPixelHistory;
+        private BrightIdeasSoftware.OLVColumn flvPixelHistoryColNumber;
+        private BrightIdeasSoftware.OLVColumn flvPixelHistoryColOperation;
+        private BrightIdeasSoftware.OLVColumn olvColumn3;
+        private BrightIdeasSoftware.OLVColumn olvColumn4;
+        private BrightIdeasSoftware.FastObjectListView flvProperties;
+        private BrightIdeasSoftware.FastObjectListView flvIssues;
+        private BrightIdeasSoftware.OLVColumn flvIssuesColType;
+        private BrightIdeasSoftware.OLVColumn flvIssuesColLayerIndex;
+        private BrightIdeasSoftware.OLVColumn flvIssuesColPosition;
+        private BrightIdeasSoftware.OLVColumn flvIssuesColPixels;
+        private System.Windows.Forms.ToolStrip tsIssuesLv;
+        private System.Windows.Forms.ToolStripButton btnIssueGroup;
+        private System.Windows.Forms.ToolStripSeparator toolStripSeparator23;
+        private System.Windows.Forms.ToolStripButton btnIssueResort;
     }
 }
 
diff --git a/UVtools.GUI/FrmMain.cs b/UVtools.GUI/FrmMain.cs
index 6e3a7e5..7e2ac2f 100644
--- a/UVtools.GUI/FrmMain.cs
+++ b/UVtools.GUI/FrmMain.cs
@@ -12,6 +12,7 @@ using System.Diagnostics;
 using System.Drawing;
 using System.Drawing.Drawing2D;
 using System.IO;
+using System.Linq;
 using System.Net;
 using System.Reflection;
 using System.Text;
@@ -43,53 +44,53 @@ namespace UVtools.GUI
         public static readonly Dictionary<LayerManager.Mutate, Mutation> Mutations =
             new Dictionary<LayerManager.Mutate, Mutation>
             {
-                {LayerManager.Mutate.Move, new Mutation(LayerManager.Mutate.Move, null,
+                {LayerManager.Mutate.Move, new Mutation(LayerManager.Mutate.Move, null, Resources.move_16x16,
                     "Moves the entire print volume around the plate.\n" +
                     "Note: Margins are in pixel values"
                 )},
-                {LayerManager.Mutate.Resize, new Mutation(LayerManager.Mutate.Resize, null,
+                {LayerManager.Mutate.Resize, new Mutation(LayerManager.Mutate.Resize, null, Resources.crop_16x16,
                     "Resizes layer images in a X and/or Y factor, starting from 100% value\n" +
                     "NOTE 1: Build volume bounds are not validated after operation, please ensure scaling stays inside your limits.\n" +
                     "NOTE 2: X and Y are applied to original image, not to the rotated preview (If enabled)."
                 )},
-                {LayerManager.Mutate.Flip, new Mutation(LayerManager.Mutate.Flip, null,
+                {LayerManager.Mutate.Flip, new Mutation(LayerManager.Mutate.Flip, null, Resources.flip_16x16,
                     "Flips layer images vertically and/or horizontally"
                 )},
-                {LayerManager.Mutate.Rotate, new Mutation(LayerManager.Mutate.Rotate, null,
+                {LayerManager.Mutate.Rotate, new Mutation(LayerManager.Mutate.Rotate, null, Resources.refresh_16x16,
                     "Rotate layer images in a certain degrees"
                 )},
-                {LayerManager.Mutate.Solidify, new Mutation(LayerManager.Mutate.Solidify, null,
+                {LayerManager.Mutate.Solidify, new Mutation(LayerManager.Mutate.Solidify, null, Resources.square_solid_16x16,
                     "Solidifies the selected layers, closes all inner holes.\n" +
                     "Warning: All surrounded holes are filled, no exceptions! Make sure you don't require any of holes in layer path.",
                     Resources.mutation_solidify
                 )},
-                {LayerManager.Mutate.PixelDimming, new Mutation(LayerManager.Mutate.PixelDimming, "Pixel Dimming",
+                {LayerManager.Mutate.PixelDimming, new Mutation(LayerManager.Mutate.PixelDimming, "Pixel Dimming", Resources.chessboard_16x16,
                     "Dims pixels in a chosen pattern over white pixels neighborhood. The selected pattern will be repeated over the image width and height as a mask. Benefits are:\n" +
                     "1) Reduce layer expansion in big masses\n" +
                     "2) Reduce cross layer exposure\n" +
                     "3) Extend pixels life\n" +
                     "NOTE: Run only this tool after all repairs and other transformations"
                 )},
-                {LayerManager.Mutate.Erode, new Mutation(LayerManager.Mutate.Erode, null,
+                {LayerManager.Mutate.Erode, new Mutation(LayerManager.Mutate.Erode, null, Resources.compress_alt_16x16,
                 "The basic idea of erosion is just like soil erosion only, it erodes away the boundaries of foreground object (Always try to keep foreground in white). " +
                         "So what happens is that, all the pixels near boundary will be discarded depending upon the size of kernel. So the thickness or size of the foreground object decreases or simply white region decreases in the image. It is useful for removing small white noises, detach two connected objects, etc.",
-                        Properties.Resources.mutation_erosion
+                        Resources.mutation_erosion
                 )},
-                {LayerManager.Mutate.Dilate, new Mutation(LayerManager.Mutate.Dilate, null,
+                {LayerManager.Mutate.Dilate, new Mutation(LayerManager.Mutate.Dilate, null, Resources.expand_alt_16x16,
                     "It is just opposite of erosion. Here, a pixel element is '1' if at least one pixel under the kernel is '1'. So it increases the white region in the image or size of foreground object increases. Normally, in cases like noise removal, erosion is followed by dilation. Because, erosion removes white noises, but it also shrinks our object. So we dilate it. Since noise is gone, they won't come back, but our object area increases. It is also useful in joining broken parts of an object.",
                     Resources.mutation_dilation
                 )},
-                {LayerManager.Mutate.Opening, new Mutation(LayerManager.Mutate.Opening, "Noise Removal",
+                {LayerManager.Mutate.Opening, new Mutation(LayerManager.Mutate.Opening, "Noise Removal", null,
                     "Noise Removal/Opening is just another name of erosion followed by dilation. It is useful in removing noise.",
-                    Properties.Resources.mutation_opening
+                    Resources.mutation_opening
                 )},
-                {LayerManager.Mutate.Closing, new Mutation(LayerManager.Mutate.Closing, "Gap Closing",
+                {LayerManager.Mutate.Closing, new Mutation(LayerManager.Mutate.Closing, "Gap Closing", Resources.bowling_ball_16x16,
                     "Gap Closing is reverse of Opening, Dilation followed by Erosion. It is useful in closing small holes inside the foreground objects, or small black points on the object.",
-                    Properties.Resources.mutation_closing
+                    Resources.mutation_closing
                 )},
-                {LayerManager.Mutate.Gradient, new Mutation(LayerManager.Mutate.Gradient, null,
+                {LayerManager.Mutate.Gradient, new Mutation(LayerManager.Mutate.Gradient, null, Resources.burn_16x16,
                     "It's the difference between dilation and erosion of an image.",
-                    Properties.Resources.mutation_gradient
+                    Resources.mutation_gradient
                 )},
                 /*{Mutation.Mutates.TopHat, new Mutation(Mutation.Mutates.TopHat,
                     "It's the difference between input image and Opening of the image.",
@@ -103,24 +104,24 @@ namespace UVtools.GUI
                     "The Hit-or-Miss transformation is useful to find patterns in binary images. In particular, it finds those pixels whose neighbourhood matches the shape of a first structuring element B1 while not matching the shape of a second structuring element B2 at the same time.",
                     null
                 )},*/
-                {LayerManager.Mutate.ThresholdPixels, new Mutation(LayerManager.Mutate.ThresholdPixels, "Threshold Pixels",
+                {LayerManager.Mutate.ThresholdPixels, new Mutation(LayerManager.Mutate.ThresholdPixels, "Threshold Pixels", Resources.th_16x16,
                     "Manipulates pixels values giving a threshold, maximum and a operation type.\n" +
                     "If a pixel brightness is less or equal to the threshold value, set this pixel to 0, otherwise set to defined maximum value.\n" +
                     "More info: https://docs.opencv.org/master/d7/d4d/tutorial_py_thresholding.html"
                 )},
-                {LayerManager.Mutate.PyrDownUp, new Mutation(LayerManager.Mutate.PyrDownUp, "Big Blur",
+                {LayerManager.Mutate.PyrDownUp, new Mutation(LayerManager.Mutate.PyrDownUp, "Big Blur", Resources.blur_16x16,
                     "Performs down/up-sampling step of Gaussian pyramid decomposition.\n" +
                     "First down-samples the image by rejecting even rows and columns, after performs up-sampling step of Gaussian pyramid decomposition.\n" +
                     "This operation will add a big blur to edges, creating a over-exaggerated anti-aliasing and as result can make edges smoother\n" +
                     "Note: Printer must support AntiAliasing on firmware to able to use this function."
                 )},
-                {LayerManager.Mutate.SmoothMedian, new Mutation(LayerManager.Mutate.SmoothMedian, "Smooth Median",
+                {LayerManager.Mutate.SmoothMedian, new Mutation(LayerManager.Mutate.SmoothMedian, "Smooth Median", Resources.blur_16x16,
                     "Each pixel becomes the median of its surrounding pixels.\n" +
                     "A good way to remove noise and can be used to reconstruct or intensify the antialiasing level.\n" +
                     "Note 1: Printer must support AntiAliasing on firmware to able to use this function.\n" +
                     "Note 2: Iterations must be a odd number."
                 )},
-                {LayerManager.Mutate.SmoothGaussian, new Mutation(LayerManager.Mutate.SmoothGaussian,  "Smooth Gaussian",
+                {LayerManager.Mutate.SmoothGaussian, new Mutation(LayerManager.Mutate.SmoothGaussian,  "Smooth Gaussian", Resources.blur_16x16,
                     "Each pixel is a sum of fractions of each pixel in its neighborhood\n" +
                     "A good way to remove noise and can be used to reconstruct or intensify the antialiasing level.\n" +
                     "Very fast, but does not preserve sharp edges well.\n" +
@@ -144,9 +145,9 @@ namespace UVtools.GUI
 
         public Mat ActualLayerImageBgr { get; private set; } = new Mat();
 
-        public Dictionary<uint, List<LayerIssue>> Issues { get; set; }
+        public List<LayerIssue> Issues { get; set; }
 
-        public uint TotalIssues { get; set; }
+        public int TotalIssues => Issues?.Count ?? 0;
 
         public bool IsChagingLayer { get; set; }
 
@@ -154,8 +155,6 @@ namespace UVtools.GUI
 
         public uint SavesCount { get; set; } = 0;
 
-        private readonly ListViewColumnSorter lvIssuesColumnSorter;
-
         #endregion
 
         #region Constructors
@@ -175,8 +174,8 @@ namespace UVtools.GUI
             Clear();
 
             tsLayerImageLayerDifference.Checked = Settings.Default.LayerDifferenceDefault;
-            tsIsuesRefreshIslands.Checked = Settings.Default.ComputeIslands;
-            tsIsuesRefreshResinTraps.Checked = Settings.Default.ComputeResinTraps;
+            tsIssuesRefreshIslands.Checked = Settings.Default.ComputeIslands;
+            tsIssuesRefreshResinTraps.Checked = Settings.Default.ComputeResinTraps;
             tsLayerImageLayerOutlinePrintVolumeBounds.Checked = Settings.Default.OutlinePrintVolumeBounds;
             tsLayerImageLayerOutlineLayerBounds.Checked = Settings.Default.OutlineLayerBounds;
             tsLayerImageLayerOutlineHollowAreas.Checked = Settings.Default.OutlineHollowAreas;
@@ -196,19 +195,13 @@ namespace UVtools.GUI
                 if(!Mutations.ContainsKey(mutate)) continue;
                 var item = new ToolStripMenuItem(Mutations[mutate].MenuName)
                 {
-                    ToolTipText = Mutations[mutate].Description, Tag = mutate, AutoToolTip = true, Image = Properties.Resources.filter_filled_16x16
+                    ToolTipText = Mutations[mutate].Description, Tag = mutate, AutoToolTip = true, Image = Mutations[mutate].MenuImage
                 };
                 item.Click += EventClick;
                 menuMutate.DropDownItems.Add(item);
             }
 
-            foreach (LayerIssue.IssueType issueType in (LayerIssue.IssueType[]) Enum.GetValues(
-                typeof(LayerIssue.IssueType)))
-            {
-                var group = new ListViewGroup(issueType.ToString(), $"{issueType}s"){HeaderAlignment = HorizontalAlignment.Center};
-                lvIssues.Groups.Add(group);
-            }
-
+            
             foreach (PixelDrawing.BrushShapeType brushShape in (PixelDrawing.BrushShapeType[])Enum.GetValues(
                 typeof(PixelDrawing.BrushShapeType)))
             {
@@ -219,10 +212,25 @@ namespace UVtools.GUI
 
             tbLayer.MouseWheel += TbLayerOnMouseWheel;
 
-            lvIssuesColumnSorter = new ListViewColumnSorter();
-            lvIssues.ListViewItemSorter = lvIssuesColumnSorter;
+            flvIssues.ShowGroups = btnIssueGroup.Checked;
+            flvIssues.AlwaysGroupByColumn = flvIssuesColType;
+            flvIssues.PrimarySortColumn = flvIssuesColType;
+            flvIssues.PrimarySortOrder = SortOrder.Ascending;
+            flvIssues.SecondarySortColumn = flvIssuesColLayerIndex;
+            flvIssues.SecondarySortOrder = SortOrder.Ascending;
 
             Generator.GenerateColumns(lvLog, typeof(Log), true);
+            lvLog.PrimarySortColumn = lvLog.AllColumns[0];
+            lvLog.PrimarySortOrder = SortOrder.Descending;
+
+            flvPixelHistory.ShowGroups = true;
+            flvPixelHistory.AlwaysGroupByColumn = flvPixelHistoryColOperation;
+            flvPixelHistory.PrimarySortColumn = flvPixelHistoryColNumber;
+            flvPixelHistory.PrimarySortOrder = SortOrder.Descending;
+
+            Generator.GenerateColumns(flvProperties, typeof(SlicerPropertyItem), true);
+            flvProperties.ShowGroups = true;
+            flvProperties.AlwaysGroupByColumn = flvProperties.AllColumns[2];
 
             if (Settings.Default.CheckForUpdatesOnStartup)
             {
@@ -268,7 +276,6 @@ namespace UVtools.GUI
         {
             base.OnShown(e);
             AddLog("UVtools Start");
-            lvLog.Sort(lvLog.AllColumns[0], SortOrder.Descending);
             ProcessFile(Program.Args);
         }
 
@@ -1300,9 +1307,10 @@ namespace UVtools.GUI
             {
                 if (!tsIssuePrevious.Enabled) return;
                 int index = Convert.ToInt32(tsIssueCount.Tag);
-                lvIssues.SelectedItems.Clear();
-                lvIssues.Items[--index].Selected = true;
-                EventItemActivate(lvIssues, null);
+                flvIssues.SelectedIndices.Clear();
+                //flvIssues.SelectObject(Issues[--index]);
+                flvIssues.SelectedIndex = --index;
+                EventItemActivate(flvIssues, null);
                 return;
             }
 
@@ -1310,9 +1318,10 @@ namespace UVtools.GUI
             {
                 if (!tsIssueNext.Enabled) return;
                 int index = Convert.ToInt32(tsIssueCount.Tag);
-                lvIssues.SelectedItems.Clear();
-                lvIssues.Items[++index].Selected = true;
-                EventItemActivate(lvIssues, null);
+                flvIssues.SelectedIndices.Clear();
+                //flvIssues.SelectObject(Issues[++index]);
+                flvIssues.SelectedIndex = ++index;
+                EventItemActivate(flvIssues, null);
                 return;
             }
 
@@ -1330,9 +1339,9 @@ namespace UVtools.GUI
                 Dictionary<uint, List<LayerIssue>> processIssues = new Dictionary<uint, List<LayerIssue>>();
                 List<uint> layersRemove = new List<uint>();
 
-                foreach (ListViewItem item in lvIssues.SelectedItems)
+
+                foreach (LayerIssue issue in flvIssues.SelectedObjects)
                 {
-                    if (!(item.Tag is LayerIssue issue)) continue;
                     //if (!issue.HaveValidPoint) continue;
                     if (issue.Type == LayerIssue.IssueType.TouchingBound) continue;
 
@@ -1431,27 +1440,38 @@ namespace UVtools.GUI
 
                 if (!task.Result) return;
 
+                var whiteListLayers = new List<uint>();
+
                 // Update GUI
-                lvIssues.BeginUpdate();
-                foreach (ListViewItem item in lvIssues.SelectedItems)
+                List<LayerIssue> removeList = new List<LayerIssue>();
+                foreach (LayerIssue issue in flvIssues.SelectedObjects)
                 {
-                    if (!(item.Tag is LayerIssue issue)) continue;
                     //if (!issue.HaveValidPoint) continue;
                     if (issue.Type == LayerIssue.IssueType.TouchingBound) continue;
+                    if (issue.Type == LayerIssue.IssueType.Island)
+                    {
+                        var nextLayer = issue.Layer.Index + 1;
+                        if (nextLayer >= SlicerFile.LayerCount) continue;
+                        if (whiteListLayers.Contains(nextLayer)) continue;
+                        whiteListLayers.Add(nextLayer);
+                    }
 
-                    Issues[issue.Layer.Index].Remove(issue);
-                    item.Remove();
-                    TotalIssues--;
+                    Issues.Remove(issue);
+                    removeList.Add(issue);
                 }
-
-                lvIssues.EndUpdate();
+                flvIssues.RemoveObjects(removeList);
 
                 if (layersRemove.Count > 0)
                 {
                     UpdateLayerLimits();
                     RefreshInfo();
                 }
-                
+
+                if (Settings.Default.PartialUpdateIslandsOnEditing)
+                {
+                    UpdateIslands(whiteListLayers);
+                }
+
                 ShowLayer();
                 UpdateIssuesInfo();
                 menuFileSave.Enabled =
@@ -1466,7 +1486,7 @@ namespace UVtools.GUI
                 return;
             }
 
-            if (ReferenceEquals(sender, tsIsuesRefresh))
+            if (ReferenceEquals(sender, tsIssuesRefresh))
             {
                 if (MessageBox.Show("Are you sure you want to compute issues?", "Issues Compute",
                     MessageBoxButtons.YesNo, MessageBoxIcon.Question) != DialogResult.Yes) return;
@@ -1476,18 +1496,33 @@ namespace UVtools.GUI
                 return;
             }
 
+            if (ReferenceEquals(sender, btnIssueGroup))
+            {
+                flvIssues.ClearObjects();
+                flvIssues.ShowGroups = btnIssueGroup.Checked;
+                UpdateIssuesList();
+                return;
+            }
+
+            if (ReferenceEquals(sender, btnIssueResort))
+            {
+                flvIssues.PrimarySortColumn = flvIssuesColType;
+                flvIssues.PrimarySortOrder = SortOrder.Ascending;
+                flvIssues.SecondarySortColumn = flvIssuesColLayerIndex;
+                flvIssues.SecondarySortOrder = SortOrder.Ascending;
+                flvIssues.RebuildColumns();
+                return;
+            }
+
             if (ReferenceEquals(sender, btnPixelHistoryRemove))
             {
                 if (!btnPixelHistoryRemove.Enabled) return;
-                lvPixelHistory.BeginUpdate();
-                foreach (ListViewItem item in lvPixelHistory.SelectedItems)
+                if (flvPixelHistory.SelectedIndices.Count == 0) return;
+                foreach (PixelOperation item in flvPixelHistory.SelectedObjects)
                 {
-                    PixelOperation operation = item.Tag as PixelOperation;
-                    item.Remove();
-                    PixelHistory.Items.Remove(operation);
+                    PixelHistory.Items.Remove(item);
                 }
-                lvPixelHistory.EndUpdate();
-                lbPixelHistoryOperations.Text = $"Operations: {PixelHistory.Count}";
+                RefreshPixelHistory();
 
                 ShowLayer();
             }
@@ -1510,47 +1545,7 @@ namespace UVtools.GUI
             if (ReferenceEquals(sender, btnPixelHistoryApply))
             {
                 if (!btnPixelHistoryApply.Enabled) return;
-                if (PixelHistory.Count == 0) return;
-                if (MessageBox.Show(
-                    "There are unsaved changes on image editor, do you want to apply modifications?",
-                    "Unsaved changes on image editor", MessageBoxButtons.YesNo,
-                    MessageBoxIcon.Question) != DialogResult.Yes) return;
-
-                btnPixelHistoryApply.Enabled = false;
-                DisableGUI();
-                FrmLoading.SetDescription("Drawing pixels");
-
-                Task task = Task.Factory.StartNew(() =>
-                {
-                    try
-                    {
-                        SlicerFile.LayerManager.DrawModifications(PixelHistory, FrmLoading.RestartProgress());
-                    }
-                    catch (OperationCanceledException)
-                    {
-
-                    }
-                    catch (Exception ex)
-                    {
-                        MessageBox.Show($"{ex.Message}", "Drawing was unsuccessful!", MessageBoxButtons.OK, MessageBoxIcon.Error);
-                    }
-                    finally
-                    {
-                        Invoke((MethodInvoker)delegate {
-                            // Running on the UI thread
-                            EnableGUI(true);
-                        });
-                    }
-
-                    return false;
-                });
-
-                FrmLoading.ShowDialog();
-
-                //lvPixelHistory.Items.Clear();
-                PixelHistory.Clear();
-                RefreshPixelHistory();
-                ShowLayer();
+                DrawModifications(false);
             }
 
             if (ReferenceEquals(sender, btnLogClear))
@@ -1601,58 +1596,7 @@ namespace UVtools.GUI
                 }
                 else
                 {
-                    if (PixelHistory.Count > 0)
-                    {
-                        var result =
-                            MessageBox.Show(
-                                "There are unsaved changes on image editor, do you want to apply modifications?",
-                                "Unsaved changes on image editor", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
-
-                        if (result == DialogResult.Cancel)
-                        {
-                            tsLayerImagePixelEdit.Checked = true;
-                            return;
-                        }
-                        if (result == DialogResult.Yes)
-                        {
-                            DisableGUI();
-                            FrmLoading.SetDescription($"Drawing pixels");
-
-                            Task task = Task.Factory.StartNew(() =>
-                            {
-                                try
-                                {
-                                    SlicerFile.LayerManager.DrawModifications(PixelHistory, FrmLoading.RestartProgress());
-                                }
-                                catch (OperationCanceledException)
-                                {
-
-                                }
-                                catch (Exception ex)
-                                {
-                                    MessageBox.Show($"{ex.Message}", "Drawing was unsuccessful!", MessageBoxButtons.OK, MessageBoxIcon.Error);
-                                }
-                                finally
-                                {
-                                    Invoke((MethodInvoker)delegate {
-                                        // Running on the UI thread
-                                        EnableGUI(true);
-                                    });
-                                }
-
-                                return false;
-                            });
-
-                            FrmLoading.ShowDialog();
-                        }
-
-                        //lvPixelHistory.Items.Clear();
-                        PixelHistory.Clear();
-                        RefreshPixelHistory();
-                        ShowLayer();
-                    }
-
-                    tabControlLeft.TabPages.Remove(tabPagePixelEditor);
+                    DrawModifications(true);
                 }
                 return;
             }
@@ -1890,13 +1834,11 @@ namespace UVtools.GUI
 
         private void EventItemActivate(object sender, EventArgs e)
         {
-            if (ReferenceEquals(sender, lvIssues))
+            if (ReferenceEquals(sender, flvIssues))
             {
-                if (lvIssues.SelectedItems.Count == 0) return;
-                var item = lvIssues.SelectedItems[0];
+                if(!(flvIssues.SelectedObject is LayerIssue issue)) return;
 
-                if (!(item.Tag is LayerIssue issue)) return;
-                if (issue.Layer.Index != ActualLayer)
+                if (issue.LayerIndex != ActualLayer)
                 {
                     ShowLayer(issue.Layer.Index);
                 }
@@ -1956,17 +1898,16 @@ namespace UVtools.GUI
                     }
                 }
 
-                tsIssueCount.Tag = lvIssues.SelectedIndices[0];
+                tsIssueCount.Tag = flvIssues.SelectedIndices[0];
                 UpdateIssuesInfo();
                 return;
             }
 
-            if (ReferenceEquals(sender, lvPixelHistory))
+            if (ReferenceEquals(sender, flvPixelHistory))
             {
-                if (lvPixelHistory.SelectedItems.Count == 0) return;
-                var item = lvPixelHistory.SelectedItems[0];
+                //if (flvPixelHistory.SelectedIndices.Count == 0) return;
 
-                if (!(item.Tag is PixelOperation operation)) return;
+                if (!(flvPixelHistory.SelectedObject is PixelOperation operation)) return;
                 if (operation.LayerIndex != ActualLayer)
                 {
                     ShowLayer(operation.LayerIndex);
@@ -2030,10 +1971,7 @@ namespace UVtools.GUI
             tabPageIssues.Tag = null;
 
             Issues = null;
-            TotalIssues = 0;
-            lvIssues.BeginUpdate();
-            lvIssues.Items.Clear();
-            lvIssues.EndUpdate();
+            flvIssues.ClearObjects();
             UpdateIssuesInfo();
 
             PixelHistory.Clear();
@@ -2042,10 +1980,7 @@ namespace UVtools.GUI
             lbMaxLayer.Text = 
             lbActualLayer.Text = 
             lbInitialLayer.Text = "???";
-            lvProperties.BeginUpdate();
-            lvProperties.Items.Clear();
-            lvProperties.Groups.Clear();
-            lvProperties.EndUpdate();
+            flvProperties.ClearObjects();
             pbLayers.Value = 0;
             tbLayer.Value = 0;
 
@@ -2293,8 +2228,8 @@ namespace UVtools.GUI
             {
                 item.Enabled = true;
             }
-            tsPropertiesLabelCount.Text = $"Properties: {lvProperties.Items.Count}";
-            tsPropertiesLabelGroups.Text = $"Groups: {lvProperties.Groups.Count}";
+            tsPropertiesLabelCount.Text = $"Properties: {flvProperties.GetItemCount()}";
+            tsPropertiesLabelGroups.Text = $"Groups: {flvProperties.OLVGroups?.Count ?? 0}";
 
             menuFileReload.Enabled =
             menuFileClose.Enabled =
@@ -2307,7 +2242,7 @@ namespace UVtools.GUI
             menuTools.Enabled =
 
             tsIssuesRepair.Enabled =
-            tsIsuesRefresh.Enabled =
+            tsIssuesRefresh.Enabled =
 
                 btnFindLayer.Enabled =
                 true;
@@ -2381,43 +2316,34 @@ namespace UVtools.GUI
                 }
             }
 
-            lvProperties.BeginUpdate();
-            lvProperties.Items.Clear();
+            flvProperties.ClearObjects();
 
             if (!ReferenceEquals(SlicerFile.Configs, null))
             {
+                List<SlicerPropertyItem> items = new List<SlicerPropertyItem>();
                 foreach (object config in SlicerFile.Configs)
                 {
-                    ListViewGroup group = new ListViewGroup(config.GetType().Name);
-                    lvProperties.Groups.Add(group);
                     foreach (PropertyInfo propertyInfo in config.GetType()
                         .GetProperties(BindingFlags.Public | BindingFlags.Instance))
                     {
                         if(propertyInfo.Name.Equals("Item")) continue;
-                        ListViewItem item = new ListViewItem(propertyInfo.Name, group);
                         var value = propertyInfo.GetValue(config);
-                        if (!ReferenceEquals(value, null))
+                        if (ReferenceEquals(value, null)) continue;
+                        if (value is IList list)
                         {
-                            if (value is IList list)
-                            {
-                                item.SubItems.Add(list.Count.ToString());
-                            }
-                            else
-                            {
-                                item.SubItems.Add(value.ToString());
-                            }
-
+                            items.Add(new SlicerPropertyItem(propertyInfo.Name, list.Count.ToString(), config.GetType().Name));
+                        }
+                        else
+                        {
+                            items.Add(new SlicerPropertyItem(propertyInfo.Name, value.ToString(), config.GetType().Name));
                         }
-
-                        lvProperties.Items.Add(item);
                     }
                 }
+                flvProperties.SetObjects(items);
             }
 
-            lvProperties.EndUpdate();
-
-            tsPropertiesLabelCount.Text = $"Properties: {lvProperties.Items.Count}";
-            tsPropertiesLabelGroups.Text = $"Groups: {lvProperties.Groups.Count}";
+            tsPropertiesLabelCount.Text = $"Properties: {flvProperties.GetItemCount()}";
+            tsPropertiesLabelGroups.Text = $"Groups: {flvProperties.OLVGroups.Count}";
 
             if (!ReferenceEquals(SlicerFile.GCode, null))
             {
@@ -2553,12 +2479,11 @@ namespace UVtools.GUI
                 }
 
                 if (tsLayerImageHighlightIssues.Checked &&
-                    !ReferenceEquals(Issues, null) && 
-                    Issues.TryGetValue(ActualLayer, out var issues))
+                    !ReferenceEquals(Issues, null))
                 {
-                    foreach (var issue in issues)
+                    foreach (var issue in Issues)
                     {
-                        if (ReferenceEquals(issue, null)) continue; // Removed issue
+                        if(issue.LayerIndex != ActualLayer) continue;
                         if(!issue.HaveValidPoint) continue;
                         Color color = Settings.Default.ResinTrapColor;
 
@@ -2776,15 +2701,15 @@ namespace UVtools.GUI
 
         private void EventSelectedIndexChanged(object sender, EventArgs e)
         {
-            if (ReferenceEquals(sender, lvIssues))
+            if (ReferenceEquals(sender, flvIssues))
             {
-                tsIssueRemove.Enabled = lvIssues.SelectedIndices.Count > 0;
+                tsIssueRemove.Enabled = flvIssues.SelectedIndices.Count > 0;
                 return;
             }
 
-            if (ReferenceEquals(sender, lvPixelHistory))
+            if (ReferenceEquals(sender, flvPixelHistory))
             {
-                btnPixelHistoryRemove.Enabled = lvPixelHistory.SelectedIndices.Count > 0;
+                btnPixelHistoryRemove.Enabled = flvPixelHistory.SelectedIndices.Count > 0;
                 return;
             }
 
@@ -2816,88 +2741,59 @@ namespace UVtools.GUI
 
         private void EventKeyUp(object sender, KeyEventArgs e)
         {
-            if (ReferenceEquals(sender, lvProperties))
+            if (ReferenceEquals(sender, flvProperties))
             {
                 if (e.KeyCode == Keys.Escape)
                 {
-                    foreach (ListViewItem item in lvProperties.Items)
-                    {
-                        item.Selected = false;
-                    }
+                    flvProperties.SelectedIndices.Clear();
                     e.Handled = true;
                     return;
                 }
 
-                if (e.Control && e.KeyCode == Keys.A)
-                {
-                    foreach (ListViewItem item in lvProperties.Items)
-                    {
-                        item.Selected = true;
-                    }
-                    e.Handled = true;
-                    return;
-                }
 
                 if (e.KeyCode == Keys.Multiply)
                 {
-                    foreach (ListViewItem item in lvProperties.Items)
-                    {
-                        item.Selected = !item.Selected;
-                    }
-                    e.Handled = true;
-                    return;
-                }
-
-                if (e.Control && e.KeyCode == Keys.C)
-                {
-                    StringBuilder clip = new StringBuilder();
-                    foreach (ListViewItem item in lvProperties.Items)
+                    int[] selectedArray = new int[flvProperties.SelectedIndices.Count];
+                    flvProperties.SelectedIndices.CopyTo(selectedArray, 0);
+                    flvProperties.SelectedIndices.Clear();
+                    for (int i = 0; i < flvProperties.GetItemCount(); i++)
                     {
-                        if(!item.Selected) continue;
-                        if (clip.Length > 0) clip.AppendLine();
-                        clip.Append($"{item.Text}: {item.SubItems[1].Text}");
+                        if (selectedArray.Contains(i)) continue;
+                        flvProperties.SelectedIndices.Add(i);
                     }
 
-                    if (clip.Length > 0)
-                    {
-                        Clipboard.SetText(clip.ToString());
-                    }
                     e.Handled = true;
                     return;
                 }
+
+                
                 return;
             }
 
-            if (ReferenceEquals(sender, lvIssues))
+            if (ReferenceEquals(sender, flvIssues))
             {
                 if (e.KeyCode == Keys.Escape)
                 {
-                    lvIssues.SelectedItems.Clear();
-                    e.Handled = true;
-                    return;
-                }
-
-                if (e.Control && e.KeyCode == Keys.A)
-                {
-                    foreach (ListViewItem item in lvIssues.Items)
-                    {
-                        item.Selected = true;
-                    }
+                    flvIssues.SelectedIndices.Clear();
                     e.Handled = true;
                     return;
                 }
 
                 if (e.KeyCode == Keys.Multiply)
                 {
-                    foreach (ListViewItem item in lvIssues.Items)
+                    int[] selectedArray = new int[flvIssues.SelectedIndices.Count];
+                    flvIssues.SelectedIndices.CopyTo(selectedArray, 0);
+                    flvIssues.SelectedIndices.Clear();
+                    for (int i = 0; i < flvIssues.GetItemCount(); i++)
                     {
-                        item.Selected = !item.Selected;
+                        if (selectedArray.Contains(i)) continue;
+                        flvIssues.SelectedIndices.Add(i);
                     }
                     e.Handled = true;
                     return;
                 }
 
-                if (e.Control && e.KeyCode == Keys.C)
+                /*if (e.Control && e.KeyCode == Keys.C)
                 {
                     StringBuilder clip = new StringBuilder();
                     foreach (ListViewItem item in lvIssues.Items)
@@ -2913,7 +2809,7 @@ namespace UVtools.GUI
                     }
                     e.Handled = true;
                     return;
-                }
+                }*/
 
                 if (e.KeyCode == Keys.Delete)
                 {
@@ -2924,39 +2820,34 @@ namespace UVtools.GUI
                 return;
             }
 
-            if (ReferenceEquals(sender, lvPixelHistory))
+            if (ReferenceEquals(sender, flvPixelHistory))
             {
                 if (e.KeyCode == Keys.Escape)
                 {
-                    lvPixelHistory.SelectedItems.Clear();
-                    e.Handled = true;
-                    return;
-                }
-
-                if (e.Control && e.KeyCode == Keys.A)
-                {
-                    foreach (ListViewItem item in lvPixelHistory.Items)
-                    {
-                        item.Selected = true;
-                    }
+                    flvPixelHistory.SelectedIndices.Clear();
                     e.Handled = true;
                     return;
                 }
 
                 if (e.KeyCode == Keys.Multiply)
                 {
-                    foreach (ListViewItem item in lvPixelHistory.Items)
+                    int[] selectedArray = new int[flvPixelHistory.SelectedIndices.Count];
+                    flvPixelHistory.SelectedIndices.CopyTo(selectedArray, 0);
+                    flvPixelHistory.SelectedIndices.Clear();
+                    for (int i = 0; i < flvPixelHistory.GetItemCount(); i++)
                     {
-                        item.Selected = !item.Selected;
+                        if (selectedArray.Contains(i)) continue;
+                        flvPixelHistory.SelectedIndices.Add(i);
                     }
+
                     e.Handled = true;
                     return;
                 }
 
-                if (e.Control && e.KeyCode == Keys.C)
+                /*if (e.Control && e.KeyCode == Keys.C)
                 {
                     StringBuilder clip = new StringBuilder();
-                    foreach (ListViewItem item in lvPixelHistory.Items)
+                    foreach (ListViewItem item in flvPixelHistory.Items)
                     {
                         if (!item.Selected) continue;
                         if (clip.Length > 0) clip.AppendLine();
@@ -2969,7 +2860,7 @@ namespace UVtools.GUI
                     }
                     e.Handled = true;
                     return;
-                }
+                }*/
 
                 if (e.KeyCode == Keys.Delete)
                 {
@@ -3116,34 +3007,19 @@ namespace UVtools.GUI
             pbLayer.Invalidate();
             //pbLayer.Update();
             //pbLayer.Refresh();
-            menuFileSave.Enabled = menuFileSaveAs.Enabled = true;
+            //menuFileSave.Enabled = menuFileSaveAs.Enabled = true;
             //sw.Stop();
             //Debug.WriteLine(sw.ElapsedMilliseconds);
         }
 
         public void RefreshPixelHistory()
         {
+            PixelHistory.Renumber();
+            flvPixelHistory.SetObjects(PixelHistory);
+            
             lbPixelHistoryOperations.Text = $"Operations: {PixelHistory.Count}";
-            lvPixelHistory.BeginUpdate();
-            lvPixelHistory.Items.Clear();
-            for (var i = PixelHistory.Count-1; i >= 0; i--)
-            {
-                var operation = PixelHistory[i];
-                var item = new ListViewItem
-                {
-                    Text = i.ToString(),
-                    Tag = operation
-                };
-                item.SubItems.Add(operation.OperationType.ToString());
-                item.SubItems.Add(operation.LayerIndex.ToString());
-                item.SubItems.Add(operation.Location.ToString());
-                //item.SubItems.Add(operation.BrushSize.ToString());
-
-                lvPixelHistory.Items.Add(item);
-            }
-
-            lvPixelHistory.EndUpdate();
-            btnPixelHistoryRemove.Enabled = false;
+            
+            btnPixelHistoryRemove.Enabled = flvPixelHistory.SelectedIndices.Count > 0;
             btnPixelHistoryClear.Enabled =
             btnPixelHistoryApply.Enabled = PixelHistory.Count > 0;
         }
@@ -3385,10 +3261,7 @@ namespace UVtools.GUI
         private void ComputeIssues(IslandDetectionConfiguration islandConfig = null, ResinTrapDetectionConfiguration resinTrapConfig = null)
         {
             tabPageIssues.Tag = true;
-            TotalIssues = 0;
-            lvIssues.BeginUpdate();
-            lvIssues.Items.Clear();
-            lvIssues.EndUpdate();
+            flvIssues.ClearObjects();
             UpdateIssuesInfo();
 
             DisableGUI();
@@ -3398,16 +3271,7 @@ namespace UVtools.GUI
             {
                 try
                 {
-                    var issues = SlicerFile.LayerManager.GetAllIssues(islandConfig, resinTrapConfig, FrmLoading.RestartProgress());
-                    Issues = new Dictionary<uint, List<LayerIssue>>();
-
-                    for (uint i = 0; i < SlicerFile.LayerCount; i++)
-                    {
-                        if (issues.TryGetValue(i, out var list))
-                        {
-                            Issues.Add(i, list);
-                        }
-                    }
+                    Issues = SlicerFile.LayerManager.GetAllIssues(islandConfig, resinTrapConfig, null, FrmLoading.RestartProgress());
                 }
                 catch (OperationCanceledException)
                 {
@@ -3430,41 +3294,7 @@ namespace UVtools.GUI
 
             var loadingResult = FrmLoading.ShowDialog();
 
-            lvIssues.BeginUpdate();
-            uint count = 0;
-
-            try
-            {
-                if (!ReferenceEquals(Issues, null))
-                {
-                    foreach (var kv in Issues)
-                    {
-                        foreach (var issue in kv.Value)
-                        {
-                            TotalIssues++;
-                            count++;
-                            ListViewItem item = new ListViewItem(lvIssues.Groups[(int) issue.Type])
-                                {Text = issue.Type.ToString()};
-                            item.SubItems.Add(count.ToString());
-                            item.SubItems.Add(kv.Key.ToString());
-                            item.SubItems.Add($"{issue.X}, {issue.Y}");
-                            item.SubItems.Add(issue.Size.ToString());
-                            item.Tag = issue;
-                            lvIssues.Items.Add(item);
-                        }
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                MessageBox.Show(ex.Message, "Error while trying compute issues", MessageBoxButtons.OK,
-                    MessageBoxIcon.Error);
-                throw;
-            }
-            
-            lvIssues.EndUpdate();
-            UpdateIssuesInfo();
-            ShowLayer();
+            UpdateIssuesList();
         }
 
         private void ZoomToFit()
@@ -3495,7 +3325,7 @@ namespace UVtools.GUI
         {
             return new IslandDetectionConfiguration
             {
-                Enabled = tsIsuesRefreshIslands.Checked,
+                Enabled = tsIssuesRefreshIslands.Checked,
                 BinaryThreshold = Settings.Default.IslandBinaryThreshold,
                 RequiredAreaToProcessCheck = Settings.Default.IslandRequiredAreaToProcessCheck,
                 RequiredPixelBrightnessToProcessCheck = Settings.Default.IslandRequiredPixelBrightnessToProcessCheck,
@@ -3508,7 +3338,7 @@ namespace UVtools.GUI
         {
             return new ResinTrapDetectionConfiguration
             {
-                Enabled = tsIsuesRefreshResinTraps.Checked,
+                Enabled = tsIssuesRefreshResinTraps.Checked,
                 BinaryThreshold = Settings.Default.ResinTrapBinaryThreshold,
                 RequiredAreaToProcessCheck = Settings.Default.ResinTrapRequiredAreaToProcessCheck,
                 RequiredBlackPixelsToDrain = Settings.Default.ResinTrapRequiredBlackPixelsToDrain,
@@ -3523,36 +3353,158 @@ namespace UVtools.GUI
             lbLogOperations.Text = $"Operations: {count}";
         }
 
-
-        private void EventColumnClick(object sender, ColumnClickEventArgs e)
+        public void DrawModifications(bool exitEditor)
         {
-            if (ReferenceEquals(sender, lvIssues))
+            if (PixelHistory.Count == 0)
+            {
+                if (exitEditor)
+                {
+                    tabControlLeft.TabPages.Remove(tabPagePixelEditor);
+                }
+                return;
+            }
+            var result = MessageBox.Show(
+                                "There are unsaved changes on image editor, do you want to apply modifications?",
+                                "Unsaved changes on image editor", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
+
+            if (result == DialogResult.Cancel)
             {
-                ListView myListView = (ListView)sender;
+                tsLayerImagePixelEdit.Checked = true;
+                return;
+            }
+            if (result == DialogResult.Yes)
+            {
+                DisableGUI();
+                FrmLoading.SetDescription("Drawing pixels");
 
-                // Determine if clicked column is already the column that is being sorted.
-                if (e.Column == lvIssuesColumnSorter.SortColumn)
+                Task task = Task.Factory.StartNew(() =>
                 {
-                    // Reverse the current sort direction for this column.
-                    if (lvIssuesColumnSorter.Order == SortOrder.Ascending)
+                    try
                     {
-                        lvIssuesColumnSorter.Order = SortOrder.Descending;
+                        SlicerFile.LayerManager.DrawModifications(PixelHistory, FrmLoading.RestartProgress());
                     }
-                    else
+                    catch (OperationCanceledException)
+                    {
+
+                    }
+                    catch (Exception ex)
+                    {
+                        MessageBox.Show($"{ex.Message}", "Drawing was unsuccessful!", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                    }
+                    finally
+                    {
+                        Invoke((MethodInvoker)delegate {
+                            // Running on the UI thread
+                            EnableGUI(true);
+                        });
+                    }
+
+                    return false;
+                });
+
+                FrmLoading.ShowDialog();
+
+                if (Settings.Default.PartialUpdateIslandsOnEditing)
+                {
+                    List<uint> whiteListLayers = new List<uint>();
+                    foreach (var item in PixelHistory.Items)
                     {
-                        lvIssuesColumnSorter.Order = SortOrder.Ascending;
+                        if (item.OperationType != PixelOperation.PixelOperationType.Drawing &&
+                            item.OperationType != PixelOperation.PixelOperationType.Supports) continue;
+                        if (whiteListLayers.Contains(item.LayerIndex)) continue;
+                        whiteListLayers.Add(item.LayerIndex);
+
+                        uint nextLayer = item.LayerIndex + 1;
+                        if (SlicerFile.LayerCount < nextLayer &&
+                            !whiteListLayers.Contains(nextLayer))
+                        {
+                            whiteListLayers.Add(nextLayer);
+                        }
                     }
+
+                    UpdateIslands(whiteListLayers);
                 }
-                else
+            }
+
+            if (exitEditor)
+            {
+                tabControlLeft.TabPages.Remove(tabPagePixelEditor);
+            }
+
+            PixelHistory.Clear();
+            RefreshPixelHistory();
+            ShowLayer();
+
+            menuFileSave.Enabled = menuFileSaveAs.Enabled = true;
+        }
+
+        private void UpdateIslands(List<uint> whiteListLayers)
+        {
+            if (whiteListLayers.Count == 0) return;
+            var islandConfig = GetIslandDetectionConfiguration();
+            var resinTrapConfig = new ResinTrapDetectionConfiguration { Enabled = false };
+            islandConfig.Enabled = true;
+            islandConfig.WhiteListLayers = whiteListLayers;
+            
+            if (ReferenceEquals(Issues, null))
+            {
+                ComputeIssues(islandConfig, resinTrapConfig);
+            }
+            else
+            {
+                DisableGUI();
+                FrmLoading.SetDescription("Updating Issues");
+
+                foreach (var layerIndex in islandConfig.WhiteListLayers)
                 {
-                    // Set the column number that is to be sorted; default to ascending.
-                    lvIssuesColumnSorter.SortColumn = e.Column;
-                    lvIssuesColumnSorter.Order = SortOrder.Ascending;
+                    Issues.RemoveAll(issue => issue.LayerIndex == layerIndex && issue.Type == LayerIssue.IssueType.Island); // Remove all islands for update
                 }
 
-                // Perform the sort with these new sort options.
-                myListView.Sort();
+                Task.Factory.StartNew(() =>
+                {
+                    try
+                    {
+                        var issues = SlicerFile.LayerManager.GetAllIssues(islandConfig, resinTrapConfig, null,
+                            FrmLoading.RestartProgress());
+
+                        issues.RemoveAll(issue => issue.Type != LayerIssue.IssueType.Island); // Remove all non islands
+                        Issues.AddRange(issues);
+                        Issues = Issues.OrderBy(issue => issue.Type).ThenBy(issue => issue.LayerIndex).ThenBy(issue => issue.PixelsCount).ToList();
+                    }
+                    catch (OperationCanceledException)
+                    {
+
+                    }
+                    catch (Exception ex)
+                    {
+                        MessageBox.Show(ex.Message, "Error while trying compute issues",
+                            MessageBoxButtons.OK,
+                            MessageBoxIcon.Error);
+                    }
+                    finally
+                    {
+                        Invoke((MethodInvoker)delegate
+                        {
+                            // Running on the UI thread
+                            EnableGUI(true);
+                        });
+                    }
+                });
+
+                FrmLoading.ShowDialog();
+                UpdateIssuesList();
+            }
+        }
+
+        void UpdateIssuesList()
+        {
+            flvIssues.ClearObjects();
+            if (!ReferenceEquals(Issues, null))
+            {
+                flvIssues.SetObjects(Issues);
             }
+            UpdateIssuesInfo();
+            ShowLayer();
         }
     }
 }
diff --git a/UVtools.GUI/FrmMain.resx b/UVtools.GUI/FrmMain.resx
index b4c568f..c4130ff 100644
--- a/UVtools.GUI/FrmMain.resx
+++ b/UVtools.GUI/FrmMain.resx
@@ -129,22 +129,19 @@
   <metadata name="tsLayer.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
     <value>201, 17</value>
   </metadata>
-  <metadata name="tsThumbnails.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>291, 17</value>
-  </metadata>
-  <metadata name="tsProperties.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>649, 17</value>
-  </metadata>
   <metadata name="tsGCode.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
     <value>551, 17</value>
   </metadata>
+  <metadata name="tsIssuesLv.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>1504, 17</value>
+  </metadata>
   <metadata name="tsIssues.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
     <value>765, 17</value>
   </metadata>
   <metadata name="tsPixelEditorHistory.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
     <value>1155, 17</value>
   </metadata>
-  <metadata name="toolStrip1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+  <metadata name="tsLog.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
     <value>1423, 17</value>
   </metadata>
   <metadata name="imageList16x16.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
@@ -154,95 +151,115 @@
     <value>
         AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w
         LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0
-        ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAAAW
-        FAAAAk1TRnQBSQFMAgEBBgEAAXgBBgF4AQYBEAEAARABAAT/ASEBAAj/AUIBTQE2BwABNgMAASgDAAFA
-        AwABIAMAAQEBAAEgBgABIC4AAxgBIgMwAUsDMAFMAzIBUDMAAQEDIwE2AygBQqwAAyIBMQNWAbkDXQHi
-        AwAB/wMAAf8BKgEtASgB/gNTAawDTQGVAwABARgAAwkBDAMuAVIDMQGdAxEB6AMAAf4DAQH8AysBSqQA
-        AyEBMANZAewBKwEuASkB+gNRAfcDUgH0A1MB8QNIAfYDQQH5AwAB/wNPAZsDAAEBCAADFQEdAzMBbgMp
-        AboDBQH4AwcB9QMsAbIDMgFnAxQBHAM0AYkDCwHwAx0BKpwAAxwBKANZAesBKgEtASgB/gNWAbYDTAGS
-        A0gBhQNIAYUDRgGAA0gBhQEqAS0BKAH+AwAB/wNOAZQEAAMpAUUDBgH2AxUB4gMyAZcDKwFLAwcBCQwA
-        AwEBAgMsAbIDGAHcAw4BE5gAAyYBOAEqAS0BKAH+A0wBkwNLAZADTQGWA0oBiwNFAX8DQwF4A0MBeANH
-        AYIDPgH4A1MBsAQAAx0B1QMyAZgYAAMYASIDBAEFAwoBDQMeAdIDJwG/AwQBBZQAA1wB1AMAAf8DUQGg
-        A04BmANQAZ8DOgFhAzgBXQNCAXQDRgGAA0gBhANMAZMDWAHjAzABTAMAAf4DKQFDCAADBwEKAywBTAMz
-        AZUDGAHdAwAB/wMuAasDAAEBAxcBIAMPAeoDMgGZkAADNgFZA0ABcANZAdcDRwGCA0wBkwNJAYkDAQEC
-        BAADMAFLA0QBeQNIAYcDSwGQA1cB6AMwAUwDFQHiAy8BpQMzAXEDKQG5AwYB9wMAAf8DAAH/AwAB/wMA
-        Af8DAAH/AzMBjAQAAyYBPQMEAfkDMwFujAADLQFGAzgBXgNKAY0DEgEYA1ABoxAAAykBPgNLAZADTQGV
-        A1kB7AMwAUwDNAGKAwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMyAWoEAAMy
-        AWMDAgH7AyoBRogAAxQBHAMwAU0DTwGcA1EBogNTAbAQAAMrAUMDTwGbA1ABngNWAbsDFQEdAwcBCgMk
-        AcYDAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAgH7AywBTAQAAzEBoAMfAdGIAANE
-        AXkDPwFuAyoBQAMeASsDKgFAA1UBsQMEAQUEAAM5AWADTAGSA04BlANWAbYDVgG4CAADDgETAxsB1wMA
-        Af8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMJAfMDIQEzAzQBggMlAcSEAAM/AW0DLgFI
-        AxoBJAMlATcDIQEwASsBLAErAUMDLAFEA0gBiANIAYUDSAGHA0kBiQNQAZoDWAHpAycBOgwAAxYBHwMT
-        AeUDAAH/AwAB/wMAAf8DAAH/AwAB/wMDAfoDIwHHAy8BqAMAAf4DEgHmAy8BVQMzAZOEAAMGAQgDCgEN
-        A1MBsAMqAUADQgF1AxQBHAM1AVgDRAF8A04BlANEAXwDSAGIA04B8AMnATsUAAMfAS4DCwHwAwAB/wMd
-        AdMDNAGDAykBRAMIAQsEAAMRARcDJQHEAwAB/wMdAdMDCwEPgAADBwEJA1UBtAMJAQwEAANBAXMDKgFB
-        A0IBdgM8AWcDUQGnA1oBygNbAdYDJAE2Ax8BLRwAAycBQAMFAfgDJwHAAx4BLAMwAVwDMgGaAxsB2AMA
-        Af4DAAH/AwAB/wMAAf8DKgG3hAADAQECA1MBrAMOARMDOwFlBAADMAFNAwcBCQMEAQUwAAMvAVUDAQH8
-        AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwEB/QMdAdQDNAGHiAADPwFuAwYBCAMxAU8DAwEEA1MBsDwA
-        AzMBbQMAAf8DAAH/AwsB8AMpAbkDNAGAAyoBRwMLAQ+QAAMxAU8DAQECTAADKQFDAx4BLAMBAQLcAANQ
-        AaMDUgGpA1IBqQNSAakDUgGpA1IBqQNSAakDUgGpA1IBqQNSAakDUgGpA1IBqQNSAakDUAGjXAADFQEd
-        AUICWQH1AVECbQH3A0MBdwNbAcgCQgFZAfUCWAFfAeMDSgGMAwoBDQQAA1UBtANZAccDLwFJAwABAQMb
-        ASYDHAEnAxwBJwMcAScDHAEnAxwBJwMcAScDHAEnAxwBJwMcAScDHAEnAwIBAwQAA1IBqTAAA1IBqRAA
-        AycBOgMwAUwDMAFMAzABTAMwAUwDMAFMAzABTAMwAUwDMAFMAycBOhQAAwUBBwNMAZIBVgJYAcEDFQEd
-        Az0BaQEAAcgB8wH/AQABkAHmAf8CAAHcAf8CAAHdAf8CFwHjAf8CAAHeAf8CAAHdAf8CWAFbAcsDBgEI
-        AwAB/wMAAf8DQwF3AykBPgMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/
-        AzIBUQQAA1IBqQQAA1ABnQNTAaoDUwGqA1MBqgNTAaoDUwGqA1MBqgNQAZ0MAANSAakQAANOAfsDAAH/
-        AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wNOAfsUAAEwAjEBTQEAAckB8wH/AQAByQH0Af8BWQJg
-        AesBWwJeAdkBAAHAAfEB/wIAAd8B/wIAAeAB/wIAAeAB/wIeAekB/wIAAeIB/wIAAeAB/wIAAeAB/wNA
-        AXEDUQGiA1YBtgMqAUAEAAMQARUDEQEXAxEBFwMRARcDEQEXAxEBFwMRARcDEQEXAxEBFwMRARcDEAEW
-        CAADUgGpBAADUAGdA1MBqgNTAaoDHwEsHAADUgGpEwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMA
-        Af8DAAH/AwAB/xQAAwcBCgFZAmcB8gEAAcoB9AH/AQABygH0Af8BAAHKAfQB/wEAAaEB7gH/AgAB4wH/
-        AgAB4wH/AgAB4wH/AqkB7wH/AgAB4wH/AgAB4wH/AgAB4wH/AlYBWAG5AwoBDgMRARcDAAEBOAADUgGp
-        MAADUgGpEwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wwAAxUBHQM9AWkDOgFi
-        AVwCYAHUAQABywH1Af8BAAHLAfUB/wEAAcsB9QH/AQABoAHwAf8CAAHmAf8CAAHmAf8CAAHmAf8CwgH2
-        Af8CAwHoAf8CAAHmAf8CAAHmAf8CVwFZAb8DUgH0AwAB/wM+AWwDDgETA0IBdgNDAXcDQwF3A0MBdwND
-        AXcDQwF3A0MBdwNDAXcDQwF3A0MBdwNCAXYDFAEbBAADUgGpAyIBMgNSAakDUgGpA1IBqQNSAakDUgGp
-        A1IBqQNSAakDUgGpA1IBqQNSAakDIgEyA1IBqRMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/
-        AwAB/wMAAf8MAAFLAkwBkAEAAcsB9gH/AQABywH2Af8BAAHLAfYB/wEAAcsB9gH/ASkCTQH6A0MBeAMi
-        ATICSwFfAfsCAAHpAf8CAAHpAf8CzQH4Af8CEgHtAf8CAAHpAf8CAAHpAf8DUAGeAwAB/gMAAf8DQwF3
-        Ax4BKwNXAcUDWQHHA1kBxwNZAccDWQHHA1kBxwNZAccDWQHHA1kBxwNZAccDWAHGAyYBOQQAA1IBqQM0
-        AVUDNAFVIAADNAFVAzQBVQNSAakTAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/
-        DAADUQGgAQABzAH3Af8BAAHMAfcB/wEAAcwB9wH/AQABzAH3Af8DQwF3CAADSgGNAgAB7AH/AgAB7AH/
-        Ag0B7wH/AgAB7AH/AgAB7AH/AgAB7QH/AVICUwGoAzMBUwM8AWcDFAEcOAADUgGpAzQBVQM0AVUDRgGA
-        A1IBqQNSAakDUgGpA1IBqQNSAakDUgGpA0UBfwM0AVUDNAFVA1IBqRMAAf8DAAH/AwAB/wMAAf8DAAH/
-        AwAB/wMAAf8DAAH/AwAB/wMAAf8PAAEBAT8CQAFvAT4CXAH4AQABzQH3Af8BAAHNAfcB/wMSARgIAAMB
-        AQIDRgF+AlIBXQHwAgAB7gH/AgAB7gH/AkABqAH9AUUCRgF+AwMBBAMzAVMDPAFnAxQBHDgAA1IBqQM0
-        AVUDNAFVAz8BbgMyAVAQAAMnATsDRAF8AzQBVQM0AVUDUgGpEwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/
-        AwAB/wMAAf8DAAH/AwAB/w8AAQEBPwJAAW8BPgJcAfgBAAHOAfgB/wEAAc4B+AH/AxIBGBAAAxcBIAEA
-        AbwB9wH/AQABxAH3Af8BQAKoAf0BRQJGAX4DAwEEAwAB/gMAAf8DQwF3Ax8BLANXAcUDWQHHA1kBxwNZ
-        AccDWQHHA1kBxwNZAccDWQHHA1kBxwNZAccDWAHGAyYBOQQAA1IBqQM0AVUDNAFVAwUBBwNVAbUDEQEX
-        A1IBqQMpAT4EAANQAZ8DEQEXAzQBVQM0AVUDUgGpEwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMA
-        Af8DAAH/AwAB/wwAA1EBoAEAAc4B+AH/AQABzwH5Af8BAAHPAfkB/wEAAc8B+QH/A0MBdxAAA0QBegEA
-        Ac8B+QH/AQABzwH5Af8BAAHPAfkB/wEAAc4B+AH/AVICUwGoA1IB9AMAAf8DPgFsAw4BEwNCAXUDQwF3
-        A0MBdwNDAXcDQwF3A0MBdwNDAXcDQwF3A0MBdwNDAXcDQwF3AxQBGwQAA1IBqQM0AVUDNAFVBAADPAFo
-        A1YBvgMjATQDVQG1AxIBGQNRAaAEAAM0AVUDNAFVA1IBqRMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMA
-        Af8DAAH/AwAB/wNcAd8MAAFLAkwBkAEAAdAB+gH/AQAB0AH6Af8BAAHQAfoB/wEAAdAB+gH/ASkCTQH6
-        A0MBeAMSARkDEwEaA0QBegEoAl8B+wEAAdAB+gH/AQAB0AH6Af8BAAHQAfoB/wEAAdAB+gH/A0oBjAMK
-        AQ4DEQEXAwABATgAA1IBqQM0AVUDNAFVAwABAQMtAUYDCgEOBAADOQFfA1wBzgMoATwEAAM0AVUDNAFV
-        A1IBqRMAAf8DggH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/A1wB3wMXASAMAAMVAR0DPQFpAzoBYgFc
+        ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAABk
+        FAAAAk1TRnQBSQFMAgEBBgEAAWABCAFgAQgBEAEAARABAAT/ASEBAAj/AUIBTQE2BwABNgMAASgDAAFA
+        AwABIAMAAQEBAAEgBgABIC4AAxgBIgMwAUsDMAFMAzIBUDMAAQEDJAE2AysBQqwAAyIBMQNWAbkDXQHi
+        AwAB/wMAAf8BKgEtASgB/gNTAawDTQGVAwABARgAAwkBDAMzAVIDUAGdA1cB6AMAAf4DKwH8Ay8BSqQA
+        AyEBMANZAewBKwEuASkB+gNRAfcDUgH0A1MB8QNIAfYDQQH5AwAB/wNPAZsDAAEBCAADFQEdAz8BbgNV
+        AboDPgH4A0IB9QNVAbIDPAFnAxQBHANJAYkDTgHwAx0BKpwAAxwBKANZAesBKgEtASgB/gNWAbYDTAGS
+        A0gBhQNIAYUDRgGAA0gBhQEqAS0BKAH+AwAB/wNOAZQEAAMtAUUDSAH2A10B4gNOAZcDMAFLAwcBCQwA
+        AwEBAgNVAbIDXAHcAw4BE5gAAyYBOAEqAS0BKAH+A0wBkwNLAZADTQGWA0oBiwNFAX8DQwF4A0MBeANH
+        AYIDPgH4A1MBsAQAA1oB1QNOAZgYAAMYASIDBAEFAwoBDQNZAdIDVwG/AwQBBZQAA1wB1AMAAf8DUQGg
+        A04BmANQAZ8DOgFhAzgBXQNCAXQDRgGAA0gBhANMAZMDWAHjAzABTAMAAf4DKwFDCAADBwEKAzABTANN
+        AZUDWAHdAwAB/wNUAasDAAEBAxcBIANVAeoDTgGZkAADNgFZA0ABcANZAdcDRwGCA0wBkwNJAYkDAQEC
+        BAADMAFLA0QBeQNIAYcDSwGQA1cB6AMwAUwDXQHiA08BpQNAAXEDVgG5A1EB9wMAAf8DAAH/AwAB/wMA
+        Af8DAAH/A0oBjAQAAygBPQNBAfkDPwFujAADLQFGAzgBXgNKAY0DEgEYA1ABoxAAAykBPgNLAZADTQGV
+        A1kB7AMwAUwDSgGKAwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wM9AWoEAAM7
+        AWMDIQH7Ay0BRogAAxQBHAMwAU0DTwGcA1EBogNTAbAQAAMrAUMDTwGbA1ABngNWAbsDFQEdAwcBCgNY
+        AcYDAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DIQH7AzABTAQAA1EBoANYAdGIAANE
+        AXkDPwFuAyoBQAMeASsDKgFAA1UBsQMEAQUEAAM5AWADTAGSA04BlANWAbYDVgG4CAADDgETA1kB1wMA
+        Af8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wNMAfMDIwEzA0cBggNZAcSEAAM/AW0DLgFI
+        AxoBJAMlATcDIQEwASsBLAErAUMDLAFEA0gBiANIAYUDSAGHA0kBiQNQAZoDWAHpAycBOgwAAxYBHwNe
+        AeUDAAH/AwAB/wMAAf8DAAH/AwAB/wMpAfoDWQHHA1IBqAMAAf4DWAHmAzQBVQNMAZOEAAMGAQgDCgEN
+        A1MBsAMqAUADQgF1AxQBHAM1AVgDRAF8A04BlANEAXwDSAGIA04B8AMnATsUAAMgAS4DTgHwAwAB/wNa
+        AdMDRwGDAywBRAMIAQsEAAMRARcDWQHEAwAB/wNaAdMDCwEPgAADBwEJA1UBtAMJAQwEAANBAXMDKgFB
+        A0IBdgM8AWcDUQGnA1oBygNbAdYDJAE2Ax8BLRwAAyoBQAM+AfgDWAHAAx8BLAM4AVwDUAGaA1oB2AMA
+        Af4DAAH/AwAB/wMAAf8DVQG3hAADAQECA1MBrAMOARMDOwFlBAADMAFNAwcBCQMEAQUwAAM0AVUDKwH8
+        AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/Az4B/QNcAdQDSAGHiAADPwFuAwYBCAMxAU8DAwEEA1MBsDwA
+        Az8BbQMAAf8DAAH/A04B8ANWAbkDRgGAAy4BRwMLAQ+QAAMxAU8DAQECTAADKwFDAx8BLAMBAQKoAAMH
+        AQkDNwFaA0gBhANTAawDUwGsA0gBhAM3AVoDBwEJFAADUAGjA1IBqQNSAakDUgGpA1IBqQNSAakDUgGp
+        A1IBqQNSAakDUgGpA1IBqQNSAakDUgGpA1ABo1wAAxUBHQFCAlkB9QFRAm0B9wNDAXcDWwHIAkIBWQH1
+        AlgBXwHjA0oBjAMKAQ0QAAMgAS4DVwG/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/A1cBvwMgAS4QAANS
+        AakwAANSAakYAAMNARIDNwFbAx0BKigAAwUBBwNMAZIBVgJYAcEDFQEdAz0BaQEAAcgB8wH/AQABkAHm
+        Af8CAAHcAf8CAAHdAf8CAAHjAf8CAAHeAf8CAAHdAf8CWAFbAcsDBgEICAADRQF/AwAB/wMAAf8DAAH/
+        AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wNFAX8MAANSAakEAANQAZ0DUwGqA1MBqgNTAaoDUwGq
+        A1MBqgNTAaoDUAGdDAADUgGpGAADVwG/AwAB/wNEAXsoAAEwAjEBTQEAAckB8wH/AQAByQH0Af8BWQJg
+        AesBWwJeAdkBAAHAAfEB/wIAAd8B/wIAAeAB/wIAAeAB/wIAAekB/wIAAeIB/wIAAeAB/wIAAeAB/wNA
+        AXEEAAMuAUcDAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DLgFH
+        CAADUgGpBAADUAGdA1MBqgNTAaoDHwEsHAADUgGpGAADQgF0AwAB/wNWAb4oAAMHAQoBWQJnAfIBAAHK
+        AfQB/wEAAcoB9AH/AQABygH0Af8BAAGhAe4B/wIAAeMB/wIAAeMB/wIAAeMB/wKpAe8B/wIAAeMB/wIA
+        AeMB/wIAAeMB/wJWAVgBuQMKAQ4DWgHYAwAB/wMAAf8DAAH/AwAB/wMqAUAIAAMqAUADAAH/AwAB/wMA
+        Af8DAAH/A1oB2AMKAQ4EAANSAakwAANSAakQAAM2AVkDJgE4Ax0BKgMAAf8DAAH/AxcBIAgAAyYEOAFc
+        DAADFQEdAz0BaQM6AWIBXAJgAdQBAAHLAfUB/wEAAcsB9QH/AQABywH1Af8BAAGgAfAB/wIAAeYB/wIA
+        AeYB/wIAAeYB/wLCAfYB/wIAAegB/wIAAeYB/wIAAeYB/wJXAVkBvwM1AVYDAAH/AwAB/wMAAf8DAAH/
+        AwAB/wNTAaoIAANFAX8DAAH/AwAB/wMAAf8DAAH/AwAB/wM1AVYEAANSAakDIgEyA1IBqQNSAakDUgGp
+        A1IBqQNSAakDUgGpA1IBqQNSAakDUgGpA1IBqQMiATIDUgGpDAADQQFzAwAB/wNMAfMDEgEZA1oB2wMA
+        Af8DPAFnBAADKgFAA0wB8wMAAf8DQgF0CAABSwJMAZABAAHLAfYB/wEAAcsB9gH/AQABywH2Af8BAAHL
+        AfYB/wEpAk0B+gNDAXgDIgEyAksBXwH7AgAB6QH/AgAB6QH/As0B+AH/AgAB7QH/AgAB6QH/AgAB6QH/
+        A1ABngNEAXsDAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8LAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DRAF7
+        BAADUgGpAzQBVQM0AVUgAAM0AVUDNAFVA1IBqQgAA0oBiwMAAf8DAAH/A08BnAQAA00BlQMAAf8DVAGr
+        CAADTwGcAwAB/wMAAf8DSgGLBAADUQGgAQABzAH3Af8BAAHMAfcB/wEAAcwB9wH/AQABzAH3Af8DQwF3
+        CAADSgGNAgAB7AH/AgAB7AH/AgAB7wH/AgAB7AH/AgAB7AH/AgAB7QH/AVICUwGoA1IBqAMAAf8DAAH/
+        AwAB/wM7AfcDEwH9A1ABnwsAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wNSAagEAANSAakDNAFVAzQBVQNG
+        AYADUgGpA1IBqQNSAakDUgGpA1IBqQNSAakDRQF/AzQBVQM0AVUDUgGpBAADUQGiAwAB/wMAAf8DSQGJ
+        CAADLwFKAwAB/wNUAe4MAANJAYkDAAH/AwAB/wNRAaIDAAEBAT8CQAFvAT4CXAH4AQABzQH3Af8BAAHN
+        AfcB/wMSARgIAAMBAQIDRgF+AlIBXQHwAgAB7gH/AgAB7gH/AkABqAH9AUUCRgF+AwMBBANSAagDAAH/
+        AwAB/wMAAf8DAAH/AwAB/wM0AVULAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DUgGoBAADUgGpAzQBVQM0
+        AVUDPwFuAzIBUBAAAycBOwNEAXwDNAFVAzQBVQNSAakEAANRAaIDAAH/AwAB/wNJAYkMAANUAe4DAAH/
+        Ay8BSggAA0kBiQMAAf8DAAH/A1EBogMAAQEBPwJAAW8BPgJcAfgBAAHOAfgB/wEAAc4B+AH/AxIBGBAA
+        AxcBIAEAAbwB9wH/AQABxAH3Af8BQAKoAf0BRQJGAX4DAwEEA0QBewMAAf8DAAH/AwAB/wMAAf8DAAH/
+        AwAB/wNcAdQDWgHVAwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/A0QBewQAA1IBqQM0AVUDNAFVAwUBBwNV
+        AbUDEQEXA1IBqQMpAT4EAANQAZ8DEQEXAzQBVQM0AVUDUgGpCAADSgGLAwAB/wMAAf8DTwGcCAADVAGr
+        AwAB/wNNAZUEAANPAZwDAAH/AwAB/wNKAYsEAANRAaABAAHOAfgB/wEAAc8B+QH/AQABzwH5Af8BAAHP
+        AfkB/wNDAXcQAANEAXoBAAHPAfkB/wEAAc8B+QH/AQABzwH5Af8BAAHOAfgB/wFSAlMBqAM1AVYDAAH/
+        AwAB/wMAAf8DAAH/AwAB/wNaAdsIAANaAdsDAAH/AwAB/wMAAf8DAAH/AwAB/wM1AVYEAANSAakDNAFV
+        AzQBVQQAAzwBaANWAb4DIwE0A1UBtQMSARkDUQGgBAADNAFVAzQBVQNSAakMAANCAXQDAAH/A0wB8wMq
+        AUAEAAM8AWcDAAH/A1oB2wMSARkDTAHzAwAB/wNBAXMIAAFLAkwBkAEAAdAB+gH/AQAB0AH6Af8BAAHQ
+        AfoB/wEAAdAB+gH/ASkCTQH6A0MBeAMSARkDEwEaA0QBegEoAl8B+wEAAdAB+gH/AQAB0AH6Af8BAAHQ
+        AfoB/wEAAdAB+gH/A0oBjAMKAQ4DWgHYAwAB/wMAAf8DAAH/AwAB/wNaAdsIAANaAdsDAAH/AwAB/wMA
+        Af8DAAH/A1oB2AMKAQ4EAANSAakDNAFVAzQBVQMAAQEDLQFGAwoBDgQAAzkBXwNcAc4DKAE8BAADNAFV
+        AzQBVQNSAakQAAM4AVwDJgE4CAADFwEgAwAB/wMAAf8DHQEqAyYBOAM2AVkMAAMVAR0DPQFpAzoBYgFc
         AmAB1AEAAdEB+gH/AQAB0QH6Af8BAAHQAfoB/wEAAcsB8wH/AQABywHzAf8BAAHQAfoB/wEAAdEB+gH/
-        AQAB0QH6Af8BXQJhAeIDOgFiAz0BaQMUARwDUQGiA1YBtgMqAUAEAAMQARUDEQEXAxEBFwMRARcDEQEX
-        AxEBFwMRARcDEQEXAxEBFwMRARcDEAEWCAADUgGpAzQBVQM0AVUDMwFTA1IBpgNKAYwHAAEBA0cBgwgA
-        AzQBVQM0AVUDUgGpEwAB/wOZAf8DhQH/AwAB/wMAAf8DAAH/AwAB/wNcAd8DFwEgGAADBwEKAVkCZwHy
-        AQAB0gH7Af8BAAHSAfsB/wEAAdIB+wH/AQAB0gH7Af8BAAHSAfsB/wEAAdIB+wH/AQAB0gH7Af8BAAHS
-        AfsB/wErAl8B+wMRARcLAAH/AwAB/wNDAXcDKQE+AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMA
-        Af8DAAH/AwAB/wMAAf8DMgFRBAADUgGpAzQBVQM0AVUDEQEXA1ABngMkATYUAAM0AVUDNAFVA1IBqRAA
-        A1AB+wMAAf8DAAH/AwAB/wMAAf8DAAH/A1wB3wMXASAcAAEwAjEBTQEAAdIB/AH/AQAB0gH8Af8BWQJg
-        AesBWwJeAdkBAAHSAfwB/wEAAdIB/AH/AVsCYQHhAV0CYQHiAQAB0gH8Af8BAAHSAfwB/wM4AV4IAANV
-        AbQDWQHHAy8BSQMAAQEDGwEmAxwBJwMcAScDHAEnAxwBJwMcAScDHAEnAxwBJwMcAScDHAEnAxwBJwMC
-        AQMEAANSAakDIgEyA1IBqQNSAakDUgGpA1IBqQNSAakDUgGpA1IBqQNSAakDUgGpA1IBqQMiATIDUgGp
-        EAADIAEuAykBPwMpAT8DKQE/AykBPwMpAT8DEQEXIAADBQEHA0wBkgFWAlgBwQMVAR0DPQFpAQAB0wH8
-        Af8BAAHTAfwB/wFFAkYBfwMQARUDVgGzAUsCTAGPAwQBBkwAA1ABowNSAakDUgGpA1IBqQNSAakDUgGp
-        A1IBqQNSAakDUgGpA1IBqQNSAakDUgGpA1IBqQNQAaNcAAMVAR0BQgJZAfUBUQJtAfcDIAEvGAABQgFN
-        AT4HAAE+AwABKAMAAUADAAEgAwABAQEAAQEGAAEBFgAD/wEAAf4BHwH+AT8EAAH4AQMB8AEfBAAB8AEB
-        AYABDwQAAeABAQEDAYcEAAHgAQEBPwEDBAAB4AEAATABAwQAAcABQAEAAREEAAHBAeABAAEIBAABwQHg
-        AQABBAQAAcABQQGABQABgAEBAcAFAAGAAQMB4AEgBAABEAEHAfAFAAGEAX8B+AUAAcEB/wH8AQMEAAHP
-        Af8B/gE/BAAC/wGAAQEC/wH8AQECAAG/Af0B4AEHAcADAAGgAR0B4AEHAcABAAEQAQEBoQH9AeABBwHA
-        AQABHwH/Ab8B/QHgAQcEAAGAAQEB4AEHBAABjwHxAeABBwEDAQABHwH/AYABAQHgAQcBAwEAAR8B/wGD
-        AcEB4AEHAQMBwAIAAYABQQHgAQcBAwHAAgABiAERAeABBwIAAR8B/wGBAREB4AEHAgABEAEBAYEBMQHg
-        AQ8BwAEDAgABgQHxAeABHwHAAQMCAAGAAQEB4AE/AcABAwL/AYABAQL/AfwBPws=
+        AQAB0QH6Af8BXQJhAeIDOgFiAz0BaQMUARwEAAMuAUcDAAH/AwAB/wMAAf8DAAH/AwAB/wNcAdQDXAHU
+        AwAB/wMAAf8DAAH/AwAB/wMAAf8DLgFHCAADUgGpAzQBVQM0AVUDMwFTA1IBpgNKAYwHAAEBA0cBgwgA
+        AzQBVQM0AVUDUgGpJAADVgG+AwAB/wNCAXQcAAMHAQoBWQJnAfIBAAHSAfsB/wEAAdIB+wH/AQAB0gH7
+        Af8BAAHSAfsB/wEAAdIB+wH/AQAB0gH7Af8BAAHSAfsB/wEAAdIB+wH/ASsCXwH7AxEBFxAAA0UBfwMA
+        Af8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wMAAf8DRQF/DAADUgGpAzQBVQM0AVUDEQEX
+        A1ABngMkATYUAAM0AVUDNAFVA1IBqSQAA0QBewMAAf8DVwG/HAABMAIxAU0BAAHSAfwB/wEAAdIB/AH/
+        AVkCYAHrAVsCXgHZAQAB0gH8Af8BAAHSAfwB/wFbAmEB4QFdAmEB4gEAAdIB/AH/AQAB0gH8Af8DOAFe
+        FAADIAEuA1cBvwMAAf8DAAH/AwAB/wMAAf8DAAH/AwAB/wNXAb8DIAEuEAADUgGpAyIBMgNSAakDUgGp
+        A1IBqQNSAakDUgGpA1IBqQNSAakDUgGpA1IBqQNSAakDIgEyA1IBqSQAAx0BKgM3AVsDDQESHAADBQEH
+        A0wBkgFWAlgBwQMVAR0DPQFpAQAB0wH8Af8BAAHTAfwB/wFFAkYBfwMQARUDVgGzAUsCTAGPAwQBBhgA
+        AwcBCQM3AVoDSAGEA1MBrANTAawDSAGEAzcBWgMHAQkUAANQAaMDUgGpA1IBqQNSAakDUgGpA1IBqQNS
+        AakDUgGpA1IBqQNSAakDUgGpA1IBqQNSAakDUAGjXAADFQEdAUICWQH1AVECbQH3AyABLxgAAUIBTQE+
+        BwABPgMAASgDAAFAAwABIAMAAQEBAAEBBgABARYAA/8BAAH+AR8B/gE/BAAB+AEDAfABHwQAAfABAQGA
+        AQ8EAAHgAQEBAwGHBAAB4AEBAT8BAwQAAeABAAEwAQMEAAHAAUABAAERBAABwQHgAQABCAQAAcEB4AEA
+        AQQEAAHAAUEBgAUAAYABAQHABQABgAEDAeABIAQAARABBwHwBQABhAF/AfgFAAHBAf8B/AEDBAABzwH/
+        Af4BPwQAAfABDwGAAQEC/wH8AQEB4AEHAb8B/QH4Af8BwAEAAcABAwGgAR0B+AH/AcABAAGAAQEBoQH9
+        AfgB/wHAAQABAQGAAb8B/QHgAWcCAAEBAoABAQHAAUMCAAEBAYABjwHxAYQBYQEDAQABAQKAAQEBDAFw
+        AQMBAAEBAYABgwHBAQ4BMAEDAcACAAGAAUEBhgEhAQMBwAEBAYABiAERAcIBAwIAAQEBgAGBAREB5gEH
+        AgABgAEBAYEBMQH/AR8BwAEDAcABAwGBAfEB/wEfAcABAwHgAQcBgAEBAf8BHwHAAQMB8AEPAYABAQL/
+        AfwBPws=
 </value>
   </data>
+  <metadata name="tsThumbnails.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>291, 17</value>
+  </metadata>
+  <metadata name="tsProperties.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>649, 17</value>
+  </metadata>
+  <metadata name="tsGCode.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>551, 17</value>
+  </metadata>
+  <metadata name="tsPixelEditorHistory.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>1155, 17</value>
+  </metadata>
+  <metadata name="tsLog.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>1423, 17</value>
+  </metadata>
+  <metadata name="toolTipInformation.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>863, 17</value>
+  </metadata>
   <metadata name="toolTipInformation.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
     <value>863, 17</value>
   </metadata>
diff --git a/UVtools.GUI/Images/Button-Info-16x16.png b/UVtools.GUI/Images/Button-Info-16x16.png
index 6b0d295..560873d 100644
--- a/UVtools.GUI/Images/Button-Info-16x16.png
+++ b/UVtools.GUI/Images/Button-Info-16x16.png
diff --git a/UVtools.GUI/Images/Donate-16x16.png b/UVtools.GUI/Images/Donate-16x16.png
index 6ce3e86..37378b3 100644
--- a/UVtools.GUI/Images/Donate-16x16.png
+++ b/UVtools.GUI/Images/Donate-16x16.png
diff --git a/UVtools.GUI/Images/blur-16x16.png b/UVtools.GUI/Images/blur-16x16.png
new file mode 100644
index 0000000..8132066
--- /dev/null
+++ b/UVtools.GUI/Images/blur-16x16.png
diff --git a/UVtools.GUI/Images/bowling-ball-16x16.png b/UVtools.GUI/Images/bowling-ball-16x16.png
new file mode 100644
index 0000000..f231665
--- /dev/null
+++ b/UVtools.GUI/Images/bowling-ball-16x16.png
diff --git a/UVtools.GUI/Images/burn-16x16.png b/UVtools.GUI/Images/burn-16x16.png
new file mode 100644
index 0000000..217963c
--- /dev/null
+++ b/UVtools.GUI/Images/burn-16x16.png
diff --git a/UVtools.GUI/Images/chessboard-16x16.png b/UVtools.GUI/Images/chessboard-16x16.png
new file mode 100644
index 0000000..e12226e
--- /dev/null
+++ b/UVtools.GUI/Images/chessboard-16x16.png
diff --git a/UVtools.GUI/Images/code-16x16.png b/UVtools.GUI/Images/code-16x16.png
new file mode 100644
index 0000000..6aa33a4
--- /dev/null
+++ b/UVtools.GUI/Images/code-16x16.png
diff --git a/UVtools.GUI/Images/compress-alt-16x16.png b/UVtools.GUI/Images/compress-alt-16x16.png
new file mode 100644
index 0000000..a2129b8
--- /dev/null
+++ b/UVtools.GUI/Images/compress-alt-16x16.png
diff --git a/UVtools.GUI/Images/crop-16x16.png b/UVtools.GUI/Images/crop-16x16.png
new file mode 100644
index 0000000..225c344
--- /dev/null
+++ b/UVtools.GUI/Images/crop-16x16.png
diff --git a/UVtools.GUI/Images/expand-16x16.png b/UVtools.GUI/Images/expand-16x16.png
new file mode 100644
index 0000000..a8c87f4
--- /dev/null
+++ b/UVtools.GUI/Images/expand-16x16.png
diff --git a/UVtools.GUI/Images/expand-alt-16x16.png b/UVtools.GUI/Images/expand-alt-16x16.png
new file mode 100644
index 0000000..22b181f
--- /dev/null
+++ b/UVtools.GUI/Images/expand-alt-16x16.png
diff --git a/UVtools.GUI/Images/filter-filled-16x16.png b/UVtools.GUI/Images/filter-filled-16x16.png
index b751a71..a19d124 100644
--- a/UVtools.GUI/Images/filter-filled-16x16.png
+++ b/UVtools.GUI/Images/filter-filled-16x16.png
diff --git a/UVtools.GUI/Images/flip-16x16.png b/UVtools.GUI/Images/flip-16x16.png
new file mode 100644
index 0000000..138d97a
--- /dev/null
+++ b/UVtools.GUI/Images/flip-16x16.png
diff --git a/UVtools.GUI/Images/internet-explorer-16x16.png b/UVtools.GUI/Images/internet-explorer-16x16.png
new file mode 100644
index 0000000..b5b3ea6
--- /dev/null
+++ b/UVtools.GUI/Images/internet-explorer-16x16.png
diff --git a/UVtools.GUI/Images/layers-alt-16x16.png b/UVtools.GUI/Images/layers-alt-16x16.png
new file mode 100644
index 0000000..230e11b
--- /dev/null
+++ b/UVtools.GUI/Images/layers-alt-16x16.png
diff --git a/UVtools.GUI/Images/list-16x16.png b/UVtools.GUI/Images/list-16x16.png
new file mode 100644
index 0000000..85d6795
--- /dev/null
+++ b/UVtools.GUI/Images/list-16x16.png
diff --git a/UVtools.GUI/Images/map-marker-16x16.png b/UVtools.GUI/Images/map-marker-16x16.png
new file mode 100644
index 0000000..a0523b2
--- /dev/null
+++ b/UVtools.GUI/Images/map-marker-16x16.png
diff --git a/UVtools.GUI/Images/move-16x16.png b/UVtools.GUI/Images/move-16x16.png
new file mode 100644
index 0000000..a018770
--- /dev/null
+++ b/UVtools.GUI/Images/move-16x16.png
diff --git a/UVtools.GUI/Images/pointer-16x16.png b/UVtools.GUI/Images/pointer-16x16.png
index 5fbfcdf..fadbd93 100644
--- a/UVtools.GUI/Images/pointer-16x16.png
+++ b/UVtools.GUI/Images/pointer-16x16.png
diff --git a/UVtools.GUI/Images/refresh-16x16.png b/UVtools.GUI/Images/refresh-16x16.png
index 3ea0349..c5f7827 100644
--- a/UVtools.GUI/Images/refresh-16x16.png
+++ b/UVtools.GUI/Images/refresh-16x16.png
diff --git a/UVtools.GUI/Images/sort-alpha-up-16x16.png b/UVtools.GUI/Images/sort-alpha-up-16x16.png
new file mode 100644
index 0000000..765a4dd
--- /dev/null
+++ b/UVtools.GUI/Images/sort-alpha-up-16x16.png
diff --git a/UVtools.GUI/Images/square-solid-16x16.png b/UVtools.GUI/Images/square-solid-16x16.png
new file mode 100644
index 0000000..d32f1a0
--- /dev/null
+++ b/UVtools.GUI/Images/square-solid-16x16.png
diff --git a/UVtools.GUI/Images/th-16x16.png b/UVtools.GUI/Images/th-16x16.png
new file mode 100644
index 0000000..16bfb6d
--- /dev/null
+++ b/UVtools.GUI/Images/th-16x16.png
diff --git a/UVtools.GUI/Images/toolbox-16x16.png b/UVtools.GUI/Images/toolbox-16x16.png
new file mode 100644
index 0000000..fda6150
--- /dev/null
+++ b/UVtools.GUI/Images/toolbox-16x16.png
diff --git a/UVtools.GUI/Images/trash-16x16.png b/UVtools.GUI/Images/trash-16x16.png
new file mode 100644
index 0000000..ef9d610
--- /dev/null
+++ b/UVtools.GUI/Images/trash-16x16.png
diff --git a/UVtools.GUI/Mutation.cs b/UVtools.GUI/Mutation.cs
index b1b0c1a..323faf3 100644
--- a/UVtools.GUI/Mutation.cs
+++ b/UVtools.GUI/Mutation.cs
@@ -20,16 +20,17 @@ namespace UVtools.GUI
         public string Description { get; }
 
         public Image Image { get; }
+        public Image MenuImage { get; }
         #endregion
 
         #region Constructor
 
-        public Mutation(LayerManager.Mutate mutate, string menuName, string description, Image image = null)
+        public Mutation(LayerManager.Mutate mutate, string menuName, Image menuImage, string description, Image image = null)
         {
             Mutate = mutate;
             MenuName = menuName ?? mutate.ToString();
             Description = description;
-            Image = image;
+            MenuImage = menuImage ?? Properties.Resources.filter_filled_16x16;
         }
 
         #endregion
diff --git a/UVtools.GUI/Properties/AssemblyInfo.cs b/UVtools.GUI/Properties/AssemblyInfo.cs
index 3c866e7..98b4453 100644
--- a/UVtools.GUI/Properties/AssemblyInfo.cs
+++ b/UVtools.GUI/Properties/AssemblyInfo.cs
@@ -35,5 +35,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("0.6.4.0")]
-[assembly: AssemblyFileVersion("0.6.4.0")]
+[assembly: AssemblyVersion("0.6.4.1")]
+[assembly: AssemblyFileVersion("0.6.4.1")]
diff --git a/UVtools.GUI/Properties/Resources.Designer.cs b/UVtools.GUI/Properties/Resources.Designer.cs
index d7b24a7..30f1532 100644
--- a/UVtools.GUI/Properties/Resources.Designer.cs
+++ b/UVtools.GUI/Properties/Resources.Designer.cs
@@ -153,6 +153,36 @@ namespace UVtools.GUI.Properties {
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
+        internal static System.Drawing.Bitmap blur_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("blur-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap bowling_ball_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("bowling-ball-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap burn_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("burn-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
         internal static System.Drawing.Bitmap Button_Info_16x16 {
             get {
                 object obj = ResourceManager.GetObject("Button-Info-16x16", resourceCulture);
@@ -203,6 +233,16 @@ namespace UVtools.GUI.Properties {
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
+        internal static System.Drawing.Bitmap chessboard_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("chessboard-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
         internal static System.Drawing.Bitmap clipboard_16x16 {
             get {
                 object obj = ResourceManager.GetObject("clipboard-16x16", resourceCulture);
@@ -223,6 +263,16 @@ namespace UVtools.GUI.Properties {
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
+        internal static System.Drawing.Bitmap compress_alt_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("compress-alt-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
         internal static System.Drawing.Bitmap Convert_16x16 {
             get {
                 object obj = ResourceManager.GetObject("Convert-16x16", resourceCulture);
@@ -233,6 +283,16 @@ namespace UVtools.GUI.Properties {
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
+        internal static System.Drawing.Bitmap crop_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("crop-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
         internal static System.Drawing.Bitmap cursor_16x16 {
             get {
                 object obj = ResourceManager.GetObject("cursor-16x16", resourceCulture);
@@ -283,6 +343,26 @@ namespace UVtools.GUI.Properties {
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
+        internal static System.Drawing.Bitmap expand_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("expand-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap expand_alt_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("expand-alt-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
         internal static System.Drawing.Bitmap Extract_object_16x16 {
             get {
                 object obj = ResourceManager.GetObject("Extract-object-16x16", resourceCulture);
@@ -353,6 +433,16 @@ namespace UVtools.GUI.Properties {
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
+        internal static System.Drawing.Bitmap flip_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("flip-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
         internal static System.Drawing.Bitmap Geometry_16x16 {
             get {
                 object obj = ResourceManager.GetObject("Geometry-16x16", resourceCulture);
@@ -373,6 +463,16 @@ namespace UVtools.GUI.Properties {
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
+        internal static System.Drawing.Bitmap internet_explorer_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("internet-explorer-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
         internal static System.Drawing.Bitmap island_16x16 {
             get {
                 object obj = ResourceManager.GetObject("island-16x16", resourceCulture);
@@ -403,6 +503,46 @@ namespace UVtools.GUI.Properties {
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
+        internal static System.Drawing.Bitmap layers_alt_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("layers-alt-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap list_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("list-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap map_marker_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("map-marker-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap move_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("move-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
         internal static System.Drawing.Bitmap mutation_blackhat {
             get {
                 object obj = ResourceManager.GetObject("mutation_blackhat", resourceCulture);
@@ -633,6 +773,56 @@ namespace UVtools.GUI.Properties {
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
+        internal static System.Drawing.Bitmap sort_alpha_up_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("sort-alpha-up-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap square_solid_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("square-solid-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap th_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("th-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap toolbox_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("toolbox-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap trash_16x16 {
+            get {
+                object obj = ResourceManager.GetObject("trash-16x16", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
         internal static System.Drawing.Bitmap UVtools {
             get {
                 object obj = ResourceManager.GetObject("UVtools", resourceCulture);
diff --git a/UVtools.GUI/Properties/Resources.resx b/UVtools.GUI/Properties/Resources.resx
index c13dd01..6873ec4 100644
--- a/UVtools.GUI/Properties/Resources.resx
+++ b/UVtools.GUI/Properties/Resources.resx
@@ -118,184 +118,241 @@
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
   <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="Error-128x128" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\Error-128x128.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="delete-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\delete-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="UVtools" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\UVtools.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="th-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\th-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="resize-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\resize-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="search-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\search-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="Cancel-24x24" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\Cancel-24x24.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="Wrench-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\Wrench-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="arrow-top-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\arrow-top-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="Error-128x128" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\Error-128x128.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="mutation_solidify" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\gui\mutation_solidify.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="island-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\island-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="eye-24x24" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\eye-24x24.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="layers-alt-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\layers-alt-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="Back-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Images\Back-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="Extract-object-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\Extract-object-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="move-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\move-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="File-Refresh-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\File-Refresh-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-  <data name="pointer-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\pointer-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-  <data name="Exit-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\Exit-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-  <data name="Global-Network-icon-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\Global-Network-icon-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="filter-filled-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\filter-filled-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="refresh-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\refresh-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="Cancel-32x32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\Cancel-32x32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="mutation_erosion" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\gui\mutation_erosion.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="crop-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\crop-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="arrow-up-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\arrow-up-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="checkbox-unmarked-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\checkbox-unmarked-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="file-image-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\file-image-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="arrow-up" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\arrow-up.ico;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="warning-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Images\warning-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="Wrench-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\Wrench-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-  <data name="pattern-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\pattern-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="CNCMachine-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\CNCMachine-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="arrow-down-double-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\arrow-down-double-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="UVtools" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\UVtools.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="mutation_opening" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\gui\mutation_opening.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="resize-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\resize-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="arrow-up" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\arrow-up.ico;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="mutation_closing" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\gui\mutation_closing.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="Ok-24x24" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Images\Ok-24x24.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="Button-Info-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\Button-Info-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="blur-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\blur-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="arrow-down-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\arrow-down-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="Save-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\Save-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="Next-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\Next-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="arrow-up-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\arrow-up-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="accept-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\accept-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="pointer-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\pointer-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="filter-filled-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\filter-filled-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="mutation_erosion" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\gui\mutation_erosion.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="Save-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\Save-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="mutation_dilation" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\gui\mutation_dilation.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="Open-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\Open-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="File-Refresh-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\File-Refresh-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="SaveAs-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\SaveAs-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="pixel-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\pixel-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="mutation_tophat" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\gui\mutation_tophat.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="cursor-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Images\cursor-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="File-Close-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\File-Close-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="Rotate-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\Rotate-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="search-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\search-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="settings-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\settings-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="mutation_blackhat" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\gui\mutation_blackhat.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="arrow-down-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\arrow-down-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="Cancel-32x32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\Cancel-32x32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="arrow-end-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\arrow-end-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="eye-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\eye-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="mutation_solidify" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\gui\mutation_solidify.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="Geometry-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\Geometry-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="clipboard-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\clipboard-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="mutation_tophat" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\gui\mutation_tophat.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="Exit-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\Exit-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="layers-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\layers-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="mutation_gradient" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\gui\mutation_gradient.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="pattern-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\pattern-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="plus" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Images\plus.ico;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="Extract-object-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\Extract-object-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="checkbox-marked-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\checkbox-marked-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="arrow-down" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\arrow-down.ico;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="sort-alpha-up-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\sort-alpha-up-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="trash-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\trash-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="accept-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\accept-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="file-image-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\file-image-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="refresh-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\refresh-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="eye-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\eye-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="compress-alt-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\compress-alt-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="Convert-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Images\Convert-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="layers-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\layers-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="bowling-ball-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\bowling-ball-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="mutation_dilation" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\gui\mutation_dilation.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="square-solid-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\square-solid-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="settings-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\settings-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="burn-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\burn-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="mutation_gradient" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\gui\mutation_gradient.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="map-marker-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\map-marker-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="Rotate-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\Rotate-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="arrow-down-double-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\arrow-down-double-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="pixel-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\pixel-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="Cancel-24x24" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\Cancel-24x24.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="arrow-end-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\arrow-end-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="Button-Info-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\Button-Info-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="SaveAs-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\SaveAs-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="Global-Network-icon-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\Global-Network-icon-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="CNCMachine-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\CNCMachine-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="photo-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\photo-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="delete-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\delete-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="Open-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\Open-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="checkbox-marked-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\checkbox-marked-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="flip-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\flip-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="checkbox-unmarked-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\checkbox-unmarked-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="mutation_blackhat" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\gui\mutation_blackhat.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="mutation_closing" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\gui\mutation_closing.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="arrow-top-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\arrow-top-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="clipboard-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\clipboard-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="Next-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\Next-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="arrow-down" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\arrow-down.ico;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="File-Close-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\File-Close-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="expand-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\expand-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="Geometry-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\Geometry-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="toolbox-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\toolbox-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="Donate-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Images\Donate-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="island-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\island-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="internet-explorer-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\internet-explorer-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="photo-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Images\photo-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="mutation_opening" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\gui\mutation_opening.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="eye-24x24" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\eye-24x24.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="ladder-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Images\ladder-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="chessboard-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\chessboard-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="expand-alt-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\expand-alt-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="list-16x16" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Images\list-16x16.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/UVtools.GUI/Properties/Settings.Designer.cs b/UVtools.GUI/Properties/Settings.Designer.cs
index 5cafb32..776ee3e 100644
--- a/UVtools.GUI/Properties/Settings.Designer.cs
+++ b/UVtools.GUI/Properties/Settings.Designer.cs
@@ -670,5 +670,17 @@ namespace UVtools.GUI.Properties {
                 this["LayerRepairRemoveIslandsBelowEqualPixelsDefault"] = value;
             }
         }
+        
+        [global::System.Configuration.UserScopedSettingAttribute()]
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+        [global::System.Configuration.DefaultSettingValueAttribute("True")]
+        public bool PartialUpdateIslandsOnEditing {
+            get {
+                return ((bool)(this["PartialUpdateIslandsOnEditing"]));
+            }
+            set {
+                this["PartialUpdateIslandsOnEditing"] = value;
+            }
+        }
     }
 }
diff --git a/UVtools.GUI/Properties/Settings.settings b/UVtools.GUI/Properties/Settings.settings
index f3dc6da..752d936 100644
--- a/UVtools.GUI/Properties/Settings.settings
+++ b/UVtools.GUI/Properties/Settings.settings
@@ -164,5 +164,8 @@
     <Setting Name="LayerRepairRemoveIslandsBelowEqualPixelsDefault" Type="System.Byte" Scope="User">
       <Value Profile="(Default)">10</Value>
     </Setting>
+    <Setting Name="PartialUpdateIslandsOnEditing" Type="System.Boolean" Scope="User">
+      <Value Profile="(Default)">True</Value>
+    </Setting>
   </Settings>
 </SettingsFile>
\ No newline at end of file
diff --git a/UVtools.GUI/UVtools.GUI.csproj b/UVtools.GUI/UVtools.GUI.csproj
index 683b110..60cfe99 100644
--- a/UVtools.GUI/UVtools.GUI.csproj
+++ b/UVtools.GUI/UVtools.GUI.csproj
@@ -152,8 +152,8 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Controls\ListViewColumnSorter.cs" />
     <Compile Include="Controls\Log.cs" />
+    <Compile Include="Controls\SlicerPropertyItem.cs" />
     <Compile Include="Controls\SplitButton.cs">
       <SubType>Component</SubType>
     </Compile>
@@ -374,6 +374,25 @@
     <None Include="Images\accept-16x16.png" />
     <None Include="Images\photo-16x16.png" />
     <None Include="Images\ladder-16x16.png" />
+    <None Include="Images\sort-alpha-up-16x16.png" />
+    <None Include="Images\trash-16x16.png" />
+    <None Include="Images\internet-explorer-16x16.png" />
+    <None Include="Images\toolbox-16x16.png" />
+    <None Include="Images\expand-16x16.png" />
+    <None Include="Images\map-marker-16x16.png" />
+    <None Include="Images\layers-alt-16x16.png" />
+    <None Include="Images\move-16x16.png" />
+    <None Include="Images\crop-16x16.png" />
+    <None Include="Images\flip-16x16.png" />
+    <None Include="Images\square-solid-16x16.png" />
+    <None Include="Images\chessboard-16x16.png" />
+    <None Include="Images\blur-16x16.png" />
+    <None Include="Images\compress-alt-16x16.png" />
+    <None Include="Images\expand-alt-16x16.png" />
+    <None Include="Images\bowling-ball-16x16.png" />
+    <None Include="Images\burn-16x16.png" />
+    <None Include="Images\th-16x16.png" />
+    <None Include="Images\list-16x16.png" />
     <Content Include="UVtools.ico" />
     <None Include="UVtools.png" />
     <None Include="Images\Exit-16x16.png" />