Moving folders somewhat works

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

@@ -17,6 +17,7 @@ namespace PixiEditor.Models.DataHolders
         {
             SetRelayCommands();
             UndoManager = new UndoManager();
+            LayerStructure = new Layers.LayerStructure(this);
             XamlAccesibleViewModel = ViewModelMain.Current ?? null;
             GeneratePreviewLayer();
             Layers.CollectionChanged += Layers_CollectionChanged;

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

@@ -18,7 +18,7 @@ namespace PixiEditor.Models.DataHolders
         public const string MainSelectedLayerColor = "#505056";
         public const string SecondarySelectedLayerColor = "#7D505056";
         private Guid activeLayerGuid;
-        private LayerStructure layerStructure = new ();
+        private LayerStructure layerStructure;
 
         private ObservableCollection<Layer> layers = new ();
 
@@ -117,24 +117,18 @@ namespace PixiEditor.Models.DataHolders
                 "Move layer"));
         }
 
-        public void MoveFolderInStructure(Guid folder, Guid referenceLayer, bool above = false)
+        public void MoveFolderInStructure(Guid folderGuid, Guid referenceLayer, bool above = false)
         {
-            var args = new object[] { layerGuid, referenceLayer, above };
+            var args = new object[] { folderGuid, referenceLayer, above };
 
-            Layer layer = Layers.First(x => x.LayerGuid == layerGuid);
+            MoveFolderInStructureProcess(args);
 
-            int oldIndex = Layers.IndexOf(layer);
-
-            Guid? oldLayerFolder = LayerStructure.GetFolderByLayer(layerGuid)?.FolderGuid;
-
-            MoveLayerInStructureProcess(args);
-
-            UndoManager.AddUndoChange(new Change(
-                ReverseMoveLayerInStructureProcess,
-                new object[] { oldIndex, layerGuid, oldLayerFolder },
-                MoveLayerInStructureProcess,
-                args,
-                "Move layer"));
+            //UndoManager.AddUndoChange(new Change(
+            //    ReverseMoveLayerInStructureProcess,
+            //    new object[] { oldIndex, layerGuid, oldLayerFolder },
+            //    MoveLayerInStructureProcess,
+            //    args,
+            //    "Move layer"));
         }
 
         public void AddNewLayer(string name, WriteableBitmap bitmap, bool setAsActive = true)
@@ -460,20 +454,47 @@ namespace PixiEditor.Models.DataHolders
             }
         }
 
-        private void MoveLayerInStructureProcess(object[] parameter)
+        private void MoveFolderInStructureProcess(object[] parameter)
         {
-            Guid layer = (Guid)parameter[0];
-            Guid referenceLayer = (Guid)parameter[1];
+            Guid folderGuid = (Guid)parameter[0];
+            Guid referenceLayerGuid = (Guid)parameter[1];
             bool above = (bool)parameter[2];
 
-            int oldIndex = Layers.IndexOf(Layers.First(x => x.LayerGuid == layer));
-            int newIndex = Layers.IndexOf(Layers.First(x => x.LayerGuid == referenceLayer));
+            GuidStructureItem folder = LayerStructure.GetFolderByGuid(folderGuid);
+            GuidStructureItem parentFolder = LayerStructure.GetFolderByLayer(referenceLayerGuid);
+
+            int oldIndex = folder.FolderDisplayIndex;
+            int newIndex = CalculateNewIndex(referenceLayerGuid, above, oldIndex, 1);
+
+            LayerStructure.MoveFolder(folderGuid, parentFolder, newIndex);
+        }
+
+        private int CalculateNewIndex(Guid referenceLayerGuid, bool above, int oldIndex, int aboveModifier = 0)
+        {
+            int newIndex = Layers.IndexOf(Layers.First(x => x.LayerGuid == referenceLayerGuid));
 
             if ((oldIndex - newIndex == -1 && !above) || (oldIndex - newIndex == 1 && above))
             {
                 newIndex += above ? 1 : -1;
             }
 
+            if (newIndex >= oldIndex)
+            {
+                newIndex += aboveModifier;
+            }
+
+            return newIndex;
+        }
+
+        private void MoveLayerInStructureProcess(object[] parameter)
+        {
+            Guid layer = (Guid)parameter[0];
+            Guid referenceLayer = (Guid)parameter[1];
+            bool above = (bool)parameter[2];
+
+            int oldIndex = Layers.IndexOf(Layers.First(x => x.LayerGuid == layer));
+            int newIndex = CalculateNewIndex(referenceLayer, above, oldIndex);
+
             Layers.Move(oldIndex, newIndex);
             if (Layers.IndexOf(ActiveLayer) == oldIndex)
             {

PixiEditor/Models/Layers/GuidStructureItem.cs

@@ -25,6 +25,8 @@ namespace PixiEditor.Models.Layers
 
         public ObservableCollection<GuidStructureItem> Subfolders { get; set; }
 
+        public GuidStructureItem Parent { get; set; }
+
         private bool isExpanded;
 
         public bool IsExpanded
@@ -49,13 +51,19 @@ namespace PixiEditor.Models.Layers
             }
         }
 
-        public GuidStructureItem(string name, IEnumerable<Guid> children, IEnumerable<GuidStructureItem> subfolders, int index)
+        public GuidStructureItem(
+            string name,
+            IEnumerable<Guid> children,
+            IEnumerable<GuidStructureItem> subfolders,
+            int index,
+            GuidStructureItem parent)
         {
             Name = name;
             LayerGuids = new ObservableCollection<Guid>(children);
             Subfolders = new ObservableCollection<GuidStructureItem>(subfolders);
             FolderGuid = Guid.NewGuid();
             FolderDisplayIndex = index;
+            Parent = parent;
         }
 
         public GuidStructureItem(string name)
@@ -65,6 +73,7 @@ namespace PixiEditor.Models.Layers
             Subfolders = new ObservableCollection<GuidStructureItem>();
             FolderGuid = Guid.NewGuid();
             FolderDisplayIndex = 0;
+            Parent = null;
         }
     }
 }

PixiEditor/Models/Layers/LayerStructure.cs

@@ -1,11 +1,15 @@
-using System;
+using PixiEditor.Models.DataHolders;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Linq;
 
 namespace PixiEditor.Models.Layers
 {
     public class LayerStructure
     {
+        public Document Owner { get; set; }
+
         public ObservableCollection<GuidStructureItem> Folders { get; set; }
 
         public GuidStructureItem GetFolderByGuid(Guid folderGuid)
@@ -38,6 +42,35 @@ namespace PixiEditor.Models.Layers
             return GetFolderByLayer(layerGuid, Folders);
         }
 
+#nullable enable
+        public void MoveFolder(Guid folderGuid, GuidStructureItem? parentFolder, int newIndex)
+        {
+            var folder = GetFolderByGuid(folderGuid);
+            int oldIndex = folder.FolderDisplayIndex;
+            if (folder.Parent == null)
+            {
+                Folders.Remove(folder);
+            }
+
+            folder.FolderDisplayIndex = newIndex;
+            if (parentFolder == null && !Folders.Contains(folder))
+            {
+                Folders.Add(folder);
+            }
+            else if (parentFolder != null)
+            {
+                parentFolder.Subfolders.Add(folder);
+            }
+
+            for (int i = 0; i < folder.LayerGuids.Count; i++)
+            {
+                Guid layerGuid = folder.LayerGuids[i];
+                int layerIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.LayerGuid == layerGuid));
+                Owner.Layers.Move(layerIndex, newIndex + folder.LayerGuids.Count - i);
+            }
+        }
+
+#nullable disable
         private GuidStructureItem GetFolderByLayer(Guid layerGuid, IEnumerable<GuidStructureItem> folders)
         {
             foreach (var folder in folders)
@@ -74,14 +107,16 @@ namespace PixiEditor.Models.Layers
             return null;
         }
 
-        public LayerStructure(ObservableCollection<GuidStructureItem> items)
+        public LayerStructure(ObservableCollection<GuidStructureItem> items, Document owner)
         {
             Folders = items;
+            Owner = owner;
         }
 
-        public LayerStructure()
+        public LayerStructure(Document owner)
         {
             Folders = new ObservableCollection<GuidStructureItem>();
+            Owner = owner;
         }
     }
 }

PixiEditor/Models/Layers/StructuredLayerTree.cs

@@ -21,11 +21,18 @@ namespace PixiEditor.Models.Layers
                 return;
             }
 
+            var parsedFolders = ParseFolders(structure.Folders, layers);
+
+            foreach (var folder in parsedFolders)
+            {
+                RootDirectoryItems.Add(folder);
+            }
+
             RootDirectoryItems.AddRange(layers.Where(x => !layersInStructure.Contains(x)));
 
-            foreach (var folder in ParseFolders(structure.Folders, layers))
+            for (int i = 0; i < parsedFolders.Count; i++)
             {
-                RootDirectoryItems.Insert(folder.DisplayIndex, folder);
+                RootDirectoryItems.Move(i, parsedFolders[i].DisplayIndex);
             }
 
             layersInStructure.Clear();

PixiEditor/ViewModels/SubViewModels/Main/FileViewModel.cs

@@ -110,24 +110,26 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
 
             Owner.ResetProgramStateValues();
 
-            //Owner.BitmapManager.ActiveDocument.AddNewLayer("Test");
-            //Owner.BitmapManager.ActiveDocument.AddNewLayer("Test1");
-            //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
-            //    },
-            //    new GuidStructureItem[] {
-            //            new GuidStructureItem("Subfolder 1", new ObservableCollection<Guid>()
-            //        {
-            //            Owner.BitmapManager.ActiveDocument.Layers[3].LayerGuid,
-            //            Owner.BitmapManager.ActiveDocument.Layers[4].LayerGuid
-            //        },  Array.Empty<GuidStructureItem>()
-            //        )})
-            //    { IsExpanded = true});
+
+            Owner.BitmapManager.ActiveDocument.AddNewLayer("Test");
+            Owner.BitmapManager.ActiveDocument.AddNewLayer("Test1");
+            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>(), 1, null)
+                { IsExpanded = true });
+
+            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>()
+                    , 3,  Owner.BitmapManager.ActiveDocument.LayerStructure.Folders[0]));
         }
 
         /// <summary>

PixiEditor/Views/UserControls/LayerItem.xaml.cs

@@ -171,9 +171,9 @@ namespace PixiEditor.Views
             if (e.Data.GetDataPresent("PixiEditor.Views.UserControls.LayerFolder"))
             {
                 var data = (LayerFolder)e.Data.GetData("PixiEditor.Views.UserControls.LayerFolder");
-                Guid layer = data.FolderGuid;
+                Guid folder = data.FolderGuid;
 
-                data.LayersViewModel.Owner.BitmapManager.ActiveDocument.MoveLayerInStructure(layer, LayerGuid, above);
+                data.LayersViewModel.Owner.BitmapManager.ActiveDocument.MoveFolderInStructure(folder, LayerGuid, above);
             }
         }