Javafx сообщение об ошибке

git clone https://github.com/amcquistan/javafx-dialog-explorer.git
cd javafx-dialog-explorer

var alert = new Alert(Alert.AlertType.NONE);

alert.setTitle("I'm an alert title");
alert.setHeaderText("I'm an alert header");
alert.setContentText("I'm the main alert context (body)");

// showAndWait is a blocking call so, the code execution path pauses in 
// the executing JavaFX thread until the user interacts with the dialog
// in a way that causes it to close
Optional<ButtonType> result = alert.showAndWait();
result.ifPresent(btnType -> {
    var msg = String.format(
    		"You clicked %s in Alert %s",
    		btnType.getButtonData(),
    		BLOCKING_NONE_ALERT
    );
    feedbackLbl.setText(msg);
});

alert.getButtonTypes().addAll(ButtonType.OK, ButtonType.CANCEL);

var alert = new Alert(AlertType.INFORMATION);
alert.setTitle(BLOCKING_INFO_ALERT);
alert.setHeaderText(BLOCKING_INFO_ALERT);
alert.setContentText(BLOCKING_INFO_ALERT);

alert.showAndWait().ifPresent((btnType) -> {
    feedbackLbl.setText("Thats all from " + BLOCKING_INFO_ALERT);
    clearDialogOptionSelections();
});

var alert = new Alert(AlertType.WARNING);
alert.setTitle(BLOCKING_WARNING_ALERT);
alert.setHeaderText(BLOCKING_WARNING_ALERT);
alert.setContentText(BLOCKING_WARNING_ALERT);
alert.showAndWait().ifPresent((btnType) -> {
    feedbackLbl.setText("Thats all from " + BLOCKING_WARNING_ALERT);
    clearDialogOptionSelections();
});

var alert = new Alert(AlertType.CONFIRMATION);
alert.setTitle(BLOCKING_CONFIRM_ALERT);
alert.setHeaderText(BLOCKING_CONFIRM_ALERT);
alert.setContentText(BLOCKING_CONFIRM_ALERT);
alert.showAndWait().ifPresent((btnType) -> {
  if (btnType == ButtonType.OK) {
    feedbackLbl.setText("Confirmed " + BLOCKING_CONFIRM_ALERT);
  } else if (btnType == ButtonType.CANCEL) {
    feedbackLbl.setText("Cancelled " + BLOCKING_CONFIRM_ALERT);
  }
  clearDialogOptionSelections();
});

var alert = new Alert(AlertType.ERROR);
alert.setTitle(BLOCKING_ERR_ALERT);
alert.setHeaderText(BLOCKING_ERR_ALERT);
alert.setContentText(BLOCKING_ERR_ALERT);
alert.showAndWait().ifPresent((btnType) -> {
    if (btnType == ButtonType.OK) {
      feedbackLbl.setText("Thats all from " + BLOCKING_ERR_ALERT);
    }
    clearDialogOptionSelections();
});

var alert = new Alert(AlertType.ERROR);
alert.setTitle(NONBLOCKING_ERR_ALERT);
alert.setHeaderText(NONBLOCKING_ERR_ALERT);
alert.setContentText(NONBLOCKING_ERR_ALERT);

// Alert#show contrasts Alert#showAndWait where Alert#show is non-blocking 
// meaning that code within the execution path that contains the Alert 
// instance will continue to execute after Alert#show is called.
alert.show();

// the code below the show() method call will get exectued immediately
// after show() is called rather than wait on a user to close the dialog
alert.setOnHiding((evt) -> {
    feedbackLbl.setText("Thats all from " + NONBLOCKING_ERR_ALERT);
    clearDialogOptionSelections();
});

feedbackLbl.setText(NONBLOCKING_ERR_ALERT + 
    " execution path kept running after the dialog was displayed");

var alert = new Alert(AlertType.ERROR);
alert.setTitle(NONMODAL_ERR_ALERT);
alert.setHeaderText(NONMODAL_ERR_ALERT);
alert.setContentText(NONMODAL_ERR_ALERT);

// Alerts exhibit Modality.APPLICATION_MODAL by default but,
// you can specify WINDOW_MODAL to block the window or NONE
// to be non-modal at all.
alert.initModality(Modality.NONE);

// you can also hook into when Dialog's are initially shown using the
// inherited Dialog#setOnShowing event handler
alert.setOnShowing((evt) -> {
    feedbackLbl.setText("Go ahead, click another option. I won't stop you.");
});

alert.showAndWait().ifPresent((btnType) -> {
    if (btnType == ButtonType.OK) {
        feedbackLbl.setText("Thats all from " + NONMODAL_ERR_ALERT);
    }
    clearDialogOptionSelections();
});

var alert = new Alert(AlertType.INFORMATION);
alert.setTitle(ALERT_NO_HEADER);
// null as a value will cause the section to not be displayed
alert.setHeaderText(null);
alert.setContentText(ALERT_NO_HEADER);

alert.showAndWait().ifPresent((btnType) -> {
    if (btnType == ButtonType.OK) {
        feedbackLbl.setText("Thats all from " + ALERT_NO_HEADER);
    }
    clearDialogOptionSelections();
});

// Two constructors: TextInputDialog() and TextInputDialog(String)
// where the String is the default value
var txtDlg = new TextInputDialog(TEXT_DIALOG);
txtDlg.setTitle(TEXT_DIALOG);
txtDlg.setHeaderText(TEXT_DIALOG);
txtDlg.setContentText("Enter name of another dialog to open.");

// returns String optional
Optional<String> result = txtDlg.showAndWait();

// true => String (ie, user entered value and clicked ok)
// false => user clicked cancel
result.ifPresent(input -> {

    // find the VBox child node that is a DialogOption
    // and matches the user's input
    Optional<Node> matchedDlg = menuVBox.getChildren().stream()
        .filter(node -> {
            return !input.equalsIgnoreCase(txtDlg.getDefaultValue())
              && ((DialogOption) node).getText().equalsIgnoreCase(input);
        }).findFirst();

    if (matchedDlg.isPresent()) {
        // if present fire the action event of the underlying ToggleButton
        var dlgOption = (DialogOption) matchedDlg.get();
        dlgOption.fire();
        dlgOption.setSelected(true);
    } else {
        // otherwise let the user know they didn't type in something
        // that matched on of the titles of the available OptionDialog(s)
        dialogsToggleGrp.selectToggle(null);
        var notFoundAlert = new Alert(AlertType.WARNING);
        notFoundAlert.setTitle("Input Not Recognized");
        notFoundAlert.setHeaderText(null);
        notFoundAlert.setContentText(String.format("%s does not match a dialog from the menu", input));
        notFoundAlert.show();
    }
});

var titles = webResourceMap.keySet().stream()
    .filter(dlgOption -> !dlgOption.equals(CHOICE_DIALOG))
    .collect(Collectors.toList());

var defaultTitle = titles.get(0);
var choiceDlg = new ChoiceDialog<String>(defaultTitle, titles);

// returns Optional<String> on clicking ok
// or false if cancel is clicked
choiceDlg.showAndWait().ifPresent(selection -> {
  Optional<Node> matchedDlg = menuVBox.getChildren().stream()
      .filter(node -> ((DialogOption) node).getText().equals(selection))
      .findFirst();

  matchedDlg.ifPresent(node -> {
      var dlgOption = (DialogOption) matchedDlg.get();
      dlgOption.fire();
      dlgOption.setSelected(true);
  });
});

package com.thecodinginterface.dialogs;

import java.util.Timer;
import java.util.TimerTask;

import javafx.application.Platform;
import javafx.beans.property.IntegerProperty;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.event.ActionEvent;
import javafx.geometry.Pos;
import javafx.scene.control.Button;
import javafx.scene.control.ButtonBar;
import javafx.scene.control.ButtonType;
import javafx.scene.control.Dialog;
import javafx.scene.control.Label;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.VBox;
import javafx.scene.text.Font;
import javafx.scene.text.FontWeight;
import javafx.stage.Stage;
import javafx.stage.StageStyle;

class CountDownDialog extends Dialog<Integer> {
    private BorderPane root;
    private int startFrom;
    private IntegerProperty current;
    private Timer timer;

    private static final String PAUSE_TXT = "Pause";
    private static final String START_TXT = "Start";


    CountDownDialog(Stage primaryStage, int startFrom, String header, boolean decorated) {
        super();
        initOwner(primaryStage);
        if (!decorated) {
            initStyle(StageStyle.UNDECORATED);
        }
        
        this.startFrom = startFrom;
        current = new SimpleIntegerProperty(startFrom);

        root = new BorderPane();
        root.setTop(new Label(header));

        var countDownLbl = new Label();
        countDownLbl.textProperty().bind(current.asString());
        countDownLbl.setFont(Font.font("Cambria", FontWeight.BOLD, 60));
        var vbox = new VBox(countDownLbl);
        vbox.setAlignment(Pos.CENTER);
        root.setCenter(vbox);

        getDialogPane().setContent(root);

        var startStopBtnType = new ButtonType(PAUSE_TXT, ButtonBar.ButtonData.APPLY);
        var resetBtnType = new ButtonType("Reset", ButtonBar.ButtonData.BACK_PREVIOUS);
        var closeBtnType = new ButtonType("Close", ButtonBar.ButtonData.CANCEL_CLOSE);

        getDialogPane().getButtonTypes().addAll(startStopBtnType, resetBtnType, closeBtnType);

        var startStopBtn = (Button) getDialogPane().lookupButton(startStopBtnType);
        var resetBtn = (Button) getDialogPane().lookupButton(resetBtnType);
        
        startStopBtn.addEventFilter(ActionEvent.ACTION, (evt) -> {
            evt.consume();
            var startCounting = timer == null;
            if (startCounting) {
              startStopBtn.setText(PAUSE_TXT);
              startTimer();
            } else {
              startStopBtn.setText(START_TXT);
              stopTimer();
            }
        });

        resetBtn.addEventFilter(ActionEvent.ACTION, (evt) -> {
            evt.consume();
            resetTimer();
            startStopBtn.setText(START_TXT);
        });

        setResultConverter((btnType) -> {
            return Integer.valueOf(current.get());
        });

        startTimer();
    }

    private void startTimer() {
        if (timer == null) {
            timer = new Timer("Custom Dialog Countdown", true);
            timer.schedule(new CountDownTask(), 1000, 1000);
        }
    }

    private void stopTimer() {
        if (timer != null) {
            timer.cancel();
            timer = null;
        }
    }

    private void resetTimer() {
        current.set(startFrom);
        if (timer != null) {
            stopTimer();
        }
    }

    private final class CountDownTask extends TimerTask {
        @Override
        public void run() {
            Platform.runLater(() -> {
                int currentCnt = current.intValue();
                if (currentCnt > 0) {
                    current.set(currentCnt - 1);
                }
            });
        }
    }
}