Insert inside folder works, isvisible folder

src/PixiEditor.AvaloniaUI/Models/DocumentModels/DocumentStructureHelper.cs

@@ -12,6 +12,7 @@ internal class DocumentStructureHelper
 {
     private IDocument doc;
     private DocumentInternalParts internals;
+
     public DocumentStructureHelper(IDocument doc, DocumentInternalParts internals)
     {
         this.doc = doc;
@@ -29,7 +30,7 @@ internal class DocumentStructureHelper
                 if (childName.StartsWith(name))
                     count++;
             }
-            
+
             return true;
         });
         return $"{name} {count}";
@@ -43,104 +44,119 @@ internal class DocumentStructureHelper
             Guid guid = Guid.NewGuid();
             //put member on top
             internals.ActionAccumulator.AddActions(new CreateStructureMember_Action(
-                doc.NodeGraphHandler.OutputNode.Id, 
+                doc.NodeGraphHandler.OutputNode.Id,
                 guid, type));
-            name ??= GetUniqueName(type == StructureMemberType.Layer ? new LocalizedString("NEW_LAYER") : new LocalizedString("NEW_FOLDER"), doc.NodeGraphHandler.OutputNode);
+            name ??= GetUniqueName(
+                type == StructureMemberType.Layer
+                    ? new LocalizedString("NEW_LAYER")
+                    : new LocalizedString("NEW_FOLDER"), doc.NodeGraphHandler.OutputNode);
             internals.ActionAccumulator.AddActions(new StructureMemberName_Action(guid, name));
             if (finish)
                 internals.ActionAccumulator.AddFinishedActions();
             return guid;
         }
+
         if (member is IFolderHandler folder)
         {
             Guid guid = Guid.NewGuid();
             //put member inside folder on top
             internals.ActionAccumulator.AddActions(new CreateStructureMember_Action(folder.Id, guid, type));
-            name ??= GetUniqueName(type == StructureMemberType.Layer ? new LocalizedString("NEW_LAYER") : new LocalizedString("NEW_FOLDER"), folder);
+            name ??= GetUniqueName(
+                type == StructureMemberType.Layer
+                    ? new LocalizedString("NEW_LAYER")
+                    : new LocalizedString("NEW_FOLDER"), folder);
             internals.ActionAccumulator.AddActions(new StructureMemberName_Action(guid, name));
             if (finish)
                 internals.ActionAccumulator.AddFinishedActions();
             return guid;
         }
+
         if (member is ILayerHandler layer)
         {
             Guid guid = Guid.NewGuid();
             //put member above the layer
             INodeHandler parent = doc.StructureHelper.GetFirstForwardNode(layer);
             internals.ActionAccumulator.AddActions(new CreateStructureMember_Action(parent.Id, guid, type));
-            name ??= GetUniqueName(type == StructureMemberType.Layer ? new LocalizedString("NEW_LAYER") : new LocalizedString("NEW_FOLDER"), parent);
+            name ??= GetUniqueName(
+                type == StructureMemberType.Layer
+                    ? new LocalizedString("NEW_LAYER")
+                    : new LocalizedString("NEW_FOLDER"), parent);
             internals.ActionAccumulator.AddActions(new StructureMemberName_Action(guid, name));
             if (finish)
                 internals.ActionAccumulator.AddFinishedActions();
             return guid;
         }
+
         throw new ArgumentException($"Unknown member type: {type}");
     }
 
-    private void HandleMoveInside(List<IStructureMemberHandler> memberToMovePath, List<IStructureMemberHandler> memberToMoveIntoPath)
+    private void HandleMoveInside(Guid memberToMove, Guid memberToMoveInto)
     {
-        if (memberToMoveIntoPath[0] is not IFolderHandler folder || memberToMoveIntoPath.Contains(memberToMovePath[0]))
+        if (memberToMoveInto == memberToMove)
             return;
-        //int index = folder.Children.Count;
-        if (memberToMoveIntoPath[0].Id == memberToMovePath[1].Id) // member is already in this folder
-            //index--;
-        //internals.ActionAccumulator.AddFinishedActions(new MoveStructureMember_Action(memberToMovePath[0].Id, folder.Id, index));
-        return;
+        
+        internals.ActionAccumulator.AddFinishedActions(new MoveStructureMember_Action(memberToMove, memberToMoveInto));
     }
 
-    private void HandleMoveAboveBelow(List<IStructureMemberHandler> memberToMovePath, List<IStructureMemberHandler> memberToMoveRelativeToPath, bool above)
+    private void HandleMoveAboveBelow(Guid memberToMove, Guid referenceMember, bool above)
     {
-        IFolderHandler targetFolder = (IFolderHandler)memberToMoveRelativeToPath[1];
+        /*IFolderHandler targetFolder = (IFolderHandler)memberToMoveRelativeToPath[1];
         if (memberToMovePath[1].Id == memberToMoveRelativeToPath[1].Id)
-        { // members are in the same folder
-            //int indexOfMemberToMove = targetFolder.Children.IndexOf(memberToMovePath[0]);
-            //int indexOfMemberToMoveAbove = targetFolder.Children.IndexOf(memberToMoveRelativeToPath[0]);
-            //int index = indexOfMemberToMoveAbove;
-           // if (above)
-           //     index++;
-           // if (indexOfMemberToMove < indexOfMemberToMoveAbove)
-           //     index--;
-          //  internals.ActionAccumulator.AddFinishedActions(new MoveStructureMember_Action(memberToMovePath[0].Id, targetFolder.Id, index));
+        {
+            // members are in the same folder
+            int indexOfMemberToMove = targetFolder.Children.IndexOf(memberToMovePath[0]);
+            int indexOfMemberToMoveAbove = targetFolder.Children.IndexOf(memberToMoveRelativeToPath[0]);
+            int index = indexOfMemberToMoveAbove;
+            if (above)
+                index++;
+            if (indexOfMemberToMove < indexOfMemberToMoveAbove)
+                index--;
+
+            Guid targetNodeId = targetFolder.Children[Math.Clamp(index, 0, targetFolder.Children.Count - 1)].Id;
+            internals.ActionAccumulator.AddFinishedActions(
+                new MoveStructureMember_Action(memberToMovePath[0].Id, targetNodeId));
         }
         else
-        { // members are in different folders
+        {
+            // members are in different folders
             if (memberToMoveRelativeToPath.Contains(memberToMovePath[0]))
                 return;
-          //  int index = targetFolder.Children.IndexOf(memberToMoveRelativeToPath[0]);
-         //   if (above)
-          //      index++;
-          //  internals.ActionAccumulator.AddFinishedActions(new MoveStructureMember_Action(memberToMovePath[0].Id, targetFolder.Id, index));
-        }
+            int index = targetFolder.Children.IndexOf(memberToMoveRelativeToPath[0]);
+            if (above)
+                index++;
+
+            Guid targetNodeId = targetFolder.Children[Math.Clamp(index, 0, targetFolder.Children.Count - 1)].Id;
+            internals.ActionAccumulator.AddFinishedActions(
+                new MoveStructureMember_Action(memberToMovePath[0].Id, targetNodeId));
+        }*/
     }
 
-    public void TryMoveStructureMember(Guid memberToMove, Guid memberToMoveIntoOrNextTo, StructureMemberPlacement placement)
+    public void TryMoveStructureMember(Guid memberToMove, Guid memberToMoveIntoOrNextTo,
+        StructureMemberPlacement placement)
     {
-        List<IStructureMemberHandler> memberPath = doc.StructureHelper.FindPath(memberToMove);
-        List<IStructureMemberHandler> refPath = doc.StructureHelper.FindPath(memberToMoveIntoOrNextTo);
-        if (memberPath.Count < 2 || refPath.Count < 2)
-            return;
         switch (placement)
         {
             case StructureMemberPlacement.Above:
-                HandleMoveAboveBelow(memberPath, refPath, true);
+                HandleMoveAboveBelow(memberToMove, memberToMoveIntoOrNextTo, true);
                 break;
             case StructureMemberPlacement.Below:
-                HandleMoveAboveBelow(memberPath, refPath, false);
+                //HandleMoveAboveBelow(memberPath, refPath, false);
                 break;
             case StructureMemberPlacement.Inside:
-                HandleMoveInside(memberPath, refPath);
+                HandleMoveInside(memberToMove, memberToMoveIntoOrNextTo);
                 break;
             case StructureMemberPlacement.BelowOutsideFolder:
+            {
+                /*IFolderHandler refFolder = (IFolderHandler)refPath[1];
+                int refIndexInParent = refFolder.Children.IndexOf(refPath[0]);
+                if (refIndexInParent > 0 || refPath.Count == 2)
                 {
-                    IFolderHandler refFolder = (IFolderHandler)refPath[1];
-                 //   int refIndexInParent = refFolder.Children.IndexOf(refPath[0]);
-                  //  if (refIndexInParent > 0 || refPath.Count == 2)
-                    {
-                        HandleMoveAboveBelow(memberPath, refPath, false);
-                        break;
-                    }
-                    HandleMoveAboveBelow(memberPath, doc.StructureHelper.FindPath(refPath[1].Id), false);
+                    HandleMoveAboveBelow(memberPath, refPath, false);
+                    break;
                 }
+
+                HandleMoveAboveBelow(memberPath, doc.StructureHelper.FindPath(refPath[1].Id), false);*/
+            }
                 break;
         }
     }

src/PixiEditor.ChangeableDocument/Changeables/Graph/Nodes/FolderNode.cs

@@ -15,6 +15,12 @@ public class FolderNode : StructureNode, IReadOnlyFolderNode
 
     public override ChunkyImage? OnExecute(KeyFrameTime frame)
     {
+        if (!IsVisible.Value)
+        {
+            Output.Value = null;
+            return null;
+        }
+        
         Output.Value = Background.Value;
         return Background.Value;
     }

src/PixiEditor.ChangeableDocument/Changeables/Graph/Nodes/MergeNode.cs

@@ -19,7 +19,7 @@ public class MergeNode : Node, IBackgroundInput
     
     public override bool Validate()
     {
-        return Top.Value != null || Bottom.Value != null;
+        return Top.Connection != null || Bottom.Connection != null;
     }
 
     public override Node CreateCopy()
@@ -31,6 +31,7 @@ public class MergeNode : Node, IBackgroundInput
     {
         if(Top.Value == null && Bottom.Value == null)
         {
+            Output.Value = null;
             return null;
         }
         

src/PixiEditor.ChangeableDocument/Changeables/Graph/Nodes/Node.cs

@@ -1,9 +1,11 @@
-using PixiEditor.ChangeableDocument.Changeables.Animations;
+using System.Diagnostics;
+using PixiEditor.ChangeableDocument.Changeables.Animations;
 using PixiEditor.ChangeableDocument.Changeables.Graph.Interfaces;
 using PixiEditor.Numerics;
 
 namespace PixiEditor.ChangeableDocument.Changeables.Graph.Nodes;
 
+[DebuggerDisplay("Type = {GetType().Name}")]
 public abstract class Node : IReadOnlyNode, IDisposable
 {
     private List<InputProperty> inputs = new();

src/PixiEditor.ChangeableDocument/Changes/NodeGraph/DisconnectProperty_Change.cs

@@ -28,6 +28,9 @@ internal class DisconnectProperty_Change : Change
             return false;
         
         originalConnection = node.GetInputProperty(property).Connection;
+        if (originalConnection is null)
+            return false;
+        
         return true;
     }
 

src/PixiEditor.ChangeableDocument/Changes/NodeGraph/NodeOperations.cs

@@ -0,0 +1,67 @@
+using PixiEditor.ChangeableDocument.Changeables.Graph;
+using PixiEditor.ChangeableDocument.Changeables.Graph.Interfaces;
+using PixiEditor.ChangeableDocument.Changeables.Graph.Nodes;
+using PixiEditor.ChangeableDocument.ChangeInfos.NodeGraph;
+
+namespace PixiEditor.ChangeableDocument.Changes.NodeGraph;
+
+public static class NodeOperations
+{
+    public static List<ConnectProperty_ChangeInfo> AppendMember(InputProperty<ChunkyImage?> parentInput,
+        OutputProperty<ChunkyImage> toAddOutput,
+        InputProperty<ChunkyImage> toAddInput, Guid memberId)
+    {
+        List<ConnectProperty_ChangeInfo> changes = new();
+        IOutputProperty? previouslyConnected = null;
+        if (parentInput.Connection != null)
+        {
+            previouslyConnected = parentInput.Connection;
+        }
+
+        toAddOutput.ConnectTo(parentInput);
+
+        if (previouslyConnected != null)
+        {
+            previouslyConnected.ConnectTo(toAddInput);
+            changes.Add(new ConnectProperty_ChangeInfo(previouslyConnected.Node.Id, memberId,
+                previouslyConnected.InternalPropertyName, toAddInput.InternalPropertyName));
+        }
+
+        changes.Add(new ConnectProperty_ChangeInfo(memberId, parentInput.Node.Id,
+            toAddOutput.InternalPropertyName, parentInput.InternalPropertyName));
+
+        return changes;
+    }
+
+    public static List<IChangeInfo> DetachStructureNode(StructureNode structureNode)
+    {
+        List<IChangeInfo> changes = new();
+
+
+        var outputs = structureNode.Output.Connections.ToArray();
+        foreach (var outputConnection in outputs)
+        {
+            structureNode.Output.DisconnectFrom(outputConnection);
+            changes.Add(new ConnectProperty_ChangeInfo(null, outputConnection.Node.Id, null,
+                outputConnection.InternalPropertyName));
+        }
+
+        if (structureNode.Background.Connection != null)
+        {
+            // connect connection to next input if possible
+
+            var connections = structureNode.Output.Connections.ToArray();
+
+            var output = structureNode.Background.Connection;
+
+            foreach (var input in connections)
+            {
+                output.ConnectTo(input);
+                changes.Add(new ConnectProperty_ChangeInfo(output.Node.Id, input.Node.Id,
+                    output.InternalPropertyName, input.InternalPropertyName));
+            }
+        }
+
+        return changes;
+    }
+}

src/PixiEditor.ChangeableDocument/Changes/Structure/CreateStructureMember_Change.cs

@@ -3,6 +3,7 @@ using PixiEditor.ChangeableDocument.Changeables.Graph.Interfaces;
 using PixiEditor.ChangeableDocument.Changeables.Graph.Nodes;
 using PixiEditor.ChangeableDocument.ChangeInfos.NodeGraph;
 using PixiEditor.ChangeableDocument.ChangeInfos.Structure;
+using PixiEditor.ChangeableDocument.Changes.NodeGraph;
 using PixiEditor.ChangeableDocument.Enums;
 using PixiEditor.Numerics;
 
@@ -59,7 +60,7 @@ internal class CreateStructureMember_Change : Change
         {
             document.NodeGraph.AddNode(member);
             List<ConnectProperty_ChangeInfo> connectPropertyChangeInfo =
-                AppendMember(backgroundInput.Background, member.Output, member.Background, member.Id);
+                NodeOperations.AppendMember(backgroundInput.Background, member.Output, member.Background, member.Id);
             changes.AddRange(connectPropertyChangeInfo);
         }
 
@@ -111,36 +112,12 @@ internal class CreateStructureMember_Change : Change
 
     private static void AppendFolder(IBackgroundInput backgroundInput, FolderNode folder, MergeNode mergeNode, List<IChangeInfo> changes)
     {
-        var appened = AppendMember(backgroundInput.Background, mergeNode.Output, mergeNode.Bottom, mergeNode.Id);
+        var appened = NodeOperations.AppendMember(backgroundInput.Background, mergeNode.Output, mergeNode.Bottom, mergeNode.Id);
         changes.AddRange(appened);
         
-        appened = AppendMember(mergeNode.Top, folder.Output, folder.Background, folder.Id);
+        appened = NodeOperations.AppendMember(mergeNode.Top, folder.Output, folder.Background, folder.Id);
         changes.AddRange(appened);
     }
 
-    private static List<ConnectProperty_ChangeInfo> AppendMember(InputProperty<ChunkyImage?> parentInput,
-        OutputProperty<ChunkyImage> toAddOutput,
-        InputProperty<ChunkyImage> toAddInput, Guid memberId)
-    {
-        List<ConnectProperty_ChangeInfo> changes = new();
-        IOutputProperty? previouslyConnected = null;
-        if (parentInput.Connection != null)
-        {
-            previouslyConnected = parentInput.Connection;
-        }
-
-        toAddOutput.ConnectTo(parentInput);
-
-        if (previouslyConnected != null)
-        {
-            toAddInput.Connection = previouslyConnected;
-            changes.Add(new ConnectProperty_ChangeInfo(previouslyConnected.Node.Id, memberId,
-                previouslyConnected.InternalPropertyName, toAddInput.InternalPropertyName));
-        }
-
-        changes.Add(new ConnectProperty_ChangeInfo(memberId, parentInput.Node.Id,
-            toAddOutput.InternalPropertyName, parentInput.InternalPropertyName));
-
-        return changes;
-    }
+    
 }

src/PixiEditor.ChangeableDocument/Changes/Structure/MoveStructureMember_Change.cs

@@ -1,5 +1,7 @@
-using PixiEditor.ChangeableDocument.Changeables.Graph.Nodes;
+using PixiEditor.ChangeableDocument.Changeables.Graph.Interfaces;
+using PixiEditor.ChangeableDocument.Changeables.Graph.Nodes;
 using PixiEditor.ChangeableDocument.ChangeInfos.Structure;
+using PixiEditor.ChangeableDocument.Changes.NodeGraph;
 
 namespace PixiEditor.ChangeableDocument.Changes.Structure;
 
@@ -7,52 +9,62 @@ internal class MoveStructureMember_Change : Change
 {
     private Guid memberGuid;
 
-    private Guid targetFolderGuid;
-    private int targetFolderIndex;
+    private Guid targetNodeGuid;
 
     private Guid originalFolderGuid;
-    private int originalFolderIndex;
+    
+    private Guid originalParentGuid;
 
     [GenerateMakeChangeAction]
-    public MoveStructureMember_Change(Guid memberGuid, Guid targetFolder, int targetFolderIndex)
+    public MoveStructureMember_Change(Guid memberGuid, Guid targetNode)
     {
         this.memberGuid = memberGuid;
-        this.targetFolderGuid = targetFolder;
-        this.targetFolderIndex = targetFolderIndex;
+        this.targetNodeGuid = targetNode;
     }
 
     public override bool InitializeAndValidate(Document document)
     {
-        var (member, curFolder) = document.FindChildAndParent(memberGuid);
-        var targetFolder = document.FindMember(targetFolderGuid);
-        if (member is null || curFolder is null || targetFolder is not FolderNode)
+        var member = document.FindMember(memberGuid);
+        var targetFolder = document.FindNode(targetNodeGuid);
+        if (member is null || targetFolder is null)
             return false;
-        originalFolderGuid = curFolder.Id;
-        // TODO: this too:
-        // originalFolderIndex = curFolder.Children.IndexOf(member);
+
+        member.TraverseForwards(node =>
+        {
+            originalParentGuid = node.Id;
+            return false;
+        });
+        
         return true;
     }
 
-    private static void Move(Document document, Guid memberGuid, Guid targetFolderGuid, int targetIndex)
+    private static List<IChangeInfo> Move(Document document, Guid sourceNodeGuid, Guid targetNodeGuid)
     {
-        // TODO: Implement
-        /*var targetFolder = document.FindMemberOrThrow<FolderNode>(targetFolderGuid);
-        var (member, curFolder) = document.FindChildAndParentOrThrow(memberGuid);
-
-        curFolder.Children = curFolder.Children.Remove(member);
-        targetFolder.Children = targetFolder.Children.Insert(targetIndex, member);*/
+        var sourceNode = document.FindMember(sourceNodeGuid);
+        var targetNode = document.FindNode(targetNodeGuid);
+        if (sourceNode is null || targetNode is not IBackgroundInput backgroundInput)
+            return [];
+        
+        List<IChangeInfo> changes = new();
+        
+        changes.AddRange(NodeOperations.DetachStructureNode(sourceNode));
+        changes.AddRange(NodeOperations.AppendMember(backgroundInput.Background, sourceNode.Output, sourceNode.Background,
+            sourceNode.Id));
+        
+        return changes;
     }
 
     public override OneOf<None, IChangeInfo, List<IChangeInfo>> Apply(Document target, bool firstApply, out bool ignoreInUndo)
     {
-        Move(target, memberGuid, targetFolderGuid, targetFolderIndex);
+        var changes = Move(target, memberGuid, targetNodeGuid);
         ignoreInUndo = false;
-        return new MoveStructureMember_ChangeInfo(memberGuid, originalFolderGuid, targetFolderGuid, targetFolderIndex);
+        return changes;
     }
 
     public override OneOf<None, IChangeInfo, List<IChangeInfo>> Revert(Document target)
     {
-        Move(target, memberGuid, originalFolderGuid, originalFolderIndex);
-        return new MoveStructureMember_ChangeInfo(memberGuid, targetFolderGuid, originalFolderGuid, originalFolderIndex);
+        // TODO: this is lossy, original connections might be lost
+        var changes = Move(target, memberGuid, originalFolderGuid);
+        return changes; 
     }
 }