JProgressBar et animation

Version imprimable

Bonjour,

J'ai une JProgressBar qui s'actualise toutes les secondes.
J'aimerais que pendant cette seconde, ma JProgressBar s'actualise "en douceur" et non d'un coup.
Je m'explique: Je voudrais qu'elle s'update progressivement afin de créer un effet "smooth" et plus agréable à l’œil.

Un existe avec l'API java (ou avec une autre) pour faire cela?
J'ai tenté avec une boucle for mais sans succès:
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 int value = 0; int last = 0; int difference = 0; int i; while(value >= 0) { /*Ma méthode pour trouver "value" est ici*/ difference = value - last; if(difference < 0){ for ( i = last ; i <= value && difference <= 0; difference++ , i++) { bar.setValue(last + difference); //Refreshing the bar } } else { for ( i = last ; i >= value && difference >= 0 ; difference-- , i--) { bar.setValue(last + difference); //Refreshing the bar } } last = value; try { t.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } }
Avec ce code, la barre ne s'actualise pas bien et si elle le fait, ce n'est pas comme je le souhaiterais.
Où sont mes erreurs s'il vous plait?

Salut,

En fait, tu peux le faire directement avec la JProgressBar, mais il ne faut surtout pas chercher à faire la boucle dans l'EDT (le Thread de SWING). Je verrais bien un système de gestion de valeur intermédiaire avec 2 variables : la variable qui constitue la valeur réelle d'avancement (celle qu'on affecte à la barre de progression, et la variable qui constitue la valeur intermédiaire, qu'on incrémente ou décrémente dans un thread.

Voici un POC rapide, sous forme de décorateur (mais ça peut être intéressant d'étendre JProgressBar en JSmoothProgressBar) :

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
public class SmoothProgressBarManager {
 
	private final Object OBJ = new Object();
	private SmoothProgressBarAnimation thread;
	private final JProgressBar progressbar;
	private int value;
	private int currentValue;
	private final Runnable progressRunnable;
	private boolean disposed; 
	private final long time;
 
	public SmoothProgressBarManager(final JProgressBar progressbar) { 
		this(progressbar, 100);
	}
 
        /**
         * 
         * @param progressbar la {@link JProgressBar} 
         * @param time la durée entre chaque incrémentation
         */
	public SmoothProgressBarManager(final JProgressBar progressbar, long time) { 
		this.time=time>0?time:0;
		this.progressbar=progressbar;
		this.currentValue=0;
		this.progressRunnable = new Runnable() {
			public void run() {
				progressbar.setValue(currentValue);
			}
		};
		this.progressbar.setValue(0);
	}
 
	public void setValue(int value) {
		if ( disposed ) throw new IllegalStateException();
		this.value=value;
		if ( currentValue!=value ) {
			synchronized (OBJ) {
				if ( thread==null || !thread.running ) {
					thread = new SmoothProgressBarAnimation();
					thread.start();
				}
				else {
					OBJ.notify(); // on relance le thread mis en wait le cas échéant
				}
			}
		}
	}
 
	public void dispose() {
		if ( !disposed ) {
			disposed=true;
			if ( thread!=null ) {
				thread.running=false;
				thread.interrupt();
			}
		}
	}
 
	public boolean isDisposed() {
		return disposed;
	}
 
	public boolean isValueReached() {
		return currentValue==value;
	}
 
	private final class SmoothProgressBarAnimation extends Thread {
 
		private volatile boolean running;
 
		@Override
		public void run() {
			running = true;
			while(running) {
				while( running && currentValue!=value ) {
					if ( currentValue<value ) {
						currentValue++;
					}
					else if ( currentValue>value ) {
						currentValue--;
					}
					updateProgressBar();
					if ( time>0 ) {
						try {
							Thread.sleep(time);
						} catch (InterruptedException e) {
							running=false;
						}
					}
					else if ( interrupted() ) {
						running=false;
					}
				}
				synchronized (OBJ) {
					try {
						OBJ.wait(); // on met le thread en état d'attente pour éviter qu'il ne consomme du cpu pour rien
					} catch (InterruptedException e) {
						running=false;
					}
				}
			}
		}
 
	}
 
	protected void updateProgressBar() {
		SwingUtilities.invokeLater(progressRunnable);
	}
 
}

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
public class DemoJProgressBar {
 
	private final static int MAX = 100; // nombre d'étapes
 
	public static void main(String[] args) {
 
		final JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		JProgressBar progressbar = new JProgressBar(0, MAX);
 
		final SmoothProgressBarManager manager = new SmoothProgressBarManager(progressbar);
 
		JPanel panel = new JPanel();
		panel.setLayout(new BorderLayout());
		panel.add(progressbar, BorderLayout.CENTER);
		frame.setContentPane(panel);
 
 
 
		frame.setSize(200, 200);
		frame.setLocationRelativeTo(null);
 
		final Thread process = new Thread() {
 
			public void run() {
 
				System.out.println("Je simule un process...");
 
				int i=0;
				while( i<100 ) {
 
					int n = 5 + (int) (Math.random()*10);
 
					i+=n;
					if ( i>100 ) {
						n=i-100;
						i=100;
					}
					System.out.printf("Traitement de %d/%d...",n,MAX);
 
					if ( !manager.isDisposed() ) {
						manager.setValue(i);
					}
 
					try {
						Thread.sleep(1000); // simulation process long
					} catch (InterruptedException e) {
						break;
					} 
 
					System.out.println(" fini.");
 
				}
 
				System.out.println("Fin du process");
				frame.dispose();				
				System.exit(0); 
 
			};
 
		};
 
		frame.addWindowListener(new WindowAdapter() {
			@Override
			public void windowOpened(WindowEvent arg0) {
				process.start();
			}
			@Override
			public void windowClosed(WindowEvent e) {
				manager.dispose(); // on dispose que le manager si la fenêtre est fermée
			}
		});
		frame.setVisible(true); 
 
	}
 
}

J'aime bien l'idée. Mais il faudrait que la valeur de la progressBar puisse diminuer également... Je crois bien que c'est possible avec ton code.

Dans mon code, ça donne ça:

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
	class Traitement implements Runnable{
 
	    @SuppressWarnings("static-access")
		public void run() { 
	    	int CPUUse = 0;
 
 
	    	//-------------------Refreshing loop---------------------
	    	int i = 0;
	    	while(i < 100) {
 
	    		try {
	    			CPUUse = getCpuUsage();
	    		} catch (SigarException e2) {
	    			e2.printStackTrace();
	    		}
 
	    		i+=CPUUse;
				if ( i>100 ) {
					CPUUse=i-100;
					i=100;
				}
 
				if ( !manager.isDisposed() ) {
					manager.setValue(i);
				}			
 
 
	    		try {
	    			t.sleep(1000);
	    		} catch (InterruptedException e) {
	    			e.printStackTrace();
	    		}
	    	}
 
 
	    	//-----------------------------------------------------
	    }   
	}

Ma barre reste à 0. Aurais-je oublié quelque chose?

edit: La valeur de CPUUse est en pourcentage. min=0 max=100

Citation:

Envoyé par JeremGamer

J'aime bien l'idée. Mais il faudrait que la valeur de la progressBar puisse diminuer également... Je crois bien que c'est possible avec ton code.

Oui, c'est le cas.

Citation:

Envoyé par JeremGamer

Ma barre reste à 0. Aurais-je oublié quelque chose?

A part que CPUse soit toujours à 0, je ne vois pas, avec le seul code que tu montres

Citation:

Envoyé par JeremGamer

edit: La valeur de CPUUse est en pourcentage. min=0 max=100

Est-ce que, du coup, le code ne serait pas plutôt tout simplement (en fait, tu voudrais te servir d'une barre de progression pour afficher une jauge) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 public void run() { while(running) { try { int cpuUse = getCpuUsage(); if ( !manager.isDisposed() ) { manager.setValue(cpuUse); } } catch (SigarException e2) { e2.printStackTrace(); } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }
Edit : ça, le truc en rouge, c'est inutile :
Code:

1 2 3 4 if ( i>100 ) { CPUUse=i-100; i=100; }
je l'avais mis juste à cause de la trace juste après, et d'ailleurs, j'ai fait une petite erreur : il fallait lire :
Code:

1 2 3 4 if ( i>100 ) { n-=i-100; i=100; }

18/04/2014, 14h13
JeremGamer

Citation:

Envoyé par joel.drigo

Est-ce que, du coup, le code ne serait pas plutôt tout simplement (en fait, tu voudrais te servir d'une barre de progression pour afficher une jauge) :

Oui c'est bien ce que je veux faire. Mais dans le dernier bout de code que tu m'as montré. Où l'actualisation de ma barre est demandée?

edit: autant pour moi j'ai lu trop vite! :oops:
18/04/2014, 14h15
joel.drigo

Citation:

Envoyé par JeremGamer

Oui c'est bien ce que je veux faire. Mais dans le dernier bout de code que tu m'as montré. Où l'actualisation de ma barre est demandée?

Le thread dans SmoothProgressManager incrémente (ou décrémente) currentValue, et appelles updateProgressBar(), qui invoque, sur l'EDT, la méthode setValue(currentValue) de JProgressBar : cet appel rafraîchit l'affichage.
18/04/2014, 14h19
joel.drigo

Tu devrais jeter un coup d'oeil à SteelSeries.

Voici le code complet de ma classe: (ça t'aidera peut-être)

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
package main;
 
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
 
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
 
import org.hyperic.sigar.CpuPerc;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;
 
@SuppressWarnings("serial")
public class CPUUsagePanel extends JPanel {
 
	private final static int MAX = 100;
	private Thread t;
	private JProgressBar bar = new JProgressBar(0 , MAX);    
	JLabel percent = new JLabel( "" );
	final SmoothProgressBarManager manager = new SmoothProgressBarManager(bar);
 
	//-----------------------------------------------------------
	//Getting CPU usage method
	//-----------------------------------------------------------
	public int getCpuUsage() throws SigarException {
 
		Sigar sigar = new Sigar();
		CpuPerc cpu = sigar.getCpuPerc();
		double cpuUsage = cpu.getUser() *100 + cpu.getSys() * 100 ;
		int display = (int)cpuUsage;
        return display;
	}
	//-----------------------------------------------------------
 
 
	public String display = new String();
 
 
	//-----------------------------------------------------------
	//Panel object
	//-----------------------------------------------------------
	CPUUsagePanel() throws SigarException {
 
 
	    t = new Thread(new Traitement());
	    bar  = new JProgressBar(JProgressBar.VERTICAL);
	    bar.setStringPainted(false);
 
	    this.setPreferredSize(new Dimension(0 , 100)); //Bizarre je sais mais ça corrige un bug visuel
		this.setLayout(new GridBagLayout());
 
		GridBagConstraints gbc = new GridBagConstraints();
		gbc.weightx = gbc.weighty = 2.0;
		gbc.fill = GridBagConstraints.BOTH ;
 
		gbc.gridx = 0;
		gbc.gridy = 0;
		this.add(bar, gbc);
 
		gbc.weightx = gbc.weighty = 1.0;
		gbc.gridx = 0;
		gbc.gridy = 4;
		this.add(percent, gbc);
 
		t.start();
 
 
		this.setVisible(true);
	}
	//-----------------------------------------------------------
 
 
 
	//-----------------------------------------------------------
	//Internal class for threading bar refresh
	//-----------------------------------------------------------
	class Traitement implements Runnable{
 
	    @SuppressWarnings("static-access")
		public void run() { 
	    	int CPUUse = 0;
 
 
	    	//-------------------Refreshing loop---------------------
	    	int i = 0;
	    	while(i < 100) {
 
	    		try {
	    			CPUUse = getCpuUsage();
					if ( !manager.isDisposed() ) {
						manager.setValue(CPUUse);
					}
	    		} catch (SigarException e2) {
	    			e2.printStackTrace();
	    		}
 
	    		i+=CPUUse;
	    		if ( i>100 ) {
	    		     CPUUse-=i-100;
	    		    i=100;
	    		}
 
    			percent.setText("CPU: " + CPUUse + "%");
 
 
	    		try {
	    			t.sleep(1000);
	    		} catch (InterruptedException e) {
	    			e.printStackTrace();
	    		}
	    	}
 
 
	    	//-----------------------------------------------------
	    }   
	}
	//-----------------------------------------------------------
}

Citation:

Envoyé par joel.drigo

Tu devrais jeter un coup d'oeil à SteelSeries.

Pas mal merci :D

Le problème est que, d'une part, tu créés, ici en rouge, une JProgressBar que tu passes au SmoothProgressBarManager :
Code:

1 2 3 4 5 6 7 public class CPUUsagePanel extends JPanel { ... private JProgressBar bar = new JProgressBar(0 , MAX); JLabel percent = new JLabel( "" ); final SmoothProgressBarManager manager = new SmoothProgressBarManager(bar); ... }
Et d'autre part, tu en crées une seconde, ici en rouge, que tu affiches dans ton panel :
Code:

1 2 3 4 5 6 7 8 9 CPUUsagePanel() throws SigarException { ... bar = new JProgressBar(JProgressBar.VERTICAL); ... this.add(bar, gbc); ... }

18/04/2014, 14h57
JeremGamer

Ah oui j'avais pas fait attention. Merci beaucoup tout fonctionne parfaitement comme je le souhaite maintenant!