Редактируемая ячейка JavaFX TableView + стиль изменения после редактирования

Обратите внимание, что простая привязка к выбранному свойству не работает. Также вам нужно сохранить тот факт, что элемент каким-то образом редактировался. Это можно сделать с помощью свойства элемента или файла ObservableMap.

Кроме того, вам необходимо фактически установить информацию о том, что элемент был отредактирован. Это можно сделать, перезаписав метод commitEdit.

// external storage of edited states by index
ObservableMap<Number, Boolean> edited = FXCollections.observableHashMap();

TableColumn<LPAttributesTableObject, String> column = (TableColumn) lpAttributesTable.getColumns().get(1);

StringConverter<String> converter = new DefaultStringConverter();

column.setCellFactory(t -> new TextFieldTableCell<LPAttributesTableObject, String>(converter) {
    
    private final BooleanBinding editedBinding = Bindings.booleanValueAt(edited, indexProperty());
    
    {
        editedBinding.addListener((a, b, newValue) -> setStyle(newValue ? "-fx-font-weight:bold;" : ""));
    }

    @Override
    public void commitEdit(String newValue) {
        if (!Objects.equals(newValue, getItem())) {
            // save data that this index has been edited
            edited.put(getIndex(), Boolean.TRUE);
        }
        super.commitEdit(newValue);
    }

});

Обратите внимание, что вам может потребоваться изменить карту в случае изменения списка элементов таблицы.

Альтернатива

Использование типа значения, в котором хранится, был ли элемент отредактирован или нет, вместо простого String позволяет сохранить простоту кода, даже если список элементов изменен:

public class EditableString {

    private final boolean edited;
    private final String value;

    public EditableString(boolean edited, String value) {
        this.edited = edited;
        this.value = value;
    }

    public EditableString(String value) {
        this(false, value);
    }

    public boolean isEdited() {
        return edited;
    }

    public String getValue() {
        return value;
    }

}

StringConverter<EditableString> converter = new StringConverter<EditableString>() {

    @Override
    public String toString(EditableString object) {
        return object == null ? null : object.getValue();
    }

    @Override
    public EditableString fromString(String string) {
        return string == null ? null : new EditableString(true, string);
    }

};

TableColumn<LPAttributesTableObject, EditableString> column = (TableColumn) lpAttributesTable.getColumns().get(1);

column.setCellFactory(t -> new TextFieldTableCell<LPAttributesTableObject, EditableString>(converter) {

    @Override
    public void updateItem(EditableString item, boolean empty) {
        super.updateItem(item, empty);

        if (item != null && item.isEdited()) {
            setStyle("-fx-font-weight: bold;");
        } else {
            setStyle("");
        }
    }

    @Override
    public void commitEdit(EditableString newValue) {
        EditableString currentItem = getItem();
        if (currentItem == null || newValue == null || !Objects.equals(newValue.getValue(), currentItem.getValue())) {
            super.commitEdit(newValue);
        } else {
            // if the string is the same, keep the old value
            super.commitEdit(currentItem);
        }
    }

});

Обратите внимание, что для этого необходимо изменить свойство LPAttributesTableObject, содержащее String, на свойство, содержащее EditableString.

Итак, наконец, вот как я имел в виду, что это работает.

    StringConverter<EditableString> converter = new StringConverter<EditableString>() {
                @Override
                public String toString(EditableString object) {
                    System.out.println("bla bla");
                    return object == null ? null : object.toString();
                }

                @Override
                public EditableString fromString(String string) {
                    System.out.println("bla");
                    return string == null ? null : new EditableString(true, string);
                }
            };


((TableColumn) lpAttributesTable.getColumns().get(1)).setCellValueFactory(new PropertyValueFactory<LPAttributesTableObject,EditableString>("val"));
            ((TableColumn) lpAttributesTable.getColumns().get(0)).setCellValueFactory(new PropertyValueFactory<LPAttributesTableObject,String>("attribute"));
    TableColumn<LPAttributesTableObject, EditableString> col = (TableColumn) lpAttributesTable.getColumns().get(1);
            col.setCellFactory(TextFieldTableCellEditable.<LPAttributesTableObject, EditableString>forTableColumn(converter));

Мне пришлось расширить существующий объект TextFieldTableCell до этого:

public class TextFieldTableCellEditable<S,EditableString> extends TextFieldTableCell<S,EditableString> {

    public static <S,EditableString> Callback<TableColumn<S,EditableString>, TableCell<S,EditableString>> forTableColumn(
            final StringConverter<EditableString> converter) {
        return list -> new TextFieldTableCellEditable<S, EditableString>(converter);
    }

    public TextFieldTableCellEditable(StringConverter<EditableString> converter) {
        this.getStyleClass().add("text-field-table-cell");
        setConverter(converter);
    }


    @Override
    public final void updateItem(EditableString item, boolean empty) {

        super.updateItem(item, empty);
        if (item != null && ((sample.EditableString)item).isEdited()) {
            setText(item.toString());
            setStyle("-fx-font-weight: bold;");
        } else if (item != null && !((sample.EditableString)item).isEdited()){
            setStyle("");
            setText(item.toString());
        } else {
            setStyle("");
            setText(null);
        }
    }

    @Override
    public void commitEdit(EditableString newValue) {
        EditableString currentItem = getItem();
        if (currentItem == null || newValue == null || !Objects.equals(((sample.EditableString)newValue).getValue(), ((sample.EditableString)currentItem).getValue())) {
            super.commitEdit(newValue);
        } else {
            // if the string is the same, keep the old value
            super.commitEdit(currentItem);
        }
    }

}

LPAttributesTableObject выглядит так:

public class LPAttributesTableObject {
    private String attribute;
    private EditableString val;

    public LPAttributesTableObject(String _attribute, EditableString _value)
    {
        this.attribute = _attribute;
        this.val = _value;
    }

    public String getAttribute() { return attribute.toString(); }
    public EditableString getVal() { return val; }
    public final EditableString getValue() { return val; }
    public StringProperty attributeProperty() { return new SimpleStringProperty(attribute.toString()); }
    public ObjectProperty<EditableString> valProperty() { return new SimpleObjectProperty<EditableString>(this,"value",val); }
    public void setAttribute(String _attr) { this.attribute = _attr;}
    public void setValue(EditableString _value) { this.val = _value;}
    public void setVal(EditableString _val) { this.val = _val; }
    public void setVal(String _val) { this.val.setValue(_val);}


}

И EditableString выглядит так:

public class EditableString { 
    private boolean edited;
    private String string;

    public EditableString(boolean edited, String val)
    {
        this.edited = edited;
        this.string = val;
    }

    public EditableString(String val)
    {
        this.edited = false;
        this.string = val;
    }

    public String getValue() { return string; }

    public void setValue(String val) { this.string = val; }

    public String toString() { return string; }

    public boolean isEdited() { return edited; }

    public void setValue(EditableString estr) { this.setValue(estr.getValue()); this.edited = estr.edited; }
}