src/Tools/Graphview/shapes.scala

 import java.awt.{BasicStroke, Graphics2D, Shape}
 import java.awt.geom.{AffineTransform, GeneralPath, Path2D, Rectangle2D,
   RoundRectangle2D, PathIterator}
 
 
-object Shapes
-{
+object Shapes {
   private val default_stroke =
     new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND)
 
   def shape(info: Layout.Info): Rectangle2D.Double =
     new Rectangle2D.Double(info.x - info.width2, info.y - info.height2, info.width, info.height)
 
-  def highlight_node(gfx: Graphics2D, graphview: Graphview, node: Graph_Display.Node): Unit =
-  {
+  def highlight_node(gfx: Graphics2D, graphview: Graphview, node: Graph_Display.Node): Unit = {
     val metrics = graphview.metrics
     val extra = metrics.char_width
     val info = graphview.layout.get_node(node)
 
     gfx.setColor(graphview.highlight_color)

       info.y - info.height2 - extra,
       info.width + 2 * extra,
       info.height + 2 * extra))
   }
 
-  def paint_node(gfx: Graphics2D, graphview: Graphview, node: Graph_Display.Node): Unit =
-  {
+  def paint_node(gfx: Graphics2D, graphview: Graphview, node: Graph_Display.Node): Unit = {
     val metrics = graphview.metrics
     val info = graphview.layout.get_node(node)
     val c = graphview.node_color(node)
     val s = shape(info)
 

       gfx.drawString(Word.bidi_override(line), x, y)
       y += metrics.height.ceil.toInt
     }
   }
 
-  def paint_dummy(gfx: Graphics2D, graphview: Graphview, info: Layout.Info): Unit =
-  {
+  def paint_dummy(gfx: Graphics2D, graphview: Graphview, info: Layout.Info): Unit = {
     gfx.setStroke(default_stroke)
     gfx.setColor(graphview.dummy_color)
     gfx.draw(shape(info))
   }
 
-  object Straight_Edge
-  {
-    def paint(gfx: Graphics2D, graphview: Graphview, edge: Graph_Display.Edge): Unit =
-    {
+  object Straight_Edge {
+    def paint(gfx: Graphics2D, graphview: Graphview, edge: Graph_Display.Edge): Unit = {
       val p = graphview.layout.get_node(edge._1)
       val q = graphview.layout.get_node(edge._2)
-      val ds =
-      {
+      val ds = {
         val a = p.y min q.y
         val b = p.y max q.y
         graphview.layout.dummies_iterator(edge).filter(d => a < d.y && d.y < b).toList
       }
       val path = new GeneralPath(Path2D.WIND_EVEN_ODD, ds.length + 2)

 
       if (graphview.show_arrow_heads) Arrow_Head.paint(gfx, path, Shapes.shape(q))
     }
   }
 
-  object Cardinal_Spline_Edge
-  {
+  object Cardinal_Spline_Edge {
     private val slack = 0.1
 
-    def paint(gfx: Graphics2D, graphview: Graphview, edge: Graph_Display.Edge): Unit =
-    {
+    def paint(gfx: Graphics2D, graphview: Graphview, edge: Graph_Display.Edge): Unit = {
       val p = graphview.layout.get_node(edge._1)
       val q = graphview.layout.get_node(edge._2)
-      val ds =
-      {
+      val ds = {
         val a = p.y min q.y
         val b = p.y max q.y
         graphview.layout.dummies_iterator(edge).filter(d => a < d.y && d.y < b).toList
       }
 

         if (graphview.show_arrow_heads) Arrow_Head.paint(gfx, path, Shapes.shape(q))
       }
     }
   }
 
-  object Arrow_Head
-  {
+  object Arrow_Head {
     type Point = (Double, Double)
 
-    private def position(path: GeneralPath, shape: Shape): Option[AffineTransform] =
-    {
-      def intersecting_line(path: GeneralPath, shape: Shape): Option[(Point, Point)] =
-      {
+    private def position(path: GeneralPath, shape: Shape): Option[AffineTransform] = {
+      def intersecting_line(path: GeneralPath, shape: Shape): Option[(Point, Point)] = {
         val i = path.getPathIterator(null, 1.0)
         val seg = Array[Double](0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
         var p1 = (0.0, 0.0)
         var p2 = (0.0, 0.0)
         while (!i.isDone) {

           i.next()
         }
         None
       }
 
-      def binary_search(line: (Point, Point), shape: Shape): Option[AffineTransform] =
-      {
+      def binary_search(line: (Point, Point), shape: Shape): Option[AffineTransform] = {
         val ((fx, fy), (tx, ty)) = line
         if (shape.contains(fx, fy) == shape.contains(tx, ty))
           None
         else {
           val (dx, dy) = (fx - tx, fy - ty)

         case None => None
         case Some(line) => binary_search(line, shape)
       }
     }
 
-    def paint(gfx: Graphics2D, path: GeneralPath, shape: Shape): Unit =
-    {
+    def paint(gfx: Graphics2D, path: GeneralPath, shape: Shape): Unit = {
       position(path, shape) match {
         case None =>
         case Some(at) =>
           val arrow = new GeneralPath(Path2D.WIND_EVEN_ODD, 3)
           arrow.moveTo(0, 0)