[JScrollPane] Taille du panel variable

Bonjour,

Je travaille sur un projet et je bloque actuellement sur quelque chose de peut-être assez bête (mais j'ai cherché sur tout le net et à moins de ne pas avoir les bons mots-clés, je ne trouve rien).

Je fais un piano roll sur un panel en redéfinissant la méthode paint. Un piano Roll, c'est une sorte de partition (musicale) plus intuitive pour des non musiciens.
Mon pianoroll est dans un JScrollPane (c'est-à-dire que j'ai bien fait un JScrollPane(monPanel) puis j'ai ajouté l'objet ainsi créé (de type JScrollPane) au container de la fenêtre principale).

La barre de défilement verticale fonctionne bien car au moment de dessiner mon pianoRoll, la hauteur en pixels est définie. J'ai même recoder getPreferredSize pour que cela fonctionne.
En revanche, pour le défilement horizontal, j'ai un problème. Sachant que la séquence que je joue (en midi) et que le pianoroll représente, peut s'agrandir par rapport à sa taille initiale, la barre de défilement horizontale ne suit pas. Quand la séquence grandit, que la taille du piano roll (un JPanel, je rappelle) grandit, et bien la scrollbar du bas garde le même maximum.
J'ai tenté un setMaximum sur la barre et cela fonctionne sans mettre le focus sr la fin, alors je clique sur la barre pour la déplacer ou sur les flèches et aussitôt la taille maximum revient à celle du début.

Comment puis-je régler ce problème ?
Je suppose qu'il y a un evenement qui a lieu quand on clique sur la barre, quelle méthode appelle-t-il ? S'il appelle le getPreferredSize de son JPanel, le setMaximum devrait reprendre la bonne taille !

Si vous avez une idée...
Merci d'avance.

Salut.J'ai essayé de modifier la valeur max grece a setMaximum() et ça a marcher,essayer de chercher ou t'as modifier ou refrechir la valeur max de ton scrollBar.desolé et bon chance .

PS:si tu peu metre le code peu etre qu'on trouvera qcq chose:bug:

Lorsque la barre est modifiée, c'est AdjustmentEvent qui est envoyé.
--> Voir addAdjustmentListener et la méthode adjustmentValueChanged()

merci, je vais tenter de voir si cela fonctionne, en attendant, je vous mets de bouts de codes, si ça peut aider.

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
package src.view;
 
import src.modele.*;
import java.awt.*;
import javax.swing.*;
import javax.sound.midi.*;
import java.lang.Long;
 
public class PianoRoll extends JPanel{
 
//Ici un ensemble d'attributs privés que je vais vous épargner car pas indispensable pour notre problème (ECHELLE_X, ECHELLE_Y...)
protected Sequence seq; //La séquence midi représentée par le pianoroll
 
        public PianoRoll(Sequence seq){
		super();
		this.seq=seq;
	}
 
	public void paint(Graphics g) {
		super.paint(g);
		this.setBackground(new Color(254,238,124));
//Longueur de la piste midi en pixels
		int longueurTrack = echelleTick(this.seq.getTickLength(),ECHELLE_X);
//Si la longueur en pixels est inférieure à 900, on va la fixer à 1250 pixels (c'est pour voir les lignes verticales tracées au moins jusqu'à 1250 pixels au début)
		longueurTrack = longueurTrack<900?1250:longueurTrack;
 
		for(int l=0; l<longueurTrack;l+=5*ECHELLE_X){
			g.setColor(Color.white);
			g.drawLine(l, 0, l, 128*ECHELLE_Y);
			if (l%10==0){
				g.setColor(Color.black);
				g.drawString(String.valueOf(l*ECHELLE_X), l, 10);
			}
//.....je vous épargne la suite, je trace ensuite les lignes perpendiculaires puis les notes du piano roll en parcourant la séquence this.seq avec une simple boucle.
}
 
	public int echelleTick(long tick,long echelle){
		Long l = new Long(tick/echelle);
		return l.intValue();
	}
 
	public Dimension getPreferredSize(){
//Redéfinition de la méthode getPreferredSize, laquelle est appelée au premier dessin du JPanel pour savoir la taille du panel
		int longueurTrack = echelleTick(this.seq.getTickLength(),ECHELLE_X);
		longueurTrack = longueurTrack<900?1250:longueurTrack;
		return new Dimension(longueurTrack, 128*ECHELLE_Y);
	}
 
 
}

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
276
277
278
279
 
package src.view;
 
import javax.swing.*;
import java.awt.*;
import javax.sound.midi.*;
import java.io.File;
import src.modele.*;
 
 
 
 
public class Fenetre extends JFrame{
 
	private static final long serialVersionUID = 3778796679640196837L;
 
	private static final String[] ACCORDS={"B","C","C#","D","Eb","E","F","F#","G","Ab","A","Bb"};
 
 
	//Barre d'outils (JToolBar)
	Menu menu;
 
	//En-tête
	JLabel haut;
 
	//Piano-Roll
	JScrollPane pianoR;
	PianoRoll pianoroll;
 
	//Panneau de contrôle
	JLabel gauche, droite;
	JTextArea accordsChoisis;
	JButton ajouterArpege, ajouterAccords, reset, melodie;
	ImageIcon melodieOn, melodieOff;
	Choice choixAccords, choixTonalite, choixArpege;
 
	//Données non graphiques
	Chargeur chargeur;
 
 
 
	public Fenetre(Controleur c, Chargeur chargeur, Sequence s) {
		super();
		this.chargeur=chargeur;
 
 
		//Construction de la fenêtre
		this.setTitle("Melo Designer");
		this.setSize(900,730);
		this.setResizable(false);
		this.setLocationRelativeTo(null);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		GridBagLayout layout = new GridBagLayout();
		this.setLayout(layout);
		GridBagConstraints cont = new GridBagConstraints();
		Container cp =  this.getContentPane();
		cp.setBackground(Color.WHITE);
 
		//Construction du Menu
		menu = new Menu(c);
		menu.setEnabled(false);
		this.setJMenuBar(menu);
 
 
		//Construction de l'en-tête
		cont.gridwidth=6;
		cont.gridheight=1;
		cont.gridx=0;
		cont.gridy=0;
		haut = new JLabel(new ImageIcon("ressource/images/haut.jpg")); 
		haut.setPreferredSize(new Dimension(900,200));
		layout.setConstraints(haut, cont);
		cp.add(haut);
 
		//Construction du PianoRoll
		cont.gridwidth=6;
		cont.gridheight=1;
		cont.gridx=0;
		cont.gridy=1;
		pianoroll = new PianoRoll(s);
		pianoR= new JScrollPane(pianoroll); 
		pianoR.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
		pianoR.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
		pianoR.setMinimumSize(new Dimension(900,230));
		layout.setConstraints(pianoR, cont);
		cp.add(pianoR);
 
 
		//Panneau de contrôle
		gauche = new JLabel(new ImageIcon("ressource/images/clef.jpg"));
		gauche.setMinimumSize(new Dimension(100,300));
		cont.gridwidth=1;
		cont.gridheight=7;
		cont.gridx=0;
		cont.gridy=2;
		layout.setConstraints(gauche, cont);
		cp.add(gauche);
 
 
			//Panneau central
			JLabel j1 = new JLabel("Ajouter un nouvel accord");
			JLabel j2 = new JLabel("Ajouter un nouvel arpège");
 
			choixAccords = new Choice();
			for(int k=0;k<ACCORDS.length;k++){
				choixAccords.add(ACCORDS[k]);
			}
			choixTonalite = new Choice();
			choixTonalite.add("Majeur");
			choixTonalite.add("Mineur");
			choixArpege = new Choice();
			int nb= chargeur.getNbArpeges();
			for (int i=0;i<nb;i++){
				choixArpege.add("Arpege " + String.valueOf(i));
			}
 
			ajouterAccords=new JButton(new ImageIcon("ressource/images/add.jpg"));
			ajouterAccords.setMaximumSize(new Dimension(100,30));
			ajouterAccords.setBorderPainted(false);
			ajouterAccords.setFocusPainted(false);
			ajouterAccords.setBackground(Color.WHITE);
			ajouterAccords.setMargin(new Insets(0,0,0,0));
			ajouterAccords.addActionListener(c);
 
			ajouterArpege=new JButton(new ImageIcon("ressource/images/add.jpg"));
			ajouterArpege.setMaximumSize(new Dimension(100,30));
			ajouterArpege.setBorderPainted(false);
			ajouterArpege.setFocusPainted(false);
			ajouterArpege.setDisabledIcon(new ImageIcon("ressource/images/addi.jpg"));
			ajouterArpege.setMargin(new Insets(0,0,0,0));
			ajouterArpege.setBackground(Color.WHITE);
			ajouterArpege.addActionListener(c);
			ajouterArpege.setEnabled(false);
 
			JLabel intitule = new JLabel("Accords Choisis : ");
 
			accordsChoisis=new JTextArea();
			accordsChoisis.setText("");
			accordsChoisis.setEnabled(false);
			accordsChoisis.setDisabledTextColor(Color.BLACK);
			accordsChoisis.setLineWrap(true);
			accordsChoisis.setWrapStyleWord(true);
			accordsChoisis.setMaximumSize(new Dimension(400,60));
			accordsChoisis.setMinimumSize(new Dimension(300,60));
 
			melodieOn = new ImageIcon("ressource/images/melodieOn.jpg");
			melodieOff = new ImageIcon("ressource/images/melodieOff.jpg");
			melodie = new JButton(melodieOff);
			melodie.setBorderPainted(false);
			melodie.setFocusPainted(false);
			melodie.setMargin(new Insets(0,0,0,0));
			melodie.setBackground(Color.WHITE);
			melodie.addActionListener(c);
 
			reset=new JButton(new ImageIcon("ressource/images/reset.jpg"));
			reset.setMaximumSize(new Dimension(100,30));
			reset.setBorderPainted(false);
			reset.setFocusPainted(false);
			reset.setMargin(new Insets(0,0,0,0));
			reset.setBackground(Color.WHITE);
			reset.addActionListener(c);
 
			JLabel head=new JLabel(new ImageIcon("ressource/images/control.jpg"));
			head.setMinimumSize(new Dimension(400,70));
 
 
//On place tous les composants un à un en appliquant les contraintes.
 
			cont.gridwidth=4;
			cont.gridheight=1;
			cont.gridx=1;
			cont.gridy=2;
			layout.setConstraints(head,cont);
			cp.add(head);
 
 
			droite = new JLabel(new ImageIcon("ressource/images/bas.jpg"));
			cont.gridwidth=1;
			cont.gridheight=7;
			cont.gridx=5;
			cont.gridy=2;
			layout.setConstraints(droite,cont);
			cp.add(droite);
 
			cont.gridwidth=4;
			cont.gridheight=1;
			cont.gridx=1;
			cont.gridy=3;
			cont.anchor = GridBagConstraints.CENTER;
			layout.setConstraints(j1,cont);
			cp.add(j1);
 
			cont.gridwidth=1;
			cont.gridheight=1;
			cont.gridx=1;
			cont.gridy=4;
			cont.anchor = GridBagConstraints.CENTER;
			layout.setConstraints(choixAccords,cont);
			cp.add(choixAccords);
 
			cont.gridwidth=1;
			cont.gridheight=1;
			cont.gridx=2;
			cont.gridy=4;
			cont.anchor = GridBagConstraints.CENTER;
			layout.setConstraints(choixTonalite,cont);
			cp.add(choixTonalite);
 
			cont.gridwidth=1;
			cont.gridheight=1;
			cont.gridx=3;
			cont.gridy=4;
			cont.anchor = GridBagConstraints.CENTER;
			layout.setConstraints(ajouterAccords,cont);
			cp.add(ajouterAccords);
 
			cont.gridwidth=1;
			cont.gridheight=1;
			cont.gridx=4;
			cont.gridy=4;
			cont.anchor = GridBagConstraints.CENTER;
			layout.setConstraints(reset,cont);
			cp.add(reset);
 
 
			cont.gridwidth=4;
			cont.gridheight=1;
			cont.gridx=1;
			cont.gridy=5;
			cont.anchor = GridBagConstraints.CENTER;
			layout.setConstraints(j2,cont);
			cp.add(j2);
 
			cont.gridwidth=2;
			cont.gridheight=1;
			cont.gridx=1;
			cont.gridy=6;
			cont.anchor = GridBagConstraints.EAST;
			layout.setConstraints(choixArpege,cont);
			cp.add(choixArpege);
 
 
			cont.gridwidth=1;
			cont.gridheight=1;
			cont.gridx=3;
			cont.gridy=6;
			cont.anchor = GridBagConstraints.WEST;
			layout.setConstraints(ajouterArpege,cont);
			cp.add(ajouterArpege);
 
			cont.gridwidth=1;
			cont.gridheight=1;
			cont.gridx=4;
			cont.gridy=6;
			cont.anchor = GridBagConstraints.CENTER;
			layout.setConstraints(melodie,cont);
			cp.add(melodie);
 
 
			cont.gridwidth=4;
			cont.gridheight=1;
			cont.gridx=1;
			cont.gridy=7;
			cont.anchor = GridBagConstraints.CENTER;
			layout.setConstraints(intitule,cont);
			cp.add(intitule);
 
			cont.gridwidth=4;
			cont.gridheight=1;
			cont.gridx=1;
			cont.gridy=8;
			cont.anchor = GridBagConstraints.NORTH;
			layout.setConstraints(accordsChoisis,cont);
			cp.add(accordsChoisis);
 
 
 
		this.setVisible(true);
	}

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
package src.view;
 
import java.awt.event.*;
import javax.swing.*;
import src.modele.*;
import javax.sound.midi.*;
import java.util.Vector;
import java.util.Random;
import java.lang.Math;
import java.lang.Double;
 
public class Controleur implements ActionListener{
 
	//Elements graphiques surveillés par le contrôleur
	Fenetre f; 	//Contient un menu, un pianoRoll et un panel de contrôle
 
 
	//Le lecteur principal
	Lecteur lecteur;
 
	//Le chargeur contient les ressources
	Chargeur chargeur;
 
	//La séquence actuellement en traitement
	MySequence seq;
 
	//La séquence a-t-elle commencé ?
	boolean running;
        //La mélodie est-elle activée ?
	boolean melodie;
 
	//Liste des accords à jouer
	Vector<Integer> accords;
	Vector<Boolean>tons;
 
	public Controleur() {
			chargeur=new Chargeur();
			running=false;
			melodie=true;
			accords=new Vector<Integer>();
			tons=new Vector<Boolean>();
			try{
				this.seq = new MySequence(0.0f,192,chargeur.getMeta());
				f = new Fenetre(this, this.chargeur, this.seq);
				this.lecteur=new Lecteur(this.seq);
			}
			catch(Exception e){
									JOptionPane.showMessageDialog(null,"Le programme ne peut pas démarrer car les ressources nécessaires sont corrompues", "Erreur", JOptionPane.ERROR_MESSAGE);
			}
	}
 
 
	public void actionPerformed(ActionEvent e){
//Ici une suite de if pour tester l'égalité avec un bouton.
//Lorsqu'on clique sur le bouton ajouter de arpege, voilà ce qu'il se passe :
if (((JButton)e.getSource()).equals(f.ajouterArpege)){
//On récupère l'arpège sélectionné dans la liste d'option
			int ar=f.choixArpege.getSelectedIndex();
			int depart;
			Sequence temp;
			try{
				if(!running){
//Si c'est la première fois qu'on appuie sur le bouton ajouter, le running était à false (séquence non commencée)
//Je récupère la séquence correspondant à l'arpège sélectionné et au premier ton contenu dans "tons" (qui existe forcément car j'ai interdit l'utilisation du bouton ajouterArpege tant qu'il n'y avait pas un élément dans "tons" et "accords"				temp=chargeur.getSequence(ar,(Boolean)tons.get(0));
//On transpose ce morceau sur le premier accord			temp=Transposition.transposer(temp,(Integer)accords.get(0));	
//On ajoute la piste ainsi crée à notre séquence qui contient désormais une nouvelle piste en 1.
					this.seq.addTrack(temp.getTracks()[1]);
//On créé un deuxième piste pour la mélodie en 2
					this.seq.createTrack();
//Le lecteur va pouvoir lire la séquence ainsi crée
					this.lecteur.setSequence(this.seq);
//Au prochain clic sur le bouton, inutile de recréé ces deux pistes
					running=true;
//On active le menu (Arrêt, Pause, Lecture car il y a quelque chose à lire)
					f.menu.setEnabled(true);
//On note que déjà un accord a été pris en compte dans la liste des accords, le début sera donc à 1, sinon à 0.
					depart=1;
				}
				else{
					depart=0;
				}
//On parcours la liste des accords et on les ajoute à la séquence par une opération de fusion
				for(int k=depart;k<accords.size();k++){
					temp=chargeur.getSequence(ar,(Boolean)tons.get(k));
					temp=Transposition.transposer(temp,(Integer)accords.get(k));	
					this.seq.fusion(temp.getTracks()[1],1);
				}
//Si la mélodi est acitvée
				if(this.melodie){
//On génère un nombre aléatoire entre 0 et nombre d'arpèges pour choisir un arpège au hasard
					Random rand = new Random();
					int alea = Math.abs(rand.nextInt())%chargeur.getNbArpeges();
					for(int n=0;n<accords.size();n++){
//Puis par les mêmes opérations, on l'ajoute mais sur la piste 2 destinée à la mélodie.
temp=chargeur.getSequence(alea,(Boolean)tons.get(n));
						temp=Transposition.transposer(temp,((Integer)accords.get(n))+24);
						this.seq.fusion(temp.getTracks()[1],2);
					}
				}
 
//Enfin et c'est ici que se passe le plus important : Je demande au pianoroll de se repeindre pour réafficher la séquence avec ses nouveaux arpèges. Vous l'aurez compris, la séquence s'est donc allongée. Cette instruction, cependant, si je ne la mets pas, il se trouve qu'elle se fait quand même automatiquement.
			f.pianoroll.repaint();
//Et là surprise, le pianoroll se met bien à jour, s'allonge bien mais pas le scrollpane qui est autour (celui créé dans la fenêtre).
//La je bidouille un truc qui ne fonctionne pas pour la scrollbar horizontale, s'adapte à la nouvelle taille du panel pianoroll qui a bien grandi :
// Je récupère la taille renvoyée par getPreferredSize() qui me donnera la largeur en pixel dans un wrapper Long
			Double doub = new Double(f.pianoroll.getPreferredSize().getWidth());
//Puis je set le maxi de la barre à la valeur entière récupérée.
f.pianoR.getHorizontalScrollBar().setMaximum(doub.intValue());
//Résultat, l'instruction s'éxécute bien et l'ascenseur de la scrollbar diminue, ce qui laisse bien penser que le scrollpane s'est adapté à la taille, mais dès que je ente de bouger l'ascenseur ou de cliquer sur les flèches, l'ascenseur reprend sa taille qu'il avait juste avant l'instruction, comme si elle n'avait pas servi à grand chose
//C'est pourquoi je pense qu'un évènement a lieu quand j'essaie de toucher aux barres, un évènement qui rappelle une méthode qui redonne la taille de départ que le jpanel avait plutot que de donner sa taille actuelle, j'aimerais rtrouver la méthode à redéfinir dans le jpanel pour lui dire de renvoyer la taille courante et non la taille initiale.
 
			}
}
}

edit :
Le getPreferredSize() redéfini sert à la chose suivante :
Au départ, j'avais testé mon pianoroll avec une séquence non vide mais qui était déjà très longue et problème : les scrollbars ne s'affichaient pas, du moins elles s'affichaient mais sans ascenseurs. J'avais alors recherché sur le net une réponse à mon problème et quelqu'un avait conseillé quelque part de redéfinir cette méthode. Ce que j'ai fait.
Cela a fonctionné, le pianoroll affichait les barre en fonction de la taille du panel, mais dès que je suis passé à une séquence de taille variable, cela ne fonctionne plus. le getPreferredSize() est appelé une fois au début pour le premier tracé (quand la fenêtre se charge), et donne donc un jpanel d'une longueur de 1250 pixels (logique) mais après, la méthode n'est plus rappelée.

J'ai déjà essayé de faire un f.pianoR.repaint().
je vais essayé eventuellement f.pianoR.updateUI()...

Sinon si je ne résouds pas mon problème, je mettrais une taille initiale de 100 00 pixels à mon panel dès le départ, comme ça, ça me laisse une bonne marge pour agrandir ma séquence, mais bon, je risque d'être pénalisé sur la notation, car ce serait vraiment très crade de faire ça.

Ne cherchez plus ! Ma dernière idée en date a fonctionné :
Code:

1 2 3 4 5 f.pianoroll.repaint(); //Double doub = new Double(f.pianoroll.getPreferredSize().getWidth()); //f.pianoR.getHorizontalScrollBar().setMaximum(doub.intValue()); f.pianoR.updateUI();
le updateUI dit au scrollpane de se réactualiser et pour sé réactualiser, il regarde de noveau ce qui le compose, à savoir le panel en rappelant getPreferredSize() et donc cela fonctionne. Ensuite je suppose que l'évènement qui se produit quand on clique sur la scrollbar ne pose plus de problème car ses données de taille sont mises à jour et il ne revient pas sur ce qui a été fait avant.
Je vous remercie en tout cas de votre aide, car l'idée m'est venue en essayant de vous expliquer le fonctionnement de mon code.

Normalement, utilise plutot : scrollPane.revalidate() ...