Rewrite editor navigation model

Bonsai.Design/CommandExecutor.cs

@@ -121,7 +121,8 @@ public void EndCompositeCommand()
 
             if (composite.Execute == null)
             {
-                throw new InvalidOperationException("A composite command must have at least one action defined.");
+                composite = null;
+                return;
             }
 
             if (composite.Undo != null)

Bonsai.Editor.Tests/MockGraphView.cs

@@ -18,6 +18,7 @@ public MockGraphView(ExpressionBuilderGraph workflow = null)
             Workflow = workflow ?? new ExpressionBuilderGraph();
             CommandExecutor = new CommandExecutor();
             var serviceContainer = new ServiceContainer();
+            serviceContainer.AddService(typeof(WorkflowBuilder), new WorkflowBuilder(Workflow));
             serviceContainer.AddService(typeof(CommandExecutor), CommandExecutor);
             ServiceProvider = serviceContainer;
         }

Bonsai.Editor.Tests/WorkflowEditorTests.cs

@@ -52,7 +52,6 @@ static string ToString(IEnumerable<T> sequence)
             var editor = new WorkflowEditor(graphView.ServiceProvider, graphView);
             editor.UpdateLayout.Subscribe(graphView.UpdateGraphLayout);
             editor.UpdateSelection.Subscribe(graphView.UpdateSelection);
-            editor.Workflow = graphView.Workflow;
 
             var nodeSequence = editor.GetGraphValues().ToArray();
             return (editor, assertIsReversible: () =>

Bonsai.Editor/Bonsai.Editor.csproj

@@ -14,6 +14,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="DockPanelSuite.ThemeVS2015" Version="3.1.1" />
     <PackageReference Include="SvgNet" Version="3.3.8" />
     <PackageReference Include="YamlDotNet" Version="16.0.0" />
     <PackageReference Include="Markdig" Version="0.37.0" />

Bonsai.Editor/Docking/DockPanelHelper.cs

@@ -0,0 +1,162 @@
+using System;
+using System.Drawing;
+using System.IO;
+using System.Text;
+using System.Xml.Linq;
+using Bonsai.Design;
+using WeifenLuo.WinFormsUI.Docking;
+
+namespace Bonsai.Editor.Docking
+{
+    internal static class DockPanelHelper
+    {
+        public static TDockContent CreateDynamicContent<TDockContent>(
+            this DockPanel dockPanel,
+            Func<DockPanel, TDockContent> contentFactory,
+            Action<TDockContent> contentClosed,
+            DockState dockState,
+            CommandExecutor commandExecutor)
+            where TDockContent : DockContent
+        {
+            int contentIndex = -1;
+            bool singletonContent = false;
+            object contentId = new();
+            object dockPaneId = default;
+            object previousPaneId = default;
+            Rectangle? floatWindowBounds = null;
+            TDockContent dockContent = default;
+            DockAlignment? dockAlignment = default;
+            double dockProportion = default;
+            var isUndoAction = false;
+            void CloseContent()
+            {
+                try
+                {
+                    isUndoAction = true;
+                    dockContent.Close();
+                }
+                finally
+                {
+                    isUndoAction = false;
+                }
+            }
+
+            void CreateAndShowContent()
+            {
+                dockContent = contentFactory(dockPanel);
+                dockContent.Tag = contentId;
+                dockContent.HideOnClose = false;
+                dockContent.FormClosed += (sender, e) =>
+                {
+                    contentClosed(dockContent);
+                    var nestedDockingStatus = dockContent.Pane.NestedDockingStatus;
+                    dockState = dockContent.DockState;
+                    dockAlignment = nestedDockingStatus.Alignment;
+                    dockProportion = nestedDockingStatus.Proportion;
+                    dockPaneId = dockContent.Pane.Tag;
+                    previousPaneId = nestedDockingStatus.PreviousPane?.Tag;
+                    singletonContent = dockContent.Pane.Contents.Count == 1;
+                    floatWindowBounds = dockState == DockState.Float
+                        ? dockContent.Pane.FloatWindow.Bounds
+                        : null;
+                    contentIndex = dockContent.Pane.Contents.IndexOf(dockContent);
+                    if (!isUndoAction)
+                    {
+                        var isRedoAction = false;
+                        commandExecutor.Execute(
+                            () =>
+                            {
+                                if (isRedoAction)
+                                    CloseContent();
+                                else
+                                    isRedoAction = true;
+                            },
+                            CreateAndShowContent);
+                    }
+                };
+
+                if (dockState == DockState.Unknown)
+                    return;
+
+                var dockPane = dockPanel.GetPaneFromId(dockPaneId);
+                if (dockPane != null && !singletonContent)
+                {
+                    dockContent.Show(dockPane, contentIndex);
+                    return;
+                }
+
+                contentIndex = -1;
+                singletonContent = default;
+                dockPane = dockPanel.GetPaneFromId(previousPaneId);
+                if (dockPane is DockPane previousPane)
+                {
+                    dockContent.Show(previousPane, dockAlignment.Value, dockProportion);
+                }
+                else if (floatWindowBounds.HasValue)
+                {
+                    dockContent.Show(dockPanel, floatWindowBounds.GetValueOrDefault());
+                }
+                else if (dockPanel.ActiveDocumentPane != null && dockState == DockState.Document)
+                {
+                    dockContent.Show(dockPanel.ActiveDocumentPane, contentIndex);
+                }
+                else
+                {
+                    dockContent.Show(dockPanel, dockState);
+                }
+            }
+
+            if (dockState == DockState.Unknown)
+                CreateAndShowContent();
+            else
+                commandExecutor.Execute(
+                    CreateAndShowContent,
+                    CloseContent);
+            return dockContent;
+        }
+
+        public static void Show(this DockContent dockContent, DockPane pane, int contentIndex)
+        {
+            pane.DockPanel.SuspendLayout(allWindows: true);
+            dockContent.DockPanel = pane.DockPanel;
+            dockContent.Pane = pane;
+            if (contentIndex >= 0 && contentIndex < pane.Contents.Count)
+            {
+                pane.SetContentIndex(dockContent, contentIndex);
+            }
+            dockContent.Show();
+            pane.DockPanel.ResumeLayout(performLayout: true, allWindows: true);
+        }
+
+        static DockPane GetPaneFromId(this DockPanel dockPanel, object paneId)
+        {
+            for (int i = 0; i < dockPanel.Panes.Count; i++)
+            {
+                if (ReferenceEquals(paneId, dockPanel.Panes[i].Tag))
+                    return dockPanel.Panes[i];
+            }
+
+            return null;
+        }
+
+        public static DockPane GetDocumentPane(this DockPanel dockPanel)
+        {
+            for (int i = 0; i < dockPanel.Panes.Count; i++)
+            {
+                var pane = dockPanel.Panes[i];
+                if (pane.IsActiveDocumentPane)
+                    return pane;
+            }
+
+            return null;
+        }
+
+        public static XDocument SaveAsXml(this DockPanel dockPanel)
+        {
+            using var memoryStream = new MemoryStream();
+            dockPanel.SaveAsXml(memoryStream, Encoding.UTF8, upstream: true);
+            memoryStream.Position = 0;
+            return XDocument.Load(memoryStream);
+        }
+    }
+}

Bonsai.Editor/Docking/DockPanelSerializer.cs

@@ -0,0 +1,65 @@
+
+using System;
+using System.Text;
+using Bonsai.Editor.GraphModel;
+using Bonsai.Editor.GraphView;
+using WeifenLuo.WinFormsUI.Docking;
+
+namespace Bonsai.Editor.Docking
+{
+    internal static class DockPanelSerializer
+    {
+        const char ContentTypeSeparator = ':';
+
+        static void ThrowNotRecognizedException(string contentString)
+        {
+            throw new ArgumentException(
+                $"The specified dock panel content was not recognized: {contentString}.",
+                nameof(contentString));
+        }
+
+        public static IDockContent DeserializeContent(
+            WorkflowEditorControl editorControl,
+            WorkflowBuilder workflowBuilder,
+            string contentString)
+        {
+            if (editorControl is null)
+                throw new ArgumentNullException(nameof(editorControl));
+
+            if (string.IsNullOrEmpty(contentString))
+                throw new ArgumentException("The dock panel content is null or empty.", nameof(contentString));
+
+            var contentElements = contentString.Split(new[] { ContentTypeSeparator });
+            if (contentElements.Length < 1 || contentElements.Length > 2)
+                ThrowNotRecognizedException(contentString);
+
+            switch (contentElements[0])
+            {
+                case nameof(WorkflowDockContent):
+                    var workflowPath = contentElements.Length > 1
+                        ? WorkflowEditorPath.Parse(contentElements[1])
+                        : null;
+                    workflowPath?.Resolve(workflowBuilder);
+                    return editorControl.CreateDockContent(workflowPath, DockState.Unknown);
+                default:
+                    ThrowNotRecognizedException(contentString);
+                    return default;
+            }
+        }
+
+        public static string SerializeContent(WorkflowDockContent dockContent)
+        {
+            if (dockContent is null)
+                throw new ArgumentNullException(nameof(dockContent));
+
+            var stringBuilder = new StringBuilder();
+            stringBuilder.Append(nameof(WorkflowDockContent));
+            if (dockContent.WorkflowGraphView.WorkflowPath != null)
+            {
+                stringBuilder.Append(ContentTypeSeparator);
+                stringBuilder.Append(dockContent.WorkflowGraphView.WorkflowPath);
+            }
+            return stringBuilder.ToString();
+        }
+    }
+}

Bonsai.Editor/Docking/InvalidDockContent.cs

@@ -0,0 +1,8 @@
+using WeifenLuo.WinFormsUI.Docking;
+
+namespace Bonsai.Editor.Docking
+{
+    internal class InvalidDockContent : DockContent
+    {
+    }
+}