1.1 --- a/isac-java/src/java/isac/gui/mawen/editor/Box.scala	Wed Jun 28 21:49:52 2017 +0200
     1.2 +++ b/isac-java/src/java/isac/gui/mawen/editor/Box.scala	Thu Jun 29 09:41:02 2017 +0200
     1.3 @@ -11,7 +11,7 @@
     1.4    class EmptyBox(val level: Int, val x0: Int, val y0: Int, override val ast: Ast) extends Box(ast)
     1.5    case class EmptyLeafOpBox(override val level: Int, override val x0: Int, override val y0: Int, override val ast: Ast) extends EmptyBox(level, x0, y0, ast)
     1.6    case class EmptyUniOpBox(override val level: Int, override val x0: Int, override val y0: Int, param: Ast, override val ast: Ast) extends EmptyBox(level, x0, y0, ast)
     1.7 -  case class EmptyBinOpBox(override val level: Int, override val x0: Int, override val y0: Int, paraml: Ast, override val ast: Ast, parent: Ast) extends EmptyBox(level, x0, y0, ast)
     1.8 +  case class EmptyBinOpBox(override val level: Int, override val x0: Int, override val y0: Int, operator: Ast, paraml: Ast, paramr: Ast, override val ast: Ast) extends EmptyBox(level, x0, y0, ast)
     1.9    
    1.10    
    1.11  

     2.1 --- a/isac-java/src/java/isac/gui/mawen/editor/CalcUtil.scala	Wed Jun 28 21:49:52 2017 +0200
     2.2 +++ b/isac-java/src/java/isac/gui/mawen/editor/CalcUtil.scala	Thu Jun 29 09:41:02 2017 +0200
     2.3 @@ -23,14 +23,12 @@
     2.4    
     2.5  
     2.6    def assembleComponent(ast : Ast) : JComponent = new AstComponent(ast)
     2.7 -  
     2.8 -//  def assembleBoxes (g : Graphics, ast : Ast) =  assembleBoxesRec(g, ast, 0, 0, Settings.INITIALFONTSIZE, 0)
     2.9  
    2.10    def assembleBoxes (g : Graphics, ast : Ast, f: (DrawBox) => Unit ) =  assembleBoxesRec(g, new EmptyBox(0,0,0,ast), f)
    2.11  
    2.12    def assembleBoxesRec(g : Graphics, emptyBox: EmptyBox, f:(DrawBox) => Unit) : DrawBox = emptyBox.ast match {
    2.13      case Appl(operator :: param :: Nil)                =>   assembleUniopBoxes(g, EmptyUniOpBox(emptyBox.level, emptyBox.x0, emptyBox.y0, param, emptyBox.ast), f)
    2.14 -    case Appl(operator :: paraml :: paramr :: Nil)     =>   assembleBinopBoxes(g, AstInfoUtil.OperatorString(operator), operator, paraml, paramr, emptyBox.ast, emptyBox.x0, emptyBox.y0, emptyBox.level, f)
    2.15 +    case Appl(operator :: paraml :: paramr :: Nil)     =>   assembleBinopBoxes(g, AstInfoUtil.OperatorString(operator), EmptyBinOpBox(emptyBox.level,emptyBox.x0, emptyBox.y0, operator, paraml, paramr,emptyBox.ast), f)
    2.16      case Appl(Constant(str) :: param)                  =>   calcDefault(g, str,param, emptyBox.x0, emptyBox.y0, emptyBox.level, emptyBox.ast, f)
    2.17      case a                                             =>   assembleLeafBoxes(g, EmptyLeafOpBox(emptyBox.level, emptyBox.x0, emptyBox.y0, emptyBox.ast), f)
    2.18    }
    2.19 @@ -43,25 +41,24 @@
    2.20      case ast => throw new AstException("assembleBoxesRec, uncovered match: " + raw_string_of(ast))
    2.21    }
    2.22    
    2.23 -  
    2.24    def assembleUniopBoxes(g : Graphics, emptyBox: EmptyUniOpBox, f:(DrawBox) => Unit) : DrawBox = emptyBox.ast match {
    2.25      
    2.26      case Appl(Constant(str) ::  ast :: Nil)       if str.startsWith("BOX")        => CalcBox(g, str.replace("BOX.", ""), emptyBox, f)
    2.27 -    case Appl(Constant("CURSOR") :: param :: Nil)                                 => calcCursor(g, emptyBox, f)
    2.28 -    case Appl(param :: Constant("CURSOR") :: Nil)                                 => calcCursor(g, emptyBox, f)
    2.29 +    case Appl(Constant("CURSOR") :: param :: Nil)                                 => calcCursor(g, EmptyUniOpBox(emptyBox.level,emptyBox.x0,emptyBox.y0, param, emptyBox.ast), f)
    2.30 +    case Appl(param :: Constant("CURSOR") :: Nil)                                 => calcCursor(g, EmptyUniOpBox(emptyBox.level,emptyBox.x0,emptyBox.y0, param, emptyBox.ast), f)
    2.31      case Appl(Constant(str) :: param :: Nil)                                      => calcDefault(g, str, List(param), emptyBox.x0, emptyBox.y0, emptyBox.level, emptyBox.ast, f)
    2.32      case ast => throw new AstException("assembleBoxesRec, uncovered match: " + raw_string_of(ast))
    2.33    }
    2.34    
    2.35    
    2.36 -  def assembleBinopBoxes(g : Graphics, operatorString: String, operator: Ast, paraml: Ast, paramr: Ast, ast : Ast, x0: Int, y0: Int, level: Int, f:(DrawBox) => Unit) : DrawBox = operatorString match {
    2.37 -    case "Groups.plus_class.plus"           => calcPlus(g, operator, paraml, paramr, x0, y0, level, ast, f)
    2.38 -    case "Groups.minus_class.minus"         => calcPlus(g, operator, paraml, paramr, x0, y0, level, ast, f)
    2.39 -    case "Groups.times_class.times"         => calcPlus(g, operator, paraml, paramr, x0, y0, level, ast, f)
    2.40 -    case "Atools.pow"                       => calcPow(g, paraml, paramr, x0, y0, level, ast, f)
    2.41 -    case "Fields.inverse_class.divide"      => calcFrac(g, paraml, paramr, x0, y0, level, ast, f)
    2.42 -    case "HOL.eq"                           => calcEqualation(g, paraml, paramr, x0, y0, level, ast, f)
    2.43 -    case _                                  => calcDefault(g, operatorString, List(paramr, paraml), x0, y0, level, ast, f)
    2.44 +  def assembleBinopBoxes(g : Graphics, operatorString: String, emptyBox: EmptyBinOpBox, f:(DrawBox) => Unit) : DrawBox = operatorString match {
    2.45 +    case "Groups.plus_class.plus"           => calcDefaultBinOp(g, emptyBox, f)
    2.46 +    case "Groups.minus_class.minus"         => calcDefaultBinOp(g, emptyBox, f)
    2.47 +    case "Groups.times_class.times"         => calcDefaultBinOp(g, emptyBox, f)
    2.48 +    case "Atools.pow"                       => calcPow(g, emptyBox, f)
    2.49 +    case "Fields.inverse_class.divide"      => calcFrac(g, emptyBox, f)
    2.50 +    case "HOL.eq"                           => calcEqualation(g, emptyBox, f)
    2.51 +    case _                                  => calcDefault(g, operatorString, List(emptyBox.paramr, emptyBox.paraml), emptyBox.x0, emptyBox.y0, emptyBox.level, emptyBox.ast, f)
    2.52      
    2.53      //case ast => throw new AstException("assembleBinopBoxes, uncovered match: " + operatorString)
    2.54    }
    2.55 @@ -83,7 +80,6 @@
    2.56      val box : Rectangle = getStringBounds(g.asInstanceOf[Graphics2D], str, x0, y0)
    2.57      
    2.58      val b = DrawBox(str, box.x, box.y + box.height, box.width, box.height, x0, y0, ast)
    2.59 -    
    2.60      f(b)
    2.61        
    2.62      b
    2.63 @@ -113,9 +109,8 @@
    2.64      val b = DrawBox(op, box.x, y0, box.width, fontWidthOf(fontsizeOf(level)),x0, newY, ast)
    2.65      
    2.66      f(b)
    2.67 +    b
    2.68      
    2.69 -    
    2.70 -    b
    2.71    }
    2.72    def calcGAP(g: Graphics, emptyBox: EmptyLeafOpBox, f:(DrawBox) => Unit) = {
    2.73      val level = emptyBox.level
    2.74 @@ -197,7 +192,16 @@
    2.75    
    2.76    
    2.77  
    2.78 -  def calcPlus(g: Graphics, operator: Ast, paraml: Ast, paramr: Ast, x0: Int, y0: Int, level: Int, ast: Ast, f:(DrawBox) => Unit) = {
    2.79 +  def calcDefaultBinOp(g: Graphics, emptyBox: EmptyBinOpBox, f:(DrawBox) => Unit) = {
    2.80 +    val operator = emptyBox.operator
    2.81 +    val paraml = emptyBox.paraml
    2.82 +    val paramr = emptyBox.paramr
    2.83 +    val x0 = emptyBox.x0
    2.84 +    val y0 = emptyBox.y0
    2.85 +    val level= emptyBox.level
    2.86 +    val ast = emptyBox.ast
    2.87 +    
    2.88 +    
    2.89      
    2.90      val l_box = assembleBoxesRec(g, new EmptyBox(level, x0, y0, paraml), f)
    2.91      val l_width = l_box.width
    2.92 @@ -219,7 +223,15 @@
    2.93      b
    2.94    }
    2.95    
    2.96 -  def calcPow(g: Graphics, paraml: Ast, paramr: Ast, x0: Int, y0: Int, level: Int, ast: Ast, f:(DrawBox) => Unit) = {
    2.97 +  def calcPow(g: Graphics, emptyBox: EmptyBinOpBox, f:(DrawBox) => Unit) = {
    2.98 +    val operator = emptyBox.operator
    2.99 +    val paraml = emptyBox.paraml
   2.100 +    val paramr = emptyBox.paramr
   2.101 +    val x0 = emptyBox.x0
   2.102 +    val y0 = emptyBox.y0
   2.103 +    val level= emptyBox.level
   2.104 +    val ast = emptyBox.ast
   2.105 +    
   2.106      val l_box = assembleBoxesRec(g, new EmptyBox(level, x0, y0, paraml), f)
   2.107      val l_width = l_box.width
   2.108      val l_height = l_box.height
   2.109 @@ -236,7 +248,16 @@
   2.110      b
   2.111    }
   2.112    
   2.113 -  def calcFrac(g: Graphics, paramUpper: Ast, paramLower: Ast, x0: Int, y0: Int, level: Int, ast: Ast, f:(DrawBox) => Unit) = {
   2.114 +  def calcFrac(g: Graphics, emptyBox: EmptyBinOpBox, f:(DrawBox) => Unit) = {
   2.115 +    val operator = emptyBox.operator
   2.116 +    val paramUpper = emptyBox.paraml
   2.117 +    val paramLower = emptyBox.paramr
   2.118 +    val x0 = emptyBox.x0
   2.119 +    val y0 = emptyBox.y0
   2.120 +    val level= emptyBox.level
   2.121 +    val ast = emptyBox.ast
   2.122 +    
   2.123 +    
   2.124      
   2.125      val u_box = assembleBoxesRec(g, new EmptyBox(level+1, x0, y0, paramUpper), emptyFunc)
   2.126      val l_box = assembleBoxesRec(g, new EmptyBox(level+1, x0, y0, paramLower), emptyFunc)
   2.127 @@ -322,7 +343,16 @@
   2.128     * calculate Boxes with the form Appl(Constant("HOL.eq"), Variable(str), Variable(str)) --> str = str
   2.129     * nearly similar to calcPlus() but with more Space between Variable and Constant (LARGESPACE instance of MEDIUMSPACE)
   2.130     */
   2.131 -  def calcEqualation(g: Graphics, paraml: Ast, paramr: Ast, x0: Int, y0: Int, level: Int, ast: Ast, f:(DrawBox) => Unit) = {
   2.132 +  def calcEqualation(g: Graphics, emptyBox: EmptyBinOpBox, f:(DrawBox) => Unit) = {
   2.133 +    val operator = emptyBox.operator
   2.134 +    val paraml = emptyBox.paraml
   2.135 +    val paramr = emptyBox.paramr
   2.136 +    val x0 = emptyBox.x0
   2.137 +    val y0 = emptyBox.y0
   2.138 +    val level= emptyBox.level
   2.139 +    val ast = emptyBox.ast
   2.140 +    
   2.141 +    
   2.142      
   2.143      val l_box = assembleBoxesRec(g, new EmptyBox(level, x0, y0, paraml), f)
   2.144      val l_width = l_box.width
   2.145 @@ -369,7 +399,6 @@
   2.146      case 0 => Settings.INITIALFONTSIZE
   2.147      case 1 => (Settings.INITIALFONTSIZE * 0.7f).round
   2.148      case _ => (Settings.INITIALFONTSIZE * 0.7f * 0.7f).round
   2.149 -    
   2.150    }
   2.151    
   2.152    def decreseFontOfLevel(fontsize: Int, level: Int) = level match {