Rewrite editor navigation model

  - Add workflow explorer treeview
  - Allow navigating to any level without opening previous levels
  - Allow visualizers to run uncoupled from the workflow view
  - Highlight build errors in explorer treeview

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

@@ -51,7 +51,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/GraphModel/WorkflowBuilderExtensions.cs

@@ -91,47 +91,6 @@ public static IEnumerable<ContextGrouping> GetDependentExpressions(this SubjectD
                 }
             }
         }
-
-        public static ExpressionScope GetExpressionScope(this WorkflowBuilder source, ExpressionBuilder target)
-        {
-            return GetExpressionScope(source.Workflow, target);
-        }
-
-        static ExpressionScope GetExpressionScope(ExpressionBuilderGraph source, ExpressionBuilder target)
-        {
-            foreach (var node in source)
-            {
-                var builder = ExpressionBuilder.Unwrap(node.Value);
-                if (builder == target)
-                {
-                    return new ExpressionScope(node.Value, innerScope: null);
-                }
-
-                if (builder is IWorkflowExpressionBuilder workflowBuilder)
-                {
-                    var innerScope = GetExpressionScope(workflowBuilder.Workflow, target);
-                    if (innerScope != null)
-                    {
-                        return new ExpressionScope(node.Value, innerScope);
-                    }
-                }
-            }
-
-            return null;
-        }
-    }
-
-    class ExpressionScope
-    {
-        public ExpressionScope(ExpressionBuilder value, ExpressionScope innerScope)
-        {
-            Value = value;
-            InnerScope = innerScope;
-        }
-
-        public ExpressionBuilder Value { get; }
-
-        public ExpressionScope InnerScope { get; }
     }
 
     class SubjectDefinition

Bonsai.Editor/GraphModel/WorkflowEditor.cs

@@ -20,10 +20,10 @@ class WorkflowEditor
         readonly IGraphView graphView;
         readonly Subject<Exception> error;
         readonly Subject<bool> updateLayout;
-        readonly Subject<bool> updateParentLayout;
         readonly Subject<bool> invalidateLayout;
         readonly Subject<IEnumerable<ExpressionBuilder>> updateSelection;
         readonly Subject<IWorkflowExpressionBuilder> closeWorkflowEditor;
+        WorkflowEditorPath workflowPath;
 
         public WorkflowEditor(IServiceProvider provider, IGraphView view)
         {
@@ -32,20 +32,47 @@ public WorkflowEditor(IServiceProvider provider, IGraphView view)
             commandExecutor = (CommandExecutor)provider.GetService(typeof(CommandExecutor));
             error = new Subject<Exception>();
             updateLayout = new Subject<bool>();
-            updateParentLayout = new Subject<bool>();
             invalidateLayout = new Subject<bool>();
             updateSelection = new Subject<IEnumerable<ExpressionBuilder>>();
             closeWorkflowEditor = new Subject<IWorkflowExpressionBuilder>();
+            WorkflowPath = null;
         }
 
-        public ExpressionBuilderGraph Workflow { get; set; }
+        public ExpressionBuilderGraph Workflow { get; private set; }
+
+        public bool IsReadOnly { get; private set; }
+
+        public WorkflowEditorPath WorkflowPath
+        {
+            get { return workflowPath; }
+            set
+            {
+                workflowPath = value;
+                var workflowBuilder = (WorkflowBuilder)serviceProvider.GetService(typeof(WorkflowBuilder));
+                if (workflowPath != null)
+                {
+                    var builder = ExpressionBuilder.Unwrap(workflowPath.Resolve(workflowBuilder, out bool isReadOnly));
+                    if (builder is not IWorkflowExpressionBuilder workflowExpressionBuilder)
+                    {
+                        throw new ArgumentException(Resources.InvalidWorkflowPath_Error, nameof(value));
+                    }
+
+                    Workflow = workflowExpressionBuilder.Workflow;
+                    IsReadOnly = isReadOnly;
+                }
+                else
+                {
+                    Workflow = workflowBuilder.Workflow;
+                    IsReadOnly = false;
+                }
+                updateLayout.OnNext(false);
+            }
+        }
 
         public IObservable<Exception> Error => error;
 
         public IObservable<bool> UpdateLayout => updateLayout;
 
-        public IObservable<bool> UpdateParentLayout => updateParentLayout;
-
         public IObservable<bool> InvalidateLayout => invalidateLayout;
 
         public IObservable<IEnumerable<ExpressionBuilder>> UpdateSelection => updateSelection;
@@ -170,8 +197,6 @@ private void AddWorkflowInput(ExpressionBuilderGraph workflow, Node<ExpressionBu
                         inputBuilder.Index++;
                     }
                 }
-
-                updateParentLayout.OnNext(false);
             }
         }
 
@@ -187,8 +212,6 @@ private void RemoveWorkflowInput(ExpressionBuilderGraph workflow, Node<Expressio
                         inputBuilder.Index--;
                     }
                 }
-
-                updateParentLayout.OnNext(false);
             }
         }
 
@@ -2069,6 +2092,23 @@ public GraphNode FindGraphNode(ExpressionBuilder value)
         {
             return graphView.Nodes.SelectMany(layer => layer).FirstOrDefault(n => n.Value == value);
         }
+
+        public void NavigateTo(WorkflowEditorPath path)
+        {
+            if (path == workflowPath)
+                return;
+
+            var previousPath = workflowPath;
+            var selectedNodes = graphView.SelectedNodes.ToArray();
+            var restoreSelectedNodes = CreateUpdateSelectionDelegate(selectedNodes);
+            commandExecutor.Execute(
+                () => WorkflowPath = path,
+                () =>
+                {
+                    WorkflowPath = previousPath;
+                    restoreSelectedNodes();
+                });
+        }
     }
 
     enum CreateGraphNodeType