[SwingWorker]Complement d'infomation sur fonctionnement

Version imprimable

Bonjour à tous,

Comme cité dans un precedent topic, j'ai un traitement lourd et un affichage à effectuer.

On m'a conseillé le SwingWorker, je me suis donc rensigné et trouvé une faq dessus à l'adresse http://rom.developpez.com/java-swingworker/
J'ai lu avec attention les explications, mais j'i des difficulté à partager les 2 phases differentes, à savoir la lecture de fichiers et l'affichage de la progression.

Tout se melange dans ma lecture :(

Je vois els 2 bloc:

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
import java.awt.BorderLayout;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.util.List;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.ScrollPaneConstants;
import javax.swing.SwingUtilities;
import javax.swing.SwingWorker;
 
public class SwingWorkerDemo extends JFrame {
 
    private JTextArea textArea;
    private JTextField textField;
    private JProgressBar progressBar;
 
    class MonSwingWorker extends SwingWorker<Integer, String> {
 
        public MonSwingWorker() {
            /* On ajoute un écouteur de barre de progression. */
            addPropertyChangeListener(new PropertyChangeListener() {
                public void propertyChange(PropertyChangeEvent evt) {
                    if("progress".equals(evt.getPropertyName())) {
                        progressBar.setValue((Integer) evt.getNewValue());
                    }
                }
            });
        }
 
        @Override
        public Integer doInBackground() {
            File userDir = new File(System.getProperty("user.dir"));
            return getNombreDeFichiers(userDir, 0, 100);
        }
 
        /* Compte le nombre de fichiers du répertoire utilisateur. */
        private int getNombreDeFichiers(File dir, double progressStart, double progressEnd) {
            File[] files = dir.listFiles();
            int nb = 0;
            if(files.length > 0) {
                /* Le calcul de l'avancement du traitement n'a que peu d'importance pour l'exemple. */
                double step = (progressEnd - progressStart) / files.length;
 
                for(File f : files) {
                    progressStart += step;
 
                    /* Transmet la nouvelle progression. */
                    setProgress((int) progressStart);
 
                    /* Ajout d'un temps d'attente pour observer les changements à l'échelle "humaine". */
                    try {
                        Thread.sleep(50);
                    } catch(InterruptedException e) {
                        e.printStackTrace();
                    }
 
                    if(f.isDirectory()) {
                        /* Publication du répertoire trouvé. */
                        publish("Exploration du répertoire " + f.getAbsolutePath() + "...");
                        nb += getNombreDeFichiers(f, progressStart, progressStart + step);
                    } else {
                        /* Publication du fichier trouvé. */
                        publish(f.getAbsolutePath());
                        nb++;
                    }
                }
            }
            return nb;
        }
 
        @Override
        protected void process(List<String> strings) {
            /* Affichage des publications reçues dans le textarea. */
            for(String s : strings)
                textArea.append(s + '\n');
        }
 
        @Override
        protected void done() {
            try {
                /* Le traitement est terminé. */
                setProgress(100);
                /* À la fin du traitement, affichage du nombre de fichiers parcourus dans le textfield. */
                textField.setText(String.valueOf(get()));
            } catch(Exception e) {
                e.printStackTrace();
            }
        }
    }
 
// FIN PREMEIR BLOC
 
    public SwingWorkerDemo() {
        /* Construction de l'interface graphique. */
        super("SwingWorkerDemo");
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        textArea = new JTextArea(12, 40);
        textArea.setEnabled(false);
        textField = new JTextField(5);
        textField.setEnabled(false);
        progressBar = new JProgressBar();
        JPanel content = new JPanel(new BorderLayout());
        content.add(new JScrollPane(textArea,
		                            ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS,
				                    ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED));
        JPanel south = new JPanel(new BorderLayout());
        south.add(progressBar);
        south.add(textField, BorderLayout.EAST);
        content.add(south, BorderLayout.SOUTH);
        setContentPane(content);
        pack();
        setLocation(100, 100);
        setVisible(true);
    }
 
    public static void main(String... args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                /* Démarrage de l'interface graphique et du SwingWorker. */
                SwingWorkerDemo demo = new SwingWorkerDemo();
                MonSwingWorker swingWorker = demo.new MonSwingWorker();
                swingWorker.execute();
            }
        });
    }
 
}

Mais je n'arrive pas à en faire 2 class differente. J'ai l'impression que l'un est imbriqué dans l'autre.

Quelqu'un peut-il m'aider?
D'avance merci
PS: pour simplifier, imaginons que mon traitement long est une simple boucle for (i=0; i<100000; i++)

30/05/2007, 18h11
Terminator

Rebonjour,

Au fait, je souhaiterai subdiviser en deux la tache pour permettre une réutilisation de cette class avec differentes taches lourdes et longues.
De ce fait, j'aurai sous la main une class me donnant un jprogress.

D'avance merci
31/05/2007, 13h12
Terminator

Personne ne peut m'aider?

D'avance merci
04/06/2007, 17h53
xavlours

Bonjour,

as-tu été voir du côté du JProgressMonitor ? C'est peut-être ce que tu cherches.

Pour répondre à ta question d'origine, afin d'avoir deux classes vraiment séparées, il faut rendre la classe SwingWorker statique. Cela va toutefois l'empêcher d'accéder aux variables de la classe qui l'englobe. Une fois que tu as résolu ces problèmes, tu peux sans encombre déplacer la classe interne dans une autre fichier.
04/06/2007, 17h58
Terminator

Tout d'abord merci pour la reponse

Oui, j'avais été voir, mais là om je bloque:

Est-ce que la JprogressBar via le Monitor prend en charge DIRECTEMENT un traitement lourd? Pour ma part, je m'en fou un peu d'avoir des % qui défile, un simple truc infini me suffit!!!! Pour l'instant, l'utilisateur n'a aucun repere pour savoir si l'application tourne ou pas, si j'ai cette bar infinie, ca lui facilitera l'attente :)

Donc voila, j'ai une seule question: la prise en charge d'un triatement lourd se fait-elle automatiquement?

D'avance merci

J'arrive pas à trouver un truc simple à faire :(

Au fait, je veux juste un truc qui s'affiche qui donne l'info suivante à l'utilisateur:

Le traitement est en cours..

Que ce soit une jprogress ou autre!

Comment peut-on faire? Je rappel que c'est un traitement lourd, mais j'arrive pas à mettre en place le truc :(

J'ai entouré l'action lourde comme ceci

//******************************

//****************************

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
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
 
import java.awt.BorderLayout;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Toolkit;
 
import javax.swing.JButton;
import javax.swing.JFrame;
 
 
import java.awt.Rectangle;
import javax.swing.JTextField;
import java.awt.Font;
import java.awt.Color;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.StringTokenizer;
 
import javax.swing.JProgressBar;
import javax.swing.filechooser.FileFilter;
 
public class AnalysePrincipale extends JFrame {
 
	String docDejaAnalyses[];
	private JPanel jContentPane = null;
	private JButton jButtonFichierAnalyser = null;
	private JTextField jTextFieldFichierAnalyser = null;
	private JTextField jTextFieldFichier = null;
	private JButton jButtonLancerAnalyse = null;
	private JProgressBar jProgressBarPourcentage = null;
 
	/**
         * This method initializes jFrame       
         *      
         * @return javax.swing.JFrame   
         */
	 public AnalysePrincipale(String[] listeDocDejaAnalyses) {
	      super();
	      initialize();
	      docDejaAnalyses = listeDocDejaAnalyses;
	   }
	   private void initialize() {
		      this.setContentPane(getJContentPane());
		      this.setSize(713, 205);
	   }   
 
	/**
         * This method initializes jContentPane 
         *      
         * @return javax.swing.JPanel   
         */
	private JPanel getJContentPane() {
		if (jContentPane == null) {
			jContentPane = new JPanel();
			jContentPane.setLayout(null);
			jContentPane.setBackground(new Color(0, 204, 255));
			jContentPane.add(getJButtonFichierAnalyser(), null);
			jContentPane.add(getJTextFieldFichierAnalyser(), null);
			jContentPane.add(getJTextFieldFichier(), null);
			jContentPane.add(getJButtonLancerAnalyse(), null);
			jContentPane.add(getJProgressBarPourcentage(), null);
		}
		return jContentPane;
	}
 
	/**
         * This method initializes jButtonFichierAnalyser       
         *      
         * @return javax.swing.JButton  
         */
	private JButton getJButtonFichierAnalyser() {
		if (jButtonFichierAnalyser == null) {
			jButtonFichierAnalyser = new JButton();
			jButtonFichierAnalyser.setBounds(new Rectangle(581, 42, 114, 21));
			jButtonFichierAnalyser.setText("Parcourir...");
			jButtonFichierAnalyser.addMouseListener(new java.awt.event.MouseAdapter() {
				public void mousePressed(java.awt.event.MouseEvent e) {
					System.out.println("mouseClicked()"); // TODO Auto-generated Event stub mouseClicked()
					JFileChooser choix = new JFileChooser();
					choix.setApproveButtonText("choix");
					FileFilter doc = new FiltreSimple("Fichiers doc",".doc");
					choix.addChoosableFileFilter(doc);
					if (choix.showOpenDialog(jButtonLancerAnalyse)== JFileChooser.APPROVE_OPTION)
					{
						System.out.println("Choix :" + choix.getSelectedFile().getAbsolutePath());
						jTextFieldFichierAnalyser.setText(choix.getSelectedFile().getAbsolutePath());
					}
					StringTokenizer st ;
					String extensionFichier =""; 
					// On verifie si c'ets bien un doc
					st = new StringTokenizer(choix.getSelectedFile().getAbsolutePath(),".");
					while(st.hasMoreTokens())
					{
						extensionFichier = st.nextToken();
					}
					extensionFichier = extensionFichier.toLowerCase();
					System.out.println(extensionFichier);
					if (extensionFichier.equals("doc") == false)
					{
						JOptionPane.showMessageDialog(jButtonLancerAnalyse, "Le fichier choisi n'est pas un document .doc! Veuillez refaire votre choix.");
						jTextFieldFichierAnalyser.setText("");
					}
 
 
				}
			});
		}
		return jButtonFichierAnalyser;
	}
	/**
         * This method initializes jTextFieldFichierAnalyser    
         *      
         * @return javax.swing.JTextField       
         */
	private JTextField getJTextFieldFichierAnalyser() {
		if (jTextFieldFichierAnalyser == null) {
			jTextFieldFichierAnalyser = new JTextField();
			jTextFieldFichierAnalyser.setBounds(new Rectangle(16, 45, 555, 15));
			jTextFieldFichierAnalyser.setFont(new Font("Dialog", Font.PLAIN, 12));
			jTextFieldFichierAnalyser.setForeground(Color.blue);
			jTextFieldFichierAnalyser.setBackground(Color.yellow);
			jTextFieldFichierAnalyser.setEditable(false);
		}
		return jTextFieldFichierAnalyser;
	}
	/**
         * This method initializes jTextFieldFichier    
         *      
         * @return javax.swing.JTextField       
         */
	private JTextField getJTextFieldFichier() {
		if (jTextFieldFichier == null) {
			jTextFieldFichier = new JTextField();
			jTextFieldFichier.setBounds(new Rectangle(15, 15, 252, 14));
			jTextFieldFichier.setBackground(new Color(0, 204, 255));
			jTextFieldFichier.setForeground(Color.black);
			jTextFieldFichier.setFont(new Font("DialogInput", Font.BOLD, 12));
			jTextFieldFichier.setEditable(false);
			jTextFieldFichier.setText("Choisir le fichier à analyser: ");
		}
		return jTextFieldFichier;
	}
	/**
         * This method initializes jButtonLancerAnalyse 
         *      
         * @return javax.swing.JButton  
         */
	private JButton getJButtonLancerAnalyse() {
		if (jButtonLancerAnalyse == null) {
			jButtonLancerAnalyse = new JButton();
			jButtonLancerAnalyse.setBounds(new Rectangle(14, 76, 680, 60));
			jButtonLancerAnalyse.setText("Lancer l'analyse");
			jButtonLancerAnalyse.addMouseListener(new java.awt.event.MouseAdapter() {
				public void mousePressed(java.awt.event.MouseEvent e) {
					System.out.println("mousePressed()"); // TODO Auto-generated Event stub mousePressed()
					System.out.println(jTextFieldFichierAnalyser.getText());
 
 
 
					if (jTextFieldFichierAnalyser.getText().equals("") == false)
					{
						int dejaAnalyse =0;
						for (int i=0; i< docDejaAnalyses.length; i++)
						{
							if (jTextFieldFichierAnalyser.getText().equals(docDejaAnalyses[i]))
							{
								dejaAnalyse =1;
							}
						}
						if (dejaAnalyse == 0)
						{
							try
							{												
								String elements[] = new String[1];
								elements[0] = jTextFieldFichierAnalyser.getText();
								System.out.println("Avant de lancer doc");
								//EnCours EC = new EnCours();
								//EC.setVisible(true);									
								//EC.setLocationRelativeTo(null);
								JOptionPane.showMessageDialog(jButtonLancerAnalyse, "Lanalyse va débuter...elle durera quelques secondes." +
										"\nAppuyez sur OK pour continuer...");
								jContentPane.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
 
//***********************************************
int retour = Doc.doc(elements);
//*********************************************
								//EC.dispose();
								if (retour != -1)
								{									
									JOptionPane.showMessageDialog(jButtonLancerAnalyse,"Analyse terminée avec succès.");
									String fichierConfig = "./config.txt";
									File fichier = new File(fichierConfig);
									File fileDoc = new File(jTextFieldFichierAnalyser.getText());
									// si fichier config existe pas, on le crée
									if (fichier.exists() == false)
									{
										System.out.println("Le fichier " + fichierConfig + " n'existe pas");
										try
										{
											fichier.createNewFile();
										}
										catch(IOException ee)
										{
											JOptionPane.showMessageDialog(jButtonLancerAnalyse, "Probleme lors de la création du fichier de configuration, veuillez contacter l'administrateur du programme.");
										}
									}
									FileOutputStream fileOutConfig = new FileOutputStream(fichierConfig,true);
									String tmp = elements[0] + "***" + fileDoc.length()/1000 + "***0***" + retour +"***0\n";
									fileOutConfig.write(tmp.getBytes());
									dispose();
								}
								else
								{
									JOptionPane.showMessageDialog(jButtonLancerAnalyse, "Une erreur est survenue lors de l'anlyse, veuillez contacter ladministrateur du programme.");
									dispose();
								}
 
 
							}
							catch (Exception ex)
							{
								JOptionPane.showMessageDialog(jButtonLancerAnalyse,"Fichier non trouvé ou problème avec le fichier en cours d'analyse. Veuillez contacter l'administrateur du programme.");
							}
							finally
							{
								jContentPane.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
							}
						}
						else
						{
							JOptionPane.showMessageDialog(jButtonLancerAnalyse, "Le document que vous souhaitez analyser l'est deja. Une nouvelle analyse ne sera pas lancée.");
						}
					}
					else
					{
						JOptionPane.showMessageDialog(jButtonLancerAnalyse, "Veuillez choisir un fichier .doc à analyser.");
					}
				}
			});
		}
		return jButtonLancerAnalyse;
	}
	/**
         * This method initializes jProgressBarPourcentage      
         *      
         * @return javax.swing.JProgressBar     
         */
	private JProgressBar getJProgressBarPourcentage() {
		if (jProgressBarPourcentage == null) {
			jProgressBarPourcentage = new JProgressBar();
			jProgressBarPourcentage.setBounds(new Rectangle(13, 150, 677, 15));
			jProgressBarPourcentage.setStringPainted(true);
			jProgressBarPourcentage.setName("Progression : 0%");
			jProgressBarPourcentage
					.addChangeListener(new javax.swing.event.ChangeListener() {
						public void stateChanged(javax.swing.event.ChangeEvent e) {
							System.out.println("stateChanged()"); // TODO Auto-generated Event stub stateChanged()
							jProgressBarPourcentage.setString("Progression :" + jProgressBarPourcentage.getPercentComplete() * 100 + "%");
						}
					});
 
 
		}
		return jProgressBarPourcentage;
	}
 
 
}  //  @jve:decl-index=0:visual-constraint="33,9"

D'avance merci pour ceux qui pourront m'aider

04/06/2007, 22h44
Janitrix

Si tu cherches un moyen d'avertir l'utilisateur qu'un traitement long est en cours, et qu'il doit patienter, alors ProgressMonitor est ce qu'il te faut.
Si l'anglais te convient, regarde ce petit tutoriel de Sun.

Son utilisation est assez déroutante, mais ne te décourages pas, j'ai mis pas mal de temps à comprendre ça fonctionnait, mais on y arrive quand même.

Bonne chance.
04/06/2007, 22h47
Terminator

Merci pour ta reponse,

Masi l'anglais ne me deroute pas, juste que j'ai vraimeent enroememnt de mal à comprendre tout ca alors que je veux un truc tres simple, il faut se "taper" des trucs compliqués! Je ne comprends pas pq Java ne prends pas en chage par defaut de deux thread, un pour traitement et un pour l'affichage ?
05/06/2007, 10h34
Janitrix

Bah c'est comme ça, et ça convient à d'autres personnes, alors si on devait faire en sorte que le langage convienne à chacun... C'est pas bien difficile, faut y aller petit à petit, et ne pas espérer réussir du premier coup. Fait un code basic, puis enrichi le au fur et à mesure.

Bonne chance.
05/06/2007, 18h27
Terminator

Bonjour,

Avec toute la volonté du monde, je ne comprends pas grand chose :(

JE me concentre sur les jProgress indterminées:

progressMonitor PM = new ProgressMonitor(ProgressMonitorDemo.this,
"Running a Long Task",
"", 0, 100);

et qd j'en ai besoin, je fais:
PM.setNote("En cours");
PM.setProgress(30); (mais je veux une indertemriné...qui bouge tout le temps)

Mais je pense que c'est pas bon tout ca :(

La preuve que je n'y comprends rien
05/06/2007, 18h36
Janitrix

Citation:

By default, a progress monitor waits a minium of 500 milliseconds before deciding whether to pop up the dialog. It also waits for the progress to become more than the minimum value. If it calculates that the task will take more than 2000 milliseconds to complete, the progress dialog appears. To adjust the minimum waiting period, invoke setMillisToDecidedToPopup. To adjust the minimum progress time required for a dialog to appear, invoke setMillisToPopup.

By the simple fact that this example uses a progress monitor, it adds a feature that wasn't present in the version of the program that uses a progress bar: The user can cancel the task by clicking the Cancel button on the dialog. Here's the code in the example that checks to see if the user canceled the task or if the task exited normally:

if (progressMonitor.isCanceled() || task.isDone()) {
progressMonitor.close();
Toolkit.getDefaultToolkit().beep();
if (progressMonitor.isCanceled()) {
task.cancel(true);
taskOutput.append("Task canceled.\n");
} else {
taskOutput.append("Task completed.\n");
}
startButton.setEnabled(true);
}

C'est la partie la plus importante. Elle dit que par défaut, le ProgressMonitor attend 500 milliseconds avant de s'afficher et qu'il attend aussi que la valeur de la progress bar ne soit plus la valeur minimum. A partir de là, il calcul si la tache prendra en tout plus de 2 secondes : si oui, il affiche le progress monitor, sinon, il ne l'affiche jamais.

Le code montre comment tu peux savoir si la tache s'est terminée normalement ou si c'est l'utilisateur qui l'a annulée.

Où est le problème ?
05/06/2007, 18h52
Terminator

Ma tache dure plus de 10 secondes
Mais au fait le PM s'affiche mais à la fin (donc je reviens à mon probleme initiale de la non apparition de la barre avant la fin de la tache lourde).

Pour ma part, l'utilisateur ne peut ni l'arreter, ni intervenir, la barre infinie est là juste pour le faire patienter.

Le probleme vient, j'en suis certtain, de mes thread :(
05/06/2007, 18h54
Janitrix

Citation:

setMillisToPopup(0)

Le progress monitor devrait s'afficher rapidement, je pense (j'ai jamais testé).

Montre le code où tu invoques le ProgressMonitor s'il te plait.

Merci pour ton aide :)

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
ProgressMonitor PM = new ProgressMonitor(AnalysePrincipale.this,
            "Running a Long Task",
            "", 0, 100);  //  @jve:decl-index=0:
	Task task;
 
	class Task extends SwingWorker<Void, Void> {
        @Override
        public Void doInBackground() {
            Random random = new Random();
            int progress = 0;
            setProgress(0);
            try {
                Thread.sleep(1000);
                while (progress < 100 && !isCancelled()) {
                    //Sleep for up to one second.
                    Thread.sleep(random.nextInt(1000));
                    //Make random progress.
                    progress += random.nextInt(10);
                    setProgress(Math.min(progress, 100));
                }
            } catch (InterruptedException ignore) {}
            return null;
        }
 
        @Override
        public void done() {
            Toolkit.getDefaultToolkit().beep();            
            PM.setProgress(0);
        }
    }

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 public void propertyChange(PropertyChangeEvent evt) {
        if ("progress" == evt.getPropertyName() ) {
            int progress = (Integer) evt.getNewValue();
            PM.setProgress(progress);
            String message =
                String.format("Completed %d%%.\n", progress);
            PM.setNote(message);
 
            if (PM.isCanceled() || task.isDone()) {
                Toolkit.getDefaultToolkit().beep();
                if (PM.isCanceled()) {
                    task.cancel(true);
 
                } else {
 
                }
 
            }
        }
 
    }

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
PM.setNote("En cours");								
								PM.setProgress(0);
								task = new Task();
								task.addPropertyChangeListener(AnalysePrincipale);
								task.execute();
 
								PM.setProgress();*/
								// TACHE LOURDE
								int retour = Doc.doc(elements);
 
								PM.close();

05/06/2007, 19h11
Janitrix

Bah je vois pas comment t'aider là...

C'est un peu le bordel dans la méthode doInBackground. Dans ce genre de cas, ne fait que le strict minimum; vires tout le code qui te sert pas encore, tu le rajouteras après. Donc allèges un max ton code. Quand tu apprends à utiliser un nouveau composant chiant comme le Progress Monitor, la meilleur manière, où tu comprends bien et tu apprends facilement, c'est de faire des exemples bateaux.

Tu t'emmerdes pas avec des calculs chiants, tu te préoccupes seulement de faire marcher le composant. Donc apprends à utiliser ce composant hors de ton projet, fais des petits tests : un programme qui calcul la suite de Fibonacci, et tu essayes de mettre en place ton ProgressMonitor.

Tes mots d'ordres doivent être : simplicité, clarté, efficacité. Pas de perte de temps en code inutile, et essai de faire ça proprement, pour bien comprend qui fais quoi.

Bonne chance et bon courage ;)
05/06/2007, 19h17
Terminator

je vais suivre ton conseil :)

MErci encore :)

En fait, si tu veux créer un JProgressMonitor qui peut surveiller n'importe quel SwingWorker, il suffit de lui faire implémenter PropertyChangeListener. Un exemple de code pas testé :

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
public class SwingWorkerProgressMonitor extends JProgressMonitor {
 
  public SwingWorkerProgressMonitor(Component parent, Object message, SwingWorker worker,  int min, int max) {
    super(parent, message, "State : " + evt.getNewValue().toString(), min, max);
    worker.addPropertyChangeListener(this);
  }
 
  public void propertyChange(PropertyChangeEvent evt) {
    SwingWorker worker = (SwingWorker) evt.getSource();
    if ("progress".equals(evt.getPropertyName()) ) {
 
      if (worker.isCancelled()) {
        worker.cancel(true);
        setNote("Cancelled");
 
      } else if(worker.isDone()){
        setNote("Completed");
 
      } else { // normal progress event
        int progress = (Integer) evt.getNewValue();
        setProgress(progress);
        String message =
            String.format("Completed %d%%.\n", progress);
        setNote(message);
      }
 
    } else if("state".equals(evt.getPropertyName())) {
      setNote("State : " + evt.getNewValue().toString());
    }
 
    if(this.isCancelled())
      worker.cancel(true);
  }
}

Avec ceci, un SwingWorker qui ne s'occupe que de sa méthode doInBackground ira très bien.