BufferedImage et JInternalFrames

Version imprimable

Bonjour,

Je rencontre un petit soucis:
Je crée des graphiques dans une JInternalFrame que je place alors dans une BufferdImage, je vient ensuite demander avec un JmenuItem la sauvegarde de ce graphique jusque la je m'en suis sortit et j'obtient ce que je veut.
Cependant j'ai fait en sorte qu'a chaque fois que l'utilisateur clique sur un bouton ("Excel_Lancement") cela créer une nouvelle JInternalFrame à laquel je réaffecte un Jmenu et les JmenuItem.
Et c'est la que mon problème arrive en effet après de multiple recherche/test je n'arrive pas faire en sorte que l'image sauvegarder ne sois pas forcément la dernière que le programme à lu. Pour faire plus clair j'ai une class qui crée le graphique et qui le place dans un buffer nommé buff2 cependant à chaque nouvelle appui de bouton cette variable est donc réaffecter avec un nouveau graphique.

Le but serait donc de pouvoir naviguer entre les différentes JInternalFrame (qui contienne en fait 3 graphique) et pouvoir sauvegarder celui que l'on veut une fois sur la JInternalFrame qui le contient.

Je vous remercie par avance.

Et voici mon code:

La classe d'un 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
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 java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Shape;
import java.awt.geom.Ellipse2D;
import java.awt.image.BufferedImage;
 
import javax.swing.BorderFactory;
import javax.swing.JPanel;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.block.BlockBorder;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
import org.jfree.chart.title.TextTitle;
import org.jfree.data.xy.XYDataset;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
 
/*
 Définition du graphique dit "brut" donc sans souctraction du Background
 */
 
public class Graph_brut extends JPanel {
	String a1 = Excel.a1_2;
	String b1 = Excel.b1_2;
	double[] Int_brut = Excel.tabInt_brut;
	double[] Slide_brut = Excel.tabSlide_brut;
	public static JFreeChart chart2;
	public static BufferedImage buff2;
 
	public Graph_brut() {
 
		initUI();
	}
 
	private void initUI() {
		// /////////////DIMENSION ET PLACEMENT GRAPHIQUE/////////
 
		Dimension dim = new Dimension(600, 390);
		XYDataset dataset = createDataset();
		JFreeChart chart = createChart(dataset);
		ChartPanel chartPanel = new ChartPanel(chart);
		chartPanel.setPreferredSize(dim);
		chartPanel.setBorder(BorderFactory.createEmptyBorder(15, 15, 15, 15));
		chartPanel.setBackground(Color.white);
		add(chartPanel);
 
	}
 
	private XYDataset createDataset() {
 
		XYSeries series = new XYSeries("Intensity");
		for (int i = 1; i < Int_brut.length; i++) {
			double Int_3 = Int_brut[i];
			double Time_3 = Slide_brut[i];
			series.add(Time_3, Int_3);
		}
 
		XYSeriesCollection dataset = new XYSeriesCollection();
		dataset.addSeries(series);
 
		return dataset;
	}
 
	private JFreeChart createChart(XYDataset dataset) {
 
		int minTab2 = Integer.MAX_VALUE;
		int maxTab2 = Integer.MIN_VALUE;
		for (int i = 1; i < Int_brut.length; i++) {
			if (Int_brut[i] < minTab2)
				minTab2 = (int) Int_brut[i];
			if (Int_brut[i] > maxTab2)
				maxTab2 = (int) Int_brut[i];
 
		}
 
		final JFreeChart chart2 = ChartFactory.createXYLineChart(a1 + " brut",
				"Slide", "Fluorescence Intensity", dataset,
				PlotOrientation.VERTICAL, true, true, false);
 
		try {
 
			chart2.getXYPlot().getRangeAxis()
					.setRange(minTab2 / 1.1,maxTab2 * 1.1);
		} catch (IllegalArgumentException e) {
			System.out.println("Probleme d'axe du graph" + a1
					+ " brut , valeurs corrigés par défault");
		}
 
		XYPlot plot = chart2.getXYPlot();
 
		XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
		renderer.setSeriesPaint(0, Color.blue);
		renderer.setSeriesStroke(0, new BasicStroke(2.0f));
 
		double size = 5.0;
		double delta = size / 2;
		Shape marqueur = new Ellipse2D.Double(-delta, -delta, size, size);
		renderer.setSeriesShape(0, marqueur);
 
		plot.setRenderer(renderer);
		plot.setBackgroundPaint(Color.white);
 
		plot.setRangeGridlinesVisible(true);
		plot.setRangeGridlinePaint(Color.BLACK);
 
		plot.setDomainGridlinesVisible(true);
		plot.setDomainGridlinePaint(Color.BLACK);
 
		chart2.getLegend().setFrame(BlockBorder.NONE);
 
		chart2.setTitle(new TextTitle(a1 + " brut", new Font("Serif",
				java.awt.Font.BOLD, 18)));
 
		buff2= chart2.createBufferedImage(650, 500);
 
 
 
		return chart2;
 
	}
 
}

la classe de ma JInternalFrame avec une sauvegarde de graphique à la fin:

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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.awt.image.RenderedImage;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
 
import javax.imageio.ImageIO;
import javax.swing.DefaultDesktopManager;
import javax.swing.JComponent;
import javax.swing.JDesktopPane;
import javax.swing.JFileChooser;
import javax.swing.JInternalFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
 
import sun.java2d.SunGraphics2D;
 
 
 
 
/*
 Méthode permettant la création de trois JPanel qui récupère en fait les graphiques lié
 au méthode associé.
 */
public class fenetre extends JPanel {
 
	public static JPanel fenetre; // JPanel qui va accueillir 
								  // les trois graphiques
	public static Graph pan;
	public static BKG_graph pan2;
	public static Graph_brut pan3;
	public static JDesktopPane desk= Depart.desktop;
	public static JMenu Fichier;
	public static JMenuBar menuBar2;
 
 
	public  static  InternalImmovableFrame intfram; 
 
	public static JFileChooser Directory;
 
	public static String atot;
 
	public static JMenuItem save_graph, save_graph2,save_graph3 ,save_All1 ,
			save_graphAs, save_graph2As, save_graph3As, save_All1As;
 
 
 
 
	public fenetre() {
 
		fenetre = new JPanel();
		repaint();
 
		fenetre.setLayout(new BorderLayout());
 
		fenetre.setBackground(Color.gray);
 
		pan = new Graph();
		pan.setBackground(Color.gray); // fichier - BKG
		pan.setLocation(0, 0);
		fenetre.add(pan, BorderLayout.NORTH);
 
		pan2 = new BKG_graph();
		pan2.setBackground(Color.gray); // BKG
		pan2.setLocation(0, 0);
		fenetre.add(pan2, BorderLayout.EAST);
 
		pan3 = new Graph_brut();
		pan3.setBackground(Color.blue); // fichier brute
		pan3.setLocation(0,0);
 
		fenetre.add(pan3, BorderLayout.WEST);
 
		desk.setDesktopManager( new ImmovableDesktopManager() );
		intfram = new InternalImmovableFrame( Excel.a1_2+"-"+Excel.b1_2, true, true );
		intfram.add(fenetre, BorderLayout.CENTER);
		intfram.setJMenuBar(new Fichier_class() );
		desk.add(intfram);
		intfram.setBounds(0,0,Depart.width-15,Depart.height-125);
		intfram.show();
 
 
 
		}
	///////////// JINTERNALFRAME ///////////
 
    private static interface InternalImmovable {}
    /// création d'une fenêtre non déplaçable
    public static class InternalImmovableFrame extends JInternalFrame implements InternalImmovable {
        public InternalImmovableFrame( String title, boolean closeable, boolean iconifiable ) {
            super( title, false, closeable, false, iconifiable );
        }
    }
 
    public static class ImmovableDesktopManager extends DefaultDesktopManager {
         // création de l'espace qui va acceuillir la fenêtre non déplaçable
        public void dragFrame( JComponent f, int x, int y ) {
            if ( !( f instanceof InternalImmovable ) ) {
                super.dragFrame( f, x, y );
            } 
        }
    }
 
	public class  Fichier_class extends JMenuBar {
 
 
		public Fichier_class() {
// menu Fichier de nos JInternalFrames qui acceuille les différentes sauvegardes
 
 
			Fichier = new JMenu("Fichier");
			Fichier.removeAll();
 
 
			save_graph = new JMenuItem("Save Graph");
			save_graph2 = new JMenuItem("Save Graph_brut");
			save_graph3 = new JMenuItem("Save Graph_BKG");
			save_All1 = new JMenuItem("Save All_graph");
			save_graphAs = new JMenuItem("SaveAs Graph");
			save_graph2As = new JMenuItem("SaveAs Graph_brut");
			save_graph3As = new JMenuItem("SaveAs Graph_BKG");
			save_All1As = new JMenuItem("SaveAs All_graph");
 
			// Ajout au menu fichier des actions save et définition des actions
			// appelant les class associées //
 
			save_graph.addActionListener(new save_graph());
			save_graph2.addActionListener(new save_brut());
			save_graph3.addActionListener(new save_BKG());
			save_All1.addActionListener(new save_All());
			save_graphAs.addActionListener(new save_graphAs());
			save_graph2As.addActionListener(new save_brutAs());
			save_graph3As.addActionListener(new save_BKGAs());
			save_All1As.addActionListener(new save_All1As());
 
			Fichier.add(save_graph);
			Fichier.add(save_graph2);
			Fichier.add(save_graph3);
			Fichier.add(save_All1);
			Fichier.addSeparator();
			Fichier.add(save_graphAs);
			Fichier.add(save_graph2As);
			Fichier.add(save_graph3As);
			Fichier.add(save_All1As);
			this.add(Fichier);
			Fichier.revalidate();
 
 
		}
 
 
	//////////////////////////////////////////////
	// ////////////Les Sauvegardes//////////////////////////////////////////////
 
	// Save Graph_brut
	class save_brut implements ActionListener {
 
		public void actionPerformed(ActionEvent arg0) {
 
			try {
				if (Directory == null) {
 
 
					BufferedImage buff2= Graph_brut.buff2;
 
					Directory = new JFileChooser();
					Directory
							.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
					int retour2 = Directory.showOpenDialog(Directory);
 
					if (retour2 == JFileChooser.APPROVE_OPTION) {
						atot = Directory.getSelectedFile().getAbsolutePath();
 
						FileOutputStream fileOut2 = new FileOutputStream(atot
								+ "\\" + Excel.a1_2 + "_brut.PNG");
						ImageIO.write(buff2, "png", fileOut2);
						fileOut2.close();
 
					} else {
						System.out
								.println("Aucun Dossier de sauvegarde choisie");
						Directory = null;
					}
				} else {
 
 
					BufferedImage buff2= Graph_brut.buff2;
					File outputfile2 = new File(atot + "\\" + Excel.a1_2
							+ "_brut.PNG");
					ImageIO.write(buff2, "png", outputfile2);
 
				}
 
			} catch (IllegalArgumentException g) {
 
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (IOException a) {
				a.printStackTrace();
			}
		}
 
	}

Ma JFrame principal dans laquel je vient placer mes différent composant dont le bouton Excel_Lancement:

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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
 
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JDesktopPane;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
 
 
 
/*
 Cette méthode représente la définition de notre fenêtre d'interface. C'est donc
 dans celle-ci que nous venons créer les menus/boutons, auquel nous associons des fonctions,
 et les JPanel qui viennent afficher les graphiques.
 */
public class Depart extends JFrame {
 
	public static JPanel container = new JPanel();
	public static JPanel container2 = new JPanel();
	public static JOptionPane Format;
	public static JPanel south;
	public static int width;
	public static int height;
 
	public final static JMenuBar menuBar = new JMenuBar();
	public static JMenuBar menuBar2 = new JMenuBar();
	public final static JMenu FichierB = new JMenu("Fichier");
 
	public static JMenuItem Excel_lancer = new JMenuItem(
			"Lancer le Traitement Excel"),
 
	ImageJ = new JMenuItem("Lancer ImageJ");
 
	final static JButton Lancement_Excel = new JButton("Traitement Excel");
	final static JButton Lancement_Macro = new JButton("Infos Macro");
 
	final JButton Lancement_ImageJ = new JButton("Lancement ImageJ");
 
	public static fenetre fen;
	BufferedImage buff = Graph.buff;
	BufferedImage buff1 = BKG_graph.buff1;
	BufferedImage buff2 = Graph_brut.buff2;
 
	public static JDesktopPane desktop= new JDesktopPane();
 
 
 
	public Depart() {
 
		// Définition de notre JFrame qui doit prendre tous l'écran
		this.setTitle("Interface_ImageJ_excel");
 
		this.setIconImage(new ImageIcon("Interface_minia.png").getImage());
		// cette ligne permet de définir la maniature de notre JFrame
 
		Toolkit tk = Toolkit.getDefaultToolkit();
		Dimension d = tk.getScreenSize();
		Insets insets = tk.getScreenInsets(getGraphicsConfiguration());
		width = (int) (d.getWidth() - insets.left - insets.right);
		height = (int) (d.getHeight() - insets.top - insets.bottom);
		Dimension dimension = new Dimension(width, height);
		this.setSize(dimension);
		int x = (int) (insets.left);
		int y = (int) (insets.top);
		this.setLocation(x, y); // this étant L'instance de la JFrame
		this.setLocationRelativeTo(null);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		this.add(container);
 
		container2.setBackground(Color.gray);
		container2.setLayout(new BorderLayout());
 
		container.setBackground(Color.gray);
		container.setLayout(new BorderLayout());
 
		south = new JPanel();
		container.add(south, BorderLayout.SOUTH);
 
		Lancement_Macro.setSize(10, 20);
		south.add(Lancement_Macro, BorderLayout.CENTER);
		Lancement_Macro.addActionListener(new Macro());
		Lancement_Macro.setEnabled(true);
 
		Lancement_ImageJ.setSize(10, 20);
		south.add(Lancement_ImageJ, BorderLayout.CENTER);
		Lancement_ImageJ.addActionListener(new ImageJ_());
		Lancement_ImageJ.setEnabled(true);
 
		Lancement_Excel.setSize(10, 20);
		south.add(Lancement_Excel, BorderLayout.CENTER);
		Lancement_Excel.addActionListener(new Excel_lancement());
		Lancement_Excel.setEnabled(true);
 
		ImageJ.addActionListener(new ImageJ_());
 
		Excel_lancer.addActionListener(new Excel_lancement());
 
		desktop.setBackground(Color.gray);
 
		this.add(menuBar);
		menuBar.add(new Fichier_debase());
 
		this.setJMenuBar(menuBar);
		this.setContentPane(container);
		this.setVisible(true);
 
 
	}
 
 
	class  Fichier_debase extends JMenuBar {
		//Menu Fichier de l'interface
		public Fichier_debase() {
 
			FichierB.add(ImageJ);
			FichierB.add(Excel_lancer);
 
			this.add(FichierB);
		}
	}
 
	public void ChangeGraph() {
 
		this.container2.add(south, BorderLayout.SOUTH);
		this.setJMenuBar(menuBar);
		this.container2.add(fenetre.desk, BorderLayout.CENTER);
		this.setContentPane(container2);
		this.revalidate();
	}
 
 
 
	public class Excel_lancement implements ActionListener {
 
		public void actionPerformed(ActionEvent e) {
 
		Lancement_Excel.setEnabled(false);
		Excel exc = new Excel();
		exc.main(null);
 
		JPanel fen = new fenetre();
 
		Depart.this.ChangeGraph();
 
		Depart.this.setVisible(true);
 
		Lancement_Excel.setEnabled(true);
 
		} .......... 
 
	} ..........}

Aurelien2d.

12/06/2017, 16h12
joel.drigo

Salut,

Ton code est assez pénible à lire : aucun respect des conventions, et le "passage de paramètres" par static est une plaie. Et c'est justement là ton souci. N'utilise pas de static, passe des paramètres de méthode en méthode, déclare des attributs dans les classes concernées, et tu verras que ton problème disparaitra de fait.
13/06/2017, 14h34
Aurelien2d

Bonjour,

Pour ce qui est de la mise en forme/convention je vais regarder, mais comme j'ai plus ou moins appris seul à programmer j'avoue que je n'y avait pas fait attention. Par contre pour cette histoire de static j'ai essayer de l'enlever sur un maximum de mes variables, néanmoins sur des variable comme "directory" et "atot" je me vois obligé de garder le static si je veut que l'utilisateur n'est pas à spécifié son chemin à chaque fois.

Cependant je n'ai pas pour autant résolue mon problème de sauvegarde qui garde en mémoire seulement la dernière variable "buff2" et cela pour toute mes JInternalFrame.

Aurelien2d.

Citation:

Envoyé par Aurelien2d

Pour ce qui est de la mise en forme/convention je vais regarder, mais comme j'ai plus ou moins appris seul à programmer j'avoue que je n'y avait pas fait attention

Et encore, je n'avais pas tout lu : ton code est un véritable sac de nœuds et ça été vraiment difficile de m'y retrouver (j'ai d'ailleurs pu loupé des trucs). Ce n'est pas un reproche, c'est normal de la part d'un débutant, en particulier autodidacte (tout le monde le fait, je l'ai fait, et tout débutant le fera, à part exception qui prétend ne jamais l'avoir fait, mais qui se trompe et ça a même un nom : "le code spaghetti"). En plus du non respect des conventions, les noms de variables sans signification, ou à déclinaison numérique, c'est une plaie aussi (on s'y perd dans les pan1, pan2, pan3...)

Citation:

Envoyé par Aurelien2d

néanmoins sur des variable comme "directory" et "atot" je me vois obligé de garder le static si je veut que l'utilisateur n'est pas à spécifié son chemin à chaque fois.

Peu importe, non seulement tu peux avoir une classe qui défint une configuration (on appelle ça aussi un contexte) dont l'instance est partagée entre tous les composants, avec des attributs non static.

Mais dans ton cas, Directory (et non pas directory, parce que je ne vois aucune variable nommée directory dans le code que tu montres) est une variable de type JFileChooser (à ce sujet au passage, Directory.showOpenDialog(Directory); ça dit que Directory est le parent de Directory...le dialogue est le parent de lui-même... ça m'étonne d'ailleurs que tu ne payes pas une exception, mais bon, à part ça ce n'est pas très logique. Le paramètre ne sert qu'à définir le parent pour la modalité du dialogue et pour le centrage auto. Si ne sais pas quoi mettre, tu mets null, et le parent sera le composant courant (la fenêtre qui a le focus), sinon mettre la fenêtre principale.
Tu conserves donc la référence de l'instance de filechooser si l'utilisateur a approuver son choix, tout ça pour ne pas redemander le dossier de sauvegarde. Autant ne conserver que le dossier de sauvegarde.
Code:

1 2 3 4 5 6 f (retour2 == JFileChooser.APPROVE_OPTION) { atot = ... } else { atot = null; }
Du coup, plus besoin de conserver Directory, static ou pas.
Et au lieu de if ( Directory==null ), if ( atot==null)En plus, si tu fais :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 if ( atot==null ) { JFileChooser Directory = ... ... if ( retour2 == JFileChooser.APPROVE_OPTION ) { atot = ... } else { atot = null; } } if ( atot != null ) { // /////////////// FileOutputStream fileOut2 = new FileOutputStream(atot + "\\" + Excel.a1_2 + "_brut.PNG"); ImageIO.write(buff2, "png", fileOut2); fileOut2.close(); // /////////////// }
Plus besoin de dupliquer le code que j'ai mis entre // /////////////// et // ///////////////.

au passage, il vaut mieux écrire :
Code:

1 2 3 4 try(OutputStream fileOut2 = Files.newOutputStream(Paths.get(atot ,Excel.a1_2 + "_brut.PNG")) { ImageIO.write(buff2, "png", fileOut2); }
Tu garantiras la fermeture du flux, même en cas d'exception, et donc tu n'auras pas un fichier verrouillé qui traine.

Pour atot, c'est déjà plus difficile de suivre ton code. La variable n'est utiliser que dans l'instance de save_brut, une classe interne de fenetre, dont atot est une variable static.
fenetre étend JPanel, mais n'est jamais utilisée comme composant affiché : aucun intérêt donc. Elle n'est utilisée en fait que dans le cadre de son constructeur, pour créer un autre panel, qu'on stocke dans une variable static (on se demande pourquoi faire aussi, mais peut-être que tu ne nous montres pas tout le code et que c'est utilisée quelque part ailleurs).
Alors déjà, le fait de créer une classe fenetre qui a une variable static fenetre, c'est déjà bien vicelar question embrouiller le monde. Mais ne pas s'en servir, c'est le comble. Et utiliser une constructeur comme méthode, c'est aussi bien tordu. Quoiqu'il en soit, j'ai l'impression que le but est que chaque fois qu'on clic sur un bouton (Excel_lancement), on créé un panel avec un graph, et on demande à l'utilisateur s'il veut sauver son graphe dans un fichier. S'il a déjà répondu où, alors on ne lui demande pas, on sauvegarde directe.
Et si on avait un appel du genre (à une méthode static, là on peut) :

Code:

endroitOuOnSauvegarde = ClasseUtilitaire.creerLeGraphe(endroitOuAfficherLeGraphe, endroitOuOnSauvegarde);

On peut stocker endroitOuOnSauvegarde dans Excel_lancement, et plus besoin de variable static ailleurs.

Citation:

Envoyé par Aurelien2d

Cependant je n'ai pas pour autant résolue mon problème de sauvegarde qui garde en mémoire seulement la dernière variable "buff2" et cela pour toute mes JInternalFrame.

De la même façon, quand tu crées ton graphe, tu crées l'image, et tu la sauvegarde donc dans une variable statique. Valeur que tu réutilises ensuite dans un menu pour sauvegarder l'image).

En résumé, ton code :
Code:

1 2 3 4 5 fenetre = new JPanel(); repaint(); // aucun intérêt, ne sert à rien, ne fait rien, parce que le code exécuté est celui d'un JPanel, non affiché. Aucun intérêt de le dessin ou de le redessiner, il est invisible, ou plutôt même, il n'existe pas pour l'UI, puisqu'elle ne le connait pas (et ne le connaitra jamais, puisque tu n'ajoutes pas l'instance de fenetre à aucun composant. pan3 = new Graph_brut(); // ça crée le graphe, le transforme en image, et le stocke dans buff2
ensuite tu crées un menu, avec des actions, dont l'une d'entre elle utilise la variable buff2
Si si au lieu de faire
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 public class Graph_brut extends JPanel { /**...je supprime ce qui est inutile à montrer ici ...**/ public static JFreeChart chart2; public static BufferedImage buff2; public Graph_brut() { initUI(); } private void initUI() { JFreeChart chart = createChart(dataset); } private JFreeChart createChart(XYDataset dataset) { final JFreeChart chart2 = ChartFactory.createXYLineChart(a1 + " brut", "Slide", "Fluorescence Intensity", dataset, PlotOrientation.VERTICAL, true, true, false); buff2= chart2.createBufferedImage(650, 500); return chart2; } }
tu faisais :
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 public class Graph_brut extends JPanel { /**...je supprime ce qui est inutile à montrer ici ...**/ public JFreeChart chart2; public Graph_brut() { initUI(); } private void initUI() { chart2 = createChart(dataset); ChartPanel chartPanel = new ChartPanel(chart2); } private JFreeChart createChart(XYDataset dataset) { final JFreeChart chart = ChartFactory.createXYLineChart(a1 + " brut", "Slide", "Fluorescence Intensity", dataset, PlotOrientation.VERTICAL, true, true, false); return chart; } public Image createimage() { return chart2.createBufferedImage(650, 500); } }
tu pourras, dans ton action de menu, appeler BufferedImage buff2 = pan3.createImage(); et obtenir ton image (que tu ne seras pas même obligé de créer d'avance même si l'utilisateur ne clique pas sur le menu). Et la variable pan3 est bien une instance de composant dans le même contexte (internal frame) que le menu associé. Pas une variable statique en tout cas, partagée entre toutes les menus de toutes les internal frames (présentee, et surtout passéee).

14/06/2017, 15h52
Aurelien2d
Bonjour,

Merci beaucoup pour vos conseils ainsi que le temps que vous m'avez consacré. Grâce à vos conseil j'ai réussi à corriger mon problème et tout semble fonctionner comme je le souhaitais.
Mis à part cette partie :
Code:

1 2 3 4 try(OutputStream fileOut2 = Files.newOutputStream(Paths.get(atot ,Excel.a1_2 + "_brut.PNG")) { ImageIO.write(buff2, "png", fileOut2); }
Lorsque j'utilise cette sauvegarde la correction Eclipse me demande de passer tout mon projet et mon JRE en version 1.7 or j'ai développé tout mon code avec la librairie "jre1.8.0_131" donc par précaution je garde la méthode sans "try".

Encore merci pour cette aide =)
14/06/2017, 18h23
joel.drigo

Citation:

Envoyé par Aurelien2d

[...]
Lorsque j'utilise cette sauvegarde la correction Eclipse me demande de passer tout mon projet et mon JRE en version 1.7 or j'ai développé tout mon code avec la librairie "jre1.8.0_131" donc par précaution je garde la méthode sans "try".

Euh, quoi ? Tout ce qui peut être fait en Java 1.7, peut être fait en Java 1.8. Et le try/with/resource existe bien en Java 8. Tu as dû mal lire le message. Ou pire, tu développes avec Java 8, mais en compatibilité 1.6 !
15/06/2017, 11h15
Aurelien2d

J'utilise l'espace de travail qu'Eclispe me propose par défaut donc "JRE (jre1.8.0_131)" que j'ai télécharger depuis le site oracle.com. Quand j'accepte la modification l'environnement devient javaSE-1.7(jre1.8.0_131) et votre méthode fonctionne. Et dans le message d'avertissement effectivement il semblerai que la version que j'utilise ne sois pas la 1.8 car il est spécifié "Resource specification not allowed here for source level below 1.7"
15/06/2017, 11h34
joel.drigo

1 pièce(s) jointe(s)

Regarde les préférences de ton projet :

Pièce jointe 285830

On peut utiliser une JRE ou JDK 1.8 (il vaut mieux d'ailleurs utiliser un JDK), et dire qu'on veut travaille et compiler en 1.6 (ce qui s'appelle dans le dialogue, compliance level).
15/06/2017, 11h58
Aurelien2d

Merci Beaucoup, effectivement la version était en 1.4, surement mise par défaut que j'ai pu changer pour 1.8.

Sur ce je clos la discussion.