Temps de latence à l'affichage

**Flophx** · 21/09/2007, 13h11

Bonjour à tous!

Je sollicite vos connaissances car mes recherches sur le forum ont été infructueuse.. voici un bout de code simple:

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
 
	public Main() {
		SwingWorker<JFrame, Void> sW =new SwingWorker<JFrame, Void> (){
 
			@Override
			protected JFrame doInBackground() throws Exception {
				JFrame jF = new JFrame("Test");
				jF.setBounds(0, 0, 100, 100);
				jF.setBackground(new Color(0,255,0));
				jF.getContentPane().setBackground(new Color(255,0,0));
				System.out.println("Initialisation achevee");
				return jF;
			}
 
			public void done(){
				try {
					System.out.println("affichage de l'ensemble");
					this.get().setVisible(true);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (ExecutionException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		};
 
		sW.execute();
	}

Lorsque j'execute ce charmant bout de code, je vois d'abord un fond vert puis un fond rouge... Ce bout de code est symptomatique d'un problème que je na'rrive pas à lever:
Lors de l'initialisation de la fenetre principale de mon programme, j'ai d'abord l'encadrement de ma fenetre avec son titre sur fond gris (= mon fond vert de l'exemple) puis au bout d'un délai d'1 à 2s, mon interface proprement dite (=fond rouge)...

d'où question: Quelqu'un sait-il comment supprimer cet énervant problème, pour que mon interface est pas l'air de se "charger", parce que ce n'est pas très très "classe", voir "pro"...

Merci à tous ceux qui ont des idées, ou qui ont déjà rencontré ce problème!!
@++
F.

**pverley** · 21/09/2007, 14h02

Bonjour,

Jette un coup d'oeil au tutorial de gfx Attendre avec style

Tu trouveras là de bonnes idées pour "détourner l'attention" de l'utilisateur pendant que ton application se charge.

A +
Philippe.

**Flophx** · 21/09/2007, 14h12

En premier commentaire... Ca en jette!!!!
Nénamoins, cela signifie que ce temps de chargement est impossible à enlever?? Dans la mesure où visiblement le "contour" de la fenetre se charge en premier, puis le jContentPane ensuite, il n'y a donc pas d'alternative autre que devenir l'Houdini de la GUI?

Ou plutot ma question exacte serait: comment être sûr que la fenetre va s'afficher en entier (donc sans le passage par le fond gris), comme le fait si bien gfx?

**sinok** · 21/09/2007, 14h59

T'es sur de ton coup car icic je ne vois que du rouge pour ma part...
Et logiquement tu ne dois voir que du rouge au vu de ton code...

Tu n'aurais pas un setVisible planqué quelquepart qui te mettrait le dawa des fois?

**Gfx** · 21/09/2007, 15h46

Déjà, n'utilise pas un SwingWorker pour ça ! Tu crées et utilise tes composants Swing dans un thread qui n'est PAS l'EDT, ce qui est contraire à la règle.

Remplace tout ton bazar par un simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
SwingUtilities.invokeLater(new Runnable() {
  public void run() {
    JFrame jF = new JFrame("Test");
    jF.setBounds(0, 0, 100, 100);
    jF.setBackground(new Color(0,255,0));
    jF.getContentPane().setBackground(new Color(255,0,0));
    System.out.println("Initialisation achevee");
    jF.setVisible(true);
  }
});

Et il faudrait vérifier mais tes 2 appels à setBackground() ont je pense le même effet (jF.setBackground délégué à getContentPane()). Comme tu fais ça dans un thread qui n'est pas l'EDT on ne peut pas prévoir ce qui se passe.

**Flophx** · 21/09/2007, 17h38

Bon, ben gfx, même avec ton code, j'ai toujours 1er temps gris, puis rouge, ou vert, puis rouge (selon si on enlève ou non le jF.setbackground())...

Et sinon pour Sinok, ben j'ai pas vu de setVisible(true) mal pacés...

Mais je développe sous Eclipse, ca pourrait venir de là??
=> je viens de faire le test via la console... et le temps de latence est minimum... La phase grise est trop rapide pour l'oeil humain...

En revanche pour mon interface graphique compète, elle est vraiment très très lente au chargement....
Comme je dessine des cadrans avec une aiguille qui est par la suite animée, plus des graphiques en temps réel (JFreeChart) , le temps de chargement de l'ensemble de l'interface au démarrage est assez long... Comment faire pour l'améliorer ou l'alléger de manière générale? Swingworker?

exemple pour le cadran:

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
90
91
92
93
94
95
96
97
 
public class Anemometre extends JPanel {
 
	/**
         * 
         */
	private static final long serialVersionUID = 1L;
	private Aiguille indicVitesse;
	private int[][] positionDepart={{95,100},{105,100},{100,0}};
	private double v=0.0;
	private double angleV=Math.PI/120;
 
	public Anemometre(int x, int y, int longueur, int hauteur){
		this.setBounds(x,y, longueur, hauteur);
		this.setBackground(new Color(255,255,255));
		this.setVisible(true);
		indicVitesse= new Aiguille(positionDepart);
	}
 
	public void paintComponent(Graphics g)
	{
		Graphics2D comp2D=(Graphics2D) g;
		comp2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
		comp2D.setColor(Color.black);
		comp2D.fillOval(1,1,200,200);
		comp2D.setColor(Color.white);
		comp2D.fillArc(10, 10, 180, 180, -165+90, +105);
		comp2D.setColor(Color.green);
		comp2D.fillArc(20, 20, 160, 160, -217+90, 147);
		comp2D.setColor(Color.orange);
		comp2D.fillArc(20, 20, 160, 160, -270+90, 53);
		comp2D.setColor(Color.black);
		comp2D.fillArc(20, 20, 160, 160, -75+90, 147);
		comp2D.setColor(Color.black);
		comp2D.fillArc(30,30,140,140, 0, 360);
		comp2D.setColor(Color.white);
 
		for (int i=40;i<210;i=i+10) 
		{
			comp2D.setFont(new java.awt.Font("Comic Sans MS", java.awt.Font.BOLD, 8));
			comp2D.drawString(String.valueOf(i),
					100+(int) ((70+(2*i)/40)*Math.cos(-Math.PI/2+i*3*Math.PI/360)),
					100+(int) (70*Math.sin(-Math.PI/2+i*3*Math.PI/360)));
			if(i==180){
				comp2D.setColor(Color.red);
				comp2D.drawLine(100+(int) (80*Math.cos(-Math.PI/2+i*3*Math.PI/360)),
						100+(int) (80*Math.sin(-Math.PI/2+i*3*Math.PI/360)),
						100+(int) (100*Math.cos(-Math.PI/2+i*3*Math.PI/360)),
						100+(int) (100*Math.sin(-Math.PI/2+i*3*Math.PI/360)));
				comp2D.setColor(Color.white);
			}
			else{
			comp2D.drawLine(100+(int) (80*Math.cos(-Math.PI/2+i*3*Math.PI/360)),
					100+(int) (80*Math.sin(-Math.PI/2+i*3*Math.PI/360)),
					100+(int) (100*Math.cos(-Math.PI/2+i*3*Math.PI/360)),
					100+(int) (100*Math.sin(-Math.PI/2+i*3*Math.PI/360)));}
		}
		for (int i=45;i<205;i=i+10) 
		{
			comp2D.drawLine(100+(int) (90*Math.cos(-Math.PI/2+i*3*Math.PI/360)),
					100+(int) (90*Math.sin(-Math.PI/2+i*3*Math.PI/360)),
					100+(int) (100*Math.cos(-Math.PI/2+i*3*Math.PI/360)),
					100+(int) (100*Math.sin(-Math.PI/2+i*3*Math.PI/360)));
		}
 
		indicVitesse.Rotation(v*angleV);
		indicVitesse.affichageEcran(comp2D);
 
	}
 
	/**
         * @return
         * @uml.property  name="v"
         */
	public double getV() {
		return v;
	}
 
	/**
         * @param v
         * @uml.property  name="v"
         */
	public void setV(double v) {
		this.v = v;
	}
 
	public static void main(String []args){
		JFrame fenetre=new JFrame("Anémomètre");
		fenetre.setBounds(0,0,200, 200);
		Anemometre anemometre = new Anemometre(50, 50, 100, 100);
		fenetre.add(anemometre);
		fenetre.setVisible(true);
 
	}
 
 
}

C'est typiquement ce que contient mon interface... des idées (la mise à jour se fait par l'intermédiaire d'un thread qui lit des données au fur et à mesure et d'un repaint())

**Sanguko** · 21/09/2007, 19h06

Il faut savoir qu'un objet JFrame (donc Window) est associé à une ressource du systeme (qui est la fenetre affichée à l'écran).
La création de la ressource systeme se fait sur certains événements particuliers, comme l'appel au premier setVisible(true) ou addNotify()
Le système ne connait que cette resource systeme. Il l'a voit comme un rectangle qu'il faut effacer avec une couleur de fond, et à qui il faut ajouter une décoration (la barre de titre avec les boutons d'iconification, de fermeture, etc ...).
Lorsque tu fais un jF.setVisible(true), tu dis au systeme d'afficher cette resource.
C'est dépendant de la plateforme, mais en général le systeme affiche le rectangle, efface le fond, ajoute la decoration, puis envoie un évenement à la vm pour dire "il faut redessiner l'interieur du rectangle".
Cet evenement est interpreté par la vm, qui cree un evenement java, poste dans l'EDT.
Bref, entre le moment ou le systeme a affiché la fenetre, et le moment ou tu vas dessiner l'interieur, il se passe du temps.
Tu peux mettre en evidence ce delai en mettant un sleep(1000) juste apres le setVisible(true). Normalement, la fenetre s'affiche avec la couleur de fond spécifié (frame.setBackground change la couleur de la ressource systeme).

Il n'est donc pas possible a priori d'éliminer complementement ce delai.

Par contre, tu peux le diminuer. En t'assurant par exemple que tous les calculs de layout on déja été fait. Ou en t'assurant que les images ont déjà été chargées.

I hope this helps

Temps de latence à l'affichage

AWT/Swing Java

Discussions similaires

Partager

Partager