Discussion :

[Frobenius]

Bonjour,

Je désire créer un interface graphique en Java de cette manière :

Mon programme calcule des possibilités de solutions à un problème. Lorsqu'il trouve une solution, il affiche une fenêtre avec la solution et deux boutons, un pour arrêter le calcul et l'autre pour chercher la solution suivante.

Je voudrais donc que lorsqu'il ouvre la fenêtre:
1) Il s'arrête de calculer et attende de savoir ce qu'il doit faire.
2) Et que la suite dépende du bouton sur lequel on clique.

J'ai créé dans ma classe, une méthode qui affiche le résultat:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int AfficheResultat(int[][] X){
        ResultatFenetre fenetre = new ResultatFenetre(X,name);
        fenetre.setVisible(true);
        int x;
 
        /* c'est ici que je voudrais quelque chose du genre
        * if(on a cliqué sur bouton1){
        *    x = 1;
        * }
        * else if (on a cliqué sur bouton2){
        *    x = 0;
        * }
        */
 
        return x;
    }

Où ma classe ResultatFenetre ressemble à ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
class ResultatFenetre extends JFrame{
    int[][] Resultat;
    String[] Noms;
    public ResultatFenetre(int[][] X, String[] N){
        super();
        Resultat = new int[X.length][X[0].length];
        Resultat = X;
        Noms = new String[N.length];
        Noms = N;
        build(); //On initialise notre fenêtre
    }
 
    private void build(){
        setTitle("Prochaine possibilite");
        setSize(550,200); 
        setLocationRelativeTo(null);
        setResizable(true);
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        setContentPane(buildContentPane());
    }
    private JPanel buildContentPane(){
        JPanel panel = new JPanel();
        panel.setBackground(Color.white);
        GridLayout tableau = new GridLayout(Resultat.length+1, Resultat[0].length+1, 5,5);
        panel.setLayout(tableau);
        panel.applyComponentOrientation(ComponentOrientation.LEFT_TO_RIGHT);
        for (int i = 0 ; i < Resultat.length ; i ++){
            panel.add(new JLabel(Noms[i]));
            for (int j = 0; j < Resultat[i].length; ++j){
                String nome;
                if(Resultat[i][j] == 1){
                    nome = "X";
                } else{
                    nome = "-";
                }
                panel.add(new JLabel(nome));
            }
            System.out.println("er2");
        }
        panel.add(new JLabel(" "));
        JButton bouton1 = new JButton(new IciAction("Stop"));
 
        panel.add(bouton1);
        for (int i = 0; i< Resultat[0].length-3;i++){
            panel.add(new JLabel(" "));
        }
        JButton bouton2 = new JButton(new LaAction("Next"));
        panel.add(bouton2);
        panel.add(new JLabel(" "));        
        return panel;
    }
}

Avec les boutons

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class IciAction extends AbstractAction {
    public IciAction(String texte){
        super(texte);
    }
 
    public void actionPerformed(ActionEvent e) {
        System.out.println("Vous avez clique ici");
    } 
}
class LaAction extends AbstractAction {
    public LaAction(String texte){
        super(texte);
    }
 
    public void actionPerformed(ActionEvent e) { 
        System.out.println("Vous avez clique la");
    } 
}

J'ai déjà tenté de rajouter un attribut aux classes IciAction et LaAction, qui changent avec actionPerformed mais après je n'arrive pas à y accéder.

Quelqu'un saurait-il m'expliquer comment faire ?

Merci d'avance pour votre aide.

[Desboys]

Bonjour,

De ce que je comprends: votre algorithme de résolution de problème fait une analyse des solutions, et vous les propose tour à tour à l'écran, en les calculant à la suite.

Le flux de l'information est donc le suivant:
L'algorithme tourne jusqu'à trouver la prochaine solution.
Lorsqu'il a trouvé une solution, son état est figé, et on effectue un affichage proposant de "continuer" ou de "terminer" le traitement du programme.
Si "continuer" est activé, l'algorithme continue, à partir de son état précédemment figé.
Si "terminer" est activé, l'algorithme termine, nettoie ses éventuelles ressources, et le programme s'achève.

Puisqu'on utilise Swing, il faut penser "Multi-Thread".
Votre algorithme, ou du moins le bloc de code qui va l'activer pour calculer la prochaine solution, doit pouvoir transmettre à Swing l'ordre d'affichage de la fenêtre de solution ( voir SwingUtilities.invokeLater(Runnable) ).
Votre interface Swing, lorsqu'elle sera activée par l'un des deux boutons, doit pouvoir transmettre à l'algorithme ( qui, je le conseille, tourne dans un Thread à part ) les ordres correspondant à l'opération demandée.

Quelques conseils:
1/ il est préférable de suivre la convention de codage Java, pour des raisons de maintenabilité. Les attributs devraient commencer par une minuscule.
2/ externalisez votre composant d'affichage de solution (le JPanel avec son GridLayout ), ça désengorgera le code, et réduira les responsabilités de votre classe ResultatFenetre.

Cordialement,
Sébastien