Handler per Column
There's another approach, if you really need to define your own on-edit-commit handlers. It would look something like this:
import javafx.fxml.FXML;
import javafx.scene.control.TableColumn;
public class Controller {
@FXML private TableColumn<Foo, String> firstNameCol;
@FXML private TableColumn<Foo, String> lastNameCol;
@FXML
private void initialize() {
firstNameCol.setOnEditCommit(e -> e.getRowValue().setFirstName(e.getNewValue()));
lastNameCol.setOnEditCommit(e -> e.getRowValue().setLastName(e.getNewValue()));
}
}
When you do it this way, you know exactly which setter to call because each column gets its own on-edit-commit handler (and columns are associated with a specific property). I personally would prefer this approach.
Get Cell's ObservableValue
Given this method is annotated with @FXML, I assume you're trying to use this one method as the implementation for the on-edit-commit handler of multiple columns. This can complicate things, but what you want is possible:
@FXML
private void onEditCommit(TableColumn.CellEditEvent<MyCustomClass, String> event) {
TableColumn<MyCustomClass, String> column = event.getTableColumn();
MyCustomClass item = event.getRowValue();
ObservableValue<String> observable = column.getCellObservableValue(item);
if (observable instanceof WritableValue<String> writable) {
writable.setValue(event.getNewValue());
}
}
Note: I did not write this in an IDE, so there may be some slight syntax errors. But it should compile, at least on newer versions of Java.
But note this is essentially what the default implementation does. And note that the existence of this default on-edit-commit handler is documented:
By default the TableColumn edit commit handler is non-null, with a default handler that attempts to overwrite the property value for the item in the currently-being-edited row.
So, unless you need to change the default behavior, you likely don't need to worry about implementing your own on-edit-commit handler.
Potential Issues
The above requires that the cellValueFactory returns an instance of WritableValue. And this WritableValue must be linked to the model's property. This should be no problem if your model class exposes JavaFX properties like so:
public class Person {
private final StringProperty name = new SimpleStringProperty(this, "name");
public final void setName(String name) { this.name.set(name); }
public final String getName() { return name.get(); }
public final StringProperty nameProperty() { return name; }
}
Note: If your model uses JavaFX properties then I suggest using lambda expressions instead of PropertyValueFactory. Check out Why should I avoid using PropertyValueFactory in JavaFX?.
Otherwise, PropertyValueFactory will return a ReadOnlyObjectWrapper that is divorced from the model's property after getting the current value. In other words, even though ReadOnlyObjectWrapper does implement WritableValue, setting the property will not forward the new value to the model item.
If you cannot or are unwilling to modify your model to use JavaFX properties, then you can use a different cell-value factory implementation than PropertyValueFactory. For example:
import javafx.beans.property.adapter.JavaBeanObjectPropertyBuilder;
import javafx.beans.value.ObservableValue;
import javafx.scene.control.TableColumn;
import javafx.util.Callback;
public class JavaBeanValueFactory<S, T> implements Callback<TableColumn.CellDataFeatures<S, T>, ObservableValue<T>> {
private final String propertyName;
public JavaBeanValueFactory(String propertyName) {
this.propertyName = propertyName;
}
@Override
@SuppressWarnings("unchecked")
public ObservableValue<T> call(TableColumn.CellDataFeatures<S, T> param) {
try {
return JavaBeanObjectPropertyBuilder.create().bean(param.getValue()).name(propertyName).build();
} catch (NoSuchMethodException ex) {
throw new RuntimeException(ex);
}
}
}
Then replace new PropertyValueFactory<>("foo") with new JavaBeanValueFactory<>("foo").
Or you could do something like this:
// where 'firstNameCol' is e.g., a TableColumn<Person, String>
firstNameCol.setCellValueFactory(data -> new SimpleStringProperty(data.getValue().getFirstName()) {
final Person item = data.getValue();
@Override
protected void invalidated() {
item.setFirstName(get());
}
});
Or anything you can think of where the property will forward new values to the model.
