JScrollPane(JPanel) - scroll inactif

Version imprimable

07/03/2011, 20h54
Ceubex

JScrollPane(JPanel) - scroll inactif
Bonjour,

Mon problème est simple, j'ai des beaucoup de boutons dans un jpanel qui s'appelle command, je veux mettre ça dans un JScrollPane pour pouvoir faire défiler verticalement.
Code:

1 2 JScrollPane scCommand=new JScrollPane(); scCommand.setViewportView(command);
Mon soucis c'est que le Scroll Vertical n'apparait pas et que je ne peux pas accèder aux boutons du bas. Si je force l'apparition du scroll, il est grisé et on ne peut pas déscendre. Aucun changement si je met command dans le constructeur de JScrollPane.
08/03/2011, 01h45
sinok

Utiliserais tu un layout null par le plus grand des hasards?

Dans ce cas là oublies tout de suite ce layout, et utilises quelque chose de correct pour organiser ton GUI (Combinaison de BorderLayout, de BoxLayout, de GridBagLayout)
08/03/2011, 13h35
Ceubex

Je ne suis pas sur de comprendre
Pour mon JPanel j'utilise un layout :

Code:

JPanel command=new JPanel(new FlowLayout());

Mais toi tu parles de mettre un layout au JScrollPane, c'est ça ? Parce que j'ignore comment faire cela
08/03/2011, 19h33
sinok

Je parlais du layout du panel contenu dans le JScrollPane.

Il n'a beau pas être nul, il est bien responsable de ton problème.
En effet le FlowLayout possède la caractéristique suivante: il ajoute les composants de façon horizontale tant qu'il a de la place vers la fin du composant. S'il n'y a plus de place, il passe à la ligne. Or mettre ton JPanel dans un JScrollPane fait en sorte que l'espace horizontal disponible pour ton JPanel est infini (ou du moins quelque chose de la sorte ;) ). De fait le FlowLayout n'estime pas avoir besoin de passer à la ligne. CQFD

Pour remédier à cela, il faut ne plus utiliser le FlowLayout.

Décrit nous ce que tu cherches à mettre en place comme interface, on te donnera le Layout le plus approprié ;)
08/03/2011, 19h48
Ceubex

Ok, en fait je veux mettre un panneau avec des boutons dans une des "cases" d'un jsplitpane. Du coup le panneau des boutons doit pouvoir être redimensionnable et que lorsqu'on le redimensionne les boutons se remettent bien pour être visibles mais qu'on puisse les atteindre quand il y en a caché.

Pour des problèmes de présentation, il faut que ces boutons soit accessibles en faisant un scroll vertical et non horizontal. Le FlowLayout était donc idéal pour cela, les boutons se mettent sur la ligne suivante quand on redimensionne lateralement le jsplitpane et il me faudrait quelque chose de proche. En tout cas quelque chose où le nombre de boutons sur une ligne varie en fonction de la taille du panneau
09/03/2011, 00h44
sinok

La solution ici passe par la création d'un layout spécifique héritant du FLowLayout, mais recalculant la preferredSize du composant en utilisant une taille maximale.

Cf le post d'Adiguba dans ce forum: http://www.developpez.net/forums/d61...s/#post3634553

OK je te remercie. J'ai essayé de me baser sur le code que tu m'as montré. Mais j'ai quelques difficultés à l'adapter pour qu'il fonctionne pour la hauteur.
Je vais regarder si je peux encore l'ameliorer mais pour le moment ça n'a aucun effet

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
class WrapFlowLayout extends FlowLayout {
	/* serialVersionUID */
	private static final long serialVersionUID = 1L;
 
	@Override
	public Dimension preferredLayoutSize(Container target) {
		final Container parent = target.getParent();
		if (parent != null) {
			final int height = parent.getHeight();
			return new Dimension(calculateHeight(target, height),height);
		}
		return super.preferredLayoutSize(target);
	}
 
	@Override
	public Dimension minimumLayoutSize(Container target) {
		final Container parent = target.getParent();
		if (parent != null) {
			final int height = parent.getHeight();
			return new Dimension(calculateHeight(target, height),height);
		}
		return super.minimumLayoutSize(target);
	}
 
	/**
         * Calcule la hauteur du layout avec une largeur fixe
         */
	public int calculateHeight(Container target, int height) {
		Insets insets = target.getInsets();
		final int vgap = getVgap();
		final int hgap = getHgap();
		// On calcule la taille du contenu :
		final int innerHeigth = Math.max(height - (insets.top + insets.bottom + vgap * 2),0);
		// On initialise la taille avec les marges
		int width = insets.left + insets.right + vgap;
 
		synchronized (target.getTreeLock()) {
			Dimension dim = new Dimension(0, 0);
 
			boolean firstVisibleComponent = true;
			final boolean useBaseline = getAlignOnBaseline();
			int maxAscent = 0;
			int maxDescent = 0;
 
			final int nmembers = target.getComponentCount();
			for (int i = 0; i < nmembers; i++) {
				Component m = target.getComponent(i);
				if (m.isVisible()) {
					Dimension d = m.getPreferredSize();
 
					if (firstVisibleComponent) {
						// Si on est sur le premier composant, on doit l'ajouter :
						dim.width = d.width;
						dim.height = d.height;
						firstVisibleComponent = false;
					} else if ((dim.height + vgap + d.height) <= innerHeigth) {
						// Si on peut ajouter un composant sur la ligne, on le fait
						dim.height += vgap + d.height;
						dim.width = Math.max(dim.width, d.width);
					} else {
						// On ne peut plus ajouter de composants, on fait une nouvelle ligne
						if (useBaseline) {
							dim.width = Math.max(maxAscent + maxDescent, dim.width);
						}
						width += dim.width + hgap;
 
						// Et on "met" le composant sur la nouvelle ligne
						dim.width = d.width;
						dim.height = d.height;
						maxAscent = 0;
						maxDescent = 0;
					}
					if (useBaseline) {
						int baseline = m.getBaseline(d.width,d.height);
						if (baseline >= 0) {
							maxAscent = Math.max(maxAscent, baseline);
							maxDescent = Math.max(maxDescent, d.width - baseline);
						}
					}
				}
			}
			if (dim.width!=0) {
				if (useBaseline) {
					dim.width = Math.max(maxAscent + maxDescent, dim.width);
				}
				width += dim.width + hgap;
			}
			return width;
		}
	}
}

10/03/2011, 10h02
adiGuba

Salut,

Citation:

Envoyé par Ceubex

OK je te remercie. J'ai essayé de me baser sur le code que tu m'as montré. Mais j'ai quelques difficultés à l'adapter pour qu'il fonctionne pour la hauteur.

C'est à dire ? Quel est le problème exactement ?

a++
10/03/2011, 13h48
Ceubex

En fait ton code ajuste la largeur mais moi c'est la hauteur qui m'intéresse
10/03/2011, 14h50
adiGuba

Dans ce cas ce n'est pas du tout approprié !

Expliques plus précisément ce que tu veux avoir, éventuellement avec des exemples de ce que tu veux obtenir (personnellement ce n'est pas très clair).

a++
10/03/2011, 15h07
Ceubex

Bon je renonce à expliquer le problème avec des mots.
Va à cette adresse : http://zivids.fr/video/d.html
Il y a une vidéo du soucis, le panneau est dans un jsplitpane et quand je monte la barre du bas je voudrais qu'un scroll verticale se mette pour qu'on puisse voir les boutons qui sont cachés

Comment faire ?
10/03/2011, 15h47
adiGuba

Tu aurais un code minimum qui reproduise le problème ?
Car avec le WrapFlowLayout j'ai bien la scrollbar verticale...

a++
13/04/2011, 11h26
Ceubex

Scroll innactif dans un JScrollPane
Bonjour,

A cette adresse vous avez une vidéo du problème. Quand je monte la barre du bas je voudrais qu'un scroll verticale se mette pour qu'on puisse voir les boutons qui sont cachés. Mais rien ne se met alors qu'il y a un JScrollPane.

Les codes ne sont pas très importants. Voilà la déclaration du JScrollPane (command est un JPanel qui contient les boutons avec un FlowLayout) :
Code:

1 2 JScrollPane scCommand=new JScrollPane(); scCommand.setViewportView(command);
Le JScrollPane est ensuite mis dans un JSplitPane.

Merci d'avance pour votre aide

Voici une solution basée sur le WrapFLowLayout fourni plus haut (légèrement modifié pour le getMinimumSize) qui est fonctionnelle. Le WrapFlowLayout permet ce que vous cherchez à faire. C'est juste que vous l'utilisez probablement de la mauvaise façon, toutefois, n'ayant vu votre façon de faire, nous ne pouvons pas plus vous 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
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
 
package layout;
 
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Insets;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
 
 
 
class WrapFlowLayout extends FlowLayout {
    /* serialVersionUID */
    /* serialVersionUID */
    private static final long serialVersionUID = 1L;
 
    @Override
    public Dimension preferredLayoutSize(Container target) {
        final Container parent = target.getParent();
        if (parent != null) {
            final int width = parent.getWidth();
            return new Dimension(width, calculateHeight(target, width));
        }
        return super.preferredLayoutSize(target);
    }
 
    @Override
    public Dimension minimumLayoutSize(Container target) {
        /*final Container parent = target.getParent();
        if (parent != null) {
            final int width = parent.getWidth();
            return new Dimension(width, calculateHeight(target, width));
        }
        return super.minimumLayoutSize(target);*/
        return new Dimension(0,0);
    }
 
 
 
    /**
     * Calcule la hauteur du layout avec une largeur fixe
     */
    public int calculateHeight(Container target, int width) {
        Insets insets = target.getInsets();
        final int vgap = getVgap();
        final int hgap = getHgap();
        // On calcule la taille du contenu :
        final int innerWidth = Math.max(0, width - (insets.left + insets.right + hgap * 2));
        // On initialise la taille avec les marges
        int height = insets.top + insets.bottom + vgap;
 
        synchronized (target.getTreeLock()) {
            Dimension dim = new Dimension(0, 0);
 
            boolean firstVisibleComponent = true;
            final boolean useBaseline = getAlignOnBaseline();
            int maxAscent = 0;
            int maxDescent = 0;
 
            final int nmembers = target.getComponentCount();
            for (int i = 0; i < nmembers; i++) {
                Component m = target.getComponent(i);
                if (m.isVisible()) {
                    Dimension d = m.getPreferredSize();
 
                    if (firstVisibleComponent) {
                        // Si on est sur le premier composant, on doit l'ajouter :
                        dim.width = d.width;
                        dim.height = d.height;
                        firstVisibleComponent = false;
                    } else if ((dim.width + hgap + d.width) <= innerWidth) {
                        // Si on peut ajouter un composant sur la ligne, on le fait
                        dim.width += hgap + d.width;
                        dim.height = Math.max(dim.height, d.height);
                    } else {
                        // On ne peut plus ajouter de composants, on fait une nouvelle ligne
                        if (useBaseline) {
                            dim.height = Math.max(maxAscent + maxDescent, dim.height);
                        }
                        height += dim.height + vgap;
 
                        // Et on "met" le composant sur la nouvelle ligne
                        dim.width = d.width;
                        dim.height = d.height;
                        maxAscent = 0;
                        maxDescent = 0;
                    }
                    if (useBaseline) {
                        int baseline = m.getBaseline(d.width, d.height);
                        if (baseline >= 0) {
                            maxAscent = Math.max(maxAscent, baseline);
                            maxDescent = Math.max(maxDescent, d.height - baseline);
                        }
                    }
                }
            }
            if (dim.height!=0) {
                if (useBaseline) {
                    dim.height = Math.max(maxAscent + maxDescent, dim.height);
                }
                height += dim.height + vgap;
            }
            return height;
        }
    }    
 
 
    public static void main(String[] args) {
        JFrame f = new JFrame();
 
        JPanel p = new JPanel();
        p.setLayout(new WrapFlowLayout());
        for (int i = 0; i<25;i++) {
            p.add(new JButton("a"));
        }
        JSplitPane sp1 = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
        JSplitPane sp2 = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
        JSplitPane sp3 = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
        sp3.setRightComponent(new JPanel());
        sp3.setLeftComponent(new JScrollPane(p));
        sp2.setRightComponent(sp3);
        sp2.setLeftComponent(new JPanel());
        sp1.setTopComponent(sp2);
        sp1.setBottomComponent(new JPanel());
        f.add(sp1);
        f.setSize(1024,768);
        f.setLocationRelativeTo(null);
        f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        f.setVisible(true);
    }
}

Cdt
Sinok.