Файл: Programming_in_Scala,_2nd_edition.pdf

Figure 35.4 · Cells that evaluate.

Another change in the Model class concerns the way cells display themselves. In the new version, the displayed value of a cell depends on its formula. If the formula is a Textual field, the contents of the field are displayed literally. In all other cases, the formula is evaluated and the result value of that evaluation is displayed.

If you compile the changed traits and classes and relaunch the Main program you get something that starts to resemble a real spreadsheet. Figure 35.4 shows an example. You can enter formulas into cells and get them to evaluate themselves. For instance, once you close the editing focus on cell C5 in Figure 35.4, you should see 86.0, the result of evaluating the formula sum(C1:C4).

However, there’s a crucial element still missing. If you change the value

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

of cell C1 in Figure 35.4 from 20 to 100, the sum in cell C5 will not be automatically updated to 166. You’ll have to click on C5 manually to see a change in its value. What’s still missing is a way to have cells recompute their values automatically after a change.

35.7 Change propagation

If a cell’s value has changed, all cells that depend on that value should have their results recomputed and redisplayed. The simplest way to achieve this would be to recompute the value of every cell in the spreadsheet after each change. However such an approach does not scale well as the spreadsheet grows in size.

A better approach is to recompute the values of only those cells that refer to a changed cell in their formula. The idea is to use an event-based publish/subscribe framework for change propagation: once a cell gets assigned a formula, it will subscribe to be notified of all value changes in cells to which the formula refers. A value change in one of these cells will trigger a re-evaluation of the subscriber cell. If such a re-evaluation causes a change in the value of the cell, it will in turn notify all cells that depend on it. The process continues until all cell values have stabilized, i.e., there are no more changes in the values of any cell.3

The publish/subscribe framework is implemented in class Model using the standard event mechanism of Scala’s Swing framework. Here’s a new (and final) version of this class:

package org.stairwaybook.scells import swing._

class Model(val height: Int, val width: Int) extends Evaluator with Arithmetic {

Compared to the previous version of Model, this version adds a new import of swing._, which makes Swing’s event abstractions directly available.

The main modifications of class Model concern the nested class Cell. Class Cell now inherits from Publisher, so that it can publish events. The event-handling logic is completely contained in the setters of two properties: value and formula. Here is Cell’s new version:

3This assumes that there are no cyclic dependencies between cells. We discuss dropping this assumption at the end of this chapter.

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

case class Cell(row: Int, column: Int) extends Publisher { override def toString = formula match {

case Textual(s) => s case _ => value.toString

}

To the outside, it looks like value and formula are two variables in class Cell. Their actual implementation is in terms of two private fields that are equipped with public getters, value and formula, and setters, value_= and formula_=. Here are the definitions implementing the value property:

private var v: Double = 0 def value: Double = v

def value_=(w: Double) {

if (!(v == w || v.isNaN && w.isNaN)) { v = w

publish(ValueChanged(this))

}

}

The value_= setter assigns a new value w to the private field v. If the new value is different from the old one, it also publishes a ValueChanged event with the cell itself as argument. Note that the test whether the value has changed is a bit tricky because it involves the value NaN. The Java spec says that NaN is different from every other value, including itself! Therefore, a test whether two values are the same has to treat NaN specially: two values v, w are the same if they are equal with respect to ==, or they are both the value

NaN, i.e., v.isNaN and w.isNaN both yield true.

Whereas the value_= setter does the publishing in the publish/subscribe framework, the formula_= setter does the subscribing:

private var f: Formula = Empty def formula: Formula = f

def formula_=(f: Formula) {

for (c <- references(formula)) deafTo(c) this.f = f

for (c <- references(formula)) listenTo(c) value = evaluate(f)

}

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

If a cell is assigned a new formula, it first unsubscribes with deafTo from all cells referenced by the previous formula value. It then stores the new formula in the private variable f and subscribes with listenTo to all cells referenced by it. Finally, it recomputes its value using the new formula.

The last piece of code in the revised class Cell specifies how to react to a ValueChanged event:

reactions += {

case ValueChanged(_) => value = evaluate(formula)

}

} // end class Cell

The ValueChanged class is also contained in class Model:

case class ValueChanged(cell: Cell) extends event.Event

The rest of class Model is as before:

val cells = new Array[Array[Cell]](height, width)

for (i <- 0 until height; j <- 0 until width) cells(i)(j) = new Cell(i, j)

} // end class Model

The spreadsheet code is now almost complete. The final piece missing is the re-display of modified cells. So far, all value propagation concerned the internal Cell values only; the visible table was not affected. One way to change this would be to add a redraw command to the value_= setter. However, this would undermine the strict separation between model and view that you have seen so far. A more modular solution is to notify the table of all ValueChanged events and let it do the redrawing itself. Listing 35.9 shows the final spreadsheet component, which implements this scheme.

Class Spreadsheet of Listing 35.9 has only two new revisions. First, the table component now subscribes with listenTo to all cells in the model. Second, there’s a new case in the table’s reactions: if it is notified of a ValueChanged(cell) event, it demands a redraw of the corresponding cell with a call of updateCell(cell.row, cell.column).

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

package org.stairwaybook.scells import swing._, event._

class Spreadsheet(val height: Int, val width: Int) extends ScrollPane {

val cellModel = new Model(height, width) import cellModel._

val table = new Table(height, width) {

... // settings as in Listing 35.1

override def rendererComponent(

isSelected: Boolean, hasFocus: Boolean, row: Int, column: Int) =

... // as in Listing 35.3

def userData(row: Int, column: Int): String =

... // as in Listing 35.3

reactions += {

case TableUpdated(table, rows, column) => for (row <- rows)

cells(row)(column).formula = FormulaParsers.parse(userData(row, column))

case ValueChanged(cell) => updateCell(cell.row, cell.column)

}

for (row <- cells; cell <- row) listenTo(cell)

}

val rowHeader = new ListView(0 until height) { fixedCellWidth = 30

fixedCellHeight = table.rowHeight

}

viewportView = table rowHeaderView = rowHeader

}

Listing 35.9 · The finished spreadsheet component.

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index