JavaFX: Como obter o estágio do controlador durante a inicialização?

Eu quero lidar com eventos de estágio (ou seja, esconder) da minha classe de controlador. Então, tudo o que tenho a fazer é adicionar um ouvinte via

((Stage)myPane.getScene().getWindow()).setOn*whatIwant*(...);

mas o problema é que a inicialização começa logo após

Parent root = FXMLLoader.load(getClass().getResource("MyGui.fxml"));

e antes

Scene scene = new Scene(root);
stage.setScene(scene);

portanto .getScene () retorna nulo.

A única solução alternativa que encontrei por mim mesmo é adicionar um ouvinte a myPane.sceneProperty () e, quando ele se tornar nulo, eu obtenho a cena, acrescente a ele .windowProperty () meu! Goddamn! ouvinte manipulação que finalmente recupero estágio. E tudo termina com a definição dos ouvintes desejados para organizar eventos. Acho que há muitos ouvintes. É a única maneira de resolver meu problema?

Você pode obter a instância do controlador FXMLLoaderapós a inicialização via getController(), mas precisa instanciar um em FXMLLoadervez de usar os métodos estáticos.

Eu passaria o estágio depois de chamar load()diretamente para o controlador:

FXMLLoader loader = new FXMLLoader(getClass().getResource("MyGui.fxml"));
Parent root = (Parent)loader.load();
MyController controller = (MyController)loader.getController();
controller.setStageAndSetupListeners(stage); // or what you want to do

Tudo que você precisa é fornecer AnchorPaneum ID, e então você pode obtê-lo a Stagepartir dele.

@FXML private AnchorPane ap;
Stage stage = (Stage) ap.getScene().getWindow();

A partir daqui, você pode adicionar o Listenerque você precisa.

Editar: conforme declarado pelo EarthMind abaixo, não precisa ser o AnchorPaneelemento; pode ser qualquer elemento que você definiu.

Eu sei que não é a resposta que você quer, mas IMO as soluções propostas não são boas (e o seu próprio jeito é). Por quê? Porque dependem do estado do aplicativo. No JavaFX, um controle, uma cena e um palco não dependem um do outro. Isso significa que um controle pode viver sem ser adicionado a uma cena e uma cena pode existir sem ser anexada a um palco. E então, em um instante t1, o controle pode ser anexado a uma cena e no instante t2, essa cena pode ser adicionada a um palco (e isso explica por que são propriedades observáveis ​​uma da outra).

Portanto, a abordagem que sugere obter a referência do controlador e invocar um método, passando o estágio para ele, adiciona um estado à sua aplicação. Isso significa que você precisa invocar esse método no momento certo, logo após a criação do estágio. Em outras palavras, você precisa seguir uma ordem agora: 1- Crie a etapa 2- Passe esta etapa criada para o controlador por meio de um método.

Você não pode (ou não deve) alterar esta ordem nesta abordagem. Então você perdeu a apatridia. E em software, geralmente, o estado é mau. Idealmente, os métodos não devem exigir nenhuma ordem de chamada.

Então, qual é a solução certa? Existem duas alternativas:

1- Sua abordagem, nas propriedades de escuta do controlador para entrar no palco. Acho que essa é a abordagem certa. Como isso:

pane.sceneProperty().addListener((observableScene, oldScene, newScene) -> {
    if (oldScene == null && newScene != null) {
        // scene is set for the first time. Now its the time to listen stage changes.
        newScene.windowProperty().addListener((observableWindow, oldWindow, newWindow) -> {
            if (oldWindow == null && newWindow != null) {
                // stage is set. now is the right time to do whatever we need to the stage in the controller.
                ((Stage) newWindow).maximizedProperty().addListener((a, b, c) -> {
                    if (c) {
                        System.out.println("I am maximized!");
                    }
                });
            }
        });
    }
});

2- Você faz o que precisa onde cria o Stage(e não é isso que você quer):

Stage stage = new Stage();
stage.maximizedProperty().addListener((a, b, c) -> {
            if (c) {
                System.out.println("I am maximized!");
            }
        });
stage.setScene(someScene);
...

A maneira mais simples de obter o objeto de estágio no controlador é:

1. Adicione um método extra na própria classe de controlador criada como (será um método setter para definir o estágio na classe de controlador),

   private Stage myStage;
   public void setStage(Stage stage) {
        myStage = stage;
   }
   

2. Coloque o controlador no método de início e defina o estágio

   FXMLLoader loader = new FXMLLoader(getClass().getResource("MyFXML.fxml"));
   OwnController controller = loader.getController();
   controller.setStage(this.stage);
   

3. Agora você pode acessar o estágio no controlador

Atribua fx: id ou declare a variável para / de qualquer nó: âncora, botão, etc. Em seguida, adicione o manipulador de eventos a ele e, dentro desse manipulador de eventos, insira o código fornecido abaixo:

Stage stage = (Stage)((Node)((EventObject) eventVariable).getSource()).getScene().getWindow();

Espero que funcione para voce!!

Platform.runLater funciona para evitar a execução até que a inicialização seja concluída. Nesse caso, quero atualizar a visualização de uma lista sempre que redimensiono a largura da janela.

Platform.runLater(() -> {
    ((Stage) listView.getScene().getWindow()).widthProperty().addListener((obs, oldVal, newVal) -> {
        listView.refresh();
    });
});

no seu caso

Platform.runLater(()->{
    ((Stage)myPane.getScene().getWindow()).setOn*whatIwant*(...);
});

Você pode obter com node.getScene, se você não ligar de Platform.runLater, o resultado é um valor nulo.

exemplo de valor nulo:

node.getScene();

exemplo sem valor nulo:

Platform.runLater(() -> {
    node.getScene().addEventFilter(KeyEvent.KEY_PRESSED, event -> {
               //your event
     });
});