Как получить предыдущее значение ячейки таблицы внутри метода updateItem ячейки в JavaFx? - PullRequest
0 голосов
/ 16 мая 2018

Я хочу иметь TableCell с пользовательским graphic, который анимирует при изменении значения, где тип анимации зависит от характера изменения, поэтому мне нужно знать предыдущее значение, чтобы сравнить с текущим.

Вот типичная ячейка таблицы (код Котлина):

class MyTableCell<S, T> : TableCell<S, T>() {

    override fun updateItem(item: T?, empty: Boolean) {
        if (empty || field == null) {
            text = null
            graphic = null
        } else {
            // need to get the old value here
        }
    }

Я вижу, что метод super в javafx/scene/control/TableCell.java знает старое значение и использует его для сравнения с текущим, но переопределение получает только newValue:

private void updateItem(int oldIndex) {
    ...
    final T oldValue = getItem();
    ...
    final T newValue = currentObservableValue == null ? null : currentObservableValue.getValue();
    ...
    if (oldIndex == index) {
        if (!isItemChanged(oldValue, newValue)) {
            ...
        }
        ...
    }
    ...
    updateItem(newValue, false); // sadly, `oldValue` is not passed

Я могу думать только об уродливом обходном пути, поэтому мне интересно, есть ли какой-то идиоматический способ получить значение старой ячейки?

Вот пример приложения:

import javafx.application.Application
import javafx.beans.property.SimpleDoubleProperty
import javafx.collections.FXCollections
import javafx.scene.Scene
import javafx.scene.control.*
import javafx.scene.control.cell.PropertyValueFactory
import javafx.stage.Stage
import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.launch
import tornadofx.*

class Foo {
    val barProperty = SimpleDoubleProperty()
    var bar: Double
        get() = barProperty.get()
        set(value) = barProperty.set(value)
}


class FooApp: Application() {
    override fun start(primaryStage: Stage) {
        val foos = FXCollections.observableArrayList(
            Foo().apply { bar = 42.0 }
        )

        val table = TableView<Foo>(foos)

        val barColumn = TableColumn<Foo, Double>("Bar")
        barColumn.cellValueFactory = PropertyValueFactory<Foo, Double>("bar")
        barColumn.setCellFactory {
            FooTableCell<Foo, Double> { "%.2f".format(it) }
        }

        table.columns.add(barColumn)

        val scene = Scene(table, 400.0, 200.0)
        primaryStage.scene = scene
        primaryStage.title = "Table Cell"
        primaryStage.show()

        launch {
            while (isActive) {
                delay(500)
                val oldFoo = foos[0]
                // Replacing the old Foo instance with a new one,
                // updating the value of the `bar` field:
                foos[0] = Foo().apply {
                    bar = oldFoo.bar - 1.0 + Math.random() * 2.0
                }
                // because a change to a field cannot be detected by an observable list
                // and so does not propagates to the table. This won't result in
                // a visible change:
                // foos[0].bar = foos[0].bar - 1.0 + Math.random() * 2.0
            }
        }
    }
}

class FooTableCell<S, T>(private val format: (T) -> String) : TableCell<S, T>() {

    init {
        contentDisplay = ContentDisplay.GRAPHIC_ONLY

        itemProperty().addListener(ChangeListener { obs, oldItem, newItem ->
            if (newItem != null && oldItem != null && newItem != oldItem) {
                // This is never true.
                println("!!! Old: $oldItem, New: $newItem")
            } else {
                println("Change listener:\nOld: $oldItem, New: $newItem\n")
            }
        })
    }

    override fun updateItem(item: T?, empty: Boolean) {
        val oldItem = this.item
        super.updateItem(item, empty)

        if (item != null && oldItem != null && item != oldItem) {
            // This is never true.
            println("!!! Old: $oldItem, New: $item")
        } else {
            println("updateItem:\nOld: $oldItem, New: $item\n")
        }

        if (empty || item == null) {
            graphic = null
            text = null
        } else if (tableRow != null) {
            val cell = this
            graphic = Label().apply {
                textProperty().bindBidirectional(cell.textProperty())
            }
            text = format(item)
        }
    }
}

fun main(args: Array<String>) {
    Application.launch(FooApp::class.java, *args)
}

1 Ответ

0 голосов
/ 16 мая 2018

Фактическое значение свойства item изменяется реализацией по умолчанию метода updateItem(), поэтому просто получите значение перед вызовом реализации по умолчанию:

public class MyTableCell<S,T> extends TableCell<S,T> {

    @Override
    protected void updateItem(T item, boolean empty) {
        T oldItem = getItem();
        super.updateItem(item, empty) ;
        // ...
    }
}

В качестве альтернативы, вы можете простозарегистрируйте прослушиватель изменений с помощью itemProperty():

public class MyTableCell<S,T> extends TableCell<S,T> {

    public MyTableCell() {
        itemProperty().addListener((obs, oldItem, newItem) -> {
            // do animation here...
        });
    }

    @Override
    protected void updateItem(T item, boolean empty) {
        super.updateItem(item, empty);
        // other functionality here...
    }
}

Вот SSCCE, демонстрирующий оба метода:

import java.util.Random;
import java.util.function.Function;

import javafx.application.Application;
import javafx.beans.property.IntegerProperty;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.beans.value.ObservableValue;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.TableCell;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableView;
import javafx.scene.layout.HBox;
import javafx.stage.Stage;

public class TableCellWithChange extends Application {

    public static class ChangeAwareCell<S,T> extends TableCell<S,T> {

        public ChangeAwareCell() {
            itemProperty().addListener((obs, oldItem, newItem) -> {
                System.out.printf("In listener, value for %s changed from %s to %s%n", getTableRow().getItem(), oldItem, newItem);
            });
        }

        @Override
        protected void updateItem(T item, boolean empty) {
            T oldItem = getItem();
            super.updateItem(item, empty);
            if (empty) {
                setText(null);
            } else {
                setText(item.toString());
                System.out.printf("Change in %s from %s to %s %n", getTableView().getItems().get(getIndex()), oldItem, item);
            }
        }
    }

    @Override
    public void start(Stage primaryStage) {

        TableView<Item> table = new TableView<>();
        TableColumn<Item, String> itemCol = column("Item", Item::nameProperty);
        table.getColumns().add(itemCol);

        TableColumn<Item, Number> valueCol = column("Value", Item:: valueProperty);
        table.getColumns().add(valueCol);

        valueCol.setCellFactory(tc -> new ChangeAwareCell<>());

        TableColumn<Item, Void> changeCol = new TableColumn<>();
        changeCol.setCellFactory(tc -> new TableCell<>() {
            private Button incButton = new Button("^");
            private Button decButton = new Button("v");
            private HBox graphic = new HBox(2, incButton, decButton);
            {
                incButton.setOnAction(e -> {
                    Item item = getTableRow().getItem();
                    item.setValue(item.getValue()+1);
                });
                decButton.setOnAction(e -> {
                    Item item = getTableRow().getItem();
                    item.setValue(item.getValue()-1);
                });
            }
            @Override
            protected void updateItem(Void item, boolean empty) {
                super.updateItem(item, empty);
                if (empty) {
                    setGraphic(null);
                } else {
                    setGraphic(graphic);
                }
            }
        });
        table.getColumns().add(changeCol);

        Random rng = new Random();
        for (int i = 1 ; i <= 20  ; i++) {
            table.getItems().add(new Item("Item "+i, rng.nextInt(100)));
        }

        Scene scene = new Scene(table);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    private <S,T> TableColumn<S,T> column(String text, Function<S, ObservableValue<T>> property) {
        TableColumn<S,T> col = new TableColumn<>(text);
        col.setCellValueFactory(cellData -> property.apply(cellData.getValue()));
        col.setPrefWidth(150);
        return col ;
    }


    public static class Item {
        private final StringProperty name = new SimpleStringProperty();
        private final IntegerProperty value = new SimpleIntegerProperty();

        public Item(String name, int value) {
            setName(name);
            setValue(value);
        }

        @Override
        public String toString() {
            return getName();
        }

        public final StringProperty nameProperty() {
            return this.name;
        }


        public final String getName() {
            return this.nameProperty().get();
        }


        public final void setName(final String name) {
            this.nameProperty().set(name);
        }


        public final IntegerProperty valueProperty() {
            return this.value;
        }


        public final int getValue() {
            return this.valueProperty().get();
        }


        public final void setValue(final int value) {
            this.valueProperty().set(value);
        }



    }

    public static void main(String[] args) {
        launch(args);
    }
}

Конечно, эти элементы также изменятся, например, когда пользователь прокручиваетвокруг стола, или если клетки используются повторно другими способами;так что это может быть не совсем тогда, когда вы хотите.Вы могли бы хотеть добавить слушателя к соответствующему свойству в модели вместо этого.Самый простой способ сделать это, вероятно, сохранить ссылку на фактическое свойство из модели в ячейке и обновить эту ссылку при обновлении ячейки:

public static class ChangeAwareCell<S,T> extends TableCell<S,T> {

    private Function<S, ObservableValue<T>> property ;
    private ObservableValue<T> lastObservableValue ;

    private ChangeListener<T> listener = (obs, oldValue, newValue) -> valueChanged(oldValue, newValue);

    public ChangeAwareCell(Function<S, ObservableValue<T>> property) {
        this.property = property ;
    }

    private void valueChanged(T oldValue, T newValue) {
        System.out.printf("Value changed from %s to %s %n", oldValue, newValue);
    }

    @Override
    protected void updateItem(T item, boolean empty) {
        super.updateItem(item, empty);
        if (lastObservableValue != null) {
            lastObservableValue.removeListener(listener);
        }
        if (empty) {
            setText(null);
        } else {
            lastObservableValue = property.apply(getTableRow().getItem());
            lastObservableValue.addListener(listener);
            setText(item.toString());
        }
    }
}

И, конечно, внести соответствующее изменение:

valueCol.setCellFactory(tc -> new ChangeAwareCell<>(Item::valueProperty));
...