Discussion :

[dwp29]

Bonjour,

Je suis en train de programmer, sous Java / JFace, une application qui liste tous les fichiers

d'un répertoire passé en paramètre (la liste inclus aussi les sous-répertoires).
A la fin du traitement, un fenêtre s'ouvre et affiche la liste.
Jusque là, çà marche.

Sachant que le temps de traitement peut être long, j'ai prévu d'afficher une fenêtre de progression (ProgressMonitorDialog).
Le problème est que je perds le focus de la fenêtre de progression dès le début : ma trace m'indique en log que la prise en compte se fait correctement mais je n'ai aucune vision de cette fenêtre.

Fenêtre JFace

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
 
WorkLessOperation wlo = null;
 
try {
	wlo = new WorkLessOperation(true);
	new ProgressMonitorDialog(shell).run(true, true, wlo);
} catch (InvocationTargetException e) {
	MessageDialog.openError(shell, "Erreur", e.getMessage());
} catch (InterruptedException e) {
	MessageDialog.openInformation(shell, "Annulée", e.getMessage());
	display.dispose();
	return;
}
 
final ArrayList<ElmFusion> liste = initListe(param);
 
wlo.setFin();
wlo = null;
 
// Affichage page ....

Action de ma ProgressMonitorDialog

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
 
public class WorkLessOperation implements IRunnableWithProgress {
	private static final int TOTAL_TIME = 10000;
	private static final int INCREMENT = 500;
	private boolean indeterminate;
	IProgressMonitor monitor;
	Timer timer;
 
	public WorkLessOperation(boolean indeterminate) {
		this.indeterminate = indeterminate;
	}
 
	public void run(final IProgressMonitor monit) throws InvocationTargetException,	
 
InterruptedException {
		monitor = monit;
 
		monitor.beginTask("Opération en cours", indeterminate ?	
 
IProgressMonitor.UNKNOWN : TOTAL_TIME);
 
		timer = new Timer();
		timer.scheduleAtFixedRate(new TimerTask() {
			public void run() {
				System.out.println("DEBUT");	// Trace de debugging
				monitor.worked(INCREMENT);
				System.out.println("FIN");	// Trace de debugging
			}
		} , INCREMENT, INCREMENT);
 
		if (this.monitor.isCanceled()) {
			timer.cancel();
			throw new InterruptedException("Opération annulée");
		}
	}
 
	public void setFin() {
		timer.cancel();
		monitor.done();
	}
}

Merci à ceux qui prendront le temps de lire ce message et de réfléchir à mon problème.

[Gueritarish]

Salut,

Le Timer que tu utilises lances ton exécution dans un Thread séparé de celui du IRunnableWithProgress, donc, pour lui, c'est juste une tache, il ne sait pas qu'elle continue. Donc, ce qu'il fait c'est qu'il lance l'exécution du Timer puis se ferme. C'est pour ça que tu as l'impression de ne plus avoir le focus.

J'ai écrit un mini programme basé sur un Snippet SWT:

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
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
import java.lang.reflect.InvocationTargetException;
import java.util.Timer;
import java.util.TimerTask;
 
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
 
 
public class Snippet108 {
 
    public static void main(final String[] args) {
        Display display = new Display();
        final Shell shell = new Shell(display);
        Button ok = new Button(shell, SWT.PUSH);
        ok.setText("OK");
        final boolean indeterminate = true;
        ok.addSelectionListener(new SelectionAdapter() {
 
            public void widgetSelected(final SelectionEvent e) {
                try {
                    new ProgressMonitorDialog(shell).run(true, true,
                        new IRunnableWithProgress() {
 
                            private static final int TIME = 10000;
 
                            private static final int INCREMENT = 500;
 
                            /**
                             * {@inheritDoc}
                             */
                            public void run(final IProgressMonitor monitor)
                                throws InvocationTargetException,
                                InterruptedException {
                                monitor.beginTask("Testing monitors...",
                                    indeterminate ? IProgressMonitor.UNKNOWN
                                        : TIME);
                                final int[] processed = new int[1];
                                final boolean[] finish = new boolean[1];
                                finish[0] = !indeterminate;
                                processed[0] = 0;
                                Timer timer = new Timer();
                                timer.scheduleAtFixedRate(new TimerTask() {
 
                                    @Override
                                    public void run() {
                                        if (!indeterminate) {
                                            monitor.worked(INCREMENT);
                                        } else {
                                            finish[0] = processed[0] < TIME;
                                        }
                                        processed[0] += INCREMENT;
                                    }
 
                                }, INCREMENT, INCREMENT);
                                while (processed[0] < TIME || finish[0]) {
                                    if (monitor.isCanceled()) {
                                        break;
                                    }
                                }
                                timer.cancel();
                                monitor.done();
                            }
                        });
                } catch (InvocationTargetException e1) {
                    e1.printStackTrace();
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
            }
        });
        shell.setLayout(new RowLayout());
        shell.pack();
        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) {
                display.sleep();
            }
        }
        display.dispose();
    }
}

Tu dois garder ton exécution dans le IProgressWithRunnable qui est déjà dans un Thread à part de ton application.

Voilà, à+
Gueritarish

[dwp29]

Bonjour,

Merci pour cette réponse.
Effectivement çà marche mais çà ne correspond pas exactement à ce que je voulais faire : en fait, je vais avoir besoin de la fenêtre de progression à plusieurs endroits de mon appli et mon but était de créer une classe qui gère l'affichage de la barre de progression et qui puisse être appelée à plusieurs endroits de mon code en parallèle de mes taches.

Si ce n'est pas possible, tant pis je me rabaterait sur ta solution et je recoderais plusieurs fenêtres de progression.

Cdt.

[Gueritarish]

Salut,

Si tu regardes la Javadoc pour la classe ProgressMonitorDialog, tu pourras lire ce passage:

Note that the ProgressMonitorDialog is not intended to be used with multiple runnables - this dialog should be discarded after completion of one IRunnableWithProgress and a new one instantiated for use by a second or sebsequent IRunnableWithProgress to ensure proper initialization

Par contre, rien ne t'empêche de te faire une classe utilitaire qui prend en charge l'exécution de la tâche en question dans une ProgressMonitorDialog.
Une question pour toi: est-ce que tu utilises cela pour une application SWT/JFace classique ou est-ce que tu l'utilises pour des plug-ins Eclipse ou une application RCP?

Voilà, à+
Gueritarish

[dwp29]

Salut,

J'utilise cette classe pour une application JFace classique.

Cdt.