Implemented new method of parsing folders

PixiEditor/Helpers/Converters/LayersToStructuredLayersConverter.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Windows.Data;
 using PixiEditor.Models.Layers;
@@ -10,7 +11,7 @@ namespace PixiEditor.Helpers.Converters
     {
         public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
         {
-            if (values[0] is IEnumerable<Layer> layers && values[1] is LayerStructure structure)
+            if (values[0] is ObservableCollection<Layer> layers && values[1] is LayerStructure structure)
             {
                 return new StructuredLayerTree(layers, structure).RootDirectoryItems;
             }

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

@@ -460,20 +460,20 @@ namespace PixiEditor.Models.DataHolders
             Guid referenceLayerGuid = (Guid)parameter[1];
             bool above = (bool)parameter[2];
 
-            GuidStructureItem folder = LayerStructure.GetFolderByGuid(folderGuid);
-            GuidStructureItem parentFolder = LayerStructure.GetFolderByLayer(referenceLayerGuid);
+            //GuidStructureItem folder = LayerStructure.GetFolderByGuid(folderGuid);
+            //GuidStructureItem parentFolder = LayerStructure.GetFolderByLayer(referenceLayerGuid);
 
-            int layerIndex = Layers.IndexOf(Layers.First(x => x.LayerGuid == referenceLayerGuid));
-            int relativeIndex = layerIndex > folder.ActualIndex ? folder.ActualIndex : folder.FolderDisplayIndex;
+            //int layerIndex = Layers.IndexOf(Layers.First(x => x.LayerGuid == referenceLayerGuid));
+            //int relativeIndex = layerIndex > folder.ActualIndex ? folder.ActualIndex : folder.FolderDisplayIndex;
 
-            int newIndex = CalculateNewIndex(layerIndex, above, relativeIndex);
+            //int newIndex = CalculateNewIndex(layerIndex, above, relativeIndex);
 
-            if (newIndex == relativeIndex)
-            {
-                return;
-            }
+            //if (newIndex == relativeIndex)
+            //{
+            //    return;
+            //}
 
-            LayerStructure.MoveFolder(folderGuid, parentFolder, newIndex);
+            //LayerStructure.MoveFolder(folderGuid, parentFolder, newIndex);
         }
 
         private int CalculateNewIndex(int layerIndex, bool above, int oldIndex)

PixiEditor/Models/DataHolders/Document/Document.cs

@@ -196,7 +196,7 @@ namespace PixiEditor.Models.DataHolders
         public void CenterContent()
         {
             var layersToCenter = Layers.Where(x => x.IsActive && x.IsVisible);
-            if (layersToCenter.Count() == 0)
+            if (!layersToCenter.Any())
             {
                 return;
             }

PixiEditor/Models/Layers/GuidStructureItem.cs

@@ -21,84 +21,66 @@ namespace PixiEditor.Models.Layers
             }
         }
 
-        public ObservableCollection<Guid> LayerGuids { get; set; }
+        private Guid? startLayerGuid = null;
 
-        public ObservableCollection<GuidStructureItem> Subfolders { get; set; }
-
-        public GuidStructureItem Parent { get; set; }
-
-        private bool isExpanded;
-
-        public bool IsExpanded
+        public Guid? StartLayerGuid
         {
-            get => isExpanded;
+            get => startLayerGuid;
             set
             {
-                isExpanded = value;
-                RaisePropertyChanged(nameof(IsExpanded));
+                startLayerGuid = value;
+                RaisePropertyChanged(nameof(StartLayerGuid));
             }
         }
 
-        private int actualIndex;
+        private Guid? endLayerGuid = null;
 
-        public int ActualIndex
+        public Guid? EndLayerGuid
         {
-            get => actualIndex;
+            get => endLayerGuid;
             set
             {
-                actualIndex = value;
-                RaisePropertyChanged(nameof(ActualIndex));
+                endLayerGuid = value;
+                RaisePropertyChanged(nameof(EndLayerGuid));
             }
         }
 
-        public int FolderDisplayIndex
-        {
-            get => ActualIndex - GetLayersCount() + 1;
-        }
+        public ObservableCollection<GuidStructureItem> Subfolders { get; set; }
 
-        public int GetLayersCount()
-        {
-            return GetLayersCount(this);
-        }
+        public GuidStructureItem Parent { get; set; }
 
-        private int GetLayersCount(GuidStructureItem item)
-        {
-            if (Subfolders.Count == 0)
-            {
-                return LayerGuids.Count;
-            }
+        private bool isExpanded;
 
-            int itemsCount = 0;
-            foreach (var subFolder in item.Subfolders)
+        public bool IsExpanded
+        {
+            get => isExpanded;
+            set
             {
-                itemsCount += GetLayersCount(subFolder);
+                isExpanded = value;
+                RaisePropertyChanged(nameof(IsExpanded));
             }
-
-            return itemsCount + LayerGuids.Count;
         }
 
         public GuidStructureItem(
             string name,
-            IEnumerable<Guid> children,
+            Guid startLayerGuid,
+            Guid endLayerGuid,
             IEnumerable<GuidStructureItem> subfolders,
-            int index,
             GuidStructureItem parent)
         {
             Name = name;
-            LayerGuids = new ObservableCollection<Guid>(children);
             Subfolders = new ObservableCollection<GuidStructureItem>(subfolders);
             FolderGuid = Guid.NewGuid();
-            ActualIndex = index;
             Parent = parent;
+            StartLayerGuid = startLayerGuid;
+            EndLayerGuid = endLayerGuid;
         }
 
         public GuidStructureItem(string name)
         {
             Name = name;
-            LayerGuids = new ObservableCollection<Guid>();
             Subfolders = new ObservableCollection<GuidStructureItem>();
             FolderGuid = Guid.NewGuid();
-            ActualIndex = 0;
             Parent = null;
         }
     }

PixiEditor/Models/Layers/LayerFolder.cs

@@ -55,6 +55,18 @@ namespace PixiEditor.Models.Layers
             }
         }
 
+        private int topIndex;
+
+        public int TopIndex
+        {
+            get => topIndex;
+            set
+            {
+                topIndex = value;
+                RaisePropertyChanged(nameof(TopIndex));
+            }
+        }
+
         private void UpdateIsExpandedInDocument(bool value)
         {
             var folder = ViewModelMain.Current.BitmapManager.ActiveDocument.LayerStructure.GetFolderByGuid(FolderGuid);
@@ -64,16 +76,17 @@ namespace PixiEditor.Models.Layers
             }
         }
 
-        public LayerFolder(IEnumerable<Layer> layers, IEnumerable<LayerFolder> subfolders, string name, int index)
-            : this(layers, subfolders, name, Guid.NewGuid(), index) { }
+        public LayerFolder(IEnumerable<Layer> layers, IEnumerable<LayerFolder> subfolders, string name, int displayIndex, int topIndex)
+            : this(layers, subfolders, name, Guid.NewGuid(), displayIndex, topIndex) { }
 
-        public LayerFolder(IEnumerable<Layer> layers, IEnumerable<LayerFolder> subfolders, string name, Guid guid, int index)
+        public LayerFolder(IEnumerable<Layer> layers, IEnumerable<LayerFolder> subfolders, string name, Guid guid, int displayIndex, int topIndex)
         {
             Layers = new ObservableCollection<Layer>(layers);
             Subfolders = new ObservableCollection<LayerFolder>(subfolders);
             Name = name;
             FolderGuid = guid;
-            DisplayIndex = index;
+            DisplayIndex = displayIndex;
+            TopIndex = topIndex;
         }
     }
 }

PixiEditor/Models/Layers/LayerStructure.cs

@@ -25,16 +25,16 @@ namespace PixiEditor.Models.Layers
         public void MoveLayerToFolder(Guid layerGuid, Guid? folderGuid)
         {
             GuidStructureItem oldFolder = GetFolderByLayer(layerGuid);
-            if (oldFolder != null)
-            {
-                oldFolder.LayerGuids.Remove(layerGuid);
-            }
-
-            if (folderGuid != null)
-            {
-                var folder = GetFolderByGuid((Guid)folderGuid);
-                folder.LayerGuids.Add(layerGuid);
-            }
+            //if (oldFolder != null)
+            //{
+            //    oldFolder.LayerGuids.Remove(layerGuid);
+            //}
+
+            //if (folderGuid != null)
+            //{
+            //    var folder = GetFolderByGuid((Guid)folderGuid);
+            //    folder.LayerGuids.Add(layerGuid);
+            //}
         }
 
         public GuidStructureItem GetFolderByLayer(Guid layerGuid)
@@ -46,88 +46,81 @@ namespace PixiEditor.Models.Layers
         public void MoveFolder(Guid folderGuid, GuidStructureItem? parentFolder, int newIndex)
         {
             var folder = GetFolderByGuid(folderGuid);
-            int oldFolderActualIndex = folder.ActualIndex;
-            int oldFolderDisplayIndex = folder.FolderDisplayIndex;
             bool reverseOrder = true;
 
-            int indexToApply;
             int difference;
 
-            if (newIndex > oldFolderActualIndex)
-            {
-                indexToApply = newIndex;
-                difference = indexToApply - oldFolderActualIndex;
-            }
-            else
-            {
-                reverseOrder = false;
-                difference = newIndex - oldFolderDisplayIndex;
-                indexToApply = oldFolderActualIndex + difference;
-            }
-
-            MoveLayersInFolder(folder, difference, reverseOrder);
-
-            folder.ActualIndex = indexToApply;
-
-            if (folder.Parent == null)
-            {
-                Folders.Remove(folder);
-            }
-
-            if (parentFolder == null && !Folders.Contains(folder))
-            {
-                Folders.Add(folder);
-            }
-            else if (parentFolder != null)
-            {
-                parentFolder.Subfolders.Add(folder);
-            }
+            //if (newIndex > oldFolderActualIndex)
+            //{
+            //    difference = indexToApply - oldFolderActualIndex;
+            //}
+            //else
+            //{
+            //    reverseOrder = false;
+            //    difference = newIndex - oldFolderDisplayIndex;
+            //}
+
+            //MoveLayersInFolder(folder, difference, reverseOrder);
+
+            //if (folder.Parent == null)
+            //{
+            //    Folders.Remove(folder);
+            //}
+
+            //if (parentFolder == null && !Folders.Contains(folder))
+            //{
+            //    Folders.Add(folder);
+            //}
+            //else if (parentFolder != null)
+            //{
+            //    parentFolder.Subfolders.Add(folder);
+            //}
         }
 
         private void MoveLayersInFolder(GuidStructureItem folder, int moveBy, bool reverseOrder)
         {
-            List<Guid> layersInOrder = GetLayersInOrder(folder);
+            //List<Guid> layersInOrder = GetLayersInOrder(folder);
 
-            List<Guid> layerGuids = reverseOrder ? layersInOrder.Reverse<Guid>().ToList() : layersInOrder;
+            //List<Guid> layerGuids = reverseOrder ? layersInOrder.Reverse<Guid>().ToList() : layersInOrder;
 
-            for (int i = 0; i < layersInOrder.Count; i++)
-            {
-                Guid layerGuid = layerGuids[i];
-                var layer = Owner.Layers.First(x => x.LayerGuid == layerGuid);
-                int layerIndex = Owner.Layers.IndexOf(layer);
-                Owner.Layers.Move(layerIndex, layerIndex + moveBy);
-            }
+            //for (int i = 0; i < layersInOrder.Count; i++)
+            //{
+            //    Guid layerGuid = layerGuids[i];
+            //    var layer = Owner.Layers.First(x => x.LayerGuid == layerGuid);
+            //    int layerIndex = Owner.Layers.IndexOf(layer);
+            //    Owner.Layers.Move(layerIndex, layerIndex + moveBy);
+            //}
         }
 
-        private List<Guid> GetLayersInOrder(GuidStructureItem folder)
-        {
-            List<Guid> layerGuids = new List<Guid>();
-            int minIndex = folder.FolderDisplayIndex;
-            int maxIndex = folder.ActualIndex;
+        //private List<Guid> GetLayersInOrder(GuidStructureItem folder)
+        //{
+        //    List<Guid> layerGuids = new ();
+        //    int minIndex = Owner.Layers.folder.FolderDisplayIndex;
+        //    int maxIndex = folder.ActualIndex;
 
-            for (int i = minIndex; i <= maxIndex; i++)
-            {
-                layerGuids.Add(Owner.Layers[i].LayerGuid);
-            }
+        //    for (int i = minIndex; i <= maxIndex; i++)
+        //    {
+        //        layerGuids.Add(Owner.Layers[i].LayerGuid);
+        //    }
 
-            return layerGuids;
-        }
+        //    return layerGuids;
+        //}
 
 #nullable disable
         private GuidStructureItem GetFolderByLayer(Guid layerGuid, IEnumerable<GuidStructureItem> folders)
         {
-            foreach (var folder in folders)
-            {
-                if (folder.LayerGuids.Contains(layerGuid))
-                {
-                    return folder;
-                }
-
-                if (folder.Subfolders.Count > 0)
-                {
-                    return GetFolderByLayer(layerGuid, folder.Subfolders);
-                }
-            }
+            //foreach (var folder in folders)
+            //{
+            //    if (folder.LayerGuids.Contains(layerGuid))
+            //    {
+            //        return folder;
+            //    }
+
+            //    if (folder.Subfolders.Count > 0)
+            //    {
+            //        return GetFolderByLayer(layerGuid, folder.Subfolders);
+            //    }
+            //}
 
             return null;
         }

PixiEditor/Models/Layers/StructuredLayerTree.cs

@@ -13,7 +13,7 @@ namespace PixiEditor.Models.Layers
 
         public ObservableCollection<object> RootDirectoryItems { get; } = new ObservableCollection<object>();
 
-        public StructuredLayerTree(IEnumerable<Layer> layers, LayerStructure structure)
+        public StructuredLayerTree(ObservableCollection<Layer> layers, LayerStructure structure)
         {
             if (structure.Folders == null || structure.Folders.Count == 0)
             {
@@ -35,7 +35,7 @@ namespace PixiEditor.Models.Layers
             layersInStructure.Clear();
         }
 
-        private List<LayerFolder> ParseFolders(IEnumerable<GuidStructureItem> folders, IEnumerable<Layer> layers)
+        private List<LayerFolder> ParseFolders(IEnumerable<GuidStructureItem> folders, ObservableCollection<Layer> layers)
         {
             List<LayerFolder> parsedFolders = new ();
             foreach (var structureItem in folders)
@@ -46,15 +46,11 @@ namespace PixiEditor.Models.Layers
             return parsedFolders;
         }
 
-        private LayerFolder ParseFolder(GuidStructureItem structureItem, IEnumerable<Layer> layers)
+        private LayerFolder ParseFolder(GuidStructureItem structureItem, ObservableCollection<Layer> layers)
         {
             List<Layer> structureItemLayers = new ();
-            foreach (var guid in structureItem.LayerGuids)
-            {
-                var layer = layers.First(x => x.LayerGuid == guid);
-                layersInStructure.Add(layer);
-                structureItemLayers.Add(layer);
-            }
+
+            Guid[] layersInFolder = GetLayersInFolder(layers, structureItem);
 
             var subFolders = new List<LayerFolder>();
 
@@ -63,14 +59,55 @@ namespace PixiEditor.Models.Layers
                 subFolders = ParseFolders(structureItem.Subfolders, layers);
             }
 
+            foreach (var guid in layersInFolder)
+            {
+                var layer = layers.First(x => x.LayerGuid == guid);
+                if (!layersInStructure.Contains(layer))
+                {
+                    layersInStructure.Add(layer);
+                    structureItemLayers.Add(layer);
+                }
+            }
+
+            int displayIndex = layersInStructure.Min(x => layers.IndexOf(x));
+
             structureItemLayers.Reverse();
 
             LayerFolder folder = new (structureItemLayers, subFolders, structureItem.Name,
-                structureItem.FolderGuid, structureItem.FolderDisplayIndex)
+                structureItem.FolderGuid, displayIndex, displayIndex + layersInStructure.Count - 1)
             {
                 IsExpanded = structureItem.IsExpanded
             };
             return folder;
         }
+
+        private Guid[] GetLayersInFolder(ObservableCollection<Layer> layers, GuidStructureItem structureItem)
+        {
+            int startIndex = layers.IndexOf(layers.First(x => x.LayerGuid == structureItem.StartLayerGuid));
+            int endIndex = layers.IndexOf(layers.First(x => x.LayerGuid == structureItem.EndLayerGuid));
+
+            if (startIndex > endIndex)
+            {
+                Swap(ref startIndex, ref endIndex);
+            }
+
+            int len = endIndex - startIndex + 1;
+
+            Guid[] guids = new Guid[len];
+
+            for (int i = 0; i < len; i++)
+            {
+                guids[i] = layers[i + startIndex].LayerGuid;
+            }
+
+            return guids;
+        }
+
+        private static void Swap(ref int startIndex, ref int endIndex)
+        {
+            int tmp = startIndex;
+            startIndex = endIndex;
+            endIndex = tmp;
+        }
     }
 }

PixiEditor/ViewModels/SubViewModels/Main/FileViewModel.cs

@@ -116,20 +116,14 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
             Owner.BitmapManager.ActiveDocument.AddNewLayer("Test1 sub1");
             Owner.BitmapManager.ActiveDocument.AddNewLayer("Test1 sub2");
             Owner.BitmapManager.ActiveDocument.LayerStructure.Folders.Add(
-                new GuidStructureItem("Folder 1", new ObservableCollection<Guid>()
-                {
-                    Owner.BitmapManager.ActiveDocument.Layers[1].LayerGuid,
-                    Owner.BitmapManager.ActiveDocument.Layers[2].LayerGuid
-                }, Array.Empty<GuidStructureItem>(), 4, null)
-                { IsExpanded = true });
+                new GuidStructureItem("Folder 1",
+                Owner.BitmapManager.ActiveDocument.Layers[1].LayerGuid,
+                Owner.BitmapManager.ActiveDocument.Layers[4].LayerGuid, Array.Empty<GuidStructureItem>(), null));
 
             Owner.BitmapManager.ActiveDocument.LayerStructure.Folders[0].Subfolders.Add(
-                        new GuidStructureItem("Subfolder 1", new ObservableCollection<Guid>()
-                    {
-                        Owner.BitmapManager.ActiveDocument.Layers[3].LayerGuid,
-                        Owner.BitmapManager.ActiveDocument.Layers[4].LayerGuid
-                    },  Array.Empty<GuidStructureItem>()
-                    , 4,  Owner.BitmapManager.ActiveDocument.LayerStructure.Folders[0]));
+                new GuidStructureItem("Subfolder 1", Owner.BitmapManager.ActiveDocument.Layers[3].LayerGuid,
+                Owner.BitmapManager.ActiveDocument.Layers[4].LayerGuid, Array.Empty<GuidStructureItem>(),
+                Owner.BitmapManager.ActiveDocument.LayerStructure.Folders[0]));
         }
 
         /// <summary>