Méthode close() Jframe

Version imprimable

21/04/2010, 16h19
bruno_nono

Méthode close() Jframe

Bonjour,

Dans mon application, je lance un graphique dans un Thread, or lors de la fermeture du graphique l'application se ferme. Je voudrais juste quitter l'interface graphique et redonner la main à l'application qui à lancer le graphique. J'ai essayer
this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
et HIDE_ON_CLOSE mais cela ne change rien, à chaque fois que je quitte l'interface graphique (avec la petite croix), cela ferme en même le processus père.

Comment dois je faire ?
22/04/2010, 13h16
DjGonk

Pourquoi n'utilises tu pas une JDialog et non pas une JFrame?
22/04/2010, 14h14
Heimdal

Salut,

tu dois faire un truc de travers car ca marche parfaitement... Fais voir ton code

Et qu'entends-tu par:

Citation:

je lance un graphique dans un Thread

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 private void graphique(){ try { Thread t = new Thread(this); // lancement du thread (méthode run()) t.start(); while (t.isAlive()){ } }catch (Exception e){} } public void run(){ traitement à exécuter }
Je n'utilise pas un Jdialog car j'utilise l'API Jfreechart... et donc c'est du jframe

Déroulement du processus je lance mon appli (qui a un menu)
option 1
option 2
etc..;
je sélectionne l'option correspondante au traçage de graphique il lance la fenêtre du graphique. J'ai crée un thread pour pouvoir en paralèlle continuer de sélectionner d'autres options, mais dès que je quitte le graphique, je n'ai plus la main sur le menu, pour cause l'application s'est terminée.

Merci d'avance !

23/04/2010, 10h49
tchize_

Citation:

Envoyé par bruno_nono

J'ai crée un thread pour pouvoir en paralèlle continuer de sélectionner d'autres options,

Ce n'est pas ce que dit ton code. Tu crée bien un thread, mais c'est inutile puisque tu attends ensuite la fin de ce thread. tu va même consommer inutilement des ressources CPU à boucle dans une boucle vide. Sans compter le catch(Exception e){} qui ne servira a rien d'autre qu'à cacher le moindre problème ;)

Si la fenetre se ferme, c'est qu'elle est en exit on close. Maintenant on peux pas t'en dire plus puisqu'on ne vois pas comment tu crée cette fenetre (le thread n'ayant rien à voir avec ton problème)

1) Oui pour le thread, je n'ai pas mis de system.err.println(ex).
Cependant je ne comprends t.start lance bien un thread ? La boucle est inutile car je lance le traitement dans le run() du thread. Est-ce correct ?
Code:

1 2 3 4 5 try { Thread t = new Thread(this); // lancement du thread (méthode run()) t.start(); }catch (Exception e){System.err.print(e);}
2) Pour le problème principal :
Code:

1 2 3 4 5 Graphique demo = new Graphique("Test") demo.pack(); RefineryUtilities.centerFrameOnScreen(demo); demo.setVisible(true);
Et dans la classe graphique, on a t.start() qui lance (je n'ai pas mis le traitement seulement les parties qui ont un rapport avec le graphique :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 JFreeChart chart = ChartFactory.createHistogram( "Test", null, null, dataset, PlotOrientation.VERTICAL, true, false, false ); ChartPanel chartPanel = new ChartPanel(chart); chartPanel.setPreferredSize(new java.awt.Dimension(500, 270)); setContentPane(chartPanel);
J'avais rajouté à la suite : setDefaultCloseOperation(HIDE_ON_CLOSE)

sauf que cela ne fonctionne pas.

J'espère que toutes les informations dont vous avez besoin y figure.

Merci ;)

26/04/2010, 10h33
tchize_

1) faire exécuter un traitement lourd en // n'est pas la problème, c'est bien ta boucle et le fait d'attendre ce thread qui rendait le thread inutile ;)

2) Difficile de t'aider avec quelques bouts de code plic/ploc sans contexte ni rien. Tu pourrais poster le code de la classe qu'on s'y retrouve un peu mieux? Je rajoute que si tu manipule "Graphique" dans le deuxième thread, tu va avoir des problèmes. Les composant AWT/Swing ne sont pas Thread Safe. A ce titre, il ne doivent pas être manipulé depuis des threads différents en même temps (ce qui semble être le cas).

Enfin, quand tu ferme la fenetre, est-ce qu'il y a d'autres fenetres toujours visible au moment ou l'application quitte?

Alors dans ma classe qui comporte le main() j'appelle la fonction lancementGraph() :

Code:

1
2
3
4
5
6
7
 
public static void graph(){
        Graphique demo = new Graphique("Graphique montant");
        demo.pack();
        RefineryUtilities.centerFrameOnScreen(demo);
        demo.setVisible(true);
}

Cela charge donc la classe graphique :

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
public class Graphique extends ApplicationFrame implements Runnable {
 
	private static final long serialVersionUID = 1L;
 
 
    public Graphique(final String title) {
    	super(title);
    	graphique();
    }
 
	private void graphique(){
		try {
			Thread t = new Thread(this);
			// lancement du thread (méthode run())
			t.start();
		}catch (Exception e){System.err.println(e);}
	}
 
	/** réalisation du graphique **/
	public void run(){
	      // note ::dataset comporte une liste de nombre.   
 
	        JFreeChart chart = ChartFactory.createHistogram(
	            "Distribution pertes", 
	            null, 
	            null, 
	            dataset, 
	            PlotOrientation.VERTICAL, 
	            true, 
	            false, 
	            false
	        );
 
	    ChartPanel chartPanel = new ChartPanel(chart);
	    chartPanel.setPreferredSize(new java.awt.Dimension(500, 270));
	    setContentPane(chartPanel);
	 }
}

ApplicationFrame vient du package jcommon

Je pense qu'il y a tout :)

edit: j'ai supprimé le thread pour le lancer 'normalement' (j'ai placé le code de run dans lancement, puis j'ai ajouté le setDefaultCloseOperation(HIDE_ON_CLOSE); cela ne fonctionne toujours pas.

Pour ce qui est du reste de l'application, sous eclipse je n'ai pu la main : elle est terminée (terminated)

Si la dernière fenetre est fermée, il est normal que l'application se termine, elle n'aura de toutes facons plus rien à faire, je vois pas comment tu voudrais encore faire quelque chose dedans (elle ne peux plus recevoir d'input, on est sorti du main et tous les threads ont fini leur travail)

Hormis ça, ta méthode de construction est dangereuse. Voici ce qui peux arriver

1) le pack est appelé alors qu'aucun graphe n'est présent sur la fenetre -> une fenetre de 1pixel
2) tu appelle le pack en même temps que ton thread du Graph ajoute le graphe à la liste des composants -> risque de crash, corruption de données, bug "bizzares" dans swing
3) tu ajoute le graphe alors que la fenetre est déjà dessinée à l'écran et se raffraichi -> même problème que ci-dessus, mais le conflit est entre l'EDT et ton thread.

Code pour éviter les conflit (ca ne supprime pas le risque que pack soit appelé sans contenu de fenetre):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 static Graphique demo; public static void graph(){ demo = new Graphique("Graphique montant"); swingUtilities.invokeLater(new Runnable(){ public void run(){ demo.pack(); RefineryUtilities.centerFrameOnScreen(demo); demo.setVisible(true); } }); }
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 public class Graphique extends ApplicationFrame implements Runnable { ChartPanel chartPanel; /** réalisation du graphique **/ public void run(){ // note ::dataset comporte une liste de nombre. JFreeChart chart = ChartFactory.createHistogram( "Distribution pertes", null, null, dataset, PlotOrientation.VERTICAL, true, false, false ); chartPanel = new ChartPanel(chart); chartPanel.setPreferredSize(new java.awt.Dimension(500, 270)); SwingUtilities.invokeLater(new Runnable(){ public void run(){ setContentPane(chartPanel); } } ); } }

26/04/2010, 14h01
bruno_nono

BAh si, quand je ferme la fenêtre du graphique, je souhaiterais continuer à travailler avec l'application

Je lance mon programme :

Menu
1) traitement 1
2) tracer le graphique
3) traitement 3
4)
5) etc..

Quand je rentrer 2 cela lance le graphique, quand je quitte ce graphique je ne peux plus rentrer d'autres choix (4 ou 5 par exemple).
Je désire une fois la fenêtre graphique terminée, pouvoir re-avoir la main sur le menu pour faire de nouvelles opérations!

Merci d'av!

ps : ok pour ce que tu m'as expliqué
26/04/2010, 14h08
tchize_

ce menu est affiché en mode texte dans le main? Si oui, regarde que tu n'a pas quitté déjà le main. Si le main n'a pas fini de s'exécuter, tu ne devrais pas sortir du programme.
26/04/2010, 14h11
bruno_nono
tout à fait, en mode texte , avec un switch case en l'occurence ici:
Code:

1 2 3 4 5 6 7 8 while(true){ switch(entier){ case i etc... (i = 1 à 4) case 5: /** Creation d'un graphique **/ graph(); break;
je ne quitte pas le main
26/04/2010, 14h14
tchize_

on peux voir le code du main entier? Tu n'a pas d'exception levée qui aurait interrompu la boucle?

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
	public static void menu(){
		System.out.println("---- Application test---- ");
 
		Scanner clavier = new Scanner(System.in);
		int choix;
		boolean typeMod = true ;
		while(true){
			System.out.println("Menu :\n"+"1: T1\n"+"2: T2\n"+"3: T3\n"+"4: T4 \n"+"5: Graphique \n"+"6: T6 \n");
			System.out.println("Quel est votre choix ?");
			choix = clavier.nextInt();
 
			switch(choix){
			case 1:
				appelT1();
				break;
			case 2: 
				appelT2();
				break;
			case 3: 
 				appelT3();
 
				break;
			case 4: 
 				appelT4();
				break;
			case 5:
		    	/** Creation d'un graphique **/
				graph();
				break;
			case 6:
 				appelT6();
		        break;
			default: break;
			}
		}
	}
 
	public static void main(String[] args) {
		menu();
	}

et graph appelle la méthode que j'ai posté plus haut, les autres méthodes n'ont pas besoin d'être spécificé.

26/04/2010, 14h31
tchize_

avant de fermer la fenetre, le menu a bien été réaffiché? (tu es bien à "entrez votre choix" ?)
26/04/2010, 14h34
bruno_nono

Oui , quand je rentre 5 il ouvre le graphique et ré-affiche le menu, tant que le graphique est ouvert je peux entrer des entiers pour appeler d'autres méthodes, mais dès que je termine l'application graphique, je n'ai plus la main... j'ai essayé d'obtenir plus d'infos en mode debug sous eclipse pour savoir ce qu'il se passait... mais pas d'infos trouvées (à mon niveau...)
26/04/2010, 14h40
tchize_

pourquoi étendre ApplicationFrame, si je lit la doc de ApplicationFrame, ce phénomène est normal, ApplicationFrame est justement dédiée à créer un fenetre qui quitte la JVM lorsque fermée 8O
26/04/2010, 15h02
bruno_nono

A base class for creating the main frame for simple applications. The frame listens for window closing events, and responds by shutting down the JVM. This is OK for small demo applications...for more serious applications, you'll want to use something more robust.

exacte, cela fonctionne maintenant... pourquoi j'ai utilisé cette classe ? Car pour les exemples java pour l'API JFreeChart que j'ai trouvé utiliser ApplicationFrame et pas une Jframe... je me suis dit que c'était sûrement pour avoir plus de propriétés...

ERREUR.

Merci pour le temps que tu as consacré à résoudre ce problème.

À l'avenir, je serais plus prévenant !