Moving folders wip

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

@@ -463,26 +463,28 @@ namespace PixiEditor.Models.DataHolders
             GuidStructureItem folder = LayerStructure.GetFolderByGuid(folderGuid);
             GuidStructureItem parentFolder = LayerStructure.GetFolderByLayer(referenceLayerGuid);
 
-            int oldIndex = folder.FolderDisplayIndex;
-            int newIndex = CalculateNewIndex(referenceLayerGuid, above, oldIndex, 1);
+            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);
+
+            if (newIndex == relativeIndex) //FIX bad new index, it moves to wrong indexes
+            {
+                return;
+            }
 
             LayerStructure.MoveFolder(folderGuid, parentFolder, newIndex);
         }
 
-        private int CalculateNewIndex(Guid referenceLayerGuid, bool above, int oldIndex, int aboveModifier = 0)
+        private int CalculateNewIndex(int layerIndex, bool above, int oldIndex)
         {
-            int newIndex = Layers.IndexOf(Layers.First(x => x.LayerGuid == referenceLayerGuid));
+            int newIndex = layerIndex;
 
-            if ((oldIndex - newIndex == -1 && !above) || (oldIndex - newIndex == 1 && above))
+            if ((oldIndex - layerIndex == -1 && !above) || (oldIndex - layerIndex == 1 && above))
             {
                 newIndex += above ? 1 : -1;
             }
 
-            if (newIndex >= oldIndex)
-            {
-                newIndex += aboveModifier;
-            }
-
             return newIndex;
         }
 
@@ -492,8 +494,9 @@ 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 newIndex = CalculateNewIndex(referenceLayer, above, oldIndex);
+            int newIndex = CalculateNewIndex(layerIndex, above, oldIndex);
 
             Layers.Move(oldIndex, newIndex);
             if (Layers.IndexOf(ActiveLayer) == oldIndex)

PixiEditor/Models/Layers/GuidStructureItem.cs

@@ -39,18 +39,44 @@ namespace PixiEditor.Models.Layers
             }
         }
 
-        private int folderDisplayIndex;
+        private int actualIndex;
 
-        public int FolderDisplayIndex
+        public int ActualIndex
         {
-            get => folderDisplayIndex;
+            get => actualIndex;
             set
             {
-                folderDisplayIndex = value;
-                RaisePropertyChanged(nameof(FolderDisplayIndex));
+                actualIndex = value;
+                RaisePropertyChanged(nameof(ActualIndex));
             }
         }
 
+        public int FolderDisplayIndex
+        {
+            get => ActualIndex - GetLayersCount() + 1;
+        }
+
+        public int GetLayersCount()
+        {
+            return GetLayersCount(this);
+        }
+
+        private int GetLayersCount(GuidStructureItem item)
+        {
+            if (Subfolders.Count == 0)
+            {
+                return LayerGuids.Count;
+            }
+
+            int itemsCount = 0;
+            foreach (var subFolder in item.Subfolders)
+            {
+                itemsCount += GetLayersCount(subFolder);
+            }
+
+            return itemsCount + LayerGuids.Count;
+        }
+
         public GuidStructureItem(
             string name,
             IEnumerable<Guid> children,
@@ -62,7 +88,7 @@ namespace PixiEditor.Models.Layers
             LayerGuids = new ObservableCollection<Guid>(children);
             Subfolders = new ObservableCollection<GuidStructureItem>(subfolders);
             FolderGuid = Guid.NewGuid();
-            FolderDisplayIndex = index;
+            ActualIndex = index;
             Parent = parent;
         }
 
@@ -72,7 +98,7 @@ namespace PixiEditor.Models.Layers
             LayerGuids = new ObservableCollection<Guid>();
             Subfolders = new ObservableCollection<GuidStructureItem>();
             FolderGuid = Guid.NewGuid();
-            FolderDisplayIndex = 0;
+            ActualIndex = 0;
             Parent = null;
         }
     }

PixiEditor/Models/Layers/LayerStructure.cs

@@ -1,8 +1,8 @@
-using PixiEditor.Models.DataHolders;
-using System;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
+using PixiEditor.Models.DataHolders;
 
 namespace PixiEditor.Models.Layers
 {
@@ -46,13 +46,32 @@ namespace PixiEditor.Models.Layers
         public void MoveFolder(Guid folderGuid, GuidStructureItem? parentFolder, int newIndex)
         {
             var folder = GetFolderByGuid(folderGuid);
-            int oldIndex = folder.FolderDisplayIndex;
+            int oldIndex = folder.ActualIndex;
+            bool reverseOrder = true;
+
+            int indexToApply = folder.ActualIndex;
+
+            if (newIndex > oldIndex)
+            {
+                indexToApply = newIndex;
+            }
+            else
+            {
+                indexToApply = newIndex + folder.ActualIndex - 1;
+                reverseOrder = false;
+            }
+
+            int difference = indexToApply - oldIndex;
+
+            MoveLayersInFolder(folder, difference, reverseOrder);
+
+            folder.ActualIndex = indexToApply;
+
             if (folder.Parent == null)
             {
                 Folders.Remove(folder);
             }
 
-            folder.FolderDisplayIndex = newIndex;
             if (parentFolder == null && !Folders.Contains(folder))
             {
                 Folders.Add(folder);
@@ -61,13 +80,35 @@ namespace PixiEditor.Models.Layers
             {
                 parentFolder.Subfolders.Add(folder);
             }
+        }
 
-            for (int i = 0; i < folder.LayerGuids.Count; i++)
+        private void MoveLayersInFolder(GuidStructureItem folder, int moveBy, bool reverseOrder)
+        {
+            List<Guid> layersInOrder = GetLayersInOrder(folder);
+
+            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);
+            }
+        }
+
+        private List<Guid> GetLayersInOrder(GuidStructureItem folder)
+        {
+            List<Guid> layerGuids = new List<Guid>();
+            int minIndex = folder.FolderDisplayIndex;
+            int maxIndex = folder.ActualIndex;
+
+            for (int i = minIndex; i <= maxIndex; 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);
+                layerGuids.Add(Owner.Layers[i].LayerGuid);
             }
+
+            return layerGuids;
         }
 
 #nullable disable

PixiEditor/Models/Layers/StructuredLayerTree.cs

@@ -23,10 +23,7 @@ namespace PixiEditor.Models.Layers
 
             var parsedFolders = ParseFolders(structure.Folders, layers);
 
-            foreach (var folder in parsedFolders)
-            {
-                RootDirectoryItems.Add(folder);
-            }
+            RootDirectoryItems.AddRange(parsedFolders);
 
             RootDirectoryItems.AddRange(layers.Where(x => !layersInStructure.Contains(x)));
 
@@ -66,7 +63,9 @@ namespace PixiEditor.Models.Layers
                 subFolders = ParseFolders(structureItem.Subfolders, layers);
             }
 
-            LayerFolder folder = new (structureItemLayers, subFolders, structureItem.Name, 
+            structureItemLayers.Reverse();
+
+            LayerFolder folder = new (structureItemLayers, subFolders, structureItem.Name,
                 structureItem.FolderGuid, structureItem.FolderDisplayIndex)
             {
                 IsExpanded = structureItem.IsExpanded

PixiEditor/ViewModels/SubViewModels/Main/FileViewModel.cs

@@ -120,7 +120,7 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
                 {
                     Owner.BitmapManager.ActiveDocument.Layers[1].LayerGuid,
                     Owner.BitmapManager.ActiveDocument.Layers[2].LayerGuid
-                }, Array.Empty<GuidStructureItem>(), 1, null)
+                }, Array.Empty<GuidStructureItem>(), 4, null)
                 { IsExpanded = true });
 
             Owner.BitmapManager.ActiveDocument.LayerStructure.Folders[0].Subfolders.Add(
@@ -129,7 +129,7 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
                         Owner.BitmapManager.ActiveDocument.Layers[3].LayerGuid,
                         Owner.BitmapManager.ActiveDocument.Layers[4].LayerGuid
                     },  Array.Empty<GuidStructureItem>()
-                    , 3,  Owner.BitmapManager.ActiveDocument.LayerStructure.Folders[0]));
+                    , 4,  Owner.BitmapManager.ActiveDocument.LayerStructure.Folders[0]));
         }
 
         /// <summary>

PixiEditor/Views/MainWindow.xaml

@@ -309,6 +309,20 @@
                                             </usercontrols:LayersManager.LayerTreeRoot>
                                         </usercontrols:LayersManager>
                                     </LayoutAnchorable>
+                                    <LayoutAnchorable ContentId="rawLayer" Title="Raw layers">
+                                        <ItemsControl ItemsSource="{Binding BitmapManager.ActiveDocument.Layers}">
+                                            <ItemsControl.ItemsPanel>
+                                                <ItemsPanelTemplate>
+                                                    <ui:ReversedOrderStackPanel />
+                                                </ItemsPanelTemplate>
+                                            </ItemsControl.ItemsPanel>
+                                            <ItemsControl.ItemTemplate>
+                                                <DataTemplate>
+                                                    <Label Foreground="White" Content="{Binding Name}"/>
+                                                </DataTemplate>
+                                            </ItemsControl.ItemTemplate>
+                                        </ItemsControl>
+                                    </LayoutAnchorable>
                                 </LayoutAnchorablePane>
                             </LayoutAnchorablePaneGroup>
                         </LayoutPanel>