Value Change Listener for Javafx's Textfield

Value Change Listener for JavaFX's TextField

Add a listener to the TextField's textProperty:

TextField textField = new TextField();
textField.textProperty().addListener((observable, oldValue, newValue) -> {
    System.out.println("textfield changed from " + oldValue + " to " + newValue);
});

One ChangeListener for multiple TextFields in Javafx

As Slaw pointed out in his comment, you can easily create a single ChangeListener and then apply it to each of your TextField nodes.

ChangeListener<String> listener = ((observable, oldValue, newValue) -> {
    System.out.println("TextField changed from " + oldValue + " to " + newValue + "!");
});

Here is a complete sample you can run to see it in action:

import javafx.application.Application;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.ListView;
import javafx.scene.control.TextField;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

import java.util.ArrayList;
import java.util.Arrays;

public class ReusableListenerSample extends Application {

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

    @Override
    public void start(Stage primaryStage) {

        // Simple Interface
        VBox root = new VBox(10);
        root.setAlignment(Pos.CENTER);
        root.setPadding(new Insets(10));

        // Create a ChangeListener that we will apply to multiple TextFields
        ChangeListener<String> listener = ((observable, oldValue, newValue) -> {
            System.out.println("TextField changed from " + oldValue + " to " + newValue + "!");
        });

        // Create some TextFields
        TextField txt1 = new TextField();
        TextField txt2 = new TextField();
        TextField txt3 = new TextField();

        // Now, we can add our preconfigured listener to each of the TextFields
        txt1.textProperty().addListener(listener);
        txt2.textProperty().addListener(listener);
        txt3.textProperty().addListener(listener);

        // Add our TextFields to the scene
        root.getChildren().addAll(txt1, txt2, txt3);

        // Show the stage
        primaryStage.setScene(new Scene(root));
        primaryStage.setTitle("ListViewSample Sample");
        primaryStage.show();

    }
}

---

Now, the above example does not indicate which TextField was changed. In order to track that, you could create your own inner class that implements ChangeListener<String> and pass your TextField (or any other data to it):

class MyChangeListener implements ChangeListener<String> {

    private final TextField myTextField;

    public MyChangeListener(TextField myTextField) {
        this.myTextField = myTextField;
    }

    @Override
    public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue) {
        System.out.println(myTextField + " changed from " + oldValue + " to " + newValue + "!");
    }
}

Then, just add a new instance of that MyChangeListener to each TextField instead:

txt1.textProperty().addListener(new MyChangeListener(txt1));

Listen to changes in TextField defined in FXML

In general, if you want to perform an action if the text of a text field changes, you need to register a listener with the text field's textProperty(), which you haver to do in the controller:

@FXML
private TextField usernameTextField ;

public void initialize() {
    usernameTextField.textProperty().addListener((obs, oldText, newText) -> {
        // do what you need with newText here, e.g.
        loginButton.setDisable(newText.isEmpty());
    });
}

However, if all you need is to bind a property in one control to a property in another control (or some simple dependency of that property), you can use FXML expression binding:

<TextField fx:id="usernameTextField"/>
<Button text="Login" disable="${usernameTextField.text.empty}" />

Here's a SSCCE:

ButtonDisableTest.fxml:

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.scene.layout.VBox?>
<?import javafx.scene.control.TextField?>
<?import javafx.scene.control.Button?>

<VBox alignment="CENTER" spacing="5" xmlns:fx="http://javafx.com/fxml/1">
    <TextField fx:id="usernameTextField"/>
    <Button text="Login" disable="${usernameTextField.text.empty}" />
</VBox>

import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;

public class ButtonDisableTest extends Application {

    @Override
    public void start(Stage primaryStage) throws Exception {
        Parent root = FXMLLoader.load(getClass().getResource("ButtonDisableTest.fxml"));
        Scene scene = new Scene(root, 400, 400);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

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

JavaFX TextField listener

You can use ObservableList with appropriate extractor and add listener directly to list. This way it will be automatically watching changes in the specified properties of its elements. It is more convenient, than adding listener to each text field, but in this case you can't get old value:

    ObservableList<TextField> oList = 
        FXCollections.observableArrayList(tf -> new Observable[]{tf.textProperty()});  

    oList.addListener((ListChangeListener.Change<? extends TextField> c) -> {
        while (c.next()) {
            if (c.wasUpdated()) {
                for (int i = c.getFrom(); i < c.getTo(); ++i) {
                    System.out.println("Updated index: " + i + ", new value: " + c.getList().get(i).getText());
                }
            }
        }
    });

How get an event when text in a TextField changes? JavaFX

Or Use ChangeListener interface.

textField.textProperty().addListener(new ChangeListener<String>() {
    @Override
    public void changed(ObservableValue<? extends String> observable,
            String oldValue, String newValue) {

        System.out.println(" Text Changed to  " + newValue + ")\n");
    }
});

Javafx detect textfield change and determine caret position

It's not the intended use of the API, but you could use a TextFormatter constructed with an UnaryOperator<TextFormatter.Change> as parameter. This is usually used to prevent/modify undesired changes to the text, but in this case we'll just use the Change object to get you the data you want.

The following example "suggests" possibilities each one replacing the selected section with some string:

@Override
public void start(Stage primaryStage) throws Exception {
    ListView<String> listView = new ListView<>();

    String[] replacements = { "foo", "bar", "42", "zap" };
    listView.getItems().setAll(replacements);

    TextField textField = new TextField();
    TextFormatter<?> formatter = new TextFormatter<>((UnaryOperator<TextFormatter.Change>) change -> {
        int a = change.getAnchor();
        int b = change.getCaretPosition();
        String newText = change.getControlNewText();

        String prefix = newText.substring(0, Math.min(a, b));
        String suffix = newText.substring(Math.max(a, b));

        listView.getItems().clear();

        for (String mid : replacements) {
            listView.getItems().add(prefix + mid + suffix);
        }

        // do not change anything about the modification
        return change;
    });
    textField.setTextFormatter(formatter);

    Scene scene = new Scene(new VBox(listView, textField));

    primaryStage.setScene(scene);
    primaryStage.show();
}

There are plenty more properies available including the text and carret and anchor positions before the change, see the javadoc.

How to trigger the ChangeListener when TextField loses focus ? JAVAFX

I had the same problem some time ago, I solved it adding a Listener to the Focused property instead the Changed property. First create a Listener you can reuse:

private ChangeListener<Boolean> focusListener = new ChangeListener<Boolean>() {
    @Override
    public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
        if (!newValue) {
            sum(); //Do the sum logic here!!!
        }
    }
};

Then apply the change listener to all your textfields

credit1.focusedProperty().addListener(focusListener);
credit2.focusedProperty().addListener(focusListener);
credit3.focusedProperty().addListener(focusListener);
credit4.focusedProperty().addListener(focusListener);

You can implement your inner class this way to trigger the event every time a Textfield loses focus.

Hope it helps...

JavaFX: Run ChangeListener

There's no way to access a listener added to a property. Obviously you could just keep a reference to it:

ChangeListener<String> textFieldListener = (observable, oldValue, newValue) -> {

    if (!newValue.matches("\\d*")) {
        textField.setText(newValue.replaceAll("[^\\d]", ""));
    }

    if (newValue.isEmpty())
        textField.setText("0");

};

textField.textProperty().addListener(textFieldListener);
textFieldListener.changed(null, null, textField.getText());

or, perhaps more naturally, just move the actual functionality to a different method:

textField.textProperty().addListener((observable, oldValue, newValue) -> vetoTextFieldChanges());
vetoTextFieldChanges();

// ...

private void vetoTextFieldChanges() {
    String newText = textField.getText();
    if (!newText.matches("\\d*")) {
        textField.setText(newText.replaceAll("[^\\d]", ""));
    }

    if (newText.isEmpty())
        textField.setText("0");
}

Note that the whole approach of watching for changes and then modifying them if they are inconsistent with your business logic is not very satisfactory. For example, if you have other listeners registered with the property, they may see the intermediate (invalid) values of the text. The supported way to do this is to use a TextFormatter. The TextFormatter both allows you to veto changes that are requested to the text, before the textProperty() is updated, and to convert the text to an appropriate value. So in your case you could do:

UnaryOperator<TextFormatter.Change> filter = change -> {

    // remove any non-digit characters from inserted text:
    if (! change.getText().matches("\\d*")) {
        change.setText(change.getText().replaceAll("[^\\d]", ""));
    }

    // if new text is empty, replace all text with "0":
    if (change.getControlNewText().isEmpty()) {
        change.setRange(0, change.getControlText().length());
        change.setText("0");
    }

    return change ;
};

TextFormatter<Integer> formatter = new TextFormatter<Integer>(new IntegerStringConverter(), 0, filter);
textField.setTextFormatter(formatter);

Now you can use the formatter to get the (numeric) values directly via the formatter's value property, and bind them to your model, etc:

// assume model is a data model and valueProperty() returns a Property<Integer>:
formatter.valueProperty().bindBidirectional(model.valueProperty());

Note that a binding like this will both update the formatter (and consequently the text field) when the model changes, and will also initialize it depending on your model value (thus providing a solution for your original question).

Triggering calculation for specific textfield when other textfields change

I would just bind the textProperty of the 5th Textfield to the other textfields..something like this:

tf5.textProperty().bind(Bindings.createStringBinding(()->{
           //Do your calculation
           //Return result as String
           return result;
        }, tf1.textProperty(),tf2.textProperty(), tf3.textProperty(), tf4.textProperty()));

---

Related Topics