Merge remote-tracking branch 'origin/program_graph_updates2--SQUASHED'

.gitignore

@@ -69,3 +69,16 @@ Release
 */*/*/*/src-gen
 */*/*/*/model/generated
 */*/*/*/test-bin
+
+# Ignore Intellij metadata
+**/*.iml
+**/.idea
+*.iml
+.idea
+
+# Ignore gradle wrapper files
+gradle/wrapper
+gradlew
+gradlew.*
+
+

Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/graph/AddressBasedGraphDisplayListener.java

@@ -19,7 +19,10 @@ import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import ghidra.app.cmd.label.AddLabelCmd;
+import ghidra.app.cmd.label.RenameLabelCmd;
 import ghidra.app.events.*;
+import ghidra.framework.cmd.Command;
 import ghidra.framework.model.*;
 import ghidra.framework.plugintool.PluginEvent;
 import ghidra.framework.plugintool.PluginTool;
@@ -161,6 +164,21 @@ public abstract class AddressBasedGraphDisplayListener
 		return p == program;
 	}
 
+	@Override
+	public boolean updateVertexName(String vertexId, String oldName, String newName) {
+		Address address = getAddressForVertexId(vertexId);
+		Symbol symbol = program.getSymbolTable().getPrimarySymbol(address);
+
+		Command command;
+		if (symbol != null) {
+			command = new RenameLabelCmd(address, oldName, newName, SourceType.USER_DEFINED);
+		}
+		else {
+			command = new AddLabelCmd(address, newName, SourceType.USER_DEFINED);
+		}
+		return tool.execute(command, program);
+	}
+
 	@Override
 	public void domainObjectChanged(DomainObjectChangedEvent ev) {
 		if (!(ev.containsEvent(ChangeManager.DOCR_SYMBOL_ADDED) ||

Ghidra/Features/GraphServices/Module.manifest

@@ -1,7 +1,9 @@
 EXCLUDE FROM GHIDRA JAR: true
 
-MODULE FILE LICENSE: lib/jungrapht-visualization-1.0-RC8.jar BSD
+MODULE FILE LICENSE: lib/jungrapht-visualization-1.0-SNAPSHOT.jar BSD
-MODULE FILE LICENSE: lib/jgrapht-core-1.4.0.jar LGPL 2.1
+MODULE FILE LICENSE: lib/jgrapht-core-1.5.0.jar LGPL 2.1
-MODULE FILE LICENSE: lib/jgrapht-io-1.4.0.jar LGPL 2.1
+MODULE FILE LICENSE: lib/jgrapht-io-1.5.0.jar LGPL 2.1
 MODULE FILE LICENSE: lib/jheaps-0.11.jar Apache License 2.0
+MODULE FILE LICENSE: lib/log4j-slf4j-impl-2.12.1.jar Apache License 2.0
 MODULE FILE LICENSE: lib/slf4j-api-1.7.25.jar MIT
+MODULE FILE LICENSE: lib/slf4j-nop-1.7.25.jar MIT

Ghidra/Features/GraphServices/build.gradle

@@ -11,13 +11,17 @@ eclipse.project.name = 'Features Graph Services'
 dependencies {
 	compile project(":Base")
 
-	compile "com.github.tomnelson:jungrapht-visualization:1.0-RC8"
+	compile "com.github.tomnelson:jungrapht-visualization:1.0-RC9"
-	compile "org.jgrapht:jgrapht-core:1.4.0"
+	compile "com.github.tomnelson:jungrapht-layout:1.0-RC9"
+	compile "org.jgrapht:jgrapht-core:1.5.0"
 	
 	// not using jgrapht-io code that depends on antlr, so exclude antlr
-	compile ("org.jgrapht:jgrapht-io:1.4.0") { exclude group: "org.antlr", module: "antlr4-runtime" }
+	compile ("org.jgrapht:jgrapht-io:1.5.0") { exclude group: "org.antlr", module: "antlr4-runtime" }
 	runtime "org.slf4j:slf4j-api:1.7.25"
+	// use this if you want no slf4j log messages
 	runtime "org.slf4j:slf4j-nop:1.7.25"
+	// use this if you want slf4j log messages sent to log4j
+//	runtime "org.apache.logging.log4j:log4j-slf4j-impl:2.12.1"
 	runtime "org.jheaps:jheaps:0.11"
       
 	helpPath project(path: ":Base", configuration: 'helpPath')

Ghidra/Features/GraphServices/certification.manifest

@@ -15,6 +15,7 @@ src/main/help/help/topics/GraphServices/GraphDisplay.htm||GHIDRA||||END|
 src/main/help/help/topics/GraphServices/GraphExport.htm||GHIDRA||||END|
 src/main/help/help/topics/GraphServices/images/DefaultGraphDisplay.png||GHIDRA||||END|
 src/main/help/help/topics/GraphServices/images/ExportDialog.png||GHIDRA||||END|
+src/main/resources/images/Lasso.png||GHIDRA||||END|
 src/main/resources/images/magnifier.png||FAMFAMFAM Icons - CC 2.5|||famfamfam silk icon set|END|
 src/main/resources/images/redspheregraph.png||GHIDRA||||END|
 src/main/resources/images/sat2.png||GHIDRA||||END|

Ghidra/Features/GraphServices/src/main/help/help/topics/GraphServices/GraphDisplay.htm

@@ -27,6 +27,8 @@
     <ul>
       <li>MouseButton1+drag will translate the display in the x and y axis</li>
       <li>Mouse Wheel will zoom in and out</li>
+      <li>CTRL+Mouse Wheel will zoom in and out in the X-Axis only</li>
+      <li>ALT+Mouse Wheel will zoom in and out in the Y-Axis only</li>
       <li>Ctrl+MouseButton1 will select a vertex or edge</li>
       <ul>
         <li>Shift+Ctrl+MouseButton1 over an unselected vertex will add that vertex to the selection</li>
@@ -37,30 +39,41 @@
     </ul>
     <H2>Upper-right Icon Buttons:</H2>
     <ul>
-      <li>The <IMG src="images/fingerPointer.png"> toggle button, when 'set' will cause a located vertex (red arrow) to be scrolled to the center of the view</li>
+      <li>The <IMG src="images/locationIn.gif"> toggle button, when 'set' will cause a located vertex (red arrow) to be scrolled to the center of the view</li>
-      <li>The <IMG src="images/sat2.png" width="16" height="16"> button will open a satellite mini view of the graph in the lower right corner. The mini-view can be manipulated with the mouse to affect the main view</li>
+      <li>The <IMG src="images/Lasso.png" width="16" height="16"> toggle button, when 'set' will allow the user to draw a free-form shape that encloses the vertices they wish to select.
+      <li>The <IMG src="images/sat2.png" width="16" height="16"> toggle button, when 'set' will open a satellite mini view of the graph in the lower right corner. The mini-view can be manipulated with the mouse to affect the main view</li>
       <li>The <IMG src="images/reload3.png"> button will reset any visual transformations on the graph and center it at a best-effort size</li>
-      <li>The <IMG src="images/magnifier.png"> button will open a rectangular magnification lens in the graph view</li>
+      <li>The <IMG src="images/magnifier.png"> toggle button, when 'set' will open a rectangular magnification lens in the graph view</li>
       <ul>
         <li>MouseButton1 click-drag on the lens center circle to move the magnifier lens</li>
         <li>MouseButton1 click-draw on a lens edge diamond to resize the magnifier lens </li>
         <li>MouseButton1 click on the upper-right circle-cross to dispose of the magnifier lens</li>
-        <li>Ctrl-MouseWheel to change the magnification of the lens</li>
+        <li>MouseWheel will change the magnification of the lens</li>
       </ul>
-      <li>The <IMG src="images/view-filter.png"> button will open a Filter dialog. Select buttons in the dialog to hide specific vertices or edges in the display</li>
+      <li>The <IMG src="images/filter_on.png"> button will open a Filter dialog. Select buttons in the dialog to hide specific vertices or edges in the display</li>
       <ul>
         <li>The Filter dialog buttons are created by examining the graph vertex/edge properties to discover candidates for filtering</li>
       </ul>
       <li>Pull-Down the <IMG src="images/katomic.png" width="16" height="16"> Arrangement menu to select one of several graph layout algorithms.</li>
       <ul>
+        <li>Compact Hierarchical is the <b>TidierTree Layout Algorithm</b>. It builds a tree structure and attempts to reduce horizontal space.</li>
+        <li>Hierarchical is a basic Tree algorithm. It prioritizes 'important' edges while constructing the tree.</li>
+        <li>Hierarchical - Edge-Aware is a basic Tree algorithm that attempts to align important edges vertically.</li>
+        <li>Hierarchical Multi Row is the Tree algorithm above, but it will create new rows (typewriter fashion) to reduce horizontal spread.</li>
+        <li>Compact Radial is the <b>TidierTree Layout Algorithm</b> with the root(s) at the center and child vertices radiating outwards.</li>
+        <li>Hierarchical MinCross is the <b>Sugiyama Layout Algorithm</b>. It attempts to route edges around vertices in order to reduce crossing.</li>
+        <ul>There are four layering algorithms:
+          <li>Top Down - biases the vertices to the top</li>
+          <li>Longest Path - biases the vertices to the bottom</li>
+          <li>Network Simplex - layers after finding an 'optimal tree'</li>
+          <li>Coffman Graham - biases the vertices using a scheduling algorithm to minimize length</li>
+        </ul>
+        <li>Circle will arrange vertices in a Circle. If there are not too many edges (less than specified in the jungrapht.circle.reduceEdgeCrossingMaxEdges property with a default of 200), it will attempt to reduce edge crossing by rearranging the vertices.</li>
         <li>Force Balanced is a <b>Force Directed Layout Algorithm</b> using the the <b>Kamada Kawai</b> approach. It attempts to balance the graph by considering vertices and edge connections.</li>
         <li>Force Directed is a <b>Force Directed Layout Algorithm</b> using the <b>Fructermann Reingold</b> approach. It pushes unconnected vertices apart and draws connected vertices together.</li>
-        <li>Circle will arrange vertices in a Circle. If there are not too many edges (less than specified in the jungrapht.circle.reduceEdgeCrossingMaxEdges property with a default of 200), it will attempt to reduce edge crossing by rearranging the vertices.</li>
-        <li>Compact Hierarchical is the <b>TidierTree Layout Algorithm</b>. It builds a tree structure and attempts to reduce horizontal space.</li>
-        <li>Hierarchical MinCross is the <b>Sugiyama Layout Algorithm</b>. It attempts to route edges around vertices in order to reduce crossing.</li>
-        <li>Hierarchical is a basic Tree algorithm. It prioritizes 'important' edges while constructing the tree.</li>
-        <li>Hierarchical Multi Row is the Tree algorithm above, but it will create new rows (typewriter fashion) to reduce horizontal spread.</li>
         <li>Radial is a Tree structure with the root(s) at the center and child vertices radiating outwards.</li>
+        <li>Balloon is a Tree structure with the root(s) at the centers of circles in a radial pattern</li>
+        <li>GEM is a Force Directed layout with locally separated components </li>
       </ul>
     
   </BODY>

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/export/AttributedGraphExporterFactory.java

@@ -33,7 +33,7 @@ public class AttributedGraphExporterFactory
 	AttributedGraphExporterFactory() {
 		vertexLabelProvider = AttributedVertex::getName;
 		edgeLabelProvider = Object::toString;
-		edgeIdProvider = e -> e.getId();
+		edgeIdProvider = AttributedEdge::getId;
 		edgeAttributeProvider = AttributedGraphExporterFactory::getComponentAttributes;
 		vertexAttributeProvider = AttributedGraphExporterFactory::getComponentAttributes;
 		vertexIdProvider = AttributedVertex::getId;
@@ -54,7 +54,7 @@ public class AttributedGraphExporterFactory
 				.entrySet()
 				.stream()
 				.map(entry -> new AbstractMap.SimpleEntry<String, Attribute>(entry.getKey(),
-					new DefaultAttribute<String>(entry.getValue(), AttributeType.STRING)))
+					new DefaultAttribute<>(entry.getValue(), AttributeType.STRING)))
 				.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
 	}
 }

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/export/ExportAttributedGraphDisplay.java

@@ -34,7 +34,7 @@ import ghidra.util.task.TaskMonitor;
  */
 class ExportAttributedGraphDisplay implements GraphDisplay {
 
-	private PluginTool pluginTool;
+	private final PluginTool pluginTool;
 	private String description;
 
 	/**

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/export/ExportAttributedGraphDisplayProvider.java

@@ -52,8 +52,7 @@ public class ExportAttributedGraphDisplayProvider implements GraphDisplayProvide
 	public GraphDisplay getGraphDisplay(boolean reuseGraph,
 			TaskMonitor monitor) {
 
-		ExportAttributedGraphDisplay display = new ExportAttributedGraphDisplay(this);
+		return new ExportAttributedGraphDisplay(this);
-		return display;
 	}
 
 	@Override

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/export/GraphExportFormat.java

@@ -20,7 +20,7 @@ enum GraphExportFormat {
 	DIMACS("col"),
 	DOT("gv"),
 	GML("gml"),
-	GRAPHML("graphhml"),
+	GRAPHML("graphml"),
 	JSON("json"),
 	LEMON("lgf"),
 	MATRIX("g"),

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/export/GraphExporterDialog.java

@@ -59,7 +59,7 @@ public class GraphExporterDialog extends DialogComponentProvider {
 	private JTextField filePathTextField;
 	private JButton fileChooserButton;
 	private GhidraComboBox<GraphExportFormat> comboBox;
-	private Graph<AttributedVertex, AttributedEdge> graph;
+	private final Graph<AttributedVertex, AttributedEdge> graph;
 
 	/**
 	 * Construct a new ExporterDialog for exporting a program, optionally only exported a

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/CenterAnimation.java

@@ -26,14 +26,14 @@ import ghidra.graph.job.AbstractAnimatorJob;
 import ghidra.service.graph.AttributedEdge;
 import ghidra.service.graph.AttributedVertex;
 
-public class CenterAnimation extends AbstractAnimatorJob {
+public class CenterAnimation<V, E> extends AbstractAnimatorJob {
 	protected int duration = 1000;
-	private Point2D oldPoint;
+	private final Point2D oldPoint;
-	private Point2D newPoint;
+	private final Point2D newPoint;
-	private Point2D lastPoint = new Point2D.Double();
+	private final Point2D lastPoint = new Point2D.Double();
-	private VisualizationViewer<AttributedVertex, AttributedEdge> viewer;
+	private final VisualizationViewer<V, E> viewer;
 
-	public CenterAnimation(VisualizationViewer<AttributedVertex, AttributedEdge> viewer,
+	public CenterAnimation(VisualizationViewer<V, E> viewer,
 			Point2D oldPoint, Point2D newPoint) {
 		this.viewer = viewer;
 		this.oldPoint = oldPoint;

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/Colors.java

@@ -195,6 +195,11 @@ public abstract class Colors {
      */
     private static Color blue = new Color(100, 100, 255);
 
+	/**
+	 * a yellow that is darker than {@code Color.yellow}
+	 */
+	private static Color darkerYellow = new Color(225, 225, 0);
+
     /**
      * these are vertex or edge types that have defined colors
      * (the keys are the property values for the vertex/edge keys:
@@ -229,7 +234,7 @@ public abstract class Colors {
                     entry("Computed",Color.cyan),
                     entry("Indirection",Color.pink),
                     entry("Unconditional-Jump", Color.green),
-                    entry("Conditional-Jump", Color.yellow),
+                    entry("Conditional-Jump", darkerYellow),
                     entry("Terminator", WEB_COLOR_MAP.get("Purple")),
                     entry("Conditional-Return", WEB_COLOR_MAP.get("Purple"))
             );

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/DefaultDisplayGraphIcons.java

@@ -29,7 +29,8 @@ final class DefaultDisplayGraphIcons {
 
 	public static final Icon SATELLITE_VIEW_ICON = Icons.get("images/sat2.png");
 	public static final Icon VIEW_MAGNIFIER_ICON = Icons.get("images/magnifier.png");
-	public static final Icon GRAPH_FILTERS_ICON = Icons.get("images/view-filter.png");
 	public static final Icon PROGRAM_GRAPH_ICON = Icons.get("images/redspheregraph.png");
 	public static final Icon LAYOUT_ALGORITHM_ICON = Icons.get("images/katomic.png");
+	public static final Icon LASSO_ICON = Icons.get("images/Lasso.png");
+	public static final Icon FILTER_ICON = Icons.get("images/filter_on.png");
 }

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/DefaultGraphDisplay.java

@@ -15,54 +15,97 @@
  */
 package ghidra.graph.visualization;
 
-import static org.jungrapht.visualization.renderers.BiModalRenderer.*;
-
-import java.awt.*;
-import java.awt.event.*;
-import java.awt.geom.Point2D;
-import java.util.*;
-import java.util.List;
-import java.util.logging.Logger;
-import java.util.stream.Collectors;
-
-import javax.swing.*;
-
-import org.jgrapht.Graph;
-import org.jungrapht.visualization.*;
-import org.jungrapht.visualization.annotations.MultiSelectedVertexPaintable;
-import org.jungrapht.visualization.annotations.SingleSelectedVertexPaintable;
-import org.jungrapht.visualization.control.*;
-import org.jungrapht.visualization.decorators.*;
-import org.jungrapht.visualization.layout.algorithms.LayoutAlgorithm;
-import org.jungrapht.visualization.layout.model.LayoutModel;
-import org.jungrapht.visualization.layout.model.Point;
-import org.jungrapht.visualization.renderers.*;
-import org.jungrapht.visualization.renderers.Renderer;
-import org.jungrapht.visualization.selection.MutableSelectedState;
-import org.jungrapht.visualization.transform.*;
-import org.jungrapht.visualization.transform.shape.MagnifyImageLensSupport;
-import org.jungrapht.visualization.transform.shape.MagnifyShapeTransformer;
-
 import docking.ActionContext;
-import docking.action.builder.*;
+import docking.action.ToggleDockingAction;
+import docking.action.builder.ActionBuilder;
+import docking.action.builder.MultiStateActionBuilder;
+import docking.action.builder.ToggleActionBuilder;
 import docking.menu.ActionState;
 import ghidra.framework.plugintool.Plugin;
 import ghidra.framework.plugintool.PluginTool;
 import ghidra.graph.AttributeFilters;
 import ghidra.graph.job.GraphJobRunner;
-import ghidra.service.graph.*;
+import ghidra.service.graph.AttributedEdge;
+import ghidra.service.graph.AttributedGraph;
+import ghidra.service.graph.AttributedVertex;
+import ghidra.service.graph.DummyGraphDisplayListener;
+import ghidra.service.graph.GraphDisplay;
+import ghidra.service.graph.GraphDisplayListener;
 import ghidra.util.Msg;
 import ghidra.util.Swing;
+import ghidra.util.exception.CancelledException;
 import ghidra.util.task.TaskMonitor;
+import org.jgrapht.Graph;
+import org.jungrapht.visualization.RenderContext;
+import org.jungrapht.visualization.SatelliteVisualizationViewer;
+import org.jungrapht.visualization.VisualizationViewer;
+import org.jungrapht.visualization.annotations.MultiSelectedVertexPaintable;
+import org.jungrapht.visualization.annotations.SingleSelectedVertexPaintable;
+import org.jungrapht.visualization.control.DefaultGraphMouse;
+import org.jungrapht.visualization.control.DefaultLensGraphMouse;
+import org.jungrapht.visualization.control.DefaultSatelliteGraphMouse;
+import org.jungrapht.visualization.control.LensGraphMouse;
+import org.jungrapht.visualization.control.LensMagnificationGraphMousePlugin;
+import org.jungrapht.visualization.control.MultiSelectionStrategy;
+import org.jungrapht.visualization.decorators.EdgeShape;
+import org.jungrapht.visualization.decorators.EllipseShapeFunction;
+import org.jungrapht.visualization.decorators.IconShapeFunction;
+import org.jungrapht.visualization.layout.algorithms.LayoutAlgorithm;
+import org.jungrapht.visualization.layout.algorithms.util.InitialDimensionFunction;
+import org.jungrapht.visualization.layout.model.LayoutModel;
+import org.jungrapht.visualization.layout.model.Point;
+import org.jungrapht.visualization.renderers.JLabelVertexLabelRenderer;
+import org.jungrapht.visualization.renderers.LightweightVertexRenderer;
+import org.jungrapht.visualization.renderers.ModalRenderer;
+import org.jungrapht.visualization.renderers.Renderer;
+import org.jungrapht.visualization.selection.MutableSelectedState;
+import org.jungrapht.visualization.selection.VertexEndpointsSelectedEdgeSelectedState;
+import org.jungrapht.visualization.transform.Lens;
+import org.jungrapht.visualization.transform.LensSupport;
+import org.jungrapht.visualization.transform.MutableTransformer;
+import org.jungrapht.visualization.transform.shape.MagnifyImageLensSupport;
+import org.jungrapht.visualization.transform.shape.MagnifyShapeTransformer;
+import org.jungrapht.visualization.util.RectangleUtils;
 import resources.Icons;
-import util.CollectionUtils;
+
+import javax.swing.AbstractButton;
+import javax.swing.BorderFactory;
+import javax.swing.JComponent;
+import javax.swing.JRadioButton;
+import javax.swing.event.AncestorEvent;
+import javax.swing.event.AncestorListener;
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.event.ComponentAdapter;
+import java.awt.event.ComponentEvent;
+import java.awt.event.ItemEvent;
+import java.awt.geom.Point2D;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+import static org.jungrapht.visualization.MultiLayerTransformer.Layer.*;
+import static org.jungrapht.visualization.renderers.BiModalRenderer.LIGHTWEIGHT;
 
 /**
  * Delegates to a {@link VisualizationViewer} to draw a graph visualization
  */
 public class DefaultGraphDisplay implements GraphDisplay {
+
 	public static final String FAVORED_EDGE = "Fall-Through";
-	private static final int MAX_NODES = 10000;
+	private static final int MAX_NODES = Integer.getInteger("maxNodes", 10000);
 	public static final Dimension PREFERRED_VIEW_SIZE = new Dimension(1000, 1000);
 	public static final Dimension PREFERRED_LAYOUT_SIZE = new Dimension(3000, 3000);
 
@@ -84,22 +127,22 @@ public class DefaultGraphDisplay implements GraphDisplay {
 	/**
 	 * the delegate viewer to display the ProgramGraph
 	 */
-	private VisualizationViewer<AttributedVertex, AttributedEdge> viewer;
+	private final VisualizationViewer<AttributedVertex, AttributedEdge> viewer;
 
 	/**
 	 * the {@link PluginTool}
 	 */
-	private PluginTool pluginTool;
+	private final PluginTool pluginTool;
 
 	/**
 	 * the {@link Plugin} that manages this {@link GraphDisplay}
 	 */
-	private String pluginName = "ProgramGraphPlugin";
+	private final String pluginName = "ProgramGraphPlugin";
 
 	/**
 	 * provides the component for the {@link GraphDisplay}
 	 */
-	private DefaultGraphDisplayComponentProvider componentProvider;
+	private final DefaultGraphDisplayComponentProvider componentProvider;
 
 	/**
 	 * whether to scroll the visualization in order to center the selected vertex
@@ -110,14 +153,65 @@ public class DefaultGraphDisplay implements GraphDisplay {
 	/**
 	 * allows selection of various {@link LayoutAlgorithm} ('arrangements')
 	 */
-	private LayoutTransitionManager layoutTransitionManager;
+	private final LayoutTransitionManager<AttributedVertex, AttributedEdge> layoutTransitionManager;
 
 	/**
-	 * manages highlight painting of a single selected vertex
+	 * provides graph displays for supplied graphs
 	 */
-	private SingleSelectedVertexPaintable<AttributedVertex, AttributedEdge> singleSelectedVertexPaintable;
+	private final DefaultGraphDisplayProvider graphDisplayProvider;
-	private MultiSelectedVertexPaintable<AttributedVertex, AttributedEdge> multiSelectedVertexPaintable;
+	/**
-	private DefaultGraphDisplayProvider graphDisplayProvider;
+	 *  a 'busy' dialog to show while the layout algorithm is working
+	 */
+	private LayoutWorkingDialog layoutWorkingDialog;
+	/**
+	 * the vertex that has been nominated to be 'located' in the graph display and listing
+	 */
+	private AttributedVertex locatedVertex;
+	private final GraphJobRunner jobRunner = new GraphJobRunner();
+	/**
+	 * a satellite view that shows in the lower left corner as a birds-eye view of the graph display
+	 */
+	private final SatelliteVisualizationViewer<AttributedVertex, AttributedEdge> satelliteViewer;
+	/**
+	 * generated filters on edges
+	 */
+	private AttributeFilters edgeFilters;
+	/**
+	 * generated filters on vertices
+	 */
+	private AttributeFilters vertexFilters;
+	/**
+	 * a dialog populated with generated vertex/edge filters
+	 */
+	private FilterDialog filterDialog;
+	/**
+	 * holds the vertex icons (instead of recomputing them)
+	 */
+	private GhidraIconCache iconCache;
+	/**
+	 * multi-selection is done in a free-form traced shape instead of a rectangle
+	 */
+	private boolean freeFormSelection;
+
+	/**
+	 * Will accept a {@link Graph} and use it to create a new graph display in
+	 * a new tab or new window
+	 */
+	Consumer<Graph<AttributedVertex, AttributedEdge>> subgraphConsumer =
+			g -> {
+				try {
+					AttributedGraph attributedGraph = new AttributedGraph();
+					g.vertexSet().forEach(attributedGraph::addVertex);
+					g.edgeSet().forEach(e -> {
+						AttributedVertex source = g.getEdgeSource(e);
+						AttributedVertex target = g.getEdgeTarget(e);
+						attributedGraph.addEdge(source, target, e);
+					});
+					displaySubGraph(attributedGraph);
+				} catch (CancelledException e) {
+					// noop
+				}
+			};
 
 	/**
 	 * Create the initial display, the graph-less visualization viewer, and its controls
@@ -129,14 +223,13 @@ public class DefaultGraphDisplay implements GraphDisplay {
 		this.displayId = id;
 		this.pluginTool = graphDisplayProvider.getPluginTool();
 		this.viewer = createViewer();
-
 		buildHighlighers();
 
 		componentProvider = new DefaultGraphDisplayComponentProvider(this, pluginTool);
 		componentProvider.addToTool();
 		satelliteViewer = createSatelliteViewer(viewer);
 		layoutTransitionManager =
-			new LayoutTransitionManager(viewer, this::isRoot, this::isFavoredEdge);
+			new LayoutTransitionManager<>(viewer, this::isRoot);
 
 		viewer.getComponent().addComponentListener(new ComponentAdapter() {
 			@Override
@@ -150,6 +243,9 @@ public class DefaultGraphDisplay implements GraphDisplay {
 			}
 		});
 
+		viewer.setInitialDimensionFunction(InitialDimensionFunction
+				.builder(viewer.getRenderContext().getVertexBoundsFunction()).build());
+
 		createActions();
 		connectSelectionStateListeners();
 	}
@@ -164,7 +260,11 @@ public class DefaultGraphDisplay implements GraphDisplay {
 		return displayId;
 	}
 
-	private LensSupport<LensGraphMouse> createManifiers() {
+	/**
+	 * create a magnification lens for the graph display
+	 * @return a {@link LensSupport} for the new magnifier
+	 */
+	private LensSupport<LensGraphMouse> createMagnifier() {
 		Lens lens = Lens.builder().lensShape(Lens.Shape.RECTANGLE).magnification(3.f).build();
 		lens.setMagnification(2.f);
 		LensMagnificationGraphMousePlugin magnificationPlugin =
@@ -172,52 +272,71 @@ public class DefaultGraphDisplay implements GraphDisplay {
 
 		MutableTransformer transformer = viewer.getRenderContext()
 				.getMultiLayerTransformer()
-				.getTransformer(MultiLayerTransformer.Layer.VIEW);
+				.getTransformer(VIEW);
 
 		MagnifyShapeTransformer shapeTransformer = MagnifyShapeTransformer.builder(lens)
 				// this lens' delegate is the viewer's VIEW layer
 				.delegate(transformer)
 				.build();
-
+		LensGraphMouse lensGraphMouse = new DefaultLensGraphMouse<>(magnificationPlugin);
 		return MagnifyImageLensSupport.builder(viewer)
 				.lensTransformer(shapeTransformer)
-				.lensGraphMouse(new DefaultLensGraphMouse<>(magnificationPlugin))
+				.lensGraphMouse(lensGraphMouse)
 				.build();
 	}
 
+	/**
+	 * create the highlighters ({@code Paintable}s to show which vertices have been selected or located
+	 */
 	private void buildHighlighers() {
 		// for highlighting of multiple selected vertices
-		this.multiSelectedVertexPaintable = MultiSelectedVertexPaintable.builder(viewer)
+		MultiSelectedVertexPaintable<AttributedVertex, AttributedEdge> multiSelectedVertexPaintable = MultiSelectedVertexPaintable.builder(viewer)
 				.selectionStrokeMin(4.f)
 				.selectionPaint(Color.red)
-				.useBounds(true)
+				.useBounds(false)
 				.build();
 
-		// for highlighting of single 'located' vertices
+
-		this.singleSelectedVertexPaintable = SingleSelectedVertexPaintable.builder(viewer)
+		// manages highlight painting of a single selected vertex
+		SingleSelectedVertexPaintable<AttributedVertex, AttributedEdge> singleSelectedVertexPaintable = SingleSelectedVertexPaintable.builder(viewer)
 				.selectionStrokeMin(4.f)
 				.selectionPaint(Color.red)
+				.selectedVertexFunction(vs -> this.locatedVertex)
 				.build();
 
-		// this draws the selection highlights
+		// draws the selection highlights
 		viewer.addPostRenderPaintable(multiSelectedVertexPaintable);
 
-		// this draws the location arrow
+		// draws the location arrow
 		viewer.addPostRenderPaintable(singleSelectedVertexPaintable);
 
 	}
 
+	/**
+	 * create the action icon buttons on the upper-right of the graph display window
+	 */
 	private void createActions() {
 
 		// create a toggle for 'scroll to selected vertex'
 		new ToggleActionBuilder("Scroll To Selection", pluginName)
 				.toolBarIcon(Icons.NAVIGATE_ON_INCOMING_EVENT_ICON)
-				.description("Scroll to Selection")
+				.description("Scroll display to center the 'Located' vertex")
 				.selected(false)
 				.onAction(context -> enableScrollToSelection =
 					((AbstractButton) context.getSourceObject()).isSelected())
 				.buildAndInstallLocal(componentProvider);
 
+		// create a toggle for enabling 'free-form' selection: selection is
+		// inside of a traced shape instead of a rectangle
+		new ToggleActionBuilder("Free-Form Selection", pluginName)
+				.toolBarIcon(DefaultDisplayGraphIcons.LASSO_ICON)
+				.description("Trace Free-Form Shape to select multiple vertices (CTRL-click-drag)")
+				.selected(false)
+				.onAction(context ->
+					freeFormSelection = ((AbstractButton) context.getSourceObject()).isSelected())
+				.buildAndInstallLocal(componentProvider);
+
+
 		// create an icon button to display the satellite view
 		new ToggleActionBuilder("SatelliteView", pluginName).description("Show Satellite View")
 				.toolBarIcon(DefaultDisplayGraphIcons.SATELLITE_VIEW_ICON)
@@ -225,56 +344,81 @@ public class DefaultGraphDisplay implements GraphDisplay {
 				.buildAndInstallLocal(componentProvider);
 
 		// create an icon button to reset the view transformations to identity (scaled to layout)
-		new ActionBuilder("Reset View", pluginName).description("Reset all view transforms")
+		new ActionBuilder("Reset View", pluginName)
+				.description("Reset all view transforms to center graph in display")
 				.toolBarIcon(Icons.REFRESH_ICON)
-				.onAction(context -> {
+				.onAction(context -> viewer.scaleToLayout())
-					viewer.reset();
-					viewer.scaleToLayout(true);
-				})
 				.buildAndInstallLocal(componentProvider);
 
 		// create a button to show the view magnify lens
-		LensSupport<LensGraphMouse> magnifyViewSupport = createManifiers();
+		LensSupport<LensGraphMouse> magnifyViewSupport = createMagnifier();
-		@SuppressWarnings("unchecked")
+		ToggleDockingAction lensToggle = new ToggleActionBuilder("View Magnifier", pluginName)
-		LensSupport<LensGraphMouse>[] lenses = new LensSupport[] { magnifyViewSupport };
+				.description("Show View Magnifier")
-		new ActionBuilder("View Magnifier", pluginName).description("Show View Magnifier")
 				.toolBarIcon(DefaultDisplayGraphIcons.VIEW_MAGNIFIER_ICON)
-				.onAction(context -> {
+				.onAction(context -> magnifyViewSupport.activate(
-					Arrays.stream(lenses).forEach(LensSupport::deactivate);
+						((AbstractButton) context.getSourceObject()).isSelected()
-					magnifyViewSupport.activate();
+				))
-				})
+				.build();
-				.buildAndInstallLocal(componentProvider);
+		magnifyViewSupport.addItemListener(itemEvent ->
+				lensToggle.setSelected(itemEvent.getStateChange() == ItemEvent.SELECTED));
+		componentProvider.addLocalAction(lensToggle);
 
+		// create an action button to show a dialog with generated filters
 		new ActionBuilder("Show Filters", pluginName).description("Show Graph Filters")
-				.toolBarIcon(Icons.CONFIGURE_FILTER_ICON)
+				.toolBarIcon(DefaultDisplayGraphIcons.FILTER_ICON)
 				.onAction(context -> showFilterDialog())
 				.buildAndInstallLocal(componentProvider);
-		
+
+		// create a menu with graph layout algorithm selections
 		new MultiStateActionBuilder<String>("Arrangement", pluginName)
-				.description("Select Layout Arrangement")
+				.description("Select Layout Arrangement Algorithm")
 				.toolBarIcon(DefaultDisplayGraphIcons.LAYOUT_ALGORITHM_ICON)
+				.fireFirstAction(false)
 				.onActionStateChanged((s, t) -> layoutChanged(s.getName()))
 				.addStates(getLayoutActionStates())
 				.buildAndInstallLocal(componentProvider);
-		
+
+		// show a 'busy' dialog while the layout algorithm is computing vertex locations
+		viewer.getVisualizationModel().getLayoutModel()
+				.getLayoutStateChangeSupport().addLayoutStateChangeListener(
+				evt -> {
+					if (evt.active) {
+						Swing.runLater(this::showLayoutWorking);
+					} else {
+						Swing.runLater(this::hideLayoutWorking);
+					}
+				}
+		);
 	}
 
+	/**
+	 * get a {@code List} of {@code ActionState} buttons for the
+	 * configured layout algorithms
+	 * @return a {@code List} of {@code ActionState} buttons
+	 */
 	private List<ActionState<String>> getLayoutActionStates() {
 		String[] names = layoutTransitionManager.getLayoutNames();
 		List<ActionState<String>> actionStates = new ArrayList<>();
 		for (String layoutName : names) {
-			actionStates.add(new ActionState<String>(layoutName,
+			actionStates.add(new ActionState<>(layoutName,
 				DefaultDisplayGraphIcons.LAYOUT_ALGORITHM_ICON, layoutName));
 		}
 		return actionStates;
 	}
 
+	/**
+	 * respond to a change in the layout name
+	 * @param layoutName the name of the layout algorithm to apply
+	 */
 	private void layoutChanged(String layoutName) {
 		if (layoutTransitionManager != null) {
 			layoutTransitionManager.setLayout(layoutName);
 		}
 	}
 
+	/**
+	 * show the dialog with generated filters
+	 */
 	private void showFilterDialog() {
 		if (filterDialog == null) {
 			if (vertexFilters == null) {
@@ -286,6 +430,31 @@ public class DefaultGraphDisplay implements GraphDisplay {
 		componentProvider.getTool().showDialog(filterDialog);
 	}
 
+	/**
+	 * show the 'busy' dialog indicating that the layout algorithm is working
+	 */
+	protected void showLayoutWorking() {
+		if (this.layoutWorkingDialog != null) {
+			layoutWorkingDialog.close();
+		}
+		this.layoutWorkingDialog =
+				new LayoutWorkingDialog(viewer.getVisualizationModel().getLayoutAlgorithm());
+		componentProvider.getTool().showDialog(layoutWorkingDialog);
+	}
+
+	/**
+	 * hide the 'busy' dialog for the layout algorithm work
+	 */
+	protected void hideLayoutWorking() {
+		if (this.layoutWorkingDialog != null) {
+			layoutWorkingDialog.close();
+		}
+	}
+
+	/**
+	 * add or remove the satellite viewer
+	 * @param context information about the event
+	 */
 	private void toggleSatellite(ActionContext context) {
 		if (((AbstractButton) context.getSourceObject()).isSelected()) {
 			viewer.getComponent().add(satelliteViewer.getComponent());
@@ -294,7 +463,17 @@ public class DefaultGraphDisplay implements GraphDisplay {
 			viewer.getComponent().remove(satelliteViewer.getComponent());
 		}
 		viewer.repaint();
+	}
 
+	/**
+	 * from the supplied {@link Graph}, create a new GraphDisplay in a new window or tab
+	 * @param subGraph
+	 * @throws CancelledException
+	 */
+	private void displaySubGraph(Graph<AttributedVertex, AttributedEdge> subGraph) throws CancelledException {
+		GraphDisplay graphDisplay = graphDisplayProvider.getGraphDisplay(false, TaskMonitor.DUMMY);
+		graphDisplay.setGraph((AttributedGraph)subGraph, "SubGraph", false, TaskMonitor.DUMMY);
+		graphDisplay.setGraphDisplayListener(listener);
 	}
 
 	/**
@@ -304,11 +483,14 @@ public class DefaultGraphDisplay implements GraphDisplay {
 	 */
 	private SatelliteVisualizationViewer<AttributedVertex, AttributedEdge> createSatelliteViewer(
 			VisualizationViewer<AttributedVertex, AttributedEdge> parentViewer) {
+		Dimension viewerSize = parentViewer.getSize();
+		Dimension satelliteSize = new Dimension(
+				viewerSize.width / 4, viewerSize.height / 4);
 		final SatelliteVisualizationViewer<AttributedVertex, AttributedEdge> satelliteViewer =
 			SatelliteVisualizationViewer.builder(parentViewer)
-					.viewSize(new Dimension(250, 250))
+					.viewSize(satelliteSize)
 					.build();
-		satelliteViewer.setGraphMouse(new DefaultSatelliteGraphMouse<>());
+		satelliteViewer.setGraphMouse(new DefaultSatelliteGraphMouse());
 		satelliteViewer.getRenderContext().setEdgeDrawPaintFunction(Colors::getColor);
 		satelliteViewer.getRenderContext()
 				.setEdgeStrokeFunction(ProgramGraphFunctions::getEdgeStroke);
@@ -316,9 +498,20 @@ public class DefaultGraphDisplay implements GraphDisplay {
 		satelliteViewer.scaleToLayout();
 		satelliteViewer.getRenderContext().setVertexLabelFunction(n -> null);
 		satelliteViewer.getComponent().setBorder(BorderFactory.createEtchedBorder());
+		parentViewer.getComponent().addComponentListener(new ComponentAdapter() {
+			@Override
+			public void componentResized(ComponentEvent evt) {
+				Dimension size = evt.getComponent().getSize();
+				Dimension quarterSize = new Dimension(size.width / 4, size.height / 4);
+				satelliteViewer.getComponent().setSize(quarterSize);
+			}
+		});
 		return satelliteViewer;
 	}
 
+	/**
+	 * close this graph display
+	 */
 	@Override
 	public void close() {
 		graphDisplayProvider.remove(this);
@@ -328,12 +521,23 @@ public class DefaultGraphDisplay implements GraphDisplay {
 		listener = null;
 	}
 
+	/**
+	 * accept a {@code GraphDisplayListener}
+	 * @param listener the listener to be notified
+	 */
 	@Override
 	public void setGraphDisplayListener(GraphDisplayListener listener) {
 		if (this.listener != null) {
 			this.listener.graphClosed();
 		}
 		this.listener = listener;
+		DefaultGraphMouse<AttributedVertex, AttributedEdge> graphMouse =
+				new GhidraGraphMouse<>(viewer,
+						subgraphConsumer,
+						listener,
+						AttributedVertex::getId,
+						AttributedVertex::getName);
+		viewer.setGraphMouse(graphMouse);
 	}
 
 	/**
@@ -341,14 +545,21 @@ public class DefaultGraphDisplay implements GraphDisplay {
 	 */
 	private void connectSelectionStateListeners() {
 		viewer.getSelectedVertexState().addItemListener(e -> Swing.runLater(() -> {
+			// there was a change in the set of selected vertices.
+			// if the locatedVertex is null, set it from one of the selected
+			// vertices
 			if (e.getStateChange() == ItemEvent.SELECTED) {
 				Collection<AttributedVertex> selectedVertices = getVertices(e.getItem());
 				List<String> selectedVertexIds = toVertexIds(selectedVertices);
 				notifySelectionChanged(selectedVertexIds);
 
-				AttributedVertex vertex = CollectionUtils.any(selectedVertices);
+				if (selectedVertices.size() == 1) {
-				if (vertex != null) {
+					// if only one vertex was selected, make it the locatedVertex
-					notifyLocationChanged(vertex.getId());
+					setLocatedVertex(selectedVertices.stream().findFirst().get());
+				} else if (this.locatedVertex == null) {
+					// if there is currently no locatedVertex, attempt to get
+					// one from the selectedVertices
+					setLocatedVertex(selectedVertices.stream().findFirst().orElse(null));
 				}
 			}
 			else if (e.getStateChange() == ItemEvent.DESELECTED) {
@@ -358,11 +569,27 @@ public class DefaultGraphDisplay implements GraphDisplay {
 		}));
 	}
 
-	private List<String> toVertexIds(Collection<AttributedVertex> selectedVertices) {
+	/**
-		return selectedVertices.stream().map(v -> v.getId()).collect(Collectors.toList());
+	 * set the vertex that has been nominated to be 'located'
+	 * @param vertex the lucky vertex
+	 */
+	protected void setLocatedVertex(AttributedVertex vertex) {
+		boolean changed = this.locatedVertex != vertex;
+		this.locatedVertex = vertex;
+		if (locatedVertex != null && changed) {
+			notifyLocationChanged(locatedVertex.getId());
+		}
+	}
+
+	/**
+	 * transform the supplied {@code AttributedVertex} Set members to a List of their ids
+	 * @param selectedVertices
+	 * @return
+	 */
+	private List<String> toVertexIds(Collection<AttributedVertex> selectedVertices) {
+		return selectedVertices.stream().map(AttributedVertex::getId).collect(Collectors.toList());
 	}
 
-	@SuppressWarnings("unchecked")
 	private Collection<AttributedVertex> getVertices(Object item) {
 		if (item instanceof Collection) {
 			return (Collection<AttributedVertex>) item;
@@ -373,10 +600,18 @@ public class DefaultGraphDisplay implements GraphDisplay {
 		return Collections.emptyList();
 	}
 
+	/**
+	 * fire an event to say the selected vertices changed
+	 * @param vertexIds
+	 */
 	private void notifySelectionChanged(List<String> vertexIds) {
 		Swing.runLater(() -> listener.selectionChanged(vertexIds));
 	}
 
+	/**
+	 * fire and event to say the located vertex changed
+	 * @param vertexId
+	 */
 	private void notifyLocationChanged(String vertexId) {
 		Swing.runLater(() -> listener.locationChanged(vertexId));
 	}
@@ -400,6 +635,11 @@ public class DefaultGraphDisplay implements GraphDisplay {
 		viewer.repaint();
 	}
 
+	/**
+	 *
+	 * @param vertexIds vertex ids of interest
+	 * @return a {@code Set} containing the {@code AttributedVertex} for ths supplied ids
+	 */
 	private Set<AttributedVertex> getVertices(Collection<String> vertexIds) {
 		Set<String> vertexSet = new HashSet<>(vertexIds);
 		return graph.vertexSet()
@@ -408,13 +648,21 @@ public class DefaultGraphDisplay implements GraphDisplay {
 				.collect(Collectors.toSet());
 	}
 
+	/**
+	 * for the supplied vertex id, find the {@code AttributedVertex} and translate
+	 * the display to center it
+	 * @param vertexID the id of the vertex to focus
+	 */
 	@Override
 	public void setLocation(String vertexID) {
-		Optional<AttributedVertex> selected =
+		Optional<AttributedVertex> located =
 			graph.vertexSet().stream().filter(v -> vertexID.equals(v.getId())).findFirst();
-		log.fine("picking address:" + vertexID + " returned " + selected);
+		log.fine("picking address:" + vertexID + " returned " + located);
 		viewer.repaint();
-		selected.ifPresent(this::scrollToSelected);
+		located.ifPresent(v -> {
+			setLocatedVertex(v);
+			scrollToSelected(v);
+		});
 		viewer.repaint();
 	}
 
@@ -425,21 +673,19 @@ public class DefaultGraphDisplay implements GraphDisplay {
 	private void doSetGraphData(AttributedGraph attributedGraph) {
 		graph = attributedGraph;
 
-		layoutTransitionManager.setGraph(graph);
+		layoutTransitionManager.setEdgeComparator(new EdgeComparator(graph, "EdgeType",
+				DefaultGraphDisplay.FAVORED_EDGE));
 
 		configureViewerPreferredSize();
 
-		Swing.runNow(() -> viewer.getVisualizationModel().setGraph(graph));
+		Swing.runNow(() ->  {
-
+			// set the graph but defer the layoutalgorithm setting
-		configureFilters();
+			viewer.getVisualizationModel().setGraph(graph, false);
-
+			configureFilters();
-		LayoutAlgorithm<AttributedVertex> initialLayoutAlgorithm =
+			LayoutAlgorithm<AttributedVertex> initialLayoutAlgorithm =
-			layoutTransitionManager.getInitialLayoutAlgorithm(graph);
+					layoutTransitionManager.getInitialLayoutAlgorithm();
-
+			viewer.getVisualizationModel().setLayoutAlgorithm(initialLayoutAlgorithm);
-		viewer.getVisualizationModel().setLayoutAlgorithm(initialLayoutAlgorithm);
+		});
-
-		viewer.scaleToLayout();
-
 		componentProvider.setVisible(true);
 	}
 
@@ -451,16 +697,12 @@ public class DefaultGraphDisplay implements GraphDisplay {
 	 */
 	private boolean isRoot(AttributedVertex vertex) {
 		Set<AttributedEdge> incomingEdgesOf = graph.incomingEdgesOf(vertex);
-		if (incomingEdgesOf.isEmpty()) {
+		return incomingEdgesOf.isEmpty();
-			return true;
-		}
-		Set<AttributedEdge> outgoingEdgesOf = graph.outgoingEdgesOf(vertex);
-		return outgoingEdgesOf.stream().anyMatch(this::isFavoredEdge) &&
-			incomingEdgesOf.stream().noneMatch(this::isFavoredEdge);
 	}
 
-
+	/**
-
+	 * configure filters for the graph, based on the vertex and edge attributes
+	 */
 	private void configureFilters() {
 		// close and rebuild filter dialog if exists
 		if (filterDialog != null) {
@@ -502,10 +744,11 @@ public class DefaultGraphDisplay implements GraphDisplay {
 						e -> e.getAttributeMap().values().stream().noneMatch(selected::contains));
 			viewer.repaint();
 		});
-
-
 	}
 
+	/**
+	 * configure a preferred size based on the size of the graph to display
+	 */
 	private void configureViewerPreferredSize() {
 		int vertexCount = graph.vertexSet().size();
 		// attempt to set a reasonable size for the layout based on the number of vertices
@@ -541,6 +784,13 @@ public class DefaultGraphDisplay implements GraphDisplay {
 		// this would have to set the label function, the label font function
 	}
 
+	/**
+	 * consume a {@link Graph} and display it
+	 * @param graph the graph to display or consume
+	 * @param description a description of the graph
+	 * @param append if true, append the new graph to any existing graph.
+	 * @param monitor a {@link TaskMonitor} which can be used to cancel the graphing operation
+	 */
 	@Override
 	public void setGraph(AttributedGraph graph, String description, boolean append,
 			TaskMonitor monitor) {
@@ -578,8 +828,10 @@ public class DefaultGraphDisplay implements GraphDisplay {
 		return newGraph;
 	}
 
+	/**
+	 * cause the graph to be centered and scaled nicely for the view window
+	 */
 	public void centerAndScale() {
-		viewer.reset();
 		viewer.scaleToLayout();
 	}
 
@@ -607,7 +859,7 @@ public class DefaultGraphDisplay implements GraphDisplay {
 				.getMultiLayerTransformer()
 				.inverseTransform(viewer.getCenter());
 
-		jobRunner.schedule(new CenterAnimation(viewer, existingCenter, newCenter));
+		jobRunner.schedule(new CenterAnimation<>(viewer, existingCenter, newCenter));
 	}
 
 	/**w
@@ -620,6 +872,11 @@ public class DefaultGraphDisplay implements GraphDisplay {
 		scrollToSelected(vertices);
 	}
 
+	/**
+	 * compute the centroid of a group of vertices, or the center of the graph display
+	 * @param vertices a collection of vertices from which to compute the centroid from their locations
+	 * @return the {@code Point2D} that is the center
+	 */
 	private Point2D getPointToCenter(Collection<AttributedVertex> vertices) {
 		LayoutModel<AttributedVertex> layoutModel = viewer.getVisualizationModel().getLayoutModel();
 
@@ -638,57 +895,76 @@ public class DefaultGraphDisplay implements GraphDisplay {
 		return new Point2D.Double(p.x, p.y);
 	}
 
-	private GraphJobRunner jobRunner = new GraphJobRunner();
+	/**
-	private SatelliteVisualizationViewer<AttributedVertex, AttributedEdge> satelliteViewer;
+	 * process a request to update the name attribute value of the vertex with the
-	private AttributeFilters edgeFilters;
+	 * supplied id
-	private AttributeFilters vertexFilters;
+	 * @param id the vertix id
-	private FilterDialog filterDialog;
+	 * @param newName the new name of the vertex
-	private GhidraIconCache iconCache;
+	 */
-
 	@Override
 	public void updateVertexName(String id, String newName) {
-		// unsupported
+		// find the vertex, if present, change the name
+		Optional<AttributedVertex> optional = graph.vertexSet().stream()
+				.filter(v -> v.getId().equals(id)).findFirst();
+		if (optional.isPresent()) {
+			AttributedVertex vertex = optional.get();
+			vertex.setName(newName);
+			vertex.clearCache();
+			iconCache.evict(vertex);
+			viewer.repaint();
+		}
 	}
 
+	/**
+	 *
+	 * @return a description of this graph
+	 */
 	@Override
 	public String getGraphDescription() {
 		return description;
 	}
 
-	private boolean isFavoredEdge(AttributedEdge edge) {
+	/**
-		if (edge.getAttributeMap().containsKey("EdgeType")) {
+	 * create and return a {@link VisualizationViewer} to display graphs
-			return edge.getAttributeMap().getOrDefault("EdgeType", "NOTEQUAL").equals(FAVORED_EDGE);
+	 * @return
-		}
+	 */
-		return true;
-	}
-
 	public VisualizationViewer<AttributedVertex, AttributedEdge> createViewer() {
 		final VisualizationViewer<AttributedVertex, AttributedEdge> vv =
 			VisualizationViewer.<AttributedVertex, AttributedEdge> builder()
+					.multiSelectionStrategySupplier(() -> freeFormSelection ?
+							MultiSelectionStrategy.arbitrary() : MultiSelectionStrategy.rectangular())
 					.viewSize(PREFERRED_VIEW_SIZE)
 					.layoutSize(PREFERRED_LAYOUT_SIZE)
 					.build();
 
-		// Add a component listener to scale and center the graph after the component
+		// Add an ancestor listener to scale and center the graph after the component
-		// has been initially sized. Remove the listener after the first time so that any 
+		// has been initially shown.
-		// subsequent resizing does not affect the graph.
+		vv.getComponent().addAncestorListener(new AncestorListener() {
-		vv.getComponent().addComponentListener(new ComponentAdapter() {
+
 			@Override
-			public void componentResized(ComponentEvent e) {
+			public void ancestorAdded(AncestorEvent ancestorEvent) {
-				vv.getComponent().removeComponentListener(this);
+				vv.getComponent().removeAncestorListener(this);
 				Swing.runLater(() -> {
-					vv.reset();
 					vv.scaleToLayout();
 				});
 			}
+
+			@Override
+			public void ancestorRemoved(AncestorEvent ancestorEvent) {
+
+			}
+
+			@Override
+			public void ancestorMoved(AncestorEvent ancestorEvent) {
+
+			}
 		});
 
+		this.iconCache = new GhidraIconCache();
 		vv.setVertexToolTipFunction(AttributedVertex::getHtmlString);
 		vv.setEdgeToolTipFunction(AttributedEdge::getHtmlString);
 		RenderContext<AttributedVertex, AttributedEdge> renderContext = vv.getRenderContext();
 
-		iconCache = new GhidraIconCache();
-
 		// set up the shape and color functions
 		IconShapeFunction<AttributedVertex> nodeImageShapeFunction =
 			new IconShapeFunction<>(new EllipseShapeFunction<>());
@@ -700,6 +976,15 @@ public class DefaultGraphDisplay implements GraphDisplay {
 		renderContext.setVertexShapeFunction(nodeImageShapeFunction);
 		renderContext.setVertexIconFunction(iconCache::get);
 
+		vv.setInitialDimensionFunction(InitialDimensionFunction
+				.builder(nodeImageShapeFunction.andThen(s -> RectangleUtils.convert(s.getBounds2D()))).build());
+
+		// the selectedEdgeState will be controlled by the vertices that are selected.
+		// if both endpoints of an edge are selected, select that edge.
+		vv.setSelectedEdgeState(
+				new VertexEndpointsSelectedEdgeSelectedState<>(vv.getVisualizationModel()::getGraph,
+						vv.getSelectedVertexState()));
+
 		// selected edges will be drawn with a wider stroke
 		renderContext.setEdgeStrokeFunction(
 			e -> renderContext.getSelectedEdgeState().isSelected(e) ? new BasicStroke(20.f)
@@ -731,14 +1016,8 @@ public class DefaultGraphDisplay implements GraphDisplay {
 
 		renderContext.setEdgeShapeFunction(EdgeShape.line());
 
-		DefaultGraphMouse<AttributedVertex, AttributedEdge> graphMouse = new DefaultGraphMouse<>();
-		vv.setGraphMouse(graphMouse);
 		vv.getComponent().requestFocus();
 		vv.setBackground(Color.WHITE);
 		return vv;
 	}
-
-	/**
-	 * a way to sort attributed vertices or edges based on attribute values
-	 */
 }

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/DefaultGraphDisplayComponentProvider.java

@@ -28,7 +28,7 @@ public class DefaultGraphDisplayComponentProvider extends ComponentProviderAdapt
 
 	static final String WINDOW_GROUP = "ProgramGraph";
 	private static final String WINDOW_MENU_GROUP_NAME = "Graph";
-	private DefaultGraphDisplay display;
+	private final DefaultGraphDisplay display;
 
 	DefaultGraphDisplayComponentProvider(DefaultGraphDisplay display, PluginTool pluginTool) {
 		super(pluginTool, "Graph", "DefaultGraphDisplay");

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/DefaultGraphDisplayProvider.java

@@ -28,7 +28,7 @@ import ghidra.util.task.TaskMonitor;
 
 public class DefaultGraphDisplayProvider implements GraphDisplayProvider {
 
-	private Set<DefaultGraphDisplay> displays = new HashSet<>();
+	private final Set<DefaultGraphDisplay> displays = new HashSet<>();
 	private PluginTool pluginTool;
 	private Options options;
 	private int displayCounter;

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/EdgeComparator.java

@@ -22,7 +22,7 @@ import ghidra.service.graph.AttributedEdge;
 import ghidra.service.graph.AttributedGraph;
 
 public class EdgeComparator implements Comparator<AttributedEdge> {
-	private Set<AttributedEdge> prioritized;
+	private final Set<AttributedEdge> prioritized;
 
 	public EdgeComparator(AttributedGraph graph, String attributeName, String value) {
 		prioritized = graph.edgeSet()

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/FilterDialog.java

@@ -41,7 +41,7 @@ public class FilterDialog extends DialogComponentProvider {
 	/**
 	 * A {@code List} (possibly empty) of filter buttons for vertices
 	 */
-	private List<? extends AbstractButton> vertexButtons;
+	private final List<? extends AbstractButton> vertexButtons;
 
 	/**
 	 * A {@code List} (possibly empty) of filter buttons for edges

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/GhidraGraphMouse.java

@@ -0,0 +1,158 @@
+/* ###
+ * IP: GHIDRA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package ghidra.graph.visualization;
+
+import ghidra.service.graph.GraphDisplayListener;
+import org.jgrapht.Graph;
+import org.jungrapht.visualization.VisualizationViewer;
+import org.jungrapht.visualization.control.AbstractPopupGraphMousePlugin;
+import org.jungrapht.visualization.control.DefaultGraphMouse;
+import org.jungrapht.visualization.control.GraphElementAccessor;
+import org.jungrapht.visualization.control.TransformSupport;
+import org.jungrapht.visualization.control.VertexSelectingGraphMousePlugin;
+import org.jungrapht.visualization.layout.model.LayoutModel;
+import org.jungrapht.visualization.selection.ShapePickSupport;
+
+import java.awt.event.MouseEvent;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import static org.jungrapht.visualization.VisualizationServer.PREFIX;
+
+/**
+ * An extension of the jungrapht DefaultGraphMouse. This class has references to
+ * <ul>
+ * <li>a {@link VisualizationViewer} (to access the Graph and LayoutModel)
+ * <li>a {@link Consumer} of the Subgraph (to make new Graph displays)
+ * <li>a {@link GraphDisplayListener} (to react to changes in node attributes)
+ * <li>a {@code Function} to supply the id for a given vertex
+ * <li>a {@code Function} to supply the name for a given vertex
+ *
+ */
+public class GhidraGraphMouse<V, E> extends DefaultGraphMouse<V, E> {
+
+    private static final String PICK_AREA_SIZE = PREFIX + "pickAreaSize";
+
+    /**
+     * holds the context for graph visualization
+     */
+    VisualizationViewer<V, E> viewer;
+    /**
+     * will accept a {@link Graph} and display it in a new tab or window
+     */
+    Consumer<Graph<V, E>> subgraphConsumer;
+    /**
+     * a listener for events, notably the event to request change of a vertex name
+     */
+    GraphDisplayListener graphDisplayListener;
+    /**
+     * supplies the id for a given vertex
+     */
+    Function<V, String> vertexIdFunction;
+    /**
+     * supplies the name for a given vertex
+     */
+    Function<V, String> vertexNameFunction;
+
+    /**
+     * create an instance with default values
+     */
+    public GhidraGraphMouse(VisualizationViewer<V, E> viewer,
+                            Consumer<Graph<V, E>> subgraphConsumer,
+                            GraphDisplayListener graphDisplayListener,
+                            Function<V, String> vertexIdFunction,
+                            Function<V, String> vertexNameFunction) {
+        super(DefaultGraphMouse.<V, E>builder().vertexSelectionOnly(true));
+        this.viewer = viewer;
+        this.subgraphConsumer = subgraphConsumer;
+        this.graphDisplayListener = graphDisplayListener;
+        this.vertexIdFunction = vertexIdFunction;
+        this.vertexNameFunction = vertexNameFunction;
+    }
+
+    /**
+     * create the plugins, and load them
+     */
+    @Override
+    public void loadPlugins() {
+        add(new PopupPlugin<>(viewer, subgraphConsumer, graphDisplayListener,
+                vertexIdFunction, vertexNameFunction));
+        super.loadPlugins();
+    }
+
+    static class PopupPlugin<V, E> extends AbstractPopupGraphMousePlugin {
+
+        VisualizationViewer<V, E> viewer;
+        Consumer<Graph<V, E>> subgraphConsumer;
+        GraphDisplayListener graphDisplayListener;
+        Function<V, String> vertexIdFunction;
+        Function<V, String> vertexNameFunction;
+        SelectionFilterMenu<V, E> selectionFilterMenu;
+
+        PopupPlugin(VisualizationViewer<V, E> viewer,
+                    Consumer<Graph<V, E>> subgraphConsumer,
+                    GraphDisplayListener graphDisplayListener,
+                    Function<V, String> vertexIdFunction,
+                    Function<V, String> vertexNameFunction
+
+        ) {
+            this.viewer = viewer;
+            this.subgraphConsumer = subgraphConsumer;
+            this.graphDisplayListener = graphDisplayListener;
+            this.vertexIdFunction = vertexIdFunction;
+            this.vertexNameFunction = vertexNameFunction;
+            this.selectionFilterMenu = new SelectionFilterMenu<>(viewer, subgraphConsumer);
+        }
+
+        @Override
+        protected void handlePopup(MouseEvent e) {
+            int pickSize = Integer.getInteger(PICK_AREA_SIZE, 4);
+            Rectangle2D footprintRectangle =
+                    new Rectangle2D.Float(
+                            (float) e.getPoint().x - pickSize / 2f,
+                            (float) e.getPoint().y - pickSize / 2f,
+                            pickSize,
+                            pickSize);
+
+            LayoutModel<V> layoutModel = viewer.getVisualizationModel().getLayoutModel();
+            GraphElementAccessor<V, E> pickSupport = viewer.getPickSupport();
+            V pickedVertex;
+            if (pickSupport instanceof ShapePickSupport) {
+                ShapePickSupport<V, E> shapePickSupport =
+                        (ShapePickSupport<V, E>) pickSupport;
+                pickedVertex = shapePickSupport.getVertex(layoutModel, footprintRectangle);
+            } else {
+                TransformSupport<V, E> transformSupport = viewer.getTransformSupport();
+                Point2D layoutPoint = transformSupport.inverseTransform(viewer, e.getPoint());
+                pickedVertex = pickSupport.getVertex(layoutModel, layoutPoint.getX(), layoutPoint.getY());
+            }
+            if (pickedVertex != null) {
+                OnVertexSelectionMenu<V, E> menu =
+                        new OnVertexSelectionMenu<>(viewer, graphDisplayListener,
+                                vertexIdFunction, vertexNameFunction,
+                                pickedVertex);
+                menu.show(viewer.getComponent(), e.getX(), e.getY());
+            } else {
+                selectionFilterMenu.show(viewer.getComponent(), e.getX(), e.getY());
+            }
+        }
+    }
+}
+
+

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/GhidraIconCache.java

@@ -30,19 +30,18 @@ import ghidra.service.graph.AttributedVertex;
 
 public class GhidraIconCache {
 
-	private static final int DEFAULT_STROKE_THICKNESS = 8;
+	private static final int DEFAULT_STROKE_THICKNESS = 12;
 	private static final int DEFAULT_FONT_SIZE = 12;
 	private static final String DEFAULT_FONT_NAME = "Dialog";
-	private static final int DEFAULT_MARGIN_BORDER_SIZE = 4;
+	private static final int DEFAULT_MARGIN_BORDER_SIZE = 8;
-	private static final float LABEL_TO_ICON_PROPORTION_WAG = 1.4f;
+	private static final float LABEL_TO_ICON_PROPORTION = 1.1f;
-	private static final double SQRT_2 = Math.sqrt(2.0);
+	private final JLabel rendererLabel = new JLabel();
-	private JLabel rendererLabel = new JLabel();
+	private final Map<RenderingHints.Key, Object> renderingHints = new HashMap<>();
-	private Map<RenderingHints.Key, Object> renderingHints = new HashMap<>();
 	private int strokeThickness = DEFAULT_STROKE_THICKNESS;
 
-	private Map<AttributedVertex, Icon> map = new ConcurrentHashMap<>();
+	private final Map<AttributedVertex, Icon> map = new ConcurrentHashMap<>();
 
-	private IconShape.Function iconShapeFunction = new IconShape.Function();
+	private final IconShape.Function iconShapeFunction = new IconShape.Function();
 
 	Icon get(AttributedVertex vertex) {
 
@@ -64,7 +63,6 @@ public class GhidraIconCache {
 
 	private Icon createIcon(AttributedVertex vertex) {
 		rendererLabel.setText(ProgramGraphFunctions.getLabel(vertex));
-
 		rendererLabel.setFont(new Font(DEFAULT_FONT_NAME, Font.BOLD, DEFAULT_FONT_SIZE));
 		rendererLabel.setForeground(Color.black);
 		rendererLabel.setBackground(Color.white);
@@ -102,15 +100,15 @@ public class GhidraIconCache {
 			// triangles have a non-zero +/- yoffset instead of centering the label
 			case TRIANGLE:
 				// scale the vertex shape
-				scalex = labelSize.getWidth() / vertexShape.getBounds().getWidth() * LABEL_TO_ICON_PROPORTION_WAG;
+				scalex = labelSize.getWidth() / vertexShape.getBounds().getWidth() * LABEL_TO_ICON_PROPORTION;
-				scaley = labelSize.getHeight() / vertexShape.getBounds().getHeight() * LABEL_TO_ICON_PROPORTION_WAG;
+				scaley = labelSize.getHeight() / vertexShape.getBounds().getHeight() * LABEL_TO_ICON_PROPORTION;
 				vertexShape = AffineTransform.getScaleInstance(scalex, scaley)
 					.createTransformedShape(vertexShape);
 				offset = -(int) ((vertexShape.getBounds().getHeight() - labelSize.getHeight()) / 2);
 				break;
 			case INVERTED_TRIANGLE:
-				scalex = labelSize.getWidth() / vertexShape.getBounds().getWidth() * LABEL_TO_ICON_PROPORTION_WAG;
+				scalex = labelSize.getWidth() / vertexShape.getBounds().getWidth() * LABEL_TO_ICON_PROPORTION;
-				scaley = labelSize.getHeight() / vertexShape.getBounds().getHeight() * LABEL_TO_ICON_PROPORTION_WAG;
+				scaley = labelSize.getHeight() / vertexShape.getBounds().getHeight() * LABEL_TO_ICON_PROPORTION;
 				vertexShape = AffineTransform.getScaleInstance(scalex, scaley)
 					.createTransformedShape(vertexShape);
 				offset = (int) ((vertexShape.getBounds().getHeight() - labelSize.getHeight()) / 2);
@@ -128,8 +126,8 @@ public class GhidraIconCache {
 			case DIAMOND:
 			default: // ELLIPSE
 				scalex =
-					labelSize.getWidth() / vertexShape.getBounds().getWidth() * SQRT_2;
+					labelSize.getWidth() / vertexShape.getBounds().getWidth() * 1.1;
-				scaley = labelSize.getHeight() / vertexShape.getBounds().getHeight() * 2;
+				scaley = labelSize.getHeight() / vertexShape.getBounds().getHeight() * 1.1;
 				vertexShape = AffineTransform.getScaleInstance(scalex, scaley)
 					.createTransformedShape(vertexShape);
 				break;
@@ -163,6 +161,21 @@ public class GhidraIconCache {
 		graphics.setPaint(Color.black);
 		graphics.setTransform(offsetTransform);
 		label.paint(graphics);
+		// draw the shape again, but lighter (on top of the label)
+		offsetTransform =
+				AffineTransform.getTranslateInstance(strokeThickness + vertexBounds.width / 2.0,
+						strokeThickness + vertexBounds.height / 2.0);
+		offsetTransform.preConcatenate(graphicsTransform);
+		graphics.setTransform(offsetTransform);
+		Paint paint = Colors.getColor(vertex);
+		if (paint instanceof Color) {
+			Color color = (Color)paint;
+			Color transparent = new Color(color.getRed(), color.getGreen(), color.getBlue(), 50);
+			graphics.setPaint(transparent);
+			graphics.setStroke(new BasicStroke(strokeThickness));
+			graphics.draw(vertexShape);
+		}
+
 		graphics.setTransform(graphicsTransform); // restore the original transform
 		graphics.dispose();
 		return new ImageIcon(bufferedImage);
@@ -171,4 +184,13 @@ public class GhidraIconCache {
 	public void clear() {
 		map.clear();
 	}
+
+	/**
+	 * evict the passed vertex from the cache so that it will be recomputed
+	 * with presumably changed values
+	 * @param vertex to remove from the cache
+	 */
+	public void evict(AttributedVertex vertex) {
+		map.remove(vertex);
+	}
 }

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/LayoutFunction.java

@@ -15,15 +15,21 @@
  */
 package ghidra.graph.visualization;
 
-import java.util.function.Function;
+import org.jungrapht.visualization.layout.algorithms.BalloonLayoutAlgorithm;
-
+import org.jungrapht.visualization.layout.algorithms.CircleLayoutAlgorithm;
-import org.jungrapht.visualization.layout.algorithms.*;
+import org.jungrapht.visualization.layout.algorithms.EiglspergerLayoutAlgorithm;
+import org.jungrapht.visualization.layout.algorithms.FRLayoutAlgorithm;
+import org.jungrapht.visualization.layout.algorithms.GEMLayoutAlgorithm;
+import org.jungrapht.visualization.layout.algorithms.KKLayoutAlgorithm;
+import org.jungrapht.visualization.layout.algorithms.LayoutAlgorithm;
+import org.jungrapht.visualization.layout.algorithms.RadialTreeLayoutAlgorithm;
+import org.jungrapht.visualization.layout.algorithms.TidierRadialTreeLayoutAlgorithm;
+import org.jungrapht.visualization.layout.algorithms.TidierTreeLayoutAlgorithm;
+import org.jungrapht.visualization.layout.algorithms.TreeLayoutAlgorithm;
+import org.jungrapht.visualization.layout.algorithms.repulsion.BarnesHutFRRepulsion;
 import org.jungrapht.visualization.layout.algorithms.sugiyama.Layering;
 
-import org.jungrapht.visualization.layout.algorithms.repulsion.BarnesHutFRRepulsion;
+import java.util.function.Function;
-
-import ghidra.service.graph.AttributedEdge;
-import ghidra.service.graph.AttributedVertex;
 
 /**
  * A central location to list and provide all layout algorithms, their names, and their builders
@@ -32,68 +38,77 @@ import ghidra.service.graph.AttributedVertex;
  * This class provides LayoutAlgorithm builders instead of LayoutAlgorithms because some LayoutAlgorithms
  * accumulate state information (so are used only one time).
  */
-class LayoutFunction
+class LayoutFunction<V, E>
-		implements Function<String, LayoutAlgorithm.Builder<AttributedVertex, ?, ?>> {
+		implements Function<String, LayoutAlgorithm.Builder<V, ?, ?>> {
 
 	static final String KAMADA_KAWAI = "Force Balanced";
 	static final String FRUCTERMAN_REINGOLD = "Force Directed";
 	static final String CIRCLE_MINCROSS = "Circle";
 	static final String TIDIER_TREE = "Compact Hierarchical";
+	static final String TIDIER_RADIAL_TREE = "Compact Radial";
 	static final String MIN_CROSS_TOP_DOWN = "Hierarchical MinCross Top Down";
 	static final String MIN_CROSS_LONGEST_PATH = "Hierarchical MinCross Longest Path";
 	static final String MIN_CROSS_NETWORK_SIMPLEX = "Hierarchical MinCross Network Simplex";
 	static final String MIN_CROSS_COFFMAN_GRAHAM = "Hierarchical MinCross Coffman Graham";
-	static final String MULTI_ROW_EDGE_AWARE_TREE = "Hierarchical MultiRow";
+	static final String TREE = "Hierarchical";
-	static final String EDGE_AWARE_TREE = "Hierarchical";
+	static final String RADIAL = "Radial";
-	static final String EDGE_AWARE_RADIAL = "Radial";
+	static final String BALLOON = "Balloon";
+	static final String GEM = "Gem (Graph Embedder)";
 
 	public String[] getNames() {
-		return new String[] { EDGE_AWARE_TREE, MULTI_ROW_EDGE_AWARE_TREE, TIDIER_TREE,
+		return new String[] { TIDIER_TREE, TREE,
-				MIN_CROSS_TOP_DOWN, MIN_CROSS_LONGEST_PATH, MIN_CROSS_NETWORK_SIMPLEX,
+				TIDIER_RADIAL_TREE, MIN_CROSS_TOP_DOWN, MIN_CROSS_LONGEST_PATH,
-				MIN_CROSS_COFFMAN_GRAHAM, CIRCLE_MINCROSS, KAMADA_KAWAI, FRUCTERMAN_REINGOLD,
+				MIN_CROSS_NETWORK_SIMPLEX, MIN_CROSS_COFFMAN_GRAHAM, CIRCLE_MINCROSS,
-				EDGE_AWARE_RADIAL };
+				KAMADA_KAWAI, FRUCTERMAN_REINGOLD, RADIAL, BALLOON, GEM
+		};
 	}
 
 	@Override
-	public LayoutAlgorithm.Builder<AttributedVertex, ?, ?> apply(String name) {
+	public LayoutAlgorithm.Builder<V, ?, ?> apply(String name) {
 		switch(name) {
+			case GEM:
+				return GEMLayoutAlgorithm.edgeAwareBuilder();
 			case KAMADA_KAWAI:
-				return KKLayoutAlgorithm.<AttributedVertex> builder().preRelaxDuration(1000);
+				return KKLayoutAlgorithm.<V> builder()
+						.preRelaxDuration(1000);
 			case FRUCTERMAN_REINGOLD:
-				return FRLayoutAlgorithm.<AttributedVertex> builder()
+				return FRLayoutAlgorithm.<V> builder()
-					.repulsionContractBuilder(BarnesHutFRRepulsion.barnesHutBuilder());
+					.repulsionContractBuilder(BarnesHutFRRepulsion.builder());
 			case CIRCLE_MINCROSS:
-				return CircleLayoutAlgorithm.<AttributedVertex> builder()
+				return CircleLayoutAlgorithm.<V> builder()
 					.reduceEdgeCrossing(true);
-			case TIDIER_TREE:
+			case TIDIER_RADIAL_TREE:
-				return TidierTreeLayoutAlgorithm.<AttributedVertex, AttributedEdge> edgeAwareBuilder();
+				return TidierRadialTreeLayoutAlgorithm.<V, E> edgeAwareBuilder();
 			case MIN_CROSS_TOP_DOWN:
-				return HierarchicalMinCrossLayoutAlgorithm
+				return EiglspergerLayoutAlgorithm
-					.<AttributedVertex, AttributedEdge> edgeAwareBuilder()
+					.<V, E> edgeAwareBuilder()
 						.layering(Layering.TOP_DOWN);
 			case MIN_CROSS_LONGEST_PATH:
 				return EiglspergerLayoutAlgorithm
-						.<AttributedVertex, AttributedEdge> edgeAwareBuilder()
+						.<V, E> edgeAwareBuilder()
 						.layering(Layering.LONGEST_PATH);
 			case MIN_CROSS_NETWORK_SIMPLEX:
 				return EiglspergerLayoutAlgorithm
-						.<AttributedVertex, AttributedEdge> edgeAwareBuilder()
+						.<V, E> edgeAwareBuilder()
 						.layering(Layering.NETWORK_SIMPLEX);
 			case MIN_CROSS_COFFMAN_GRAHAM:
 				return EiglspergerLayoutAlgorithm
-						.<AttributedVertex, AttributedEdge> edgeAwareBuilder()
+						.<V, E> edgeAwareBuilder()
 						.layering(Layering.COFFMAN_GRAHAM);
-			case MULTI_ROW_EDGE_AWARE_TREE:
+			case RADIAL:
-				return MultiRowEdgeAwareTreeLayoutAlgorithm
+				return RadialTreeLayoutAlgorithm
-					.<AttributedVertex, AttributedEdge> edgeAwareBuilder();
+					.<V> builder()
-			case EDGE_AWARE_RADIAL:
-				return RadialEdgeAwareTreeLayoutAlgorithm
-					.<AttributedVertex, AttributedEdge> edgeAwareBuilder()
 					.verticalVertexSpacing(300);
-			case EDGE_AWARE_TREE:
+			case BALLOON:
+				return BalloonLayoutAlgorithm
+						.<V> builder()
+						.verticalVertexSpacing(300);
+			case TREE:
+				return TreeLayoutAlgorithm
+						.builder();
+			case TIDIER_TREE:
 			default:
-				return EdgeAwareTreeLayoutAlgorithm
+				return TidierTreeLayoutAlgorithm.<V, E> edgeAwareBuilder();
-						.<AttributedVertex, AttributedEdge> edgeAwareBuilder();
 		}
 	}
 }

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/LayoutTransitionManager.java

@@ -15,101 +15,80 @@
  */
 package ghidra.graph.visualization;
 
-import static ghidra.graph.visualization.LayoutFunction.*;
-
-import java.awt.Shape;
-import java.util.*;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-
-import org.jgrapht.Graph;
 import org.jungrapht.visualization.RenderContext;
 import org.jungrapht.visualization.VisualizationServer;
-import org.jungrapht.visualization.layout.algorithms.*;
+import org.jungrapht.visualization.layout.algorithms.Balloon;
-import org.jungrapht.visualization.layout.algorithms.util.*;
+import org.jungrapht.visualization.layout.algorithms.BalloonLayoutAlgorithm;
-import org.jungrapht.visualization.layout.model.LayoutModel;
+import org.jungrapht.visualization.layout.algorithms.EdgeSorting;
-import org.jungrapht.visualization.util.Context;
+import org.jungrapht.visualization.layout.algorithms.Layered;
+import org.jungrapht.visualization.layout.algorithms.LayoutAlgorithm;
+import org.jungrapht.visualization.layout.algorithms.RadialTreeLayout;
+import org.jungrapht.visualization.layout.algorithms.RadialTreeLayoutAlgorithm;
+import org.jungrapht.visualization.layout.algorithms.TreeLayout;
+import org.jungrapht.visualization.layout.algorithms.util.VertexBoundsFunctionConsumer;
+import org.jungrapht.visualization.layout.model.Rectangle;
+import org.jungrapht.visualization.util.LayoutAlgorithmTransition;
+import org.jungrapht.visualization.util.LayoutPaintable;
 
-import docking.menu.MultiActionDockingAction;
+import java.util.Comparator;
-import ghidra.service.graph.*;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import static ghidra.graph.visualization.LayoutFunction.TIDIER_TREE;
 
 /**
  * Manages the selection and transition from one {@link LayoutAlgorithm} to another
  */
-class LayoutTransitionManager {
+class LayoutTransitionManager<V, E> {
 
 	LayoutFunction layoutFunction = new LayoutFunction();
 	/**
 	 * the {@link VisualizationServer} used to display graphs using the requested {@link LayoutAlgorithm}
 	 */
-	VisualizationServer<AttributedVertex, AttributedEdge> visualizationServer;
+	VisualizationServer<V, E> visualizationServer;
 
 	/**
 	 * a {@link Predicate} to assist in determining which vertices are root vertices (for Tree layouts)
 	 */
-	Predicate<AttributedVertex> rootPredicate;
+	Predicate<V> rootPredicate;
-
-	/**
-	 * a {@link Predicate} to allow different handling of specific edge types
-	 */
-	Predicate<AttributedEdge> edgePredicate;
 
 	/**
 	 * a {@link Comparator} to sort edges during layout graph traversal
 	 */
-	Comparator<AttributedEdge> edgeComparator = (e1, e2) -> 0;
+	Comparator<E> edgeComparator = (e1, e2) -> 0;
 
 	/**
-	 * a {@link MultiActionDockingAction} to allow the user to select a layout algorithm
+	 * a {@link Function} to provide {@link Rectangle} (and thus bounds} for vertices
 	 */
-	MultiActionDockingAction multiActionDockingAction;
+	Function<V, Rectangle> vertexBoundsFunction;
-
-	/**
-	 * the currently active {@code LayoutAlgorithm.Builder}
-	 */
-	LayoutAlgorithm.Builder<AttributedVertex, ?, ?> activeBuilder;
-
-	/**
-	 * a {@link Function} to provide {@link Shape} (and thus bounds} for vertices
-	 */
-	Function<AttributedVertex, Shape> vertexShapeFunction;
 
 	/**
 	 * the {@link RenderContext} used to draw the graph
 	 */
-	RenderContext<AttributedVertex, AttributedEdge> renderContext;
+	RenderContext<V, E> renderContext;
 
-	/**
+	LayoutPaintable.BalloonRings<V, E> balloonLayoutRings;
-	 * a LayoutAlgorithm may change the edge shape function (Sugiyama for articulated edges)
+
-	 * This is a reference to the original edge shape function so that it can be returned to
+	LayoutPaintable.RadialRings<V> radialLayoutRings;
-	 * the original edge shape function for subsequent LayoutAlgorithm requests
-	 */
-	private Function<Context<Graph<AttributedVertex, AttributedEdge>, AttributedEdge>, Shape> originalEdgeShapeFunction;
 
 
 	/**
 	 * Create an instance with passed parameters
 	 * @param visualizationServer displays the graph
 	 * @param rootPredicate selects root vertices
-	 * @param edgePredicate differentiates edges
 	 */
 	public LayoutTransitionManager(
-			VisualizationServer<AttributedVertex, AttributedEdge> visualizationServer,
+			VisualizationServer<V, E> visualizationServer,
-			Predicate<AttributedVertex> rootPredicate, Predicate<AttributedEdge> edgePredicate) {
+			Predicate<V> rootPredicate) {
 		this.visualizationServer = visualizationServer;
 		this.rootPredicate = rootPredicate;
-		this.edgePredicate = edgePredicate;
 
 		this.renderContext = visualizationServer.getRenderContext();
-		this.vertexShapeFunction = visualizationServer.getRenderContext().getVertexShapeFunction();
+		this.vertexBoundsFunction = visualizationServer.getRenderContext().getVertexBoundsFunction();
-		this.originalEdgeShapeFunction =
-			visualizationServer.getRenderContext().getEdgeShapeFunction();
-
 	}
 
-	public void setGraph(AttributedGraph graph) {
+	public void setEdgeComparator(Comparator<E> edgeComparator) {
-		edgeComparator = new EdgeComparator(graph, "EdgeType", DefaultGraphDisplay.FAVORED_EDGE);
+		this.edgeComparator = edgeComparator;
 	}
 
 	/**
@@ -118,93 +97,71 @@ class LayoutTransitionManager {
 	 */
 	@SuppressWarnings("unchecked")
 	public void setLayout(String layoutName) {
-		LayoutAlgorithm.Builder<AttributedVertex, ?, ?> builder = layoutFunction.apply(layoutName);
+		LayoutAlgorithm.Builder<V, ?, ?> builder = layoutFunction.apply(layoutName);
-		visualizationServer.getRenderContext().getMultiLayerTransformer().setToIdentity();
+		LayoutAlgorithm<V> layoutAlgorithm = builder.build();
-		LayoutAlgorithm<AttributedVertex> layoutAlgorithm = builder.build();
+		if (layoutAlgorithm instanceof VertexBoundsFunctionConsumer) {
-
+			((VertexBoundsFunctionConsumer<V>) layoutAlgorithm)
-		if (layoutAlgorithm instanceof RenderContextAware) {
+				.setVertexBoundsFunction(vertexBoundsFunction);
-			((RenderContextAware<AttributedVertex, AttributedEdge>) layoutAlgorithm)
-				.setRenderContext(visualizationServer.getRenderContext());
 		}
-		else {
+		if (layoutAlgorithm instanceof Layered) {
-			visualizationServer.getRenderContext().setEdgeShapeFunction(originalEdgeShapeFunction);
+			((Layered<V, E>)layoutAlgorithm)
-		}
+					.setMaxLevelCrossFunction(g ->
-		if (layoutAlgorithm instanceof VertexShapeAware) {
+							Math.max(1, Math.min(10, 500 / g.vertexSet().size())));
-			((VertexShapeAware<AttributedVertex>) layoutAlgorithm)
-				.setVertexShapeFunction(vertexShapeFunction);
 		}
 		if (layoutAlgorithm instanceof TreeLayout) {
-			((TreeLayout<AttributedVertex>) layoutAlgorithm).setRootPredicate(rootPredicate);
+			((TreeLayout<V>) layoutAlgorithm).setRootPredicate(rootPredicate);
 		}
+		// remove any previously added layout paintables
+		removePaintable(radialLayoutRings);
+		removePaintable(balloonLayoutRings);
+		if (layoutAlgorithm instanceof BalloonLayoutAlgorithm) {
+			balloonLayoutRings =
+					new LayoutPaintable.BalloonRings<>(
+							visualizationServer, (BalloonLayoutAlgorithm<V>) layoutAlgorithm);
+			visualizationServer.addPreRenderPaintable(balloonLayoutRings);
+		}
+		if (layoutAlgorithm instanceof RadialTreeLayout) {
+			radialLayoutRings =
+					new LayoutPaintable.RadialRings<>(
+							visualizationServer, (RadialTreeLayout<V>) layoutAlgorithm);
+			visualizationServer.addPreRenderPaintable(radialLayoutRings);
+		}
+
 		if (layoutAlgorithm instanceof EdgeSorting) {
-			((EdgeSorting<AttributedEdge>) layoutAlgorithm).setEdgeComparator(edgeComparator);
+			((EdgeSorting<E>) layoutAlgorithm).setEdgeComparator(edgeComparator);
 		}
-		if (layoutAlgorithm instanceof EdgePredicated) {
+		LayoutAlgorithmTransition.apply(visualizationServer, layoutAlgorithm);
-			((EdgePredicated<AttributedEdge>) layoutAlgorithm).setEdgePredicate(edgePredicate);
+	}
+
+	private void removePaintable(VisualizationServer.Paintable paintable) {
+		if (paintable != null) {
+			visualizationServer.removePreRenderPaintable(paintable);
 		}
-		if (!(layoutAlgorithm instanceof TreeLayout)) {
-			LayoutModel<AttributedVertex> layoutModel =
-				visualizationServer.getVisualizationModel().getLayoutModel();
-			int preferredWidth = layoutModel.getPreferredWidth();
-			int preferredHeight = layoutModel.getPreferredHeight();
-			layoutModel.setSize(preferredWidth, preferredHeight);
-		}
-		if (layoutAlgorithm instanceof RenderContextAware) {
-			((RenderContextAware<AttributedVertex, AttributedEdge>) layoutAlgorithm)
-				.setRenderContext(renderContext);
-		}
-		if (layoutAlgorithm instanceof AfterRunnable) {
-			((AfterRunnable) layoutAlgorithm).setAfter(visualizationServer::scaleToLayout);
-		}
-		LayoutAlgorithmTransition.apply(visualizationServer, layoutAlgorithm,
-			visualizationServer::scaleToLayout);
 	}
 
 	@SuppressWarnings("unchecked")
-	public LayoutAlgorithm<AttributedVertex> getInitialLayoutAlgorithm(
+	public LayoutAlgorithm<V> getInitialLayoutAlgorithm() {
-			AttributedGraph graph) {
+		LayoutAlgorithm<V> initialLayoutAlgorithm =
-		Set<AttributedVertex> roots = getRoots(graph);
+			layoutFunction.apply(TIDIER_TREE).build();
-
-		// if there are no roots, don't attempt to create a Tree layout
-		if (roots.size() == 0) {
-			return layoutFunction.apply(FRUCTERMAN_REINGOLD).build();
-		}
-
-		LayoutAlgorithm<AttributedVertex> initialLayoutAlgorithm =
-			layoutFunction.apply(EDGE_AWARE_TREE).build();
 
 		if (initialLayoutAlgorithm instanceof TreeLayout) {
-			((TreeLayout<AttributedVertex>) initialLayoutAlgorithm)
+			((TreeLayout<V>) initialLayoutAlgorithm)
 					.setRootPredicate(rootPredicate);
-			((TreeLayout<AttributedVertex>) initialLayoutAlgorithm)
+			((TreeLayout<V>) initialLayoutAlgorithm)
-					.setVertexShapeFunction(vertexShapeFunction);
+					.setVertexBoundsFunction(vertexBoundsFunction);
 		}
 		if (initialLayoutAlgorithm instanceof EdgeSorting) {
-			((EdgeSorting<AttributedEdge>) initialLayoutAlgorithm)
+			((EdgeSorting<E>) initialLayoutAlgorithm)
 					.setEdgeComparator(edgeComparator);
 		}
-		if (initialLayoutAlgorithm instanceof EdgePredicated) {
+		if (initialLayoutAlgorithm instanceof VertexBoundsFunctionConsumer) {
-			((EdgePredicated<AttributedEdge>) initialLayoutAlgorithm)
+			((VertexBoundsFunctionConsumer<V>) initialLayoutAlgorithm)
-					.setEdgePredicate(edgePredicate);
+					.setVertexBoundsFunction(vertexBoundsFunction);
-		}
-		if (initialLayoutAlgorithm instanceof ShapeFunctionAware) {
-			((ShapeFunctionAware<AttributedVertex>) initialLayoutAlgorithm)
-					.setVertexShapeFunction(vertexShapeFunction);
 		}
 		return initialLayoutAlgorithm;
 	}
 
-	private Set<AttributedVertex> getRoots(AttributedGraph graph) {
-		return graph.edgeSet()
-				.stream()
-				.sorted(edgeComparator)
-				.map(graph::getEdgeSource)
-				.filter(rootPredicate)
-				.collect(Collectors.toCollection(LinkedHashSet::new));
-	}
-
 	public String[] getLayoutNames() {
 		return layoutFunction.getNames();
 	}
-
 }

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/LayoutWorkingDialog.java

@@ -0,0 +1,57 @@
+/* ###
+ * IP: GHIDRA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package ghidra.graph.visualization;
+
+import java.awt.BorderLayout;
+
+import javax.swing.*;
+
+import org.jungrapht.visualization.layout.algorithms.LayoutAlgorithm;
+
+import docking.DialogComponentProvider;
+import ghidra.service.graph.AttributedVertex;
+
+/**
+ * Extends DialogComponentProvider to make a dialog with buttons to show that the
+ * layout arrangement algorithm is busy
+ */
+public class LayoutWorkingDialog extends DialogComponentProvider {
+
+	public LayoutWorkingDialog(LayoutAlgorithm<AttributedVertex> layoutAlgorithm) {
+		super("Working....", false);
+		super.addWorkPanel(createPanel(layoutAlgorithm));
+		setRememberSize(false);
+		addDismissButton();
+		setDefaultButton(dismissButton);
+	}
+
+	/**
+	 * Create a layout-formatted JComponent holding 2 vertical lists
+	 * of buttons, one list for vertex filter buttons and one list for
+	 * edge filter buttons. Each list has a border and title.
+	 * @return a formatted JComponent (container)
+	 */
+	JComponent createPanel(LayoutAlgorithm<AttributedVertex> layoutAlgorithm) {
+		JProgressBar progressBar = new JProgressBar();
+		progressBar.setIndeterminate(true);
+		JPanel panel = new JPanel(new BorderLayout());
+		panel.add(progressBar, BorderLayout.CENTER);
+		panel.add(new JLabel("Please wait......."), BorderLayout.NORTH);
+		addCancelButton();
+		cancelButton.addActionListener(evt -> layoutAlgorithm.cancel());
+		return panel;
+	}
+}

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/OnEdgeSelectionMenu.java

@@ -0,0 +1,68 @@
+/* ###
+ * IP: GHIDRA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package ghidra.graph.visualization;
+
+import ghidra.service.graph.GraphDisplayListener;
+import org.apache.commons.lang3.StringUtils;
+import org.jungrapht.visualization.VisualizationViewer;
+
+import javax.swing.AbstractButton;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPopupMenu;
+import java.util.function.Function;
+
+/**
+ * a Popup menu to allow actions relative to a particular vertex.
+ * The popup appears on a right click over a vertex in the display.
+ * The user can:
+ * <ul>
+ *     <li>select/deselect the vertex
+ *     <li>rename the selected vertex (may modify the value in the listing)
+ *     <li>re-label the selected vertex locally (affects only the local visual display)
+ */
+public class OnVertexSelectionMenu<V, E> extends JPopupMenu {
+
+    public OnVertexSelectionMenu(VisualizationViewer<V, E> visualizationViewer,
+                                 GraphDisplayListener graphDisplayListener,
+                                 Function<V, String> vertexIdFunction,
+                                 Function<V, String> vertexNameFunction,
+                                 V vertex) {
+        AbstractButton selectButton = new JMenuItem("Select");
+        AbstractButton deselectButton = new JMenuItem("Deselect");
+        AbstractButton renameAttributeButton = new JMenuItem("Rename vertex");
+        renameAttributeButton.addActionListener(evt -> {
+                    String newName = JOptionPane.showInputDialog("New Name Attribute");
+                    if (!StringUtils.isEmpty(newName)) {
+                        graphDisplayListener.updateVertexName(vertexIdFunction.apply(vertex),
+                                vertexNameFunction.apply(vertex), newName);
+                    }
+                }
+        );
+        selectButton.addActionListener(evt -> {
+            if (vertex != null) {
+                visualizationViewer.getSelectedVertexState().select(vertex);
+            }
+        });
+        deselectButton.addActionListener(evt -> {
+            if (vertex != null) {
+                visualizationViewer.getSelectedVertexState().deselect(vertex);
+            }
+        });
+        add(visualizationViewer.getSelectedVertexState().isSelected(vertex) ? deselectButton : selectButton);
+        add(renameAttributeButton);
+    }
+}

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/OnVertexSelectionMenu.java

@@ -0,0 +1,68 @@
+/* ###
+ * IP: GHIDRA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package ghidra.graph.visualization;
+
+import ghidra.service.graph.GraphDisplayListener;
+import org.apache.commons.lang3.StringUtils;
+import org.jungrapht.visualization.VisualizationViewer;
+
+import javax.swing.AbstractButton;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPopupMenu;
+import java.util.function.Function;
+
+/**
+ * a Popup menu to allow actions relative to a particular vertex.
+ * The popup appears on a right click over a vertex in the display.
+ * The user can:
+ * <ul>
+ *     <li>select/deselect the vertex
+ *     <li>rename the selected vertex (may modify the value in the listing)
+ *     <li>re-label the selected vertex locally (affects only the local visual display)
+ */
+public class OnVertexSelectionMenu<V, E> extends JPopupMenu {
+
+    public OnVertexSelectionMenu(VisualizationViewer<V, E> visualizationViewer,
+                                 GraphDisplayListener graphDisplayListener,
+                                 Function<V, String> vertexIdFunction,
+                                 Function<V, String> vertexNameFunction,
+                                 V vertex) {
+        AbstractButton selectButton = new JMenuItem("Select");
+        AbstractButton deselectButton = new JMenuItem("Deselect");
+        AbstractButton renameAttributeButton = new JMenuItem("Rename vertex");
+        renameAttributeButton.addActionListener(evt -> {
+                    String newName = JOptionPane.showInputDialog("New Name Attribute");
+                    if (!StringUtils.isEmpty(newName)) {
+                        graphDisplayListener.updateVertexName(vertexIdFunction.apply(vertex),
+                                vertexNameFunction.apply(vertex), newName);
+                    }
+                }
+        );
+        selectButton.addActionListener(evt -> {
+            if (vertex != null) {
+                visualizationViewer.getSelectedVertexState().select(vertex);
+            }
+        });
+        deselectButton.addActionListener(evt -> {
+            if (vertex != null) {
+                visualizationViewer.getSelectedVertexState().deselect(vertex);
+            }
+        });
+        add(visualizationViewer.getSelectedVertexState().isSelected(vertex) ? deselectButton : selectButton);
+        add(renameAttributeButton);
+    }
+}

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/ProgramGraphFunctions.java

@@ -18,6 +18,7 @@ package ghidra.graph.visualization;
 import com.google.common.base.Splitter;
 import ghidra.service.graph.Attributed;
 import ghidra.service.graph.AttributedEdge;
+import org.apache.commons.text.StringEscapeUtils;
 import org.jungrapht.visualization.util.ShapeFactory;
 
 import java.awt.BasicStroke;
@@ -129,7 +130,7 @@ abstract class ProgramGraphFunctions {
 	public static String getLabel(Attributed attributed) {
 		Map<String, String> map = attributed.getAttributeMap();
 		if (map.get("Code") != null) {
-			String code = map.get("Code");
+			String code = StringEscapeUtils.escapeHtml4(map.get("Code"));
 			return "<html>" + String.join("<p>", Splitter.on('\n').split(code));
 		}
 		return map.get("Name");

Ghidra/Features/GraphServices/src/main/java/ghidra/graph/visualization/SelectionFilterMenu.java

@@ -0,0 +1,228 @@
+/* ###
+ * IP: GHIDRA
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package ghidra.graph.visualization;
+
+import org.jgrapht.Graph;
+import org.jgrapht.graph.AsSubgraph;
+import org.jungrapht.visualization.VisualizationViewer;
+import org.jungrapht.visualization.selection.MutableSelectedState;
+
+import javax.swing.AbstractButton;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JMenuItem;
+import javax.swing.JPopupMenu;
+import java.awt.Component;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+/**
+ * {@code PopupMenu to offer vertex selection options. The user can
+ * <ul>
+ *     <li>hide vertices that are not selected.
+ *     <li>hide vertices that are selected.
+ *     <li>invert the selection.
+ *     <li>'grow' the selected vertex set outwards following outgoing edges.
+ *     <li>'grow' the selected vertex set inwards following incoming edges.
+ *     <li>Create a new graph display consisting of the SubGraph of the selected vertices and their edges.
+ */
+public class SelectionFilterMenu<V, E> extends JPopupMenu {
+
+    /**
+     * holds the context of graph visualization
+     */
+    private final VisualizationViewer<V, E> visualizationViewer;
+
+    /**
+     * button to extend the selection outwards along outgoing edges
+     * its a class member so that it can be re-enabled any time the popup is shown
+     */
+    AbstractButton growSelectionOutButton;
+
+    /**
+     * button to extend the selection inwards along incoming edges
+     * its a class member so that it can be re-enabled any time the popup is shown
+     */
+    AbstractButton growSelectionInButton;
+
+    /**
+     * Create the popup menu and populate with buttons to:
+     * <ul>
+     *     <li>hide unselected vertices</li>
+     *     <li>hide selected vertices</li>
+     *     <li>Invert the selection</li>
+     *     <li>Grow the selection outwards following outgoing edges</li>
+     *     <li>Grow the selection inwards following incoming edges</li>
+     *     <li>Display the selected vertices only in a new Graph display</li>
+     * </ul>
+     * @param visualizationViewer the {@link VisualizationViewer} that holds the context for graph visualization
+     * @param subgraphConsumer a {@code Consumer} of a {@link Graph} to display in a new tab or window
+     */
+    public SelectionFilterMenu(VisualizationViewer<V, E> visualizationViewer,
+                               Consumer<Graph<V, E>> subgraphConsumer) {
+        this.visualizationViewer = visualizationViewer;
+        MutableSelectedState<V> selectedVertexState = visualizationViewer.getSelectedVertexState();
+        AbstractButton hideUnselectedToggleButton = new JCheckBox("Hide Unselected");
+        AbstractButton hideSelectedToggleButton = new JCheckBox("Hide Selected");
+        hideUnselectedToggleButton.addItemListener(evt ->
+            manageVertexDisplay(hideSelectedToggleButton.isSelected(), hideUnselectedToggleButton.isSelected()));
+        hideSelectedToggleButton.addItemListener(evt ->
+                manageVertexDisplay(hideSelectedToggleButton.isSelected(), hideUnselectedToggleButton.isSelected()));
+        AbstractButton toggleSelectionButton = new JCheckBox("Invert Selection");
+        toggleSelectionButton.addActionListener(evt -> {
+            Graph<V, E> graph = visualizationViewer.getVisualizationModel().getGraph();
+            graph.vertexSet().forEach(v -> {
+                        if (selectedVertexState.isSelected(v)) {
+                            selectedVertexState.deselect(v);
+                        } else {
+                            selectedVertexState.select(v);
+                        }
+                    }
+            );
+            visualizationViewer.repaint();
+        });
+        this.growSelectionOutButton = new JButton("Grow Selection Outwards");
+        this.growSelectionInButton = new JButton("Grow Selection Inwards");
+
+        this.growSelectionOutButton.addActionListener(evt -> {
+            growSelection(Graph::outgoingEdgesOf, Graph::getEdgeTarget);
+            growSelectionInButton.setEnabled(canGrowSelection(Graph::incomingEdgesOf));
+            growSelectionOutButton.setEnabled(canGrowSelection(Graph::outgoingEdgesOf));
+                });
+
+        this.growSelectionInButton.addActionListener(evt -> {
+            growSelection(Graph::incomingEdgesOf, Graph::getEdgeSource);
+            growSelectionInButton.setEnabled(canGrowSelection(Graph::incomingEdgesOf));
+            growSelectionOutButton.setEnabled(canGrowSelection(Graph::outgoingEdgesOf));
+        });
+
+        JMenuItem subgraphDisplay = new JMenuItem("Display Selected As Graph");
+        subgraphDisplay.addActionListener(evt -> {
+            Graph<V, E> graph = visualizationViewer.getVisualizationModel().getGraph();
+            subgraphConsumer.accept(new AsSubgraph<>(graph, selectedVertexState.getSelected()));
+        });
+
+        add(hideSelectedToggleButton);
+        add(hideUnselectedToggleButton);
+        add(toggleSelectionButton);
+        add(growSelectionInButton);
+        add(growSelectionOutButton);
+        add(subgraphDisplay);
+    }
+
+    private boolean canGrowSelection(BiFunction<Graph<V, E>, V, Set<E>> growthFunction) {
+        Graph<V, E> graph = visualizationViewer.getVisualizationModel().getGraph();
+        Set<V> selectedVertices = visualizationViewer.getSelectedVertexState().getSelected();
+        Set<E> selectedEdges = visualizationViewer.getSelectedEdgeState().getSelected();
+
+        return selectedVertices.stream()
+                .map(v -> growthFunction.apply(graph, v))
+                .anyMatch(adjacentEdges -> !selectedEdges.containsAll(adjacentEdges));
+    }
+
+    /**
+     * re-enaable the grow buttons in case the user cleared the selection in the graph display
+     * @param invoker
+     * @param x
+     * @param y
+     */
+    @Override
+    public void show(Component invoker, int x, int y) {
+        this.growSelectionInButton.setEnabled(true);
+        this.growSelectionOutButton.setEnabled(true);
+        super.show(invoker, x, y);
+    }
+
+    /**
+     * Use the supplied boolean flags to determine what vertices are shown:
+     * <ul>
+     *     <li>unselected vertices only</li>
+     *     <li>selected vertices only</li>
+     *     <li>both selected and unselected vertices are shown</li>
+     *     <li>neither selected nor unselected vertices are shown</li>
+     * </ul>
+     * @param hideSelected a {@code boolean} flag to request hiding of selected vertices
+     * @param hideUnselected a {@code boolean} flag to request hiding of unselected vertices
+     */
+    private void manageVertexDisplay(boolean hideSelected, boolean hideUnselected) {
+        MutableSelectedState<V> selectedVertexState = visualizationViewer.getSelectedVertexState();
+        if (hideSelected && hideUnselected) {
+            visualizationViewer.getRenderContext()
+                    .setVertexIncludePredicate(v -> false);
+        } else if (hideSelected) {
+            visualizationViewer.getRenderContext()
+                    .setVertexIncludePredicate(Predicate.not(selectedVertexState::isSelected));
+        } else if (hideUnselected) {
+            visualizationViewer.getRenderContext()
+                    .setVertexIncludePredicate(selectedVertexState::isSelected);
+        } else {
+            visualizationViewer.getRenderContext()
+                    .setVertexIncludePredicate(v -> true);
+        }
+        visualizationViewer.repaint();
+    }
+
+    /**
+     * select all vertices that are one hop away from any currently selected vertices
+     * @param growthFunction either outgoing or incoming edges
+     * @param neighborFunction either target or source vertices
+     * @return true if the selection has changed
+     */
+    private boolean growSelection(BiFunction<Graph<V, E>, V, Set<E>> growthFunction,
+                               BiFunction<Graph<V, E>, E, V> neighborFunction) {
+        MutableSelectedState<V> selectedVertexState = visualizationViewer.getSelectedVertexState();
+
+        Set<V> selectedVertices = new HashSet<>(selectedVertexState.getSelected());
+        selectedVertexState.getSelected()
+                .forEach(v -> selectedVertices.addAll(growSelection(v, growthFunction, neighborFunction)));
+        return selectedVertexState.select(selectedVertices);
+    }
+
+    /**
+     * select all vertices that are one hop away from the supplied vertex. The outgoing ar
+     * incoming edges are not followed if they are already selected, or if they are hidden
+     * by the edgeIncludePredicate. Likewise
+     * @param vertex the vertex to start the selection from
+     * @param growthFunction either outgoing or incoming edges
+     * @param neighborFunction either target or source vertices
+     * @return a collection of selected vertices
+     */
+    private Collection<V> growSelection(V vertex,
+                                        BiFunction<Graph<V, E>, V, Set<E>> growthFunction,
+                                        BiFunction<Graph<V, E>, E, V> neighborFunction) {
+        Graph<V, E> graph = visualizationViewer.getVisualizationModel().getGraph();
+        MutableSelectedState<V> selectedVertexState = visualizationViewer.getSelectedVertexState();
+        MutableSelectedState<E> selectedEdgeState = visualizationViewer.getSelectedEdgeState();
+        Predicate<E> edgeIncludePredicate = visualizationViewer.getRenderContext().getEdgeIncludePredicate();
+        Predicate<V> vertexIncludePredicate = visualizationViewer.getRenderContext().getVertexIncludePredicate();
+        // filter out edges we have already selected
+        Set<E> connectingEdges = growthFunction.apply(graph, vertex)
+                .stream().filter(e -> !selectedEdgeState.isSelected(e))
+                .filter(edgeIncludePredicate)
+                .collect(Collectors.toSet());
+        visualizationViewer.getSelectedEdgeState().select(connectingEdges);
+        // get the opposite endpoints for each edge and select them, if they are not already selected
+        return connectingEdges.stream().map(e -> neighborFunction.apply(graph, e))
+                .filter(v -> !selectedVertexState.isSelected(v))
+                .filter(vertexIncludePredicate)
+                .collect(Collectors.toSet());
+    }
+}

Ghidra/Features/GraphServices/src/main/resources/jungrapht.properties

@@ -10,10 +10,11 @@ jungrapht.modalRendererTimerSleep=30
 
 # whether the satellite view is drawn with a transparent background
 jungrapht.satelliteBackgroundTransparent=false
+jungrapht.satelliteLensColor= 0xFAFAFA
 
 # default spacing for tree layouts
-jungrapht.treeLayoutHorizontalSpacing=400
+jungrapht.treeLayoutHorizontalSpacing=2
-jungrapht.treeLayoutVerticalSpacing=300
+jungrapht.treeLayoutVerticalSpacing=2
 
 # default area of pick footprint (item is picked when footprint intersects item shape)
 jungrapht.pickAreaSize=20
@@ -26,14 +27,14 @@ jungrapht.edgeWidth=4.0f
 
 # stroke size for the magnifier lens
 jungrapht.lensStrokeWidth=10.0
-# when scale is < .3, switch to lightweight rendering
+# when scale is < .1, switch to lightweight rendering
-jungrapht.lightweightScaleThreshold=.8
+jungrapht.lightweightScaleThreshold=.1
 # under 50 vertices will use heavyweight rendering all the time
 jungrapht.lightweightCountThreshold=50
 
 # default pixels spacings for vertices
-jungrapht.mincross.horizontalOffset=100
+jungrapht.mincross.horizontalOffset=10
-jungrapht.mincross.verticalOffset=50
+jungrapht.mincross.verticalOffset=5
 
 # how many times to run the full all-level cross count
 jungrapht.mincross.maxLevelCross=10
@@ -50,4 +51,7 @@ jungrapht.mincross.eiglspergerThreshold=200
 # over 200 edges and the reduce edge crossing algorithm will not run
 jungrapht.circle.reduceEdgeCrossingMaxEdges=200
 
-
+# density of a graph in layout. (non-zero) values are 0 < density <= 1.0
+# for layout algorithms that attempt to make the area optimal for the number
+# of graph vertices, this sets how dense the space is.
+jungrapht.initialDimensionVertexDensity=0.3f

Ghidra/Framework/Docking/src/main/java/docking/action/builder/MultiStateActionBuilder.java

@@ -35,6 +35,7 @@ public class MultiStateActionBuilder<T> extends
 
 	private BiConsumer<ActionState<T>, EventTrigger> actionStateChangedCallback;
 	private boolean performActionOnButtonClick = false;
+	private boolean fireFirstAction = true;
 
 	private List<ActionState<T>> states = new ArrayList<>();
 
@@ -114,6 +115,17 @@ public class MultiStateActionBuilder<T> extends
 		return self();
 	}
 
+	/**
+	 * controls whether the first action added will automatically fire an event or not
+	 *
+	 * @param fireFirstAction do fire an action on the first action. Defaults to {@code true}
+	 * @return this MultiActionDockingActionBuilder (for chaining)
+	 */
+	public MultiStateActionBuilder<T> fireFirstAction(boolean fireFirstAction) {
+		this.fireFirstAction = fireFirstAction;
+		return self();
+	}
+
 	@Override
 	public MultiStateDockingAction<T> build() {
 		validate();
@@ -133,6 +145,7 @@ public class MultiStateActionBuilder<T> extends
 					}
 				}
 			};
+		action.setFireFirstEvent(fireFirstAction);
 
 		for (ActionState<T> actionState : states) {
 			action.addActionState(actionState);

Ghidra/Framework/Docking/src/main/java/docking/menu/MultiStateDockingAction.java

@@ -53,6 +53,7 @@ public abstract class MultiStateDockingAction<T> extends DockingAction {
 	private int currentStateIndex = 0;
 	private MultiActionDockingActionIf multiActionGenerator;
 	private MultipleActionDockingToolbarButton multipleButton;
+	private boolean fireFirstEvent = true;
 
 	private boolean performActionOnPrimaryButtonClick = true;
 
@@ -136,6 +137,21 @@ public abstract class MultiStateDockingAction<T> extends DockingAction {
 		doActionPerformed(context);
 	}
 
+	/**
+	 * @return {@code true} if the first action automatically fire its event
+	 */
+	public boolean isFireFirstEvent() {
+		return fireFirstEvent;
+	}
+
+	/**
+	 * set the flag to fire an event on the first action
+	 * @param fireFirstEvent whether to fire the event
+	 */
+	public void setFireFirstEvent(boolean fireFirstEvent) {
+		this.fireFirstEvent = fireFirstEvent;
+	}
+
 	/**
 	 * This is the callback to be overridden when the child wishes to respond to user button
 	 * presses that are on the button and not the drop-down.  This will only be called if
@@ -176,9 +192,14 @@ public abstract class MultiStateDockingAction<T> extends DockingAction {
 		tbd.setToolBarSubGroup(subGroup);
 	}
 
+	/**
+	 * add the supplied {@code ActionState}
+	 * if {@code fireFirstEvent} is {@code true} the first one will fire its event
+	 * @param actionState the {@code ActionState} to add
+	 */
 	public void addActionState(ActionState<T> actionState) {
 		actionStates.add(actionState);
-		if (actionStates.size() == 1) {
+		if (actionStates.size() == 1 && fireFirstEvent) {
 			setCurrentActionState(actionState);
 		}
 	}
@@ -188,7 +209,9 @@ public abstract class MultiStateDockingAction<T> extends DockingAction {
 			throw new IllegalArgumentException("You must provide at least one ActionState");
 		}
 		actionStates = new ArrayList<>(newStates);
-		setCurrentActionState(actionStates.get(0));
+		if (fireFirstEvent) {
+			setCurrentActionState(actionStates.get(0));
+		}
 	}
 
 	public T getCurrentUserData() {

Ghidra/Framework/Generic/src/main/resources/generic.log4jdev.xml

@@ -73,9 +73,11 @@
 		<logger name="ghidra.app.util.opinion" level="DEBUG" />
 		<logger name="ghidra.util.classfinder" level="DEBUG" />			
 		<logger name="ghidra.util.task" level="DEBUG" />		
+		<logger name="org.jungrapht.visualization" level="WARN" />
+		<logger name="org.jungrapht.visualization.DefaultVisualizationServer" level="DEBUG" />
 
 		<Root level="ALL">
-			<AppenderRef ref="console" level="DEBUG"/>      
+			<AppenderRef ref="console" level="DEBUG"/>
 			<AppenderRef ref="detail" level="DEBUG"/> 
 			<AppenderRef ref="script" level="DEBUG"/> 
 			<AppenderRef ref="logPanel" level="INFO"/> 

Ghidra/Framework/Graph/src/main/java/ghidra/service/graph/AttributedVertex.java

@@ -15,6 +15,8 @@
  */
 package ghidra.service.graph;
 
+import org.apache.commons.text.StringEscapeUtils;
+
 import java.util.Map;
 
 /**
@@ -74,6 +76,10 @@ public class AttributedVertex extends Attributed {
 		return getName() + " (" + id + ")";
 	}
 
+	public void clearCache() {
+		this.htmlString = null;
+	}
+
 	/**
 	 * parse (one time) then cache the attributes to html
 	 * @return the html string
@@ -84,7 +90,7 @@ public class AttributedVertex extends Attributed {
 			for (Map.Entry<String, String> entry : entrySet()) {
 				buf.append(entry.getKey());
 				buf.append(":");
-				buf.append(entry.getValue());
+				buf.append(StringEscapeUtils.escapeHtml4(entry.getValue()));
 				buf.append("<br>");
 			}
 			htmlString = buf.toString();

Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/service/graph/GraphDisplayListener.java

@@ -38,4 +38,9 @@ public interface GraphDisplayListener {
 	 * @param vertexId the vertex id of the currently "focused" vertex
 	 */
 	public void locationChanged(String vertexId);
+
+	default boolean updateVertexName(String vertexId, String oldName, String newName) {
+		// no op
+		return false;
+	}
 }