Bold lables if a node is collapsed and has children

ATrefzer · ATrefzer · commit 745f0547a51f · 2025-10-19T18:35:53.000+02:00
diff --git a/CSharpCodeAnalyst/Areas/GraphArea/MsaglBuilderBase.cs b/CSharpCodeAnalyst/Areas/GraphArea/MsaglBuilderBase.cs
@@ -100,7 +100,7 @@ private static Color ToColor(int colorValue)
         return new Color((byte)r, (byte)g, (byte)b);
     }
 
-    protected static Node CreateNode(Graph graph, CodeElement codeElement, PresentationState presentationState)
+    protected virtual Node CreateNode(Graph graph, CodeElement codeElement, PresentationState presentationState)
     {
         var node = graph.AddNode(codeElement.Id);
         node.LabelText = codeElement.Name;
diff --git a/CSharpCodeAnalyst/Areas/GraphArea/MsaglFlatBuilder.cs b/CSharpCodeAnalyst/Areas/GraphArea/MsaglFlatBuilder.cs
@@ -12,7 +12,7 @@ public override Graph CreateGraph(CodeGraph codeGraph, PresentationState present
         return CreateFlatGraph(codeGraph, presentationState, showInformationFlow, hideFilter);
     }
 
-    private static Graph CreateFlatGraph(CodeGraph codeGraph, PresentationState presentationState, bool showInformationFlow, GraphHideFilter hideFilter)
+    private Graph CreateFlatGraph(CodeGraph codeGraph, PresentationState presentationState, bool showInformationFlow, GraphHideFilter hideFilter)
     {
         // Since we start with a fresh graph we don't need to check for existing nodes and edges.
 
diff --git a/CSharpCodeAnalyst/Areas/GraphArea/MsaglHierarchicalBuilder.cs b/CSharpCodeAnalyst/Areas/GraphArea/MsaglHierarchicalBuilder.cs
@@ -64,7 +64,20 @@ private static void CollectVisibleNodes(CodeElement root, PresentationState stat
         }
     }
 
-    private static void AddNodesToHierarchicalGraph(Graph graph, CodeGraph visibleGraph, CodeGraph codeGraph,
+    protected override Node CreateNode(Graph graph, CodeElement codeElement, PresentationState presentationState)
+    {
+        var node = base.CreateNode(graph, codeElement, presentationState);
+
+        if (codeElement.Children.Any() && presentationState.IsCollapsed(codeElement.Id))
+        {
+            // This is a collapsed node. Show bold if it hides children and can be expanded.
+            node.Label.FontStyle = FontStyle.Bold;
+        }
+
+        return node;
+    }
+
+    private void AddNodesToHierarchicalGraph(Graph graph, CodeGraph visibleGraph, CodeGraph codeGraph,
         Dictionary<string, Subgraph> subGraphs, PresentationState presentationState)
     {
         // Add nodes and sub graphs. Each node that has children becomes a subgraph.
@@ -99,7 +112,7 @@ private static void AddSubgraphToParent(Graph graph, CodeElement visibleNode, Su
         }
     }
 
-    private static void AddNodeToParent(Graph graph, CodeElement node, Dictionary<string, Subgraph> subGraphs, PresentationState presentationState)
+    private void AddNodeToParent(Graph graph, CodeElement node, Dictionary<string, Subgraph> subGraphs, PresentationState presentationState)
     {
         var newNode = CreateNode(graph, node, presentationState);
         if (node.Parent != null)
diff --git a/CSharpCodeAnalyst/AssemblyInfo.cs b/CSharpCodeAnalyst/AssemblyInfo.cs
@@ -1,4 +1,5 @@
 using System.Windows;
+using System.Runtime.CompilerServices;
 
 [assembly: ThemeInfo(
     ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
@@ -7,4 +8,7 @@
     ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
     //(used if a resource is not found in the page,
     // app, or any theme specific resource dictionaries)
-)]
+)]
+
+// Allow test project to access internal types for unit testing (e.g., MsaglHierarchicalBuilder)
+[assembly: InternalsVisibleTo("Tests")]
diff --git a/CSharpCodeAnalyst/MainViewModel.cs b/CSharpCodeAnalyst/MainViewModel.cs
@@ -1047,15 +1047,10 @@ private void RestoreProjectData(ProjectData projectData)
         // Restore analyzer data
         _analyzerManager.RestoreAnalyzerData(projectData.AnalyzerData);
     }
-
-    
-    
-    
-    
     
     public void ClearQuickInfo()
     {
         _infoPanelViewModel?.ClearQuickInfo();
-        _graphViewModel.ClearQuickInfo();
+        _graphViewModel?.ClearQuickInfo();
     }
 }
diff --git a/ReferencedAssemblies/Microsoft.Msagl.Drawing.dll b/ReferencedAssemblies/Microsoft.Msagl.Drawing.dll
diff --git a/ReferencedAssemblies/Microsoft.Msagl.GraphViewerGdi.dll b/ReferencedAssemblies/Microsoft.Msagl.GraphViewerGdi.dll
diff --git a/ReferencedAssemblies/Microsoft.Msagl.WpfGraphControl.dll b/ReferencedAssemblies/Microsoft.Msagl.WpfGraphControl.dll
diff --git a/ReferencedAssemblies/Microsoft.Msagl.dll b/ReferencedAssemblies/Microsoft.Msagl.dll
diff --git a/ReferencedAssemblies/Note.md b/ReferencedAssemblies/Note.md
@@ -1,9 +1,15 @@
 This folder contains the MSAGL assemblies.
 
-Instead of the NUGET package, a modified version built from the fork https://github.com/ATrefzer/automatic-graph-layout (branch: `csharp-code-analyst-changes`) is used.
+Instead of the NUGET package, a modified version built from the fork https://github.com/ATrefzer/automatic-graph-layout (branch: csharp-code-analyst-changes) is used.
 
 **Changes**
 
-- Hide the collapse button for subgraphs by default and use a context menu for collapse/expand. The original repository had bugs, which are now resolved. However, this approach has the added benefit of enabling lazy loading, allowing handling of very large graphs that are initially collapsed.
+- Hide the collapse button for subgraphs by default. I use now my own mechanism to collapse/expand. The original repository had bugs, making it unusable. Instead, I handle collapse now by rendering a completely new graph. This approach has the added benefit of enabling lazy loading, allowing handling of huge graphs that are initially collapsed.
 - Performance optimized Canvas
+- Added possibility to use font styles for the labels.
 
+
+
+**Note**
+
+Compile Samples\WpfApplicationSample to get all assemblies at once.
diff --git a/Tests/Tests.csproj b/Tests/Tests.csproj
@@ -23,6 +23,15 @@
         <ProjectReference Include="..\CSharpCodeAnalyst\CSharpCodeAnalyst.csproj"/>
     </ItemGroup>
 
+    <ItemGroup>
+        <Reference Include="Microsoft.Msagl">
+            <HintPath>..\ReferencedAssemblies\Microsoft.Msagl.dll</HintPath>
+        </Reference>
+        <Reference Include="Microsoft.Msagl.Drawing">
+            <HintPath>..\ReferencedAssemblies\Microsoft.Msagl.Drawing.dll</HintPath>
+        </Reference>
+    </ItemGroup>
+
     <ItemGroup>
         <Using Include="NUnit.Framework"/>
     </ItemGroup>
diff --git a/Tests/UnitTests/Export/CodeGraphSerializerTests.cs b/Tests/UnitTests/Export/CodeGraphSerializerTests.cs
@@ -0,0 +1,101 @@
+using System.Text;
+using Contracts.Graph;
+
+namespace CodeParserTests.UnitTests.Export;
+
+[TestFixture]
+public class CodeGraphSerializerTests
+{
+    private CodeGraph CreateSampleGraph()
+    {
+        var g = new CodeGraph();
+        var asm = new CodeElement("Asm", CodeElementType.Assembly, "Asm", "Asm", null);
+        var ns = new CodeElement("Ns", CodeElementType.Namespace, "Ns", "Ns", asm);
+        var cls = new CodeElement("Cls", CodeElementType.Class, "Cls", "Ns.Cls", ns);
+        var method = new CodeElement("M", CodeElementType.Method, "M", "Ns.Cls.M", cls);
+        var field = new CodeElement("F", CodeElementType.Field, "F", "Ns.Cls.F", cls);
+
+        asm.Children.Add(ns);
+        ns.Children.Add(cls);
+        cls.Children.Add(method);
+        cls.Children.Add(field);
+        g.Nodes[asm.Id] = asm;
+        g.Nodes[ns.Id] = ns;
+        g.Nodes[cls.Id] = cls;
+        g.Nodes[method.Id] = method;
+        g.Nodes[field.Id] = field;
+
+        // attributes + external + locations
+        cls.Attributes.Add("Serializable");
+        method.SourceLocations.Add(new SourceLocation("file1.cs", 10, 5));
+        method.SourceLocations.Add(new SourceLocation("file1.cs", 12, 15));
+        field.IsExternal.Equals(false); // just keep reference
+
+        // relationships
+        var rel1 = new Relationship(method.Id, field.Id, RelationshipType.Uses, RelationshipAttribute.IsInstanceCall | RelationshipAttribute.IsMethodGroup);
+        rel1.SourceLocations.Add(new SourceLocation("file1.cs", 20, 3));
+        method.Relationships.Add(rel1);
+
+        return g;
+    }
+
+    [Test]
+    public void SerializeDeserialize_RoundTrip_MatchesStructure()
+    {
+        var g = CreateSampleGraph();
+        var text = CodeGraphSerializer.Serialize(g);
+        var restored = CodeGraphSerializer.Deserialize(text);
+
+        Assert.That(restored.Nodes.Count, Is.EqualTo(g.Nodes.Count));
+
+        foreach (var id in g.Nodes.Keys)
+        {
+            Assert.That(restored.Nodes.ContainsKey(id), $"Missing node {id}");
+            var orig = g.Nodes[id];
+            var copy = restored.Nodes[id];
+            Assert.That(copy.ElementType, Is.EqualTo(orig.ElementType));
+            Assert.That(copy.Name, Is.EqualTo(orig.Name));
+            Assert.That(copy.FullName, Is.EqualTo(orig.FullName));
+            Assert.That(copy.Parent?.Id, Is.EqualTo(orig.Parent?.Id));
+            CollectionAssert.AreEquivalent(orig.Attributes, copy.Attributes);
+            CollectionAssert.AreEquivalent(orig.SourceLocations, copy.SourceLocations);
+        }
+
+        // Relationship checks (only one in sample)
+        var restoredMethod = restored.Nodes["M"];
+        Assert.That(restoredMethod.Relationships.Count, Is.EqualTo(1));
+        var r = restoredMethod.Relationships.First();
+        Assert.That(r.SourceId, Is.EqualTo("M"));
+        Assert.That(r.TargetId, Is.EqualTo("F"));
+        Assert.That(r.Type, Is.EqualTo(RelationshipType.Uses));
+        Assert.That(r.Attributes.HasFlag(RelationshipAttribute.IsInstanceCall));
+        Assert.That(r.Attributes.HasFlag(RelationshipAttribute.IsMethodGroup));
+        Assert.That(r.SourceLocations.Count, Is.EqualTo(1));
+    }
+
+    [Test]
+    public void Deserialize_InvalidLine_Throws()
+    {
+        var invalid = "BogusLine"; // not enough parts
+        Assert.Throws<InvalidOperationException>(() => CodeGraphSerializer.Deserialize(invalid));
+    }
+
+    [Test]
+    public void Deserialize_BadLocationFormat_Throws()
+    {
+        var sb = new StringBuilder();
+        sb.AppendLine("Class A");
+        sb.AppendLine("loc=fileonly-no-line");
+        var txt = sb.ToString();
+        Assert.Throws<InvalidOperationException>(() => CodeGraphSerializer.Deserialize(txt));
+    }
+
+    [Test]
+    public void Serialize_DeterministicOrdering()
+    {
+        var g = CreateSampleGraph();
+        var t1 = CodeGraphSerializer.Serialize(g);
+        var t2 = CodeGraphSerializer.Serialize(g);
+        Assert.That(t1, Is.EqualTo(t2));
+    }
+}
diff --git a/Tests/UnitTests/Graph/MsaglHierarchicalBuilderTests.cs b/Tests/UnitTests/Graph/MsaglHierarchicalBuilderTests.cs
@@ -0,0 +1,118 @@
+using Contracts.Graph;
+using CSharpCodeAnalyst.Areas.GraphArea;
+using CSharpCodeAnalyst.Areas.GraphArea.Filtering;
+
+namespace CodeParserTests.UnitTests.Graph;
+
+[TestFixture]
+public class MsaglHierarchicalBuilderTests
+{
+    private CodeGraph BuildHierarchy()
+    {
+        var g = new CodeGraph();
+        var asm = new CodeElement("Asm", CodeElementType.Assembly, "Asm", "Asm", null);
+        var ns = new CodeElement("Ns", CodeElementType.Namespace, "Ns", "Ns", asm);
+        var cls = new CodeElement("Cls", CodeElementType.Class, "Cls", "Ns.Cls", ns);
+        var methodA = new CodeElement("M1", CodeElementType.Method, "M1", "Ns.Cls.M1", cls);
+        var methodB = new CodeElement("M2", CodeElementType.Method, "M2", "Ns.Cls.M2", cls);
+        asm.Children.Add(ns);
+        ns.Children.Add(cls);
+        cls.Children.Add(methodA);
+        cls.Children.Add(methodB);
+        g.Nodes[asm.Id] = asm;
+        g.Nodes[ns.Id] = ns;
+        g.Nodes[cls.Id] = cls;
+        g.Nodes[methodA.Id] = methodA;
+        g.Nodes[methodB.Id] = methodB;
+        // Relationships M1 -> M2
+        methodA.Relationships.Add(new Relationship(methodA.Id, methodB.Id, RelationshipType.Calls));
+        return g;
+    }
+
+    private (MsaglHierarchicalBuilder builder, PresentationState state, GraphHideFilter filter) CreateBuilder()
+    {
+        var state = new PresentationState();
+        var builder = new MsaglHierarchicalBuilder();
+        var filter = new GraphHideFilter();
+        return (builder, state, filter);
+    }
+
+    [Test]
+    public void CollapsedClass_HidesChildren()
+    {
+        var g = BuildHierarchy();
+        var (builder, state, filter) = CreateBuilder();
+        state.SetCollapsedState("Cls", true); // collapse class -> methods hidden
+        var msagl = builder.CreateGraph(g, state, false, filter);
+
+        // Graph should have nodes: Asm, Ns, Cls only
+        var ids = msagl.Nodes.Select(n => n.Id).ToHashSet();
+        CollectionAssert.AreEquivalent(new[] { "Cls" }, ids);
+
+        // Nodes with children are subgraphs: Asm, Ns, Cls
+        var subGraphs = msagl.SubgraphMap.Values.Select(s => s.LabelText);
+        CollectionAssert.AreEquivalent(new[] { "Asm", "Ns", "the root subgraph's boundary" }, subGraphs);
+    }
+
+    [Test]
+    public void ExpandedClass_ShowsChildren()
+    {
+        var g = BuildHierarchy();
+        var (builder, state, filter) = CreateBuilder();
+        var msagl = builder.CreateGraph(g, state, false, filter);
+
+        var ids = msagl.Nodes.Select(n => n.Id).ToHashSet();
+        CollectionAssert.AreEquivalent(new[] { "M1", "M2" }, ids);
+
+        // Nodes with children are subgraphs: Asm, Ns, Cls
+        var subGraphs = msagl.SubgraphMap.Values.Select(s => s.LabelText);
+        CollectionAssert.AreEquivalent(new[] { "Asm", "Ns", "Cls", "the root subgraph's boundary" }, subGraphs);
+    }
+
+    [Test]
+    public void EdgeBundling_WhenCollapsed()
+    {
+        var g = BuildHierarchy();
+        var (builder, state, filter) = CreateBuilder();
+        // Add second edge M2->M1 so when collapsed they bundle between Cls and Cls (self) -> removed
+        var m2 = g.Nodes["M2"];
+        var m1 = g.Nodes["M1"];
+        m2.Relationships.Add(new Relationship(m2.Id, m1.Id, RelationshipType.Calls));
+        state.SetCollapsedState("Cls", true);
+        var msagl = builder.CreateGraph(g, state, false, filter);
+        // No edge expected because both directions collapse into same container
+        Assert.That(msagl.Edges.Count(), Is.EqualTo(0));
+    }
+
+    [Test]
+    public void InformationFlow_ReversesHandlesOverridesImplements()
+    {
+        var g = new CodeGraph();
+        var clsA = new CodeElement("A", CodeElementType.Class, "A", "A", null);
+        var clsB = new CodeElement("B", CodeElementType.Class, "B", "B", null);
+        g.Nodes[clsA.Id] = clsA;
+        g.Nodes[clsB.Id] = clsB;
+        clsA.Relationships.Add(new Relationship(clsA.Id, clsB.Id, RelationshipType.Overrides));
+        var (builder, state, filter) = CreateBuilder();
+        var graphNormal = builder.CreateGraph(g, state, false, filter);
+        var edgeNormal = graphNormal.Edges.First();
+        Assert.That(edgeNormal.Source, Is.EqualTo("A"));
+        Assert.That(edgeNormal.Target, Is.EqualTo("B"));
+        var graphFlow = builder.CreateGraph(g, state, true, filter);
+        var edgeFlow = graphFlow.Edges.First();
+        Assert.That(edgeFlow.Source, Is.EqualTo("B"));
+        Assert.That(edgeFlow.Target, Is.EqualTo("A"));
+    }
+
+    [Test]
+    public void HideFilter_ExcludesHiddenElementsAndRelationships()
+    {
+        var g = BuildHierarchy();
+        var (builder, state, filter) = CreateBuilder();
+        filter.HiddenElementTypes.Add(CodeElementType.Method);
+        var msagl = builder.CreateGraph(g, state, false, filter);
+        var ids = msagl.Nodes.Select(n => n.Id).ToHashSet();
+        Assert.That(ids.Contains("M1"), Is.False);
+        Assert.That(ids.Contains("M2"), Is.False);
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ private static Color ToColor(int colorValue)`
`100`	`100`	`return new Color((byte)r, (byte)g, (byte)b);`
`101`	`101`	`}`
`102`	`102`
`103`		`- protected static Node CreateNode(Graph graph, CodeElement codeElement, PresentationState presentationState)`
	`103`	`+ protected virtual Node CreateNode(Graph graph, CodeElement codeElement, PresentationState presentationState)`
`104`	`104`	`{`
`105`	`105`	`var node = graph.AddNode(codeElement.Id);`
`106`	`106`	`node.LabelText = codeElement.Name;`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public override Graph CreateGraph(CodeGraph codeGraph, PresentationState present`
`12`	`12`	`return CreateFlatGraph(codeGraph, presentationState, showInformationFlow, hideFilter);`
`13`	`13`	`}`
`14`	`14`
`15`		`- private static Graph CreateFlatGraph(CodeGraph codeGraph, PresentationState presentationState, bool showInformationFlow, GraphHideFilter hideFilter)`
	`15`	`+ private Graph CreateFlatGraph(CodeGraph codeGraph, PresentationState presentationState, bool showInformationFlow, GraphHideFilter hideFilter)`
`16`	`16`	`{`
`17`	`17`	`// Since we start with a fresh graph we don't need to check for existing nodes and edges.`
`18`	`18`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,20 @@ private static void CollectVisibleNodes(CodeElement root, PresentationState stat`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`
`67`		`- private static void AddNodesToHierarchicalGraph(Graph graph, CodeGraph visibleGraph, CodeGraph codeGraph,`
	`67`	`+ protected override Node CreateNode(Graph graph, CodeElement codeElement, PresentationState presentationState)`
	`68`	`+ {`
	`69`	`+ var node = base.CreateNode(graph, codeElement, presentationState);`
	`70`	`+`
	`71`	`+ if (codeElement.Children.Any() && presentationState.IsCollapsed(codeElement.Id))`
	`72`	`+ {`
	`73`	`+ // This is a collapsed node. Show bold if it hides children and can be expanded.`
	`74`	`+ node.Label.FontStyle = FontStyle.Bold;`
	`75`	`+ }`
	`76`	`+`
	`77`	`+ return node;`
	`78`	`+ }`
	`79`	`+`
	`80`	`+ private void AddNodesToHierarchicalGraph(Graph graph, CodeGraph visibleGraph, CodeGraph codeGraph,`
`68`	`81`	`Dictionary<string, Subgraph> subGraphs, PresentationState presentationState)`
`69`	`82`	`{`
`70`	`83`	`// Add nodes and sub graphs. Each node that has children becomes a subgraph.`
`@@ -99,7 +112,7 @@ private static void AddSubgraphToParent(Graph graph, CodeElement visibleNode, Su`
`99`	`112`	`}`
`100`	`113`	`}`
`101`	`114`
`102`		`- private static void AddNodeToParent(Graph graph, CodeElement node, Dictionary<string, Subgraph> subGraphs, PresentationState presentationState)`
	`115`	`+ private void AddNodeToParent(Graph graph, CodeElement node, Dictionary<string, Subgraph> subGraphs, PresentationState presentationState)`
`103`	`116`	`{`
`104`	`117`	`var newNode = CreateNode(graph, node, presentationState);`
`105`	`118`	`if (node.Parent != null)`
Original file line number	Diff line number	Diff line change
`@@ -1047,15 +1047,10 @@ private void RestoreProjectData(ProjectData projectData)`
`1047`	`1047`	`// Restore analyzer data`
`1048`	`1048`	`_analyzerManager.RestoreAnalyzerData(projectData.AnalyzerData);`
`1049`	`1049`	`}`
`1050`		`-`
`1051`		`-`
`1052`		`-`
`1053`		`-`
`1054`		`-`
`1055`	`1050`
`1056`	`1051`	`public void ClearQuickInfo()`
`1057`	`1052`	`{`
`1058`	`1053`	`_infoPanelViewModel?.ClearQuickInfo();`
`1059`		`- _graphViewModel.ClearQuickInfo();`
	`1054`	`+ _graphViewModel?.ClearQuickInfo();`
`1060`	`1055`	`}`
`1061`	`1056`	`}`