Composant de taille variable

**size_one_1** · 21/02/2009, 20h59

bonjour a tous,
j essais de faire un composant dont la taille peut etre "extanded" ou "collapsed"
je vous explique comment je m y prends :

un JPanel conteneur contient deux nouveaux JPanel, un pour le titre et un conteneur.
quand un clic sur le Jpanel du titre survient, le conteneur voit sa taille augmenter progressivement de 0 a sa taille maximale. le but etant de creer une petite animation.
je procede avec un javax.swing.Timer et cela fonctionne.
le probleme est que des que je mets des objets dans mon conteneur et que je bouge la souris, l animation s en trouve ralentie, voire tres ralentie.

je pensais a threader le tout, mais en lisant a droite a gauche, j ai remarque qu'on ne pouvait pas faire n importe quoi avec l EDT

je ne sais vraiment pas comment m y prendre..
pouvez vous m orienter s il vous plait?

cordialement

**gifffftane** · 22/02/2009, 18h18

Je présume que, à chaque étape de ton animation, tu provoques le recalcul des positions de tous les panneaux emboités.

Il faudrait que tu nous précises la façon dont tu vois les choses d'une part, la façon dont tu les codes d'autre part, particulièrement au niveau du comportement des sous panneaux.

**size_one_1** · 23/02/2009, 11h12

bonjour
merci de l attention que vous portez a mon probleme,
voici comment je vois les choses :

chaque conteneur est une classe extend JPanel redefinie par mes soins.

en fait seul le jpanel depliable voit ses coordonnees recalculees.
(il y a plusieurs conteneurs de volet dans un conteneur general)

quand un clic survient sur le JPanel du titre, en fonction de l etat du panneau depliable, on le deroule ou le fait disparaitre.

n'hesitez pas a me dire si tout cela manque d explication.
merci encore

**adiGuba** · 23/02/2009, 11h29

Salut,

Le Timer me semble un bon choix... On pourrait voir son code ?

a++

**size_one_1** · 23/02/2009, 15h57

alors voila les sources de ce que j ai fait

sources volet

sans rajouter trop de composant, ca se passe assez bien, mais en y ajoutant des boutons / imgs avec listeners, ca devient tres lent, et si la souris bouge la vitesse change / ralentie

voici le code direct

JVolet.class

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
 
import java.awt.BorderLayout;
import java.util.Vector;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class JVolet extends JPanel {
 
	private Vector<Volet> mesVolets;
	private int rounded;
	private int nbVolet;
 
	public JVolet(int rounded) {
		super();
		this.rounded = rounded;
		mesVolets = new Vector<Volet>();
		this.nbVolet = 0;
	}
 
	public int addVolet(String title) {
		Volet v = new Volet(nbVolet, this.rounded, title, this);
		this.mesVolets.add(v);
		add(v);
		this.nbVolet++;
		return (nbVolet - 1);
	}
 
	public void manageVolet(int id) {
		for(Volet v : mesVolets) {
			v.changeEtat();
		}
	}
}

Volet.class

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
 
import java.awt.BorderLayout;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
 
import swing.JRoundedPanel;
//import swing.volet.JVoletSW;
 
public class Volet extends JPanel {
 
	private int rounded;
	private int id;
	private JvTitle jvT;
	private JvContentPane jvC;
	private JVolet jv;
 
	Volet(int id, int rounded, String title, JVolet jv) {
		super();
		this.rounded = rounded;
		this.id = id;
		this.jv = jv;
		jvT = new JvTitle(this.rounded, title, id, jv);
		jvC = new JvContentPane(rounded);
		this.setLayout(new BorderLayout());
		this.add(jvT, BorderLayout.NORTH);
		this.add(jvC, BorderLayout.CENTER);
	}
 
	public int getId() {
		return this.id;
	}
 
	public JvTitle getJvTitle() {
		return this.jvT;
	}
	public JvContentPane getJvContentPane() {
		return this.jvC;
	}
 
	public void changeEtat() {
		this.jvC.changeEtat();
	}
 
}

JvTitle.class

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
 
import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
 
import javax.swing.JLabel;
 
import swing.JRoundedPanel;
 
public class JvTitle extends JRoundedPanel implements MouseListener {
 
	private int rounded;
	private String title;
	private JLabel lblTitle;
	private JVolet jv;
	private int id;
	private Dimension maxDim;
 
	JvTitle(int rounded, String title, int id, JVolet jv) {
		super(rounded);
		this.rounded = rounded;
		this.title = title;
		this.lblTitle = new JLabel(title);
		this.id = id;
		this.jv = jv;
		this.maxDim = new Dimension(200, 30);
		add(lblTitle);
		this.setBackground(Color.gray);
		this.addMouseListener(this);
	}
 
	public void setTitle(String title) {
		this.title = title;
		this.lblTitle.setText(title);
	}
 
	public String getTitle() {
		return this.title;
	}
 
	public Dimension getPreferredSize() {
		return maxDim;
	}
 
	@Override
	public void mouseClicked(MouseEvent e) {
		// TODO Auto-generated method stub
 
	}
 
	@Override
	public void mouseEntered(MouseEvent e) {
		// TODO Auto-generated method stub
 
	}
 
	@Override
	public void mouseExited(MouseEvent e) {
		// TODO Auto-generated method stub
 
	}
 
	@Override
	public void mousePressed(MouseEvent e) {
		// TODO Auto-generated method stub
		jv.manageVolet(this.id);
	}
 
	@Override
	public void mouseReleased(MouseEvent e) {
		// TODO Auto-generated method stub
 
	}
}

JvContentPane.class

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
 
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JPanel;
import javax.swing.Timer;
 
import swing.JRoundedPanel;
 
public class JvContentPane extends JRoundedPanel implements ActionListener {
 
	private int rounded;
	private Dimension maxDim;
	private boolean etat;
	private Timer t;
	private int height;
 
	JvContentPane(int rounded) {
		super(rounded);
		this.rounded = rounded;
		this.maxDim = new Dimension(200, 50);
		this.height = 0;
		this.etat = false; // par defaut il est repli&#142;
		setSize(getPreferredSize().width, this.height);
		this.setBackground(Color.gray);
		this.t = new Timer(10, this);
		System.out.println(getHeight() + " " + this.etat);
		JPanel p = new JPanel();
		p.setMinimumSize(new Dimension(100, 100));
		p.setPreferredSize(new Dimension(100, 100));
		p.setMaximumSize(new Dimension(100, 100));
		p.setBackground(Color.red);
		add(p);
	}
 
	/*public void setMaxSize(Dimension d) {
		this.maxDim = d;
	}
	public void setMaxSize(int width, int height) {
		this.maxDim = new Dimension(width, height);
	}*/
 
	public Dimension getPreferredSize() {
		return new Dimension(maxDim.width, height);
	}
 
	public void changeEtat() {
		if(! this.t.isRunning()) {
			this.t.start();
			this.etat = ! this.etat;
		}
	}
 
	private void setHeight(int height) {
		//this.setSize(this.getWidth(), height);
		this.height = height;
		this.setSize(getWidth(), height);
	}
 
	public void paintComponent(Graphics g) {
		g.setColor(getBackground());
	    g.fillRoundRect(0, 0, getWidth(), getHeight(), rounded, rounded);
	}
 
	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		Object o = e.getSource();
 
		if(o == this.t) {
			//System.out.println(getHeight() + " " + this.etat);
			if(this.etat) {
				setVisible(true);
				if(getHeight() < super.getPreferredSize().height) {
					this.setHeight(getHeight() + 1);
				}
				else {
					this.t.stop();
				}
			}
			else {
				if(getHeight() > 0) {
					this.setHeight(getHeight() - 1);
				}
				else {
					this.t.stop();
				}
			}
			revalidate();
			repaint();
		}
	}
}

et voila, pour faire tourner ca voir dans le zip, ou j ai aussi mis mon JroundedPanel

**gifffftane** · 23/02/2009, 18h08

Je pense que c'est le revalidate de l'actionPerformed du JvContentPane qui créé le blême. Supprime le pour voir, et tu vas retrouver la vitesse d'exécution (mais tu ne verras plus rien).

Le revalidate provoque le recalcul de la position de tous les sous composants, qui essaient tous de s'adapter à la nouvelle taille, et ce à chaque petite modif de taille.

Pour résoudre ça il faudrait savoir quel comportement tu souhaites avoir dans les sous-composants : se déplient-ils aussi, ont-il dès le départ la taille finale, respectent-ils la taille minimale ou je ne sais quoi d'autre ?

**size_one_1** · 23/02/2009, 19h18

ok, je vois..
donc a priori, pas question de SwingWorker?
(j avous que c est une notion toute nouvelle pour moi et je ne sais pas trop quand devoir l utiliser)

oui, les composants a l interieur auront une taille fixe.
il ne se deplient pas vraiment, ils sont juste invisible tant que le JContentPane est plié (vu que c est leur conteneur).
ils ne respectent rien de particulier d autre je crois bien ?

**gifffftane** · 23/02/2009, 22h16

Le SwingWorker sert lorsque tu veux faire un traitement long en dehors de swing. Or, là, comme avec justesse tu utilises un timer swing, tout se passe à l'intérieur de swing, donc pas besoin de SwingWorker.

Si tu ne veux rien afficher durant le dépliage, alors tu peux enlever les composants interieurs, et les remettre à la fin du dépliage. La seule contrainte est qu'il faut connaître la taille finale du composant qui se déplie au départ. Je ne sais pas si c'est ton cas ?

**size_one_1** · 24/02/2009, 10h51

merci pour ces precisions, non je ne connais pas la taille des composants qui seront a l interieur (le nombre de volets et leur contenu sont generes dynamiquement par un fichier de donnees XML, mais une fois crees, leur taille et composants ne changent plus)

y aurait il un moyen de calculer les dimensions ?

**bouye** · 24/02/2009, 12h24

Je te conseille fortement de lire le livre de Romain Guy (Gfx) et de Chett Haase, Filthy Rich Clients, ainsi que les exemples présents sur le site du livre (faire des recherches sur Google ou le forum) avant de te lancer dans ce genre de projets ambitieux (très ambitieux). Plutôt que de faire une vraie animation des changements de taille des panneaux, tu seras peut-être amené à simuler celle-ci avec des images montrant les panneaux avant et après la transformation.

**sinok** · 24/02/2009, 13h02

Et également d'essayer de comprendre ce qu'ont fait les gens de Swingx dans leur JXCollapsiblePane...
http://swinglabs.org/hudson/job/Swin...siblePane.java

Basiquement, la clef est la manimulation de façon intelligente de la preferredSize du composant.

**size_one_1** · 24/02/2009, 14h55

merci pour les bouquins, j irais jeter un oeil

pourquoi le "projet" est si ambitieux?

j ai deja regarde du cote de swingX, et leur solution est sympas, mais je voulais pouvoir faire ce que je veux de mes composants titre et conteneur pliable.

simuler avec des images? mais comment?
sachant qu il n y as pas la meme chose dans les conteneurs et que c est definis par un fichier de donnees xml..

je m'excuse si je pose des question bateau, je suis un d'jeuns

**gifffftane** · 24/02/2009, 15h06

Dans les animations on essaie de montrer des images des composants, comme si on avait pris une photo d'écran, non les composants eux mêmes, parce que cela simplifie les calculs pour les déplacements.

Ce qui t'arrive en est un peu la démonstration : dans ton premier jet, tu places et déplaces les composants comme si c'était pareil, et tu as pu voir que ce n'était pas pareil. Et tu as encore eu de la chance de ne pas avoir de listeners actifs, sinon tu déclenchais une mitraillette d'évenements !

**size_one_1** · 24/02/2009, 16h04

ok...
que me reste t il comme solution?

**gifffftane** · 24/02/2009, 18h09

Je ne vois pas la difficulté

Lorsque tu fais le déroulé comme actuellement, tu sais bien à quel moment il faut l'arrêter, non ? Donc, pendant le déroulé, tu enlèves ce qu'il y a dans ton panneau (ou encore plus beouf tu ne fais pas d'appel à revalidate), et, lorsque le déroulé est fini, alors tu fais l'appel à revalidate (après avoir tout remis si tu avait tout enlevé).

Et puis, si un jour tu veux mieux faire, alors tu lis le bouquin que l'on t'a indiqué.

**size_one_1** · 25/02/2009, 00h07

bon ben merci bien pour toutes ces precisions,
je vais me pencher sur la solution qui consiste a enlever les composants pour les rajouter ensuite.

quand j aurais un moment je ne manquerais pas de lire les dis bouquins

thanks pour avoir pris le temps de me repondre

Composant de taille variable

EDT/SwingWorker Java

Discussions similaires

Partager

Partager