Layer tree caching wip

PixiEditor/Helpers/Converters/DebugConverter.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Globalization;
+
+namespace PixiEditor.Helpers.Converters
+{
+    public class DebugConverter
+        : SingleInstanceConverter<DebugConverter>
+    {
+        public override object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            return value;
+        }
+
+        public override object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            return value;
+        }
+    }
+}

PixiEditor/Helpers/Converters/LayersToStructuredLayersConverter.cs

@@ -1,12 +1,10 @@
-using PixiEditor.Models.Layers;
+using PixiEditor.Models.DataHolders;
+using PixiEditor.Models.Layers;
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Windows;
-using System.Windows.Data;
-using PixiEditor.Models.DataHolders;
 
 namespace PixiEditor.Helpers.Converters
 {
@@ -35,7 +33,7 @@ namespace PixiEditor.Helpers.Converters
                 {
                     cachedTree = new StructuredLayerTree(layers, structure);
                     lastLayers = layers;
-                    lastLayerGuids = layers.Select(x => x.LayerGuid).ToList();
+                    lastLayerGuids = layers.Select(x => x.GuidValue).ToList();
                     lastStructure = structure.CloneGroups();
                 }
 
@@ -52,7 +50,7 @@ namespace PixiEditor.Helpers.Converters
 
         private bool LayerOrderIsDifferent(IList<Layer> layers)
         {
-            var guids = layers.Select(x => x.LayerGuid).ToArray();
+            var guids = layers.Select(x => x.GuidValue).ToArray();
             return !guids.SequenceEqual(lastLayerGuids);
         }
 

PixiEditor/Helpers/Extensions/ParserHelpers.cs

@@ -75,8 +75,8 @@ namespace PixiEditor.Helpers.Extensions
                 Opacity = sgroup.Opacity,
                 IsVisible = sgroup.IsVisible,
                 Parent = parent,
-                StartLayerGuid = document.Layers[sgroup.StartLayer].LayerGuid,
-                EndLayerGuid = document.Layers[sgroup.EndLayer].LayerGuid
+                StartLayerGuid = document.Layers[sgroup.StartLayer].GuidValue,
+                EndLayerGuid = document.Layers[sgroup.EndLayer].GuidValue
             };
 
             group.Subgroups = new(sgroup.Subgroups.ToGroups(document, group));
@@ -127,12 +127,12 @@ namespace PixiEditor.Helpers.Extensions
 
             for (int i = 0; i < document.Layers.Count; i++)
             {
-                if (group.StartLayerGuid == document.Layers[i].LayerGuid)
+                if (group.StartLayerGuid == document.Layers[i].GuidValue)
                 {
                     serializable.StartLayer = i;
                 }
 
-                if (group.EndLayerGuid == document.Layers[i].LayerGuid)
+                if (group.EndLayerGuid == document.Layers[i].GuidValue)
                 {
                     serializable.EndLayer = i;
                 }

PixiEditor/Models/Controllers/BitmapOperationsUtility.cs

@@ -37,7 +37,7 @@ namespace PixiEditor.Models.Controllers
             BitmapPixelChanges changes = BitmapPixelChanges.FromSingleColoredArray(pixels, SKColors.Empty);
             for (int i = 0; i < layers.Length; i++)
             {
-                Guid guid = layers[i].LayerGuid;
+                Guid guid = layers[i].GuidValue;
                 layers[i].SetPixels(changes);
             }
 

PixiEditor/Models/DataHolders/Document/Document.Constructors.cs

@@ -41,7 +41,7 @@ namespace PixiEditor.Models.DataHolders
             RaisePropertyChanged(nameof(LayerStructure));
             foreach (var layerGuid in e.AffectedLayerGuids)
             {
-                Layer layer = Layers.First(x => x.LayerGuid == layerGuid);
+                Layer layer = Layers.First(x => x.GuidValue == layerGuid);
                 layer.RaisePropertyChange(nameof(layer.IsVisible));
                 layer.RaisePropertyChange(nameof(layer.Opacity));
             }

PixiEditor/Models/DataHolders/Document/Document.Layers.cs

@@ -9,7 +9,6 @@ using SkiaSharp;
 using System;
 using System.Buffers;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Linq;
 using System.Text.RegularExpressions;
 using System.Windows;
@@ -78,7 +77,7 @@ namespace PixiEditor.Models.DataHolders
             get => referenceLayerRenderer;
         }
 
-        public Layer ActiveLayer => Layers.Count > 0 ? Layers.FirstOrDefault(x => x.LayerGuid == ActiveLayerGuid) : null;
+        public Layer ActiveLayer => Layers.Count > 0 ? Layers.FirstOrDefault(x => x.GuidValue == ActiveLayerGuid) : null;
 
         public Guid ActiveLayerGuid
         {
@@ -111,7 +110,7 @@ namespace PixiEditor.Models.DataHolders
                 }
             }
 
-            ActiveLayerGuid = Layers[index].LayerGuid;
+            ActiveLayerGuid = Layers[index].GuidValue;
             ActiveLayer.IsActive = true;
             LayersChanged?.Invoke(this, new LayersChangedEventArgs(ActiveLayerGuid, LayerAction.SetActive));
         }
@@ -126,7 +125,7 @@ namespace PixiEditor.Models.DataHolders
         {
             foreach (var layer in Layers)
             {
-                if (layer.LayerGuid == ActiveLayerGuid)
+                if (layer.GuidValue == ActiveLayerGuid)
                 {
                     layer.LayerHighlightColor = MainSelectedLayerColor;
                 }
@@ -141,7 +140,7 @@ namespace PixiEditor.Models.DataHolders
         {
             var args = new object[] { layerGuid, referenceLayer, above };
 
-            Layer layer = Layers.First(x => x.LayerGuid == layerGuid);
+            Layer layer = Layers.First(x => x.GuidValue == layerGuid);
 
             int oldIndex = Layers.IndexOf(layer);
 
@@ -167,8 +166,8 @@ namespace PixiEditor.Models.DataHolders
         {
             var args = new object[] { groupGuid, referenceLayer, above };
 
-            var topLayer = Layers.First(x => x.LayerGuid == LayerStructure.GetGroupByGuid(groupGuid).EndLayerGuid);
-            var bottomLayer = Layers.First(x => x.LayerGuid == LayerStructure.GetGroupByGuid(groupGuid).StartLayerGuid);
+            var topLayer = Layers.First(x => x.GuidValue == LayerStructure.GetGroupByGuid(groupGuid).EndLayerGuid);
+            var bottomLayer = Layers.First(x => x.GuidValue == LayerStructure.GetGroupByGuid(groupGuid).StartLayerGuid);
 
             int indexOfTopLayer = Layers.IndexOf(topLayer);
             Guid oldReferenceLayerGuid;
@@ -176,12 +175,12 @@ namespace PixiEditor.Models.DataHolders
 
             if (indexOfTopLayer + 1 < Layers.Count)
             {
-                oldReferenceLayerGuid = topLayer.LayerGuid;
+                oldReferenceLayerGuid = topLayer.GuidValue;
             }
             else
             {
                 int indexOfBottomLayer = Layers.IndexOf(bottomLayer);
-                oldReferenceLayerGuid = Layers[indexOfBottomLayer - 1].LayerGuid;
+                oldReferenceLayerGuid = Layers[indexOfBottomLayer - 1].GuidValue;
                 oldAbove = true;
             }
 
@@ -241,12 +240,12 @@ namespace PixiEditor.Models.DataHolders
                 UndoManager.AddUndoChange(
                     storageChange.ToChange(
                         RemoveLayerProcess,
-                        new object[] { Layers[^1].LayerGuid },
+                        new object[] { Layers[^1].GuidValue },
                         RestoreLayersProcess,
                         "Add layer"));
             }
 
-            LayersChanged?.Invoke(this, new LayersChangedEventArgs(Layers[^1].LayerGuid, LayerAction.Add));
+            LayersChanged?.Invoke(this, new LayersChangedEventArgs(Layers[^1].GuidValue, LayerAction.Add));
         }
 
         /// <summary>
@@ -267,7 +266,7 @@ namespace PixiEditor.Models.DataHolders
             UndoManager.AddUndoChange(
                 storageChange.ToChange(
                     RemoveLayerProcess,
-                    new object[] { duplicate.LayerGuid },
+                    new object[] { duplicate.GuidValue },
                     RestoreLayersProcess,
                     "Duplicate Layer"));
 
@@ -294,9 +293,9 @@ namespace PixiEditor.Models.DataHolders
             var selectedLayers = Layers.Where(x => x.IsActive);
             foreach (var layer in selectedLayers)
             {
-                if (layer.LayerGuid != lastLayerGuid)
+                if (layer.GuidValue != lastLayerGuid)
                 {
-                    ActiveLayerGuid = layer.LayerGuid;
+                    ActiveLayerGuid = layer.GuidValue;
                     LayersChanged?.Invoke(this, new LayersChangedEventArgs(ActiveLayerGuid, LayerAction.SetActive));
                     return;
                 }
@@ -313,9 +312,9 @@ namespace PixiEditor.Models.DataHolders
                     return;
                 }
 
-                if (ActiveLayerGuid == layer.LayerGuid)
+                if (ActiveLayerGuid == layer.GuidValue)
                 {
-                    SetNextSelectedLayerAsActive(layer.LayerGuid);
+                    SetNextSelectedLayerAsActive(layer.GuidValue);
                 }
 
                 layer.IsActive = !layer.IsActive;
@@ -358,7 +357,7 @@ namespace PixiEditor.Models.DataHolders
                 return;
             }
 
-            LayerStructure.AssignParent(Layers[layerIndex].LayerGuid, null);
+            LayerStructure.AssignParent(Layers[layerIndex].GuidValue, null);
 
             bool wasActive = Layers[layerIndex].IsActive;
 
@@ -366,7 +365,7 @@ namespace PixiEditor.Models.DataHolders
             {
                 StorageBasedChange change = new(this, new[] { Layers[layerIndex] });
                 UndoManager.AddUndoChange(
-                    change.ToChange(RestoreLayersProcess, RemoveLayerProcess, new object[] { Layers[layerIndex].LayerGuid }));
+                    change.ToChange(RestoreLayersProcess, RemoveLayerProcess, new object[] { Layers[layerIndex].GuidValue }));
             }
 
             Layers.RemoveAt(layerIndex);
@@ -393,7 +392,7 @@ namespace PixiEditor.Models.DataHolders
             Layer[] layers = Layers.Where(x => x.IsActive).ToArray();
             int firstIndex = Layers.IndexOf(layers[0]);
 
-            object[] guidArgs = new object[] { layers.Select(x => x.LayerGuid).ToArray() };
+            object[] guidArgs = new object[] { layers.Select(x => x.GuidValue).ToArray() };
 
             StorageBasedChange change = new(this, layers);
 
@@ -440,11 +439,11 @@ namespace PixiEditor.Models.DataHolders
 
             Layer mergedLayer = layersToMerge[0];
 
-            var groupParent = LayerStructure.GetGroupByLayer(layersToMerge[^1].LayerGuid);
+            var groupParent = LayerStructure.GetGroupByLayer(layersToMerge[^1].GuidValue);
 
             Layer placeholderLayer = new("_placeholder");
             Layers.Insert(index, placeholderLayer);
-            LayerStructure.AssignParent(placeholderLayer.LayerGuid, groupParent?.GroupGuid);
+            LayerStructure.AssignParent(placeholderLayer.GuidValue, groupParent?.GroupGuid);
 
             for (int i = 0; i < layersToMerge.Length - 1; i++)
             {
@@ -455,7 +454,7 @@ namespace PixiEditor.Models.DataHolders
             }
 
             Layers.Insert(index, mergedLayer);
-            LayerStructure.AssignParent(mergedLayer.LayerGuid, groupParent?.GroupGuid);
+            LayerStructure.AssignParent(mergedLayer.GuidValue, groupParent?.GroupGuid);
 
             RemoveLayer(placeholderLayer, false);
             RemoveLayer(layersToMerge[^1], false);
@@ -488,7 +487,7 @@ namespace PixiEditor.Models.DataHolders
                 InsertLayersAtIndexesProcess,
                 new object[] { indexes[0] },
                 MergeLayersProcess,
-                new object[] { indexes, nameIsLastLayers, layer.LayerGuid }));
+                new object[] { indexes, nameIsLastLayers, layer.GuidValue }));
 
             UndoManager.SquashUndoChanges(2, "Undo merge layers");
 
@@ -531,13 +530,13 @@ namespace PixiEditor.Models.DataHolders
             int indexTo = (int)props[0];
             Guid layerGuid = (Guid)props[1];
 
-            Guid layerAtOldIndex = Layers[indexTo].LayerGuid;
+            Guid layerAtOldIndex = Layers[indexTo].GuidValue;
 
             var startGroup = LayerStructure.GetGroupByLayer(layerGuid);
 
             LayerStructure.PreMoveReassignBounds(new GroupData(startGroup?.GroupGuid), layerGuid);
 
-            Layers.Move(Layers.IndexOf(Layers.First(x => x.LayerGuid == layerGuid)), indexTo);
+            Layers.Move(Layers.IndexOf(Layers.First(x => x.GuidValue == layerGuid)), indexTo);
 
             var newGroup = LayerStructure.GetGroupByLayer(layerAtOldIndex);
 
@@ -607,7 +606,7 @@ namespace PixiEditor.Models.DataHolders
                     Layers.Insert(data[i].LayerIndex, layer);
                 }
 
-                ActiveLayerGuid = layers.First(x => x.LayerHighlightColor == MainSelectedLayerColor).LayerGuid;
+                ActiveLayerGuid = layers.First(x => x.LayerHighlightColor == MainSelectedLayerColor).GuidValue;
                 // Identifying main layer by highlightColor is a bit hacky, but shhh
             }
         }
@@ -645,15 +644,15 @@ namespace PixiEditor.Models.DataHolders
             GuidStructureItem group = LayerStructure.GetGroupByGuid(groupGuid);
             GuidStructureItem referenceLayerGroup = LayerStructure.GetGroupByLayer(referenceLayerGuid);
 
-            Layer referenceLayer = Layers.First(x => x.LayerGuid == referenceLayerGuid);
+            Layer referenceLayer = Layers.First(x => x.GuidValue == referenceLayerGuid);
 
             int layerIndex = Layers.IndexOf(referenceLayer);
-            int folderTopIndex = Layers.IndexOf(Layers.First(x => x.LayerGuid == group?.EndLayerGuid));
+            int folderTopIndex = Layers.IndexOf(Layers.First(x => x.GuidValue == group?.EndLayerGuid));
             int oldIndex = folderTopIndex;
 
             if (layerIndex < folderTopIndex)
             {
-                int folderBottomIndex = Layers.IndexOf(Layers.First(x => x.LayerGuid == group.StartLayerGuid));
+                int folderBottomIndex = Layers.IndexOf(Layers.First(x => x.GuidValue == group.StartLayerGuid));
                 oldIndex = folderBottomIndex;
             }
 
@@ -690,8 +689,8 @@ namespace PixiEditor.Models.DataHolders
             Guid referenceLayer = (Guid)parameter[1];
             bool above = (bool)parameter[2];
 
-            int layerIndex = Layers.IndexOf(Layers.First(x => x.LayerGuid == referenceLayer));
-            int oldIndex = Layers.IndexOf(Layers.First(x => x.LayerGuid == layer));
+            int layerIndex = Layers.IndexOf(Layers.First(x => x.GuidValue == referenceLayer));
+            int oldIndex = Layers.IndexOf(Layers.First(x => x.GuidValue == layer));
             int newIndex = CalculateNewIndex(layerIndex, above, oldIndex);
 
             var startGroup = LayerStructure.GetGroupByLayer(layer);
@@ -710,6 +709,7 @@ namespace PixiEditor.Models.DataHolders
             }
 
             RaisePropertyChanged(nameof(LayerStructure));
+            Renderer.ForceRerender();
         }
 
         private void RestoreLayersProcess(Layer[] layers, UndoLayer[] layersData)
@@ -730,19 +730,19 @@ namespace PixiEditor.Models.DataHolders
         {
             if (parameters is { Length: > 0 } && parameters[0] is Guid layerGuid)
             {
-                Layer layer = Layers.First(x => x.LayerGuid == layerGuid);
+                Layer layer = Layers.First(x => x.GuidValue == layerGuid);
                 int index = Layers.IndexOf(layer);
                 bool wasActive = layer.IsActive;
 
-                var layerGroup = LayerStructure.GetGroupByLayer(layer.LayerGuid);
+                var layerGroup = LayerStructure.GetGroupByLayer(layer.GuidValue);
 
                 LayerStructure.ExpandParentGroups(layerGroup);
 
-                if (layerGroup?.Parent != null && LayerStructure.GroupContainsOnlyLayer(layer.LayerGuid, layerGroup))
+                if (layerGroup?.Parent != null && LayerStructure.GroupContainsOnlyLayer(layer.GuidValue, layerGroup))
                 {
                     LayerStructure.PreMoveReassignBounds(new GroupData(layerGroup.Parent.GroupGuid), new GroupData(layerGroup.GroupGuid));
                 }
-                LayerStructure.AssignParent(Layers[index].LayerGuid, null);
+                LayerStructure.AssignParent(Layers[index].GuidValue, null);
                 RemoveGroupsIfEmpty(layer, layerGroup);
 
                 Layers.Remove(layer);
@@ -758,7 +758,7 @@ namespace PixiEditor.Models.DataHolders
 
         private void RemoveGroupsIfEmpty(Layer layer, GuidStructureItem layerGroup)
         {
-            if (LayerStructure.GroupContainsOnlyLayer(layer.LayerGuid, layerGroup))
+            if (LayerStructure.GroupContainsOnlyLayer(layer.GuidValue, layerGroup))
             {
                 if (layerGroup.Parent != null)
                 {

PixiEditor/Models/ImageManipulation/BitmapUtils.cs

@@ -149,7 +149,7 @@ namespace PixiEditor.Models.ImageManipulation
                     var cl = layer.GetPixel(position.X, position.Y);
                     pixels[j] = cl;
                 }
-                result[layer.LayerGuid] = pixels;
+                result[layer.GuidValue] = pixels;
             }
 
             return result;

PixiEditor/Models/Layers/BasicLayer.cs

@@ -1,10 +1,10 @@
-using System;
-using PixiEditor.Helpers;
+using PixiEditor.Helpers;
+using System;
 
 namespace PixiEditor.Models.Layers
 {
     [Serializable]
-    public class BasicLayer : NotifyableObject
+    public class BasicLayer : NotifyableObject, IHasGuid
     {
         private int height;
 
@@ -30,6 +30,6 @@ namespace PixiEditor.Models.Layers
             }
         }
 
-        public Guid LayerGuid { get; protected set; }
+        public Guid GuidValue { get; protected set; }
     }
-}
+}

PixiEditor/Models/Layers/IHasGuid.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace PixiEditor.Models.Layers
+{
+    public interface IHasGuid
+    {
+        Guid GuidValue { get; }
+    }
+}

PixiEditor/Models/Layers/Layer.cs

@@ -38,7 +38,7 @@ namespace PixiEditor.Models.Layers
             IsReset = true;
             Width = 1;
             Height = 1;
-            LayerGuid = Guid.NewGuid();
+            GuidValue = Guid.NewGuid();
         }
 
         public Layer(string name, int width, int height)
@@ -48,7 +48,7 @@ namespace PixiEditor.Models.Layers
             IsReset = true;
             Width = width;
             Height = height;
-            LayerGuid = Guid.NewGuid();
+            GuidValue = Guid.NewGuid();
         }
 
         public Layer(string name, Surface layerBitmap)
@@ -57,7 +57,7 @@ namespace PixiEditor.Models.Layers
             LayerBitmap = layerBitmap;
             Width = layerBitmap.Width;
             Height = layerBitmap.Height;
-            LayerGuid = Guid.NewGuid();
+            GuidValue = Guid.NewGuid();
         }
 
         public Dictionary<Coordinates, SKColor> LastRelativeCoordinates { get; set; }
@@ -119,7 +119,7 @@ namespace PixiEditor.Models.Layers
                             isVisible,
                             value,
                             LayerHelper.FindLayerByGuidProcess,
-                            new object[] { LayerGuid },
+                            new object[] { GuidValue },
                             "Change layer visibility"));
                     IsVisible = value;
                     InvokeLayerBitmapChange();
@@ -178,7 +178,7 @@ namespace PixiEditor.Models.Layers
                                    opacity,
                                    value,
                                    LayerHelper.FindLayerByGuidProcess,
-                                   new object[] { LayerGuid },
+                                   new object[] { GuidValue },
                                    "Change layer opacity"));
                     Opacity = value;
                 }
@@ -230,7 +230,7 @@ namespace PixiEditor.Models.Layers
         /// <remarks>This is potentially destructive operation, use when absolutelly necessary.</remarks>
         public void ChangeGuid(Guid newGuid)
         {
-            LayerGuid = newGuid;
+            GuidValue = newGuid;
         }
 
         public IEnumerable<Layer> GetLayers()
@@ -252,7 +252,7 @@ namespace PixiEditor.Models.Layers
                 Opacity = Opacity,
                 IsActive = IsActive,
                 IsRenaming = IsRenaming,
-                LayerGuid = generateNewGuid ? Guid.NewGuid() : LayerGuid
+                GuidValue = generateNewGuid ? Guid.NewGuid() : GuidValue
             };
         }
 

PixiEditor/Models/Layers/LayerGroup.cs

@@ -1,28 +1,33 @@
-using System;
-using System.Collections;
+using PixiEditor.Helpers;
+using PixiEditor.ViewModels;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
-using PixiEditor.Helpers;
-using PixiEditor.ViewModels;
 
 namespace PixiEditor.Models.Layers
 {
-    public class LayerGroup : NotifyableObject
+    public class LayerGroup : NotifyableObject, IHasGuid
     {
-        public Guid GroupGuid { get; init; }
+        public Guid GuidValue { get; init; }
 
-        public GuidStructureItem StructureData { get; init; }
+        private GuidStructureItem structureData;
+        public GuidStructureItem StructureData
+        {
+            get => structureData;
+            set => SetProperty(ref structureData, value);
+        }
 
-        public ObservableCollection<Layer> Layers { get; set; } = new ObservableCollection<Layer>();
+        private ObservableCollection<Layer> Layers { get; set; } = new ObservableCollection<Layer>();
 
-        public ObservableCollection<LayerGroup> Subfolders { get; set; } = new ObservableCollection<LayerGroup>();
+        private ObservableCollection<LayerGroup> Subfolders { get; set; } = new ObservableCollection<LayerGroup>();
 
-        public IEnumerable Items => BuildItems();
+        private ObservableCollection<IHasGuid> items = null;
+        public ObservableCollection<IHasGuid> Items => items ??= BuildItems();
 
-        private IEnumerable BuildItems()
+        private ObservableCollection<IHasGuid> BuildItems()
         {
-            List<object> obj = new(Layers.Reverse());
+            List<IHasGuid> obj = new(Layers.Reverse());
             foreach (var subfolder in Subfolders)
             {
                 obj.Insert(Math.Clamp(subfolder.DisplayIndex - DisplayIndex, 0, obj.Count), subfolder);
@@ -30,7 +35,7 @@ namespace PixiEditor.Models.Layers
 
             obj.Reverse();
 
-            return obj;
+            return new ObservableCollection<IHasGuid>(obj);
         }
 
         private string name;
@@ -95,7 +100,7 @@ namespace PixiEditor.Models.Layers
 
         private void UpdateIsExpandedInDocument(bool value)
         {
-            var folder = ViewModelMain.Current.BitmapManager.ActiveDocument.LayerStructure.GetGroupByGuid(GroupGuid);
+            var folder = ViewModelMain.Current.BitmapManager.ActiveDocument.LayerStructure.GetGroupByGuid(GuidValue);
             if (folder != null)
             {
                 folder.IsExpanded = value;
@@ -114,10 +119,10 @@ namespace PixiEditor.Models.Layers
             Layers = new ObservableCollection<Layer>(layers);
             Subfolders = new ObservableCollection<LayerGroup>(subfolders);
             Name = name;
-            GroupGuid = guid;
+            GuidValue = guid;
             DisplayIndex = displayIndex;
             TopIndex = topIndex;
             StructureData = structureData;
         }
     }
-}
+}

PixiEditor/Models/Layers/LayerHelper.cs

@@ -12,7 +12,7 @@ namespace PixiEditor.Models.Layers
     {
         public static Layer FindLayerByGuid(Document document, Guid guid)
         {
-            return document.Layers.FirstOrDefault(x => x.LayerGuid == guid);
+            return document.Layers.FirstOrDefault(x => x.GuidValue == guid);
         }
 
         public static object FindLayerByGuidProcess(object[] parameters)

PixiEditor/Models/Layers/LayerStructure.cs

@@ -175,8 +175,8 @@ namespace PixiEditor.Models.Layers
             var group = GetGroupByGuid(groupGuid);
             var parentGroup = group.Parent;
             bool reverseOrder = true;
-            int groupTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.LayerGuid == group.EndLayerGuid));
-            int groupBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.LayerGuid == group.StartLayerGuid));
+            int groupTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == group.EndLayerGuid));
+            int groupBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == group.StartLayerGuid));
 
             int difference = newIndex - groupTopIndex;
 
@@ -336,7 +336,7 @@ namespace PixiEditor.Models.Layers
             var layerGuids = GetGroupLayerGuids(group);
             foreach (var layerGuid in layerGuids)
             {
-                layers.Add(Owner.Layers.First(x => x.LayerGuid == layerGuid));
+                layers.Add(Owner.Layers.First(x => x.GuidValue == layerGuid));
             }
 
             return layers;
@@ -390,8 +390,8 @@ namespace PixiEditor.Models.Layers
         /// <returns>List of layer guids.</returns>
         private List<Guid> GetGroupLayerGuids(GuidStructureItem group)
         {
-            Layer layerTop = Owner.Layers.FirstOrDefault(x => x.LayerGuid == group.EndLayerGuid);
-            Layer layerBottom = Owner.Layers.FirstOrDefault(x => x.LayerGuid == group.StartLayerGuid);
+            Layer layerTop = Owner.Layers.FirstOrDefault(x => x.GuidValue == group.EndLayerGuid);
+            Layer layerBottom = Owner.Layers.FirstOrDefault(x => x.GuidValue == group.StartLayerGuid);
 
             if (layerTop == null || layerBottom == null)
             {
@@ -412,7 +412,7 @@ namespace PixiEditor.Models.Layers
 
             for (int i = minIndex; i <= maxIndex; i++)
             {
-                layerGuids.Add(Owner.Layers[i].LayerGuid);
+                layerGuids.Add(Owner.Layers[i].GuidValue);
             }
 
             return layerGuids;
@@ -488,10 +488,10 @@ namespace PixiEditor.Models.Layers
                 Guid? oldStart = parentGroup.StartLayerGuid;
                 Guid? oldEnd = parentGroup.EndLayerGuid;
 
-                int layerIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.LayerGuid == layerGuid));
+                int layerIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == layerGuid));
 
-                int folderTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.LayerGuid == parentGroup.EndLayerGuid));
-                int folderBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.LayerGuid == parentGroup.StartLayerGuid));
+                int folderTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == parentGroup.EndLayerGuid));
+                int folderBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == parentGroup.StartLayerGuid));
 
                 int finalTopIndex = Math.Max(folderTopIndex, layerIndex);
                 int finalBottomIndex = Math.Min(folderBottomIndex, layerIndex);
@@ -535,11 +535,11 @@ namespace PixiEditor.Models.Layers
             {
                 Guid oldStart = parentGroup.StartLayerGuid;
                 Guid oldEnd = parentGroup.EndLayerGuid;
-                int folderTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.LayerGuid == group.EndLayerGuid));
-                int folderBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.LayerGuid == group.StartLayerGuid));
+                int folderTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == group.EndLayerGuid));
+                int folderBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == group.StartLayerGuid));
 
-                int parentFolderTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.LayerGuid == parentGroup.EndLayerGuid));
-                int parentFolderBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.LayerGuid == parentGroup.StartLayerGuid));
+                int parentFolderTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == parentGroup.EndLayerGuid));
+                int parentFolderBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == parentGroup.StartLayerGuid));
 
                 int finalTopIndex = Math.Max(folderTopIndex, parentFolderTopIndex);
                 int finalBottomIndex = Math.Min(folderBottomIndex, parentFolderBottomIndex);
@@ -639,8 +639,8 @@ namespace PixiEditor.Models.Layers
 
         private Guid FindBoundLayer(GuidStructureItem parentFolder, Guid layerGuid, bool above)
         {
-            int parentFolderTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.LayerGuid == parentFolder.EndLayerGuid));
-            int parentFolderBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.LayerGuid == parentFolder.StartLayerGuid));
+            int parentFolderTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == parentFolder.EndLayerGuid));
+            int parentFolderBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == parentFolder.StartLayerGuid));
 
             return FindBoundLayer(layerGuid, parentFolderTopIndex, parentFolderBottomIndex, above);
         }
@@ -652,7 +652,7 @@ namespace PixiEditor.Models.Layers
             for (int i = 0; i < layers.Count; i++)
             {
                 Guid layerGuid = layerGuids[i];
-                var layer = Owner.Layers.First(x => x.LayerGuid == layerGuid);
+                var layer = Owner.Layers.First(x => x.GuidValue == layerGuid);
                 int layerIndex = Owner.Layers.IndexOf(layer);
                 Owner.Layers.Move(layerIndex, layerIndex + moveBy);
             }
@@ -662,8 +662,8 @@ namespace PixiEditor.Models.Layers
         {
             foreach (var currentGroup in groups)
             {
-                var endLayer = Owner.Layers.First(x => x.LayerGuid == currentGroup.EndLayerGuid);
-                var startLayer = Owner.Layers.First(x => x.LayerGuid == currentGroup.StartLayerGuid);
+                var endLayer = Owner.Layers.First(x => x.GuidValue == currentGroup.EndLayerGuid);
+                var startLayer = Owner.Layers.First(x => x.GuidValue == currentGroup.StartLayerGuid);
 
                 int topIndex = Owner.Layers.IndexOf(endLayer);
                 int bottomIndex = Owner.Layers.IndexOf(startLayer);

PixiEditor/Models/Layers/StructuredLayerTree.cs

@@ -1,10 +1,9 @@
 using PixiEditor.Helpers;
-using PixiEditor.Helpers.Extensions;
+using PixiEditor.Models.DataHolders;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
-using PixiEditor.Models.DataHolders;
 
 namespace PixiEditor.Models.Layers
 {
@@ -12,7 +11,7 @@ namespace PixiEditor.Models.Layers
     {
         private List<Guid> layersInStructure = new();
 
-        public WpfObservableRangeCollection<object> RootDirectoryItems { get; } = new WpfObservableRangeCollection<object>();
+        public WpfObservableRangeCollection<IHasGuid> RootDirectoryItems { get; } = new WpfObservableRangeCollection<IHasGuid>();
 
         private static void Swap(ref int startIndex, ref int endIndex)
         {
@@ -49,7 +48,7 @@ namespace PixiEditor.Models.Layers
 
             for (int i = 0; i < layers.Count; i++)
             {
-                if (currentFolder != null && layers[i].LayerGuid == currentFolder.StructureData.EndLayerGuid)
+                if (currentFolder != null && layers[i].GuidValue == currentFolder.StructureData.EndLayerGuid)
                 {
                     if (unfinishedFolders.Count > 0)
                     {
@@ -65,7 +64,7 @@ namespace PixiEditor.Models.Layers
 
                 AssignGroup(parsedFolders, layers, ref currentFolder, ref groupsAtIndex, unfinishedFolders, i);
 
-                if (currentFolder == null && !layersInStructure.Contains(layers[i].LayerGuid))
+                if (currentFolder == null && !layersInStructure.Contains(layers[i].GuidValue))
                 {
                     RootDirectoryItems.Add(layers[i]);
                 }
@@ -78,9 +77,9 @@ namespace PixiEditor.Models.Layers
 
         private void AssignGroup(List<LayerGroup> parsedFolders, ObservableCollection<Layer> layers, ref LayerGroup currentFolder, ref List<LayerGroup> groupsAtIndex, Stack<LayerGroup> unfinishedFolders, int i)
         {
-            if (parsedFolders.Any(x => x.StructureData.StartLayerGuid == layers[i].LayerGuid))
+            if (parsedFolders.Any(x => x.StructureData.StartLayerGuid == layers[i].GuidValue))
             {
-                groupsAtIndex = parsedFolders.Where(x => x.StructureData.StartLayerGuid == layers[i].LayerGuid).ToList();
+                groupsAtIndex = parsedFolders.Where(x => x.StructureData.StartLayerGuid == layers[i].GuidValue).ToList();
                 for (int j = 0; j < groupsAtIndex.Count; j++)
                 {
                     LayerGroup group = groupsAtIndex[j];
@@ -90,10 +89,10 @@ namespace PixiEditor.Models.Layers
                         unfinishedFolders.Push(currentFolder);
                     }
 
-                    groupsAtIndex[j] = parsedFolders.First(x => x.StructureData.StartLayerGuid == layers[i].LayerGuid);
+                    groupsAtIndex[j] = parsedFolders.First(x => x.StructureData.StartLayerGuid == layers[i].GuidValue);
                     groupsAtIndex[j].DisplayIndex = RootDirectoryItems.Count;
                     groupsAtIndex[j].TopIndex = CalculateTopIndex(group.DisplayIndex, group.StructureData, layers);
-                    if (groupsAtIndex[j].StructureData.EndLayerGuid != layers[i].LayerGuid)
+                    if (groupsAtIndex[j].StructureData.EndLayerGuid != layers[i].GuidValue)
                     {
                         currentFolder = groupsAtIndex[j];
                     }
@@ -103,8 +102,8 @@ namespace PixiEditor.Models.Layers
 
         private int CalculateTopIndex(int displayIndex, GuidStructureItem structureData, ObservableCollection<Layer> layers)
         {
-            var endLayer = layers.FirstOrDefault(x => x.LayerGuid == structureData.EndLayerGuid);
-            var bottomLayer = layers.FirstOrDefault(x => x.LayerGuid == structureData.StartLayerGuid);
+            var endLayer = layers.FirstOrDefault(x => x.GuidValue == structureData.EndLayerGuid);
+            var bottomLayer = layers.FirstOrDefault(x => x.GuidValue == structureData.StartLayerGuid);
             int originalTopIndex = 0;
             int originalBottomIndex = 0;
             if (endLayer != null)
@@ -145,18 +144,18 @@ namespace PixiEditor.Models.Layers
 
             foreach (var guid in layersInFolder)
             {
-                var layer = layers.FirstOrDefault(x => x.LayerGuid == guid);
+                var layer = layers.FirstOrDefault(x => x.GuidValue == guid);
                 if (layer != null)
                 {
-                    if (!layersInStructure.Contains(layer.LayerGuid))
+                    if (!layersInStructure.Contains(layer.GuidValue))
                     {
-                        layersInStructure.Add(layer.LayerGuid);
+                        layersInStructure.Add(layer.GuidValue);
                         structureItemLayers.Add(layer);
                     }
                 }
             }
 
-            int displayIndex = layersInFolder.Length > 0 ? layers.IndexOf(layers.First(x => x.LayerGuid == structureItem.StartLayerGuid)) : 0;
+            int displayIndex = layersInFolder.Length > 0 ? layers.IndexOf(layers.First(x => x.GuidValue == structureItem.StartLayerGuid)) : 0;
 
             structureItemLayers.Reverse();
 
@@ -171,8 +170,8 @@ namespace PixiEditor.Models.Layers
 
         private Guid[] GetLayersInGroup(ObservableCollection<Layer> layers, GuidStructureItem structureItem)
         {
-            var startLayer = layers.FirstOrDefault(x => x.LayerGuid == structureItem.StartLayerGuid);
-            var endLayer = layers.FirstOrDefault(x => x.LayerGuid == structureItem.EndLayerGuid);
+            var startLayer = layers.FirstOrDefault(x => x.GuidValue == structureItem.StartLayerGuid);
+            var endLayer = layers.FirstOrDefault(x => x.GuidValue == structureItem.EndLayerGuid);
 
             if (startLayer == null || endLayer == null)
             {
@@ -193,7 +192,7 @@ namespace PixiEditor.Models.Layers
 
             for (int i = 0; i < len; i++)
             {
-                guids[i] = layers[i + startIndex].LayerGuid;
+                guids[i] = layers[i + startIndex].GuidValue;
             }
 
             return guids;

PixiEditor/Models/Layers/Utils/LayerStructureUtils.cs

@@ -16,7 +16,7 @@ namespace PixiEditor.Models.Layers.Utils
                 return 0f;
             }
 
-            var group = structure.GetGroupByLayer(layer.LayerGuid);
+            var group = structure.GetGroupByLayer(layer.GuidValue);
             GuidStructureItem groupToCheck = group;
             float finalOpacity = layer.Opacity;
 
@@ -41,7 +41,7 @@ namespace PixiEditor.Models.Layers.Utils
                 return false;
             }
 
-            var group = structure.GetGroupByLayer(layer.LayerGuid);
+            var group = structure.GetGroupByLayer(layer.GuidValue);
             bool atLeastOneParentIsInvisible = false;
             GuidStructureItem groupToCheck = group;
             while (groupToCheck != null)

PixiEditor/Models/Undo/StorageBasedChange.cs

@@ -1,16 +1,13 @@
 using PixiEditor.Models.DataHolders;
 using PixiEditor.Models.IO;
 using PixiEditor.Models.Layers;
+using SkiaSharp;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Text;
 using System.Windows;
-using PixiEditor.Models.ImageManipulation;
-using PixiEditor.Models.Position;
-using SkiaSharp;
 
 namespace PixiEditor.Models.Undo
 {
@@ -49,7 +46,7 @@ namespace PixiEditor.Models.Undo
             {
                 var chunk = chunkData[i];
                 layerChunks[i] = chunk;
-                layersToStore.Add(chunk.Layer.LayerGuid);
+                layersToStore.Add(chunk.Layer.GuidValue);
             }
 
             UndoChangeLocation = DefaultUndoChangeLocation;
@@ -68,7 +65,7 @@ namespace PixiEditor.Models.Undo
             {
                 var layer = layersArray[i];
                 layerChunks[i] = new LayerChunk(layer, SKRectI.Create(layer.OffsetX, layer.OffsetY, layer.Width, layer.Height));
-                layersToStore.Add(layer.LayerGuid);
+                layersToStore.Add(layer.GuidValue);
             }
 
             UndoChangeLocation = undoChangeLocation;
@@ -84,7 +81,7 @@ namespace PixiEditor.Models.Undo
             int i = 0;
             foreach (var layerGuid in layersToStore)
             {
-                Layer layer = Document.Layers.First(x => x.LayerGuid == layerGuid);
+                Layer layer = Document.Layers.First(x => x.GuidValue == layerGuid);
                 UndoLayer storedLayer = StoredLayers[i];
                 if (Directory.Exists(Path.GetDirectoryName(storedLayer.StoredPngLayerName)))
                 {
@@ -138,7 +135,7 @@ namespace PixiEditor.Models.Undo
                 File.Delete(StoredLayers[i].StoredPngLayerName);
             }
 
-            layersToStore = layers.Select(x => x.LayerGuid).ToList();
+            layersToStore = layers.Select(x => x.GuidValue).ToList();
             return layers;
         }
 
@@ -281,7 +278,7 @@ namespace PixiEditor.Models.Undo
             int i = 0;
             foreach (var layerGuid in layersToStore)
             {
-                Layer layer = Document.Layers.First(x => x.LayerGuid == layerGuid);
+                Layer layer = Document.Layers.First(x => x.GuidValue == layerGuid);
                 if (!Document.Layers.Contains(layer))
                 {
                     throw new ArgumentException("Provided document doesn't contain selected layer");
@@ -308,7 +305,7 @@ namespace PixiEditor.Models.Undo
                 {
                     Layer layer = layers[i];
                     UndoLayer layerData = data[i];
-                    var foundLayer = document.Layers.FirstOrDefault(x => x.LayerGuid == layerData.LayerGuid);
+                    var foundLayer = document.Layers.FirstOrDefault(x => x.GuidValue == layerData.LayerGuid);
 
                     if (foundLayer != null)
                     {

PixiEditor/Models/Undo/UndoLayer.cs

@@ -52,7 +52,7 @@ namespace PixiEditor.Models.Undo
             OffsetY = layer.OffsetY;
             Opacity = layer.Opacity;
             IsActive = layer.IsActive;
-            LayerGuid = layer.LayerGuid;
+            LayerGuid = layer.GuidValue;
             LayerHighlightColor = layer.LayerHighlightColor;
             SerializedRect = serializedRect;
         }

PixiEditor/ViewModels/SubViewModels/Main/LayersViewModel.cs

@@ -92,7 +92,7 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
             }
             else if (parameter is LayerGroup group)
             {
-                DeleteGroup(group.GroupGuid);
+                DeleteGroup(group.GuidValue);
             }
             else if (parameter is LayerGroupControl groupControl)
             {
@@ -137,7 +137,7 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
                 var lastGroups = doc.LayerStructure.CloneGroups();
                 if (parameter is Layer or LayerStructureItemContainer)
                 {
-                    GuidStructureItem group = doc.LayerStructure.AddNewGroup($"{doc.ActiveLayer.Name} Group", doc.ActiveLayer.LayerGuid);
+                    GuidStructureItem group = doc.LayerStructure.AddNewGroup($"{doc.ActiveLayer.Name} Group", doc.ActiveLayer.GuidValue);
 
                     Owner.BitmapManager.ActiveDocument.LayerStructure.ExpandParentGroups(group);
                 }
@@ -181,7 +181,7 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
 
             if (doc.Layers.Count > 1)
             {
-                doc.MoveLayerInStructure(doc.Layers[^1].LayerGuid, lastActiveLayerGuid, true);
+                doc.MoveLayerInStructure(doc.Layers[^1].GuidValue, lastActiveLayerGuid, true);
                 Guid? parent = parameter is Layer or LayerStructureItemContainer ? activeLayerParent?.GroupGuid : activeLayerParent.Parent?.GroupGuid;
                 doc.LayerStructure.AssignParent(doc.ActiveLayerGuid, parent);
                 doc.AddLayerStructureToUndo(oldGroups);
@@ -265,16 +265,16 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
         public void MoveLayerToFront(object parameter)
         {
             int oldIndex = (int)parameter;
-            Guid layerToMove = Owner.BitmapManager.ActiveDocument.Layers[oldIndex].LayerGuid;
-            Guid referenceLayer = Owner.BitmapManager.ActiveDocument.Layers[oldIndex + 1].LayerGuid;
+            Guid layerToMove = Owner.BitmapManager.ActiveDocument.Layers[oldIndex].GuidValue;
+            Guid referenceLayer = Owner.BitmapManager.ActiveDocument.Layers[oldIndex + 1].GuidValue;
             Owner.BitmapManager.ActiveDocument.MoveLayerInStructure(layerToMove, referenceLayer, true);
         }
 
         public void MoveLayerToBack(object parameter)
         {
             int oldIndex = (int)parameter;
-            Guid layerToMove = Owner.BitmapManager.ActiveDocument.Layers[oldIndex].LayerGuid;
-            Guid referenceLayer = Owner.BitmapManager.ActiveDocument.Layers[oldIndex - 1].LayerGuid;
+            Guid layerToMove = Owner.BitmapManager.ActiveDocument.Layers[oldIndex].GuidValue;
+            Guid referenceLayer = Owner.BitmapManager.ActiveDocument.Layers[oldIndex - 1].GuidValue;
             Owner.BitmapManager.ActiveDocument.MoveLayerInStructure(layerToMove, referenceLayer, false);
         }
 
@@ -349,7 +349,7 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
             }
             else if (parameter is Layer || parameter is LayerStructureItemContainer)
             {
-                Guid layerGuid = parameter is Layer layer ? layer.LayerGuid : ((LayerStructureItemContainer)parameter).Layer.LayerGuid;
+                Guid layerGuid = parameter is Layer layer ? layer.GuidValue : ((LayerStructureItemContainer)parameter).Layer.GuidValue;
                 var group = Owner.BitmapManager.ActiveDocument.LayerStructure.GetGroupByLayer(layerGuid);
                 if (group != null)
                 {

PixiEditor/Views/UserControls/Layers/LayerGroupControl.xaml

@@ -29,11 +29,11 @@
                 <CheckBox Style="{StaticResource ImageCheckBox}" VerticalAlignment="Center"
                       IsThreeState="False" HorizontalAlignment="Center" Click="CheckBox_Checked"
                       IsChecked="{Binding Path=IsVisibleUndoTriggerable, ElementName=groupControl}" Grid.Column="0" Height="16"/>
-                
+
                 <StackPanel Orientation="Horizontal" Grid.Column="1" HorizontalAlignment="Left">
                     <Rectangle Width="{Binding Path=(helpers:TreeViewItemHelper.Indent).Value, Mode=OneWay, RelativeSource={RelativeSource AncestorType=ItemsPresenter}}" Fill="Transparent" StrokeThickness="0"/>
-                
-                <StackPanel Grid.Row="1" Orientation="Horizontal" Grid.Column="0" HorizontalAlignment="Left">
+
+                    <StackPanel Grid.Row="1" Orientation="Horizontal" Grid.Column="0" HorizontalAlignment="Left">
                         <Border Width="30" Height="30" BorderThickness="1" BorderBrush="Black" Background="{StaticResource MainColor}"
                            Margin="5, 0, 10, 0">
                             <Image Source="{Binding PreviewImage, ElementName=groupControl}" Stretch="Uniform" Width="20" Height="20" 
@@ -44,7 +44,7 @@
                     VerticalAlignment="Center"
                     IsEditing="{Binding GroupData.IsRenaming, ElementName=groupControl, Mode=TwoWay}"
                     Text="{Binding GroupData.Name, ElementName=groupControl, Mode=TwoWay}" />
-                </StackPanel>
+                    </StackPanel>
                     <Image Source="/Images/Folder.png" Height="20" Margin="0,0,10,0" HorizontalAlignment="Right"/>
                 </StackPanel>
             </Grid>

PixiEditor/Views/UserControls/Layers/LayerGroupControl.xaml.cs

@@ -170,7 +170,7 @@ namespace PixiEditor.Views.UserControls.Layers
         private void HandleLayerDrop(IDataObject dataObj, bool above, Guid referenceLayer, bool putItInside) // step brother
         {
             var data = (LayerStructureItemContainer)dataObj.GetData(LayerContainerDataName);
-            Guid group = data.Layer.LayerGuid;
+            Guid group = data.Layer.GuidValue;
 
             data.LayerCommandsViewModel.Owner.BitmapManager.ActiveDocument.MoveLayerInStructure(group, referenceLayer, above);
 
@@ -193,7 +193,7 @@ namespace PixiEditor.Views.UserControls.Layers
 
             int modifier = above ? 1 : 0;
 
-            Layer layer = document.Layers.First(x => x.LayerGuid == referenceLayer);
+            Layer layer = document.Layers.First(x => x.GuidValue == referenceLayer);
             int indexOfReferenceLayer = Math.Clamp(document.Layers.IndexOf(layer) + modifier, 0, document.Layers.Count);
             MoveGroupWithTempLayer(above, document, group, indexOfReferenceLayer, putItInside);
         }
@@ -206,9 +206,9 @@ namespace PixiEditor.Views.UserControls.Layers
 
             Guid? refGuid = putItInside ? GroupData?.GroupGuid : GroupData?.Parent?.GroupGuid;
 
-            document.LayerStructure.AssignParent(tempLayer.LayerGuid, refGuid);
-            document.MoveGroupInStructure(group, tempLayer.LayerGuid, above);
-            document.LayerStructure.AssignParent(tempLayer.LayerGuid, null);
+            document.LayerStructure.AssignParent(tempLayer.GuidValue, refGuid);
+            document.MoveGroupInStructure(group, tempLayer.GuidValue, above);
+            document.LayerStructure.AssignParent(tempLayer.GuidValue, null);
             document.RemoveLayer(tempLayer, false);
         }
 
@@ -247,8 +247,8 @@ namespace PixiEditor.Views.UserControls.Layers
         private void Border_MouseDown(object sender, MouseButtonEventArgs e)
         {
             var doc = LayersViewModel.Owner.BitmapManager.ActiveDocument;
-            var layer = doc.Layers.First(x => x.LayerGuid == GroupData.EndLayerGuid);
-            if (doc.ActiveLayerGuid != layer.LayerGuid)
+            var layer = doc.Layers.First(x => x.GuidValue == GroupData.EndLayerGuid);
+            if (doc.ActiveLayerGuid != layer.GuidValue)
             {
                 doc.SetMainActiveLayer(doc.Layers.IndexOf(layer));
             }

PixiEditor/Views/UserControls/Layers/LayerItem.xaml.cs

@@ -158,7 +158,7 @@ namespace PixiEditor.Views.UserControls.Layers
             if (e.Data.GetDataPresent(LayerGroupControl.LayerContainerDataName))
             {
                 var data = (LayerStructureItemContainer)e.Data.GetData(LayerGroupControl.LayerContainerDataName);
-                Guid layer = data.Layer.LayerGuid;
+                Guid layer = data.Layer.GuidValue;
                 var doc = data.LayerCommandsViewModel.Owner.BitmapManager.ActiveDocument;
 
                 doc.MoveLayerInStructure(layer, LayerGuid, above);

PixiEditor/Views/UserControls/Layers/LayerStructureItemContainer.xaml

@@ -12,7 +12,7 @@
                                        IsActive="{Binding IsActive, Mode=TwoWay}"
                                        IsRenaming="{Binding IsRenaming, Mode=TwoWay}"
                                        LayerForPreview="{Binding}"
-                                       LayerGuid="{Binding LayerGuid}"
+                                       LayerGuid="{Binding GuidValue}"
                                        LayerColor="{Binding LayerHighlightColor}"
                                        LayerIndex="{Binding ContainerIndex, ElementName=layerStructureContainer}"
                                       MoveToBackCommand="{Binding LayerCommandsViewModel.MoveToBackCommand, ElementName=layerStructureContainer}"

PixiEditor/Views/UserControls/Layers/LayersManager.xaml

@@ -59,7 +59,7 @@
         </DockPanel>
         <Separator Grid.Row="1" Margin="0,-12, 0, 0" BorderBrush="{StaticResource DarkerAccentColor}" BorderThickness="2" />
         <DockPanel LastChildFill="True" Grid.Row="2" Margin="0, -12, 0, 0">
-            <TreeView DockPanel.Dock="Top" Name="treeView" ItemsSource="{Binding LayerTreeRoot, ElementName=layersManager}"  SelectedItemChanged="TreeView_SelectedItemChanged">
+            <TreeView DockPanel.Dock="Top" Name="treeView" ItemsSource="{Binding CachedLayerTreeRoot, ElementName=layersManager}"  SelectedItemChanged="TreeView_SelectedItemChanged">
                 <TreeView.ItemsPanel>
                     <ItemsPanelTemplate>
                         <ui:ReversedOrderStackPanel/>
@@ -71,7 +71,7 @@
                                              IsVisibleUndoTriggerable="{Binding StructureData.IsVisible}" 
                                              GroupOpacity="{Binding StructureData.Opacity}"
                                              LayersViewModel="{Binding LayerCommandsViewModel, ElementName=layersManager}" 
-                                             GroupGuid="{Binding GroupGuid}" 
+                                             GroupGuid="{Binding GuidValue}" 
                                              GroupData="{Binding StructureData}"
                                              MouseMove="LayerGroup_MouseMove"/>
                     </HierarchicalDataTemplate>

PixiEditor/Views/UserControls/Layers/LayersManager.xaml.cs

@@ -4,6 +4,7 @@ using PixiEditor.Models.Layers;
 using PixiEditor.Models.Undo;
 using PixiEditor.ViewModels.SubViewModels.Main;
 using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Windows;
 using System.Windows.Controls;
@@ -23,21 +24,34 @@ namespace PixiEditor.Views.UserControls.Layers
         }
 
         public static readonly DependencyProperty SelectedItemProperty =
-            DependencyProperty.Register("SelectedItem", typeof(object), typeof(LayersManager), new PropertyMetadata(0));
+            DependencyProperty.Register(nameof(SelectedItem), typeof(object), typeof(LayersManager), new PropertyMetadata(0));
 
-
-        public ObservableCollection<object> LayerTreeRoot
+        public ObservableCollection<IHasGuid> LayerTreeRoot
         {
-            get { return (ObservableCollection<object>)GetValue(LayerTreeRootProperty); }
+            get { return (ObservableCollection<IHasGuid>)GetValue(LayerTreeRootProperty); }
             set { SetValue(LayerTreeRootProperty, value); }
         }
 
         public static readonly DependencyProperty LayerTreeRootProperty =
             DependencyProperty.Register(
-                "LayerTreeRoot",
-                typeof(ObservableCollection<object>),
+                nameof(LayerTreeRoot),
+                typeof(ObservableCollection<IHasGuid>),
                 typeof(LayersManager),
-                new PropertyMetadata(default(ObservableCollection<object>)));
+                new PropertyMetadata(default(ObservableCollection<IHasGuid>), LayerTreeRootChanged));
+
+        public ObservableCollection<IHasGuid> CachedLayerTreeRoot
+        {
+            get { return (ObservableCollection<IHasGuid>)GetValue(CachedLayerTreeRootProperty); }
+            set { SetValue(CachedLayerTreeRootProperty, value); }
+        }
+
+        public static readonly DependencyProperty CachedLayerTreeRootProperty =
+            DependencyProperty.Register(
+                nameof(CachedLayerTreeRoot),
+                typeof(ObservableCollection<IHasGuid>),
+                typeof(LayersManager),
+                new PropertyMetadata(default(ObservableCollection<IHasGuid>)));
+
         public LayersViewModel LayerCommandsViewModel
         {
             get { return (LayersViewModel)GetValue(LayerCommandsViewModelProperty); }
@@ -45,7 +59,7 @@ namespace PixiEditor.Views.UserControls.Layers
         }
 
         public static readonly DependencyProperty LayerCommandsViewModelProperty =
-            DependencyProperty.Register("LayerCommandsViewModel", typeof(LayersViewModel), typeof(LayersManager), new PropertyMetadata(default(LayersViewModel), ViewModelChanged));
+            DependencyProperty.Register(nameof(LayerCommandsViewModel), typeof(LayersViewModel), typeof(LayersManager), new PropertyMetadata(default(LayersViewModel), ViewModelChanged));
 
         public bool OpacityInputEnabled
         {
@@ -54,13 +68,171 @@ namespace PixiEditor.Views.UserControls.Layers
         }
 
         public static readonly DependencyProperty OpacityInputEnabledProperty =
-            DependencyProperty.Register("OpacityInputEnabled", typeof(bool), typeof(LayersManager), new PropertyMetadata(false));
+            DependencyProperty.Register(nameof(OpacityInputEnabled), typeof(bool), typeof(LayersManager), new PropertyMetadata(false));
 
         public LayersManager()
         {
             InitializeComponent();
         }
 
+        private static void LayerTreeRootChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var manager = (LayersManager)d;
+            var newRoot = (ObservableCollection<IHasGuid>)e.NewValue;
+
+            manager.CachedLayerTreeRoot = newRoot;
+            return;
+            //layer tree caching goes after than and disabled for now
+
+            if (manager.CachedLayerTreeRoot == null || newRoot == null)
+            {
+                manager.CachedLayerTreeRoot = newRoot;
+                return;
+            }
+
+            if (object.ReferenceEquals(manager.CachedLayerTreeRoot, newRoot))
+                return;
+
+            UpdateCachedTree(manager.CachedLayerTreeRoot, newRoot);
+        }
+
+        private static void UpdateCachedTree(IList<IHasGuid> tree, IList<IHasGuid> newTree)
+        {
+            var (lcs1, lcs2) = LongestCommonSubsequence(tree, newTree);
+            UpdateListUsingLCS(tree, newTree, lcs1);
+
+            bool suc = AreCollectionsTheSame(tree, newTree);
+
+
+            for (int i = 0; i < lcs1.Count; i++)
+            {
+                var entry = lcs1[i];
+                if (entry is LayerGroup group)
+                {
+                    var corrGroup = (LayerGroup)lcs2[i];
+                    UpdateCachedTree(group.Items, corrGroup.Items);
+                    group.StructureData = corrGroup.StructureData;
+                }
+            }
+        }
+
+        private static void UpdateListUsingLCS(IList<IHasGuid> list, IList<IHasGuid> newList, IList<IHasGuid> lcs)
+        {
+            int oldI = 0;
+            int newI = 0;
+            for (int i = 0; i < lcs.Count; i++)
+            {
+                Guid curLcsEntry = lcs[i].GuidValue;
+
+                while (true)
+                {
+                    if (curLcsEntry != list[oldI].GuidValue && curLcsEntry != newList[newI].GuidValue)
+                    {
+                        list[oldI] = newList[newI];
+                        oldI++;
+                        newI++;
+                    }
+                    else if (curLcsEntry == list[oldI].GuidValue && curLcsEntry != newList[newI].GuidValue)
+                    {
+                        list.Insert(oldI, newList[newI]);
+                        oldI++;
+                        newI++;
+                    }
+                    else if (curLcsEntry != list[oldI].GuidValue && curLcsEntry == newList[newI].GuidValue)
+                    {
+                        list.RemoveAt(oldI);
+                    }
+                    else
+                    {
+                        oldI++;
+                        newI++;
+                        break;
+                    }
+                }
+            }
+            while (list.Count > oldI)
+                list.RemoveAt(list.Count - 1);
+            for (; newI < newList.Count; newI++)
+                list.Add(newList[newI]);
+        }
+
+        private static bool AreCollectionsTheSame(IList<IHasGuid> coll1, IList<IHasGuid> coll2)
+        {
+            if (coll1.Count != coll2.Count)
+                return false;
+            for (int i = 0; i < coll1.Count; i++)
+            {
+                if (coll1[i].GuidValue != coll2[i].GuidValue)
+                    return false;
+            }
+            return true;
+        }
+
+        private static (IList<IHasGuid>, IList<IHasGuid>) LongestCommonSubsequence(IList<IHasGuid> coll1, IList<IHasGuid> coll2)
+        {
+            if (AreCollectionsTheSame(coll1, coll2))
+                return (coll1, coll2);
+            if (coll1.Count == 0 || coll2.Count == 0)
+                return (new List<IHasGuid>(), new List<IHasGuid>());
+
+            //calculate LCS matrix
+            int w = coll1.Count;
+            int h = coll2.Count;
+            int[,] matrix = new int[w, h];
+            for (int j = 0; j < h; j++)
+            {
+                for (int i = 0; i < w; i++)
+                {
+                    if (coll1[i].GuidValue == coll2[j].GuidValue)
+                        matrix[i, j] = (i == 0 || j == 0) ? 1 : matrix[i - 1, j - 1] + 1;
+                    else
+                        matrix[i, j] = (i == 0 || j == 0) ? 0 : Math.Max(matrix[i - 1, j], matrix[i, j - 1]);
+                }
+            }
+
+            //find the actual subsequence
+            List<IHasGuid> subsequence1 = new();
+            List<IHasGuid> subsequence2 = new();
+            int x = w - 1;
+            int y = h - 1;
+            while (x >= 0 || y >= 0)
+            {
+                if (coll1[x].GuidValue == coll2[y].GuidValue)
+                {
+                    subsequence1.Add(coll1[x]);
+                    subsequence2.Add(coll2[y]);
+                    if (x == 0 & y == 0)
+                        break;
+                    if (x > 0)
+                        x--;
+                    if (y > 0)
+                        y--;
+                    continue;
+                }
+                if (x == 0 && y == 0)
+                    break;
+                if (x == 0)
+                {
+                    y--;
+                    continue;
+                }
+                if (y == 0)
+                {
+                    x--;
+                    continue;
+                }
+
+                if (matrix[x - 1, y] > matrix[x, y - 1])
+                    x--;
+                else
+                    y--;
+            }
+
+            subsequence1.Reverse();
+            subsequence2.Reverse();
+            return (subsequence1, subsequence2);
+        }
+
         private static void ViewModelChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
             if (e.NewValue is LayersViewModel vm)
@@ -209,7 +381,7 @@ namespace PixiEditor.Views.UserControls.Layers
 
             layer.OpacityUndoTriggerable = val;
 
-            doc.LayerStructure.ExpandParentGroups(layer.LayerGuid);
+            doc.LayerStructure.ExpandParentGroups(layer.GuidValue);
 
             doc.RaisePropertyChange(nameof(doc.LayerStructure));
 
@@ -259,9 +431,9 @@ namespace PixiEditor.Views.UserControls.Layers
             if (doc.Layers.Count == 0) return;
 
             var layerContainer = (LayerStructureItemContainer)data.GetData(LayerGroupControl.LayerContainerDataName);
-            var refLayer = doc.Layers[0].LayerGuid;
-            doc.MoveLayerInStructure(layerContainer.Layer.LayerGuid, refLayer);
-            doc.LayerStructure.AssignParent(layerContainer.Layer.LayerGuid, null);
+            var refLayer = doc.Layers[0].GuidValue;
+            doc.MoveLayerInStructure(layerContainer.Layer.GuidValue, refLayer);
+            doc.LayerStructure.AssignParent(layerContainer.Layer.GuidValue, null);
         }
 
         private void HandleGroupControlDrop(IDataObject data)

PixiEditorTests/ModelsTests/DataHoldersTests/DocumentLayersTests.cs

@@ -146,9 +146,9 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
                 layer.IsActive = true;
             }
 
-            document.SetNextSelectedLayerAsActive(document.Layers[1].LayerGuid);
+            document.SetNextSelectedLayerAsActive(document.Layers[1].GuidValue);
 
-            Assert.Equal(document.Layers[0].LayerGuid, document.ActiveLayerGuid);
+            Assert.Equal(document.Layers[0].GuidValue, document.ActiveLayerGuid);
         }
     }
 }

PixiEditorTests/ModelsTests/DataHoldersTests/LayerStructureTests.cs

@@ -13,11 +13,11 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
             Document doc = new Document(1, 1);
             doc.Layers.Add(new("_testLayer"));
             var testLayer = doc.Layers[^1];
-            doc.LayerStructure.AddNewGroup("test", testLayer.LayerGuid);
+            doc.LayerStructure.AddNewGroup("test", testLayer.GuidValue);
 
             Assert.Single(doc.LayerStructure.Groups);
-            Assert.Equal(testLayer.LayerGuid, doc.LayerStructure.Groups[0].StartLayerGuid);
-            Assert.Equal(testLayer.LayerGuid, doc.LayerStructure.Groups[0].EndLayerGuid);
+            Assert.Equal(testLayer.GuidValue, doc.LayerStructure.Groups[0].StartLayerGuid);
+            Assert.Equal(testLayer.GuidValue, doc.LayerStructure.Groups[0].EndLayerGuid);
         }
 
         [Fact]
@@ -26,15 +26,15 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
             Document doc = new Document(1, 1);
             doc.Layers.Add(new("_testLayer"));
             var testLayer = doc.Layers[^1];
-            doc.LayerStructure.AddNewGroup("test", testLayer.LayerGuid);
-            doc.LayerStructure.AddNewGroup("test1", testLayer.LayerGuid);
+            doc.LayerStructure.AddNewGroup("test", testLayer.GuidValue);
+            doc.LayerStructure.AddNewGroup("test1", testLayer.GuidValue);
 
             Assert.Single(doc.LayerStructure.Groups);
             Assert.Single(doc.LayerStructure.Groups[0].Subgroups);
-            Assert.Equal(testLayer.LayerGuid, doc.LayerStructure.Groups[0].StartLayerGuid);
-            Assert.Equal(testLayer.LayerGuid, doc.LayerStructure.Groups[0].EndLayerGuid);
-            Assert.Equal(testLayer.LayerGuid, doc.LayerStructure.Groups[0].Subgroups[0].StartLayerGuid);
-            Assert.Equal(testLayer.LayerGuid, doc.LayerStructure.Groups[0].Subgroups[0].EndLayerGuid);
+            Assert.Equal(testLayer.GuidValue, doc.LayerStructure.Groups[0].StartLayerGuid);
+            Assert.Equal(testLayer.GuidValue, doc.LayerStructure.Groups[0].EndLayerGuid);
+            Assert.Equal(testLayer.GuidValue, doc.LayerStructure.Groups[0].Subgroups[0].StartLayerGuid);
+            Assert.Equal(testLayer.GuidValue, doc.LayerStructure.Groups[0].Subgroups[0].EndLayerGuid);
         }
 
         [Fact]
@@ -45,8 +45,8 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
             doc.Layers.Add(new Layer("_testLayer1"));
             var testLayer = doc.Layers[0];
             var testLayer1 = doc.Layers[^1];
-            doc.LayerStructure.AddNewGroup("test", testLayer.LayerGuid);
-            doc.LayerStructure.AddNewGroup("test1", testLayer1.LayerGuid);
+            doc.LayerStructure.AddNewGroup("test", testLayer.GuidValue);
+            doc.LayerStructure.AddNewGroup("test1", testLayer1.GuidValue);
 
             Assert.Equal(0, doc.Layers.IndexOf(testLayer));
             Assert.Equal(1, doc.Layers.IndexOf(testLayer1));
@@ -62,8 +62,8 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
         {
             LayerStructure ls = new LayerStructure(new Document(1, 1));
             Layer testLayer = new Layer("tst");
-            ls.Groups.Add(new GuidStructureItem("group 1", testLayer.LayerGuid));
-            ls.Groups[0].Subgroups.Add(new GuidStructureItem("group 1 nested", testLayer.LayerGuid));
+            ls.Groups.Add(new GuidStructureItem("group 1", testLayer.GuidValue));
+            ls.Groups[0].Subgroups.Add(new GuidStructureItem("group 1 nested", testLayer.GuidValue));
 
             Assert.True(ls.IsChildOf(ls.Groups[0].Subgroups[0], ls.Groups[0]));
             Assert.False(ls.IsChildOf(ls.Groups[0], ls.Groups[0].Subgroups[0]));
@@ -74,7 +74,7 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
         {
             var doc = new Document(1, 1);
             doc.Layers.Add(new Layer("tst"));
-            Guid testLayerGuid = doc.Layers[0].LayerGuid;
+            Guid testLayerGuid = doc.Layers[0].GuidValue;
             LayerStructure ls = new LayerStructure(doc);
             ls.AddNewGroup("Test group", testLayerGuid);
             ls.AddNewGroup("Test group nested", testLayerGuid);
@@ -88,7 +88,7 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
         {
             var doc = new Document(1, 1);
             doc.Layers.Add(new Layer("layer"));
-            var guid = doc.Layers[0].LayerGuid;
+            var guid = doc.Layers[0].GuidValue;
             doc.LayerStructure.AddNewGroup("layer group", guid);
             Assert.True(LayerStructure.GroupContainsOnlyLayer(guid, doc.LayerStructure.Groups[0]));
         }
@@ -98,7 +98,7 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
         {
             var doc = new Document(1, 1);
             doc.Layers.Add(new Layer("layer"));
-            var guid = doc.Layers[0].LayerGuid;
+            var guid = doc.Layers[0].GuidValue;
             doc.LayerStructure.AddNewGroup("layer group", guid);
             doc.LayerStructure.AddNewGroup("layer group nested", guid);
             Assert.False(LayerStructure.GroupContainsOnlyLayer(guid, doc.LayerStructure.Groups[0]));
@@ -112,7 +112,7 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
             doc.Layers.Add(new("Test"));
             doc.Layers.Add(new("Test2"));
             LayerStructure structure = new(doc);
-            structure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
+            structure.AddNewGroup("Test group", doc.Layers[0].GuidValue);
 
             var clone = structure.CloneGroups();
 
@@ -136,7 +136,7 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
         {
             Document doc = new(1, 1);
             doc.Layers.Add(new("Test"));
-            var group = doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
+            var group = doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].GuidValue);
 
             Assert.Equal(group.GroupGuid, doc.LayerStructure.GetGroupByGuid(group.GroupGuid).GroupGuid);
         }
@@ -146,10 +146,10 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
         {
             Document doc = new(1, 1);
             doc.Layers.Add(new("Test"));
-            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
-            var group1 = doc.LayerStructure.AddNewGroup("Test group nested", doc.Layers[0].LayerGuid);
+            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].GuidValue);
+            var group1 = doc.LayerStructure.AddNewGroup("Test group nested", doc.Layers[0].GuidValue);
 
-            doc.LayerStructure.PreMoveReassignBounds(new GroupData(group1.GroupGuid), doc.Layers[0].LayerGuid);
+            doc.LayerStructure.PreMoveReassignBounds(new GroupData(group1.GroupGuid), doc.Layers[0].GuidValue);
 
             Assert.Empty(doc.LayerStructure.Groups);
         }
@@ -159,22 +159,22 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
         {
             Document doc = new(1, 1);
             doc.Layers.Add(new("Test"));
-            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
-            var group1 = doc.LayerStructure.AddNewGroup("Test group nested", doc.Layers[0].LayerGuid);
+            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].GuidValue);
+            var group1 = doc.LayerStructure.AddNewGroup("Test group nested", doc.Layers[0].GuidValue);
 
             doc.Layers.Add(new("Test 1"));
 
             var firstLayer = doc.Layers[0];
             var layer = doc.Layers[^1];
 
-            doc.LayerStructure.PostMoveReassignBounds(new GroupData(group1.GroupGuid), layer.LayerGuid);
+            doc.LayerStructure.PostMoveReassignBounds(new GroupData(group1.GroupGuid), layer.GuidValue);
 
             Assert.Single(doc.LayerStructure.Groups);
             Assert.Single(doc.LayerStructure.Groups[0].Subgroups);
-            Assert.Equal(layer.LayerGuid, doc.LayerStructure.Groups[0].Subgroups[0].EndLayerGuid);
-            Assert.Equal(firstLayer.LayerGuid, doc.LayerStructure.Groups[0].Subgroups[0].StartLayerGuid);
-            Assert.Equal(layer.LayerGuid, doc.LayerStructure.Groups[0].EndLayerGuid);
-            Assert.Equal(firstLayer.LayerGuid, doc.LayerStructure.Groups[0].StartLayerGuid);
+            Assert.Equal(layer.GuidValue, doc.LayerStructure.Groups[0].Subgroups[0].EndLayerGuid);
+            Assert.Equal(firstLayer.GuidValue, doc.LayerStructure.Groups[0].Subgroups[0].StartLayerGuid);
+            Assert.Equal(layer.GuidValue, doc.LayerStructure.Groups[0].EndLayerGuid);
+            Assert.Equal(firstLayer.GuidValue, doc.LayerStructure.Groups[0].StartLayerGuid);
         }
 
         [Fact]
@@ -185,16 +185,16 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
 
             var firstLayer = doc.Layers[0];
 
-            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
+            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].GuidValue);
 
             doc.Layers.Add(new Layer("Test 1"));
 
             var layer = doc.Layers[^1];
 
-            doc.LayerStructure.AssignParent(doc.Layers[^1].LayerGuid, doc.LayerStructure.Groups[0].GroupGuid);
+            doc.LayerStructure.AssignParent(doc.Layers[^1].GuidValue, doc.LayerStructure.Groups[0].GroupGuid);
 
-            Assert.Equal(layer.LayerGuid, doc.LayerStructure.Groups[0].EndLayerGuid);
-            Assert.Equal(firstLayer.LayerGuid, doc.LayerStructure.Groups[0].StartLayerGuid);
+            Assert.Equal(layer.GuidValue, doc.LayerStructure.Groups[0].EndLayerGuid);
+            Assert.Equal(firstLayer.GuidValue, doc.LayerStructure.Groups[0].StartLayerGuid);
         }
 
         [Fact]
@@ -205,17 +205,17 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
 
             var firstLayer = doc.Layers[0];
 
-            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
+            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].GuidValue);
 
             doc.Layers.Add(new Layer("Test 1"));
 
             var layer = doc.Layers[^1];
 
-            doc.LayerStructure.AssignParent(layer.LayerGuid, doc.LayerStructure.Groups[0].GroupGuid);
-            doc.LayerStructure.AssignParent(layer.LayerGuid, null);
+            doc.LayerStructure.AssignParent(layer.GuidValue, doc.LayerStructure.Groups[0].GroupGuid);
+            doc.LayerStructure.AssignParent(layer.GuidValue, null);
 
-            Assert.Equal(firstLayer.LayerGuid, doc.LayerStructure.Groups[0].EndLayerGuid);
-            Assert.Equal(firstLayer.LayerGuid, doc.LayerStructure.Groups[0].StartLayerGuid);
+            Assert.Equal(firstLayer.GuidValue, doc.LayerStructure.Groups[0].EndLayerGuid);
+            Assert.Equal(firstLayer.GuidValue, doc.LayerStructure.Groups[0].StartLayerGuid);
         }
 
         [Fact]
@@ -226,11 +226,11 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
             doc.Layers.Add(new Layer("Test 1"));
             doc.Layers.Add(new Layer("Test 2"));
             doc.Layers.Add(new Layer("Test 3"));
-            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
+            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].GuidValue);
 
-            doc.LayerStructure.AssignParent(doc.Layers[1].LayerGuid, doc.LayerStructure.Groups[0].GroupGuid);
-            doc.LayerStructure.AssignParent(doc.Layers[2].LayerGuid, doc.LayerStructure.Groups[0].GroupGuid);
-            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[2].LayerGuid);
+            doc.LayerStructure.AssignParent(doc.Layers[1].GuidValue, doc.LayerStructure.Groups[0].GroupGuid);
+            doc.LayerStructure.AssignParent(doc.Layers[2].GuidValue, doc.LayerStructure.Groups[0].GroupGuid);
+            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[2].GuidValue);
 
             var layersInGroup = doc.LayerStructure.GetGroupLayers(doc.LayerStructure.Groups[0]);