JavaFX Fenétre d'attente

Version imprimable

Bonjour,

J'utilise JavaFX2 et j'ai voulu afficher une fenétre d'attente pour l'utilisateur pendant qu'un certain traitement s'éxécute. Le probléme est que ma fenétre s'affiche mais sans contenu.

Je vous communique mon code :

Ma fenetre :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
public class PreparingTestWindow {
    /*
     * The scene Title
     */
    Text title = new Text("Preparing Test Operation");
 
    /*
     * A layout to host the Text field and the button
     */
    HBox hboxLayout = new HBox(5);
    /*
     * The layout of the page
     */
    VBox layout = new VBox(10);
    /*
     * The stage of the page
     */
    Stage stage = new Stage();
 
                    /**
                     * The Default Constructor : builds the user interface of the page
                     */
                    public PreparingTestWindow() {
                        /*
                         * Set the style of the text title
                         */
                        title.setFill(Color.BLUE);
 
                        /*
                         * Progress Bar to show the preparation of the test
                         */
                         ProgressBar pb = new ProgressBar();
 
 
 
                        /*
                         * set the text field and the button in the same line (HBox)
                         */
                        hboxLayout.getChildren().addAll(pb);
 
 
                        /*
                         * Set all UI components in the final page layout
                         */
                        layout.getChildren().addAll(title,hboxLayout);
                        layout.setPrefWidth(400);
                        layout.setPrefHeight(100);
                        layout.setPadding(new Insets(10, 10, 10, 10));
                        stage.setScene(new Scene(layout));
                        stage.setTitle("Chose directory");
 
 
                    }
 
                    public void open() {
                        stage.show();
                    }
 
                    public void close() {
                        stage.close();
                    }
 
}

La fonction qui appelle la fenetre et l'affiche :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public void call() {
 
 
                         PreparingTestWindow window = new PreparingTestWindow();
 
 
		window.open();
                        StringBuilder sb= null;
                        WebServiceCallManager callManager = new WebServiceCallManager();
 
 
 
                                try {
 
 
                                        BusinessLog.logger.log(Level.INFO, " Calling /info web service !!");
 
                                        System.out.println("appel du web service /info");
                                        sb=callManager.CallInfoWebService();
                                        System.out.println(" fin appel du web service /info");
 
                                        BusinessLog.logger.log(Level.INFO, " End Calling /info web service !!");
                                        BusinessLog.logger.log(Level.INFO, " Response of /info web service is "+sb.toString());
 
 
 
 
 
 
                                        InfoWebServiceResponseParser infoParser = new InfoWebServiceResponseParser();
                                        Long parameterPages = infoParser.getNumberOfPages(sb);
                                        System.out.println("parameter pages extracted = "+parameterPages);
                                        GlobalParameters.setPagesParameter(parameterPages);
 
                                         window.close;
 
                                    } catch (Exception e) {
                                        e.getMessage();
                                        e.getLocalizedMessage();
                                        e.getClass();
                                        e.getStackTrace();
                                    }
 
 
 
                    }

Merci pour votre aide :)

27/06/2013, 12h18
jeffray03
salut,
remplace ceci :

Code:

Text title = new Text("Preparing Test Operation");

par :
Code:

1 2 TextField title = new TextField("Preparing Test Operation");
et ceci :

Code:

title.setFill(Color.BLUE);

par:

Code:

title.setStyle("-fx-text-fill: blue;");

Eric
27/06/2013, 12h59
albert55

Merci Eric pour la réponse , mais la fenétre s'affiche toujours sans contenu. En effet je crois qu'il s'agit plutot d'un probléme de thread parce que si retarde l'affichage de la fenétre aprés l'éxécution d'un autre traitement , elle s'affiche de la façon souhaitée.
27/06/2013, 13h15
bouye

Les traitements de tache de fond doivent s'exécuter dans un couple Service / Task ! :mrgreen:
27/06/2013, 13h17
jeffray03

ah ok, si tu la mets dans un thread, je crois qu´il faudra un wait pour qu´il puisse creer tout ses composantes.

voici un petit example que je viens de bidouiller :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.concurrent.Task;
import javafx.geometry.Insets;
import javafx.scene.Scene;
import javafx.scene.control.ProgressBar;
import javafx.scene.control.TextField;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
 
public class PreparingTestWindow
{
    /*
     * The scene Title
     */
    TextField title = new TextField("Preparing Test Operation");
 
    /*
     * A layout to host the Text field and the button
     */
    HBox hboxLayout = new HBox(5);
    /*
     * The layout of the page
     */
    VBox layout = new VBox(10);
    /*
     * The stage of the page
     */
    Stage stage;
 
    ProgressBar pb = new ProgressBar();
    Task copyWorker;
 
    /**
     * The Default Constructor : builds the user interface of the page
     */
    public PreparingTestWindow(Stage stage)
    {
        this.stage = stage;
        /*
         * Set the style of the text title
         */
        title.setStyle("-fx-text-fill: blue;");
        /*
         * Progress Bar to show the preparation of the test
         */
 
        /*
         * set the text field and the button in the same line (HBox)
         */
        hboxLayout.getChildren().addAll(pb);
 
        /*
         * Set all UI components in the final page layout
         */
        layout.getChildren().addAll(title, hboxLayout);
        layout.setPrefWidth(400);
        layout.setPrefHeight(100);
        layout.setPadding(new Insets(10, 10, 10, 10));
        stage.setScene(new Scene(layout));
        stage.setTitle("Chose directory");
 
    }
 
    @SuppressWarnings("rawtypes")
    public Task createWorker()
    {
        return new Task()
            {
                @Override
                protected Object call() throws Exception
                {
                    for (int i = 0; i < 10; i++)
                    {
                        Thread.sleep(2000);
                        updateMessage("2000 milliseconds");
                        updateProgress(i + 1, 10);
                    }
                    return true;
                }
            };
    }
 
    public void open()
    {
        stage.show();
    }
 
    public void close()
    {
        stage.close();
    }
 
    public void start()
    {
        title.setDisable(true);
        pb.setProgress(0);
 
        copyWorker = createWorker();
 
        pb.progressProperty().unbind();
        pb.progressProperty().bind(copyWorker.progressProperty());
 
        copyWorker.messageProperty().addListener(new ChangeListener<String>()
            {
                @Override
                public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue)
                {
                    System.out.println(newValue);
                }
            });
 
        new Thread(copyWorker).start();
    }
 
    public void stopp()
    {
 
        title.setDisable(false);
        copyWorker.cancel(true);
        pb.progressProperty().unbind();
        pb.setProgress(0);
        title.setText("cancelled.");
 
    }
}

et pour la tester en incluant la fonction call():

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Priority;
import javafx.stage.Stage;
 
public class Main_test extends Application
{
    private Button min, close, openfile;
    Stage stage;
    private PreparingTestWindow window;// = new PreparingTestWindow();
 
    @Override
    public void start(Stage stage)
    {
        this.stage = stage;
        window = new PreparingTestWindow(stage);
        stage.setTitle("Button Test");
 
        BorderPane borderpane = new BorderPane();
        setUpButtons();
        HBox hbox = new HBox();
        hbox.setSpacing(10);
        hbox.getChildren().add(openfile);
        HBox hbox1 = new HBox();
        hbox1.setAlignment(Pos.CENTER_RIGHT);
        hbox1.getChildren().addAll(min, close);
 
        hbox.getChildren().add(hbox1);
        HBox.setHgrow(hbox1, Priority.ALWAYS);
        borderpane.setTop(hbox);
 
        Scene scene = new Scene(borderpane, 800, 600);
        stage.setFullScreen(true);
        scene.getStylesheets().add("button.css");
        stage.setScene(scene);
        stage.show();
    }
 
    private void setUpButtons()
    {
        close = new Button("x");
        close.setId("closeBtn");
 
        min = new Button("_");
        min.setId("minBtn");
 
        openfile = new Button("Open file");
        openfile.setId("openFileBtn");
        openfile.setOnAction(new EventHandler<ActionEvent>()
            {
 
                @Override
                public void handle(ActionEvent event)
                {
                    call(stage);
                }
            });
        close.setOnAction(new EventHandler<ActionEvent>()
            {
 
                @Override
                public void handle(ActionEvent event)
                {
                    stopp();
                }
            });
 
    }
 
    public void call(Stage stage)
    {
        window = new PreparingTestWindow(stage);
 
        window.open();
        window.start();
 
    }
 
    public void stopp()
    {
        if (window != null)
        {
            window.stopp();
        }
 
    }
 
    public static void main(String[] args)
    {
        launch(args);
    }
 
}

j´espere que tu pourras y trouver un debut de solution.

Eric

27/06/2013, 15h12
bouye

Citation:

Envoyé par jeffray03

ah ok, si tu la mets dans un thread, je crois qu´il faudra un wait pour qu´il puisse creer tout ses composantes.

Dans la majorité des cas, il ne faut pas utiliser un Thread, mais un Service.
27/06/2013, 15h42
albert55

Malheureusement , ça n'a pas marché :(

salut a la place de:

Code:

1
2
3
4
5
6
7
 
for (int i = 0; i < 10; i++)
                    {
                        Thread.sleep(2000);
                        updateMessage("2000 milliseconds");
                        updateProgress(i + 1, 10);
                    }

tu as mis :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
StringBuilder sb= null;
                        WebServiceCallManager callManager = new WebServiceCallManager();
 
 
 
                                try {
 
 
                                        BusinessLog.logger.log(Level.INFO, " Calling /info web service !!");
 Thread.sleep(2000);
                        updateMessage("Appel du Web ServiceInfo");
 
                                        sb=callManager.CallInfoWebService();
                                        System.out.println(" fin appel du web service /info");
 
                                        BusinessLog.logger.log(Level.INFO, " End Calling /info web service !!");
                                        BusinessLog.logger.log(Level.INFO, " Response of /info web service is "+sb.toString());
 
 
 
 
 
 
                                        InfoWebServiceResponseParser infoParser = new InfoWebServiceResponseParser();
                                        Long parameterPages = infoParser.getNumberOfPages(sb);
                                        System.out.println("parameter pages extracted = "+parameterPages);
                                        GlobalParameters.setPagesParameter(parameterPages);
 
                                         window.close;
 
                                    } catch (Exception e) {
                                        e.getMessage();
                                        e.getLocalizedMessage();
                                        e.getClass();
                                        e.getStackTrace();
                                    }

et cela n´a toujours rien affiché? je vais tester cela dans la soirée.

... C'est toujours sympa quand on a l'impression de parler dans le vide... :fessee:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
private void doSomething() {
  ///////////////////////////////////////////////////////////////
  // ICI ON EST DANS LE JAVAFX APPLICATION THREAD. //
  ///////////////////////////////////////////////////////////////
  // Créer la GUI du popup/fenetre d'attente ici.
  final <Whatever> monUI = [...]
  [...]
  // L'afficher.
  [...]
  // Créer le service ici.
  final Service<Void> monService = new Service<Void>() {
     @Override 
     protected Task<Void> createTask() {  
        return new Task<Void>() {
          /////////////////////////////////////////////////////////////////
          // ICI ON EST DANS LA THREAD DE LA TACHE EN FOND. //
          ////////////////////////////////////////////////////////////////
          // Faire ma @#$%@#$ de tache ici!        
          // A intervalles réguliers, tester si la tache a été annulée.
          if (isCancelled()) {
             return null;
          }
          // Mettre a jour les messages.
          updateMessage("Truc");
          // Mettre a jour le progres.
          updateProgress(progress, totalProgress);
          [...]
          // Si tu veux faire des #$$$%#$%^ de Thread.sleep() ici, tu peux !
          [...]
          return null;
       };
    }
  }
  // Faire les bindings avec l'UI.
  monUI.monTitreLabel.textProperty().bind(monService.titleProperty());
  monUI.monMessageLabel.textProperty().bind(monService.messageProperty());
  monUI.maProgressBar.progressProperty().bind(monService.progressProperty());
 // Mettre les callbacks pour faire ce qui est nécessaire lorsque le service se termine.
  monService.setOnSucceeded(new EventHandler<WorkerStateEvent>(){
    public void handle(WorkerStateEvent event) {
      ///////////////////////////////////////////////////////////////
      // ICI ON EST A NOUVEAU DANS LE JAVAFX APPLICATION THREAD. //
      ///////////////////////////////////////////////////////////////
      // Cacher l'UI.
      // Penser a défaire le binding.   
      // Gérer le succès.
      // Si c'est un service qui retourne quelque chose :
      // <MachinChose> result = monService.getValue();
     [...]
    }
  });
  monService.setOnCancelled(new EventHandler<WorkerStateEvent>(){
    public void handle(WorkerStateEvent event) {
      ///////////////////////////////////////////////////////////////
      // ICI ON EST A NOUVEAU DANS LE JAVAFX APPLICATION THREAD. //
      ///////////////////////////////////////////////////////////////
      // Cacher l'UI.
      // Penser a défaire le binding.   
      // Gérer l'annulation si besoin.
     [...]
    }
  });
  monService.setOnFailed(new EventHandler<WorkerStateEvent>(){
    public void handle(WorkerStateEvent event) {
      ///////////////////////////////////////////////////////////////
      // ICI ON EST A NOUVEAU DANS LE JAVAFX APPLICATION THREAD. //
      ///////////////////////////////////////////////////////////////
      // Cacher l'UI.
      // Penser a défaire le binding.   
      // Gérer l'erreur.
      Throwable t = monService.getException();
      [...]
    }
  });
  // Démarrer le service.
  monService.start();
}

Merci bouye pour ta réponse , ça m'a vraiment aidé. Maintenant un nouveau probléme se pose : En effet , aprés l'affichage de ma fenétre et l'éxécution de son traitement et sa fermeture , j'ai un nouveau thread qui va se lancer pour exécuter un autre traitement. Actuellement les deux threads s'éxécutent en méme temps mais je veux que le deuxiéme thread s'éxécute seulement aprés la fermeture de la fenétre car ce thread va utiliser un résultat produit par le traitement de la fenétre. Pour les threads en java, l'instruction thread.join permet d'attendre ce thread avant de lancer un nouveau traitement, comment modéliser ça en javaFX.
Je te montre mon code pour bien comprendre la situation :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 /** * Show waiting window and execute /info call */ WebServicesListManagerPageController controller = new WebServicesListManagerPageController(); controller.showPreparingTestWindow(); // declaration deuxiéme thread (task) RegularTestGETExecutor t = new RegularTestGETExecutor(TestConfigPage.OrderedWSList, RequestsNumberTab); TabPaneManager.openAnalysesTablePage(); // Execution deuxiéme thread (Task) t.startTest();
Merci

30/06/2013, 22h41
bouye
Au choix :
- dans le callback gérant le succès (puisque c'est le seul cas où on est amené à lancer le second traitement), appeler une nouvelle méthode qui lancer le second traitement avec une architecture service similaire. On a deux deux services qui se lancent l'un après l'autre.
- faire une méta tache qui lance les deux traitements l'un après l'autre. si tu as vraiment besoin de changer l'UI au niveau de la progression, tu peux le faire en monitorant le progrès et les messages via des listeners* ou une autre propriété custom qui indique le passage d'une tache à une autre. On a donc un seul service et une tache qui fait les deux traitements.
*Pour la seconde méthode quelques avertissements :
- il n'est pas possible pour le progrès d'une tache de dépasser la valeur de progrès max (une exception est levée si c'est le cas) et je ne sais pas s'il est possible de setter une valeur de progrès plus basse que la précédente (jamais testé)
- Pour éviter de surcharger la pile d'event, les messages d'une tache sont agrégés. Il ne sont donc pas tous transmis à la JavaFX Application Thread. Si trop de messages ont lieu en succession, on en perds certain ce qui rend le monitoring d'une certaine valeur de message incertain.
- Ça doit être probablement la même chose pour les changements de la valeur de la propriété progress.