src/Tools/Graphview/mutator.scala

     Info(true, visualizer.Colors.next, m)
 
   class Graph_Filter(
     val name: String,
     val description: String,
-    pred: Model.Graph => Model.Graph) extends Filter
+    pred: Graph_Display.Graph => Graph_Display.Graph) extends Filter
   {
-    def filter(graph: Model.Graph) : Model.Graph = pred(graph)
+    def filter(graph: Graph_Display.Graph): Graph_Display.Graph = pred(graph)
   }
 
   class Graph_Mutator(
     val name: String,
     val description: String,
-    pred: (Model.Graph, Model.Graph) => Model.Graph) extends Mutator
+    pred: (Graph_Display.Graph, Graph_Display.Graph) => Graph_Display.Graph) extends Mutator
   {
-    def mutate(complete_graph: Model.Graph, graph: Model.Graph): Model.Graph =
+    def mutate(complete_graph: Graph_Display.Graph, graph: Graph_Display.Graph): Graph_Display.Graph =
       pred(complete_graph, graph)
   }
 
   class Node_Filter(
     name: String,
     description: String,
-    pred: (Model.Graph, String) => Boolean)
+    pred: (Graph_Display.Graph, Graph_Display.Node) => Boolean)
     extends Graph_Filter(name, description, g => g.restrict(pred(g, _)))
 
   class Edge_Filter(
     name: String,
     description: String,
-    pred: (Model.Graph, String, String) => Boolean)
+    pred: (Graph_Display.Graph, Graph_Display.Node, Graph_Display.Node) => Boolean)
     extends Graph_Filter(
       name,
       description,
       g => (g /: g.dest) {
         case (graph, ((from, _), tos)) =>

     name: String,
     description: String,
     reverse: Boolean,
     parents: Boolean,
     children: Boolean,
-    pred: (Model.Graph, String) => Boolean)
+    pred: (Graph_Display.Graph, Graph_Display.Node) => Boolean)
     extends Node_Filter(
       name,
       description,
       (g, k) =>
         reverse !=

       "Filter by Name",
       "Only shows or hides all nodes with any family member's name matching a regex.",
       reverse,
       parents,
       children,
-      (g, k) => (regex.r findFirstIn k).isDefined)
+      (g, node) => (regex.r findFirstIn node.toString).isDefined)
 
   case class Node_List(
-    list: List[String],
+    list: List[Graph_Display.Node],
     reverse: Boolean,
     parents: Boolean,
     children: Boolean)
     extends Node_Family_Filter(
       "Filter by Name List",
       "Only shows or hides all nodes with any family member's name matching any string in a comma separated list.",
       reverse,
       parents,
       children,
-      (g, k) => list.exists(_ == k))
+      (g, node) => list.contains(node))
 
-  case class Edge_Endpoints(source: String, dest: String)
+  case class Edge_Endpoints(source: Graph_Display.Node, dest: Graph_Display.Node)
     extends Edge_Filter(
       "Hide edge",
       "Hides the edge whose endpoints match strings.",
       (g, s, d) => !(s == source && d == dest))
 
-  private def add_node_group(from: Model.Graph, to: Model.Graph, keys: List[String]) =
+  private def add_node_group(from: Graph_Display.Graph, to: Graph_Display.Graph,
+    keys: List[Graph_Display.Node]) =
   {
     // Add Nodes
     val with_nodes =
       (to /: keys)((graph, key) => graph.default_node(key, from.get_node(key)))
 
     // Add Edges
     (with_nodes /: keys) {
       (gv, key) => {
-        def add_edges(g: Model.Graph, keys: SortedSet[String], succs: Boolean) =
+        def add_edges(g: Graph_Display.Graph, keys: from.Keys, succs: Boolean) =
           (g /: keys) {
             (graph, end) => {
               if (!graph.keys_iterator.contains(end)) graph
               else {
                 if (succs) graph.add_edge(key, end)

       "Add by name",
       "Adds every node whose name matches the regex. " +
       "Adds all relevant edges.",
       (complete_graph, graph) =>
         add_node_group(complete_graph, graph,
-          complete_graph.keys.filter(k => (regex.r findFirstIn k).isDefined).toList))
+          complete_graph.keys.filter(node => (regex.r findFirstIn node.toString).isDefined).toList))
 
   case class Add_Transitive_Closure(parents: Boolean, children: Boolean)
     extends Graph_Mutator(
       "Add transitive closure",
       "Adds all family members of all current nodes.",

 
 trait Mutator
 {
   val name: String
   val description: String
-  def mutate(complete_graph: Model.Graph, graph: Model.Graph): Model.Graph
+  def mutate(complete_graph: Graph_Display.Graph, graph: Graph_Display.Graph): Graph_Display.Graph
 
   override def toString: String = name
 }
 
 trait Filter extends Mutator
 {
-  def mutate(complete_graph: Model.Graph, graph: Model.Graph) = filter(graph)
-  def filter(graph: Model.Graph) : Model.Graph
+  def mutate(complete_graph: Graph_Display.Graph, graph: Graph_Display.Graph) = filter(graph)
+  def filter(graph: Graph_Display.Graph): Graph_Display.Graph
 }