Merge pull request #25 from idontsov/sub-tree-navigation

Drill-through navigation

Author: bjorkstromm

src/Depends/Depends.csproj

@@ -18,7 +18,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="3.1.8" />
     <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="3.0.0" />
-    <PackageReference Include="Terminal.Gui" Version="0.81.0" />
+    <PackageReference Include="Terminal.Gui" Version="1.3.1" />
     <PackageReference Include="MinVer" Version="2.3.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>

src/Depends/Program.cs

@@ -111,6 +111,16 @@ private void OnExecute()
                 .SetMinimumLevel(Verbosity)
                 .AddConsole());
 
+            var graph = GetDependencyGraph(loggerFactory);
+
+            Application.Init();
+            Application.QuitKey = Key.Esc;
+            Application.Top.Add(new AppWindow(graph));
+            Application.Run();
+        }
+
+        private DependencyGraph GetDependencyGraph(ILoggerFactory loggerFactory)
+        {
             var analyzer = new DependencyAnalyzer(loggerFactory);
             DependencyGraph graph;
             if (!string.IsNullOrEmpty(Package))
@@ -125,140 +135,199 @@ private void OnExecute()
             {
                 graph = analyzer.Analyze(Project, Framework);
             }
+            return graph;
+        }
 
-            Application.Init();
+        private class AppWindow : Window
+        {
+            private readonly DependencyGraph _graph;
+            private readonly ImmutableList<Node> _dependencies;
+            private ImmutableList<Node> _visibleDependencies;
+            private bool _assembliesVisible;
+            private int _lastSelectedDependencyIndex;
+
+            private readonly ListView _dependenciesView;
+            private readonly ListView _runtimeDependsView;
+            private readonly ListView _packageDependsView;
+            private readonly ListView _reverseDependsView;
+
+            class DependsListItemModel
+            {
+                public Node Node { get; }
+                public string DisplayText { get; }
 
-            var top = new CustomWindow();
+                public DependsListItemModel(Node node, string label)
+                {
+                    Node = node ?? throw new ArgumentNullException(nameof(node));
+                    DisplayText = $"{node}{(string.IsNullOrEmpty(label) ? string.Empty : " (Wanted: " + label + ")")}";
+                }
 
-            var left = new FrameView("Dependencies")
-            {
-                Width = Dim.Percent(50),
-                Height = Dim.Fill(1)
-            };
-            var right = new View()
-            {
-                X = Pos.Right(left),
-                Width = Dim.Fill(),
-                Height = Dim.Fill(1)
-            };
-            var helpText = new Label("Use arrow keys and Tab to move around. Ctrl+D to toggle assembly visibility. Esc to quit.")
-            {
-                Y = Pos.AnchorEnd(1)
-            };
+                public override string ToString()
+                {
+                    return DisplayText;
+                }
+            }
 
-            var runtimeDepends = new FrameView("Runtime depends")
-            {
-                Width = Dim.Fill(),
-                Height = Dim.Percent(33f)
-            };
-            var packageDepends = new FrameView("Package depends")
-            {
-                Y = Pos.Bottom(runtimeDepends),
-                Width = Dim.Fill(),
-                Height = Dim.Percent(50f)
-            };
-            var reverseDepends = new FrameView("Reverse depends")
+            public AppWindow(DependencyGraph graph) : base("Depends", 0)
             {
-                Y = Pos.Bottom(packageDepends),
-                Width = Dim.Fill(),
-                Height = Dim.Fill()
-            };
+                _graph = graph ?? throw new ArgumentNullException(nameof(graph));
+                _dependencies = _graph.Nodes.OrderBy(x => x.Id).ToImmutableList();
+                _visibleDependencies = _dependencies;
+                _assembliesVisible = true;
+                _lastSelectedDependencyIndex = -1;
 
-            var orderedDependencyList = graph.Nodes.OrderBy(x => x.Id).ToImmutableList();
-            var dependenciesView = new ListView(orderedDependencyList)
-            {
-                CanFocus = true,
-                AllowsMarking = false
-            };
-            left.Add(dependenciesView);
-            var runtimeDependsView = new ListView(Array.Empty<Node>())
-            {
-                CanFocus = true,
-                AllowsMarking = false
-            };
-            runtimeDepends.Add(runtimeDependsView);
-            var packageDependsView = new ListView(Array.Empty<Node>())
-            {
-                CanFocus = true,
-                AllowsMarking = false
-            };
-            packageDepends.Add(packageDependsView);
-            var reverseDependsView = new ListView(Array.Empty<Node>())
-            {
-                CanFocus = true,
-                AllowsMarking = false
-            };
-            reverseDepends.Add(reverseDependsView);
+                ColorScheme = new ColorScheme
+                {
+                    Focus = Application.Driver.MakeAttribute(Color.Black, Color.White),
+                    Normal = Application.Driver.MakeAttribute(Color.White, Color.Black),
+                    HotFocus = Application.Driver.MakeAttribute(Color.Black, Color.White),
+                    HotNormal = Application.Driver.MakeAttribute(Color.White, Color.Black)
+                };
 
-            right.Add(runtimeDepends, packageDepends, reverseDepends);
-            top.Add(left, right, helpText);
-            Application.Top.Add(top);
+                var left = new FrameView("Dependencies")
+                {
+                    Width = Dim.Percent(50),
+                    Height = Dim.Fill(1)
+                };
+                var right = new View()
+                {
+                    X = Pos.Right(left),
+                    Width = Dim.Fill(),
+                    Height = Dim.Fill(1)
+                };
+                var helpText = new Label("Use arrow keys and Tab to move around. Ctrl+D to toggle assembly visibility. Esc to quit.")
+                {
+                    Y = Pos.AnchorEnd(1)
+                };
 
-            top.Dependencies = orderedDependencyList;
-            top.VisibleDependencies = orderedDependencyList;
-            top.DependenciesView = dependenciesView;
+                var runtimeDepends = new FrameView("Runtime depends")
+                {
+                    Width = Dim.Fill(),
+                    Height = Dim.Percent(33f)
+                };
+                var packageDepends = new FrameView("Package depends")
+                {
+                    Y = Pos.Bottom(runtimeDepends),
+                    Width = Dim.Fill(),
+                    Height = Dim.Percent(33f)
+                };
+                var reverseDepends = new FrameView("Reverse depends")
+                {
+                    Y = Pos.Bottom(packageDepends),
+                    Width = Dim.Fill(),
+                    Height = Dim.Fill()
+                };
+                _dependenciesView = new ListView()
+                {
+                    CanFocus = true,
+                    AllowsMarking = false,
+                    Width = Dim.Fill(),
+                    Height = Dim.Fill()
+                };
+                left.Add(_dependenciesView);
+                _runtimeDependsView = new ListView()
+                {
+                    CanFocus = true,
+                    AllowsMarking = false,
+                    Width = Dim.Fill(),
+                    Height = Dim.Fill()
+                };
+                runtimeDepends.Add(_runtimeDependsView);
+                _packageDependsView = new ListView()
+                {
+                    CanFocus = true,
+                    AllowsMarking = false,
+                    Width = Dim.Fill(),
+                    Height = Dim.Fill()
+                };
+                packageDepends.Add(_packageDependsView);
+                _reverseDependsView = new ListView()
+                {
+                    CanFocus = true,
+                    AllowsMarking = false,
+                    Width = Dim.Fill(),
+                    Height = Dim.Fill()
+                };
+                reverseDepends.Add(_reverseDependsView);
 
-            dependenciesView.SelectedItem = 0;
-            UpdateLists();
+                right.Add(runtimeDepends, packageDepends, reverseDepends);
+                Add(left, right, helpText);
 
-            dependenciesView.SelectedChanged += UpdateLists;
+                _runtimeDependsView.OpenSelectedItem += RuntimeDependsView_OpenSelectedItem;
+                _packageDependsView.OpenSelectedItem += PackageDependsView_OpenSelectedItem;
+                _reverseDependsView.OpenSelectedItem += ReverseDependsView_OpenSelectedItem;
 
-            Application.Run();
+                _dependenciesView.SelectedItemChanged += DependenciesView_SelectedItemChanged; ;
+                _dependenciesView.SetSource(_visibleDependencies);
+            }
 
-            void UpdateLists()
+            public override bool ProcessKey(KeyEvent keyEvent)
             {
-                var selectedNode = top.VisibleDependencies[dependenciesView.SelectedItem];
+                if (keyEvent.Key == (Key.D | Key.CtrlMask))
+                {
+                    _assembliesVisible = !_assembliesVisible;
+                    _visibleDependencies = _assembliesVisible ?
+                        _dependencies :
+                        _dependencies.Where(d => !(d is AssemblyReferenceNode)).ToImmutableList();
 
-                runtimeDependsView.SetSource(graph.Edges.Where(x => x.Start.Equals(selectedNode) && x.End is AssemblyReferenceNode)
-                    .Select(x => x.End).ToImmutableList());
-                packageDependsView.SetSource(graph.Edges.Where(x => x.Start.Equals(selectedNode) && x.End is PackageReferenceNode)
-                    .Select(x => $"{x.End}{(string.IsNullOrEmpty(x.Label) ? string.Empty : " (Wanted: " + x.Label + ")")}").ToImmutableList());
-                reverseDependsView.SetSource(graph.Edges.Where(x => x.End.Equals(selectedNode))
-                    .Select(x => $"{x.Start}{(string.IsNullOrEmpty(x.Label) ? string.Empty : " (Wanted: " + x.Label + ")")}").ToImmutableList());
+                    _dependenciesView.SetSource(_visibleDependencies);
+                    _lastSelectedDependencyIndex = -1;
+                    _dependenciesView.SetFocus();
+                    return true;
+                }
+
+                return base.ProcessKey(keyEvent);
             }
-        }
 
-        private class CustomWindow : Window
-        {
-            public CustomWindow() : base("Depends", 0)
+            private void DependenciesView_SelectedItemChanged(ListViewItemEventArgs args)
             {
-                ColorScheme = new ColorScheme
+                // The ListView.SelectedItemChanged event is fired on enter (focus), see https://github.com/migueldeicaza/gui.cs/issues/831
+                // To keep the current selection in the right pane (runtime, package & reverse depends lists), call UpdateLists() only if the selected item has actually been changed.
+                if(_lastSelectedDependencyIndex != args.Item)
                 {
-                    Focus = Application.Driver.MakeAttribute(Color.Black, Color.White),
-                    Normal = Application.Driver.MakeAttribute(Color.White, Color.Black),
-                    HotFocus = Application.Driver.MakeAttribute(Color.Black, Color.White),
-                    HotNormal = Application.Driver.MakeAttribute(Color.Black, Color.White)
-                };
+                    _lastSelectedDependencyIndex = args.Item;
+                    UpdateLists();
+                }
             }
 
-            public ListView DependenciesView { get; set; }
-            public ImmutableList<Node> Dependencies { get; set; }
-            public ImmutableList<Node> VisibleDependencies { get; set; }
-
-            private bool _assembliesVisible = true;
-
-            public override bool ProcessKey(KeyEvent keyEvent)
+            private void RuntimeDependsView_OpenSelectedItem(ListViewItemEventArgs args)
             {
-                if (keyEvent.Key == Key.Esc)
+                if(_assembliesVisible)
                 {
-                    Application.RequestStop();
-                    return true;
+                    SetSelectedDependency((Node)args.Value);
                 }
-                if (keyEvent.Key == Key.ControlD)
-                {
-                    _assembliesVisible = !_assembliesVisible;
+                // else: would be nice to provide a feedback so that the user understands that navigation is not possible.
+            }
 
-                    VisibleDependencies = _assembliesVisible ?
-                        Dependencies :
-                        Dependencies.Where(d => !(d is AssemblyReferenceNode)).ToImmutableList();
+            private void PackageDependsView_OpenSelectedItem(ListViewItemEventArgs args)
+            {
+                var node = ((DependsListItemModel)args.Value).Node;
+                SetSelectedDependency(node);
+            }
 
-                    DependenciesView.SetSource(VisibleDependencies);
+            private void ReverseDependsView_OpenSelectedItem(ListViewItemEventArgs args)
+            {
+                var node = ((DependsListItemModel)args.Value).Node;
+                SetSelectedDependency(node);
+            }
 
-                    DependenciesView.SelectedItem = 0;
-                    return true;
-                }
+            private void SetSelectedDependency(Node node)
+            {
+                var index = _visibleDependencies.FindIndex(x => x.Equals(node));
+                _dependenciesView.SelectedItem = index;
+                _dependenciesView.SetFocus();
+            }
 
-                return base.ProcessKey(keyEvent);
+            private void UpdateLists()
+            {
+                var selectedNode = _visibleDependencies[_dependenciesView.SelectedItem];
+
+                _runtimeDependsView.SetSource(_graph.Edges.Where(x => x.Start.Equals(selectedNode) && x.End is AssemblyReferenceNode)
+                    .Select(x => x.End).ToImmutableList());
+                _packageDependsView.SetSource(_graph.Edges.Where(x => x.Start.Equals(selectedNode) && x.End is PackageReferenceNode)
+                    .Select(x => new DependsListItemModel(x.End, x.Label)).ToImmutableList());
+                _reverseDependsView.SetSource(_graph.Edges.Where(x => x.End.Equals(selectedNode))
+                    .Select(x => new DependsListItemModel(x.Start, x.Label)).ToImmutableList());
             }
         }
     }