Discussion :

[lvr]

Bonjour,

J'utilise un JPanel comme renderer du mon JTree. La hauteur du panel varie d'une ligne à l'autre. Je connais la hauteur du panel en écrivant
renderer.layout.minimumLayoutSize(this)

J'ai indiqué au JTree que ses lignes auraient une hauteur variable en écrivant
tree.setRowHeight(-1);

Et la doc enchaine en disant: "If the specified value is less than or equal to zero the current cell renderer is queried for each row's height."

Ma question est: comment ? Comment dois-je indiquer que la hauteur de ma ligne vaut la hauteur du panel ? J'ai essayé avec un setPreferredSize, setSize sans résultat.

J'attends avec impatience vos suggestions ! !

PS: Ce qui complique peut-être les choses, c'est que la hauteur du panel varie suivant que la ligne soit sélectionnée ou pas.

[lvr]

C'est si compliqué que ça ? Ou au contraire tellement trivial ?

[lvr]

Up please, je suis complètemment

[euyeusu]

En fait, il faut que tu crée une classe implémentant l'interface

Code :

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

javax.swing.tree.TreeCellRenderer

Cette classe te permet de définir comment tu affiches une "ligne" de ton tree (dont la hauteur)

il te suffit ensuite de preciser à ton tree d'utiliser ce renderer avec l'instruction suivante :

Code :

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

myTree.setCellRenderer(myRenderer);

[lvr]

C'est ce que je fais !
La question, c'est comment dans mon TreeCellRender indiquer sa hauteur.

Comme je l'indique dans mon 1er message, j'ai essayé plus trucs dont

Code :

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

renderer.setPreferredSize(...)

mais ça ne fonctionne pas.

[euyeusu]

Bonjour, désolé pour la réponse tardive mais j'étai très occupé.

Je pense que tu n'as pas compris le principe du renderer. Car je vois que tu essayes de lui attribuer une taille. Le renderer te permet de "dessiner" le contenu de ta ligne.

pour cela tu dois créer ton propre renderer et implementer la méthode

Code :

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

1
2
3
4
5
6
7
public Component getTreeCellRendererComponent(JTree tree,
                                              Object value,
                                              boolean selected,
                                              boolean expanded,
                                              boolean leaf,
                                              int row,
                                              boolean hasFocus)

Cette méthode renvoie comme resultat un composant graphique qui correspond à la ligne spécifiée par le paramètre row.

Par exemple pour afficher une ligne aux dimensions voulues :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public Component getTreeCellRendererComponent(JTree tree,
                                              Object value,
                                              boolean selected,
                                              boolean expanded,
                                              boolean leaf,
                                              int row,
                                              boolean hasFocus)
{
          JLabel myLabel = new myLabel(String.valueOf(row));
          myLabel.setPreferredSize(...)
          return myLabel
}

[lvr]

Merci de me répondre.
Je mets mon code, comme ça on parlera de la même chose.
Tu verras que (je pense) je fais un usage correcte du Renderer.

Mon renderer se compose d'un JPanel qui implémente TreeCellRenderer,
dans lequel je mets un DefaultTreeCellRenderer (donc un JLabel étendu) avec le texte du noeud, et un JLabel simple qui ne doit être affiché que lorsque le noeud est sélectionné. La hauteur d'une ligne dépend donc du fait qu'elle soit sélectionnée ou pas.

Dans le getTreeCellRendererComponent, je fais un this.setSize(...,...) et ça ne donne rien.

Mon implémentation de l'arbre: ultra-simple

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class EditableTree extends JTree {
 
    /**
     * Le constructeur par défaut
     * @param newModel TreeModel
     */
    public EditableTree(TreeModel newModel) {
        super(newModel);
        this.setCellRenderer(new dlgMessageSelector_Renderer(this.getFont()));
        this.setRowHeight(-1); // La hauteur des lignes n'est pas fixe: elle est fixée par le renderer
    }

Le renderer

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
 
    class dlgMessageSelector_Renderer extends JPanel implements TreeCellRenderer {
        ...
        /**
         * Un label qui se comportera comme un noeud dans un arbre classique 
         */
        DefaultTreeCellRenderer labLabel = new DefaultTreeCellRenderer();
        /**
         * Le label avec l'info supplémentaire, qui apparaît ou pas suivant les cas.
         */
        JLabel labAutre = new JLabel("Autre info");
        LayoutManager layout;
 
        public dlgMessageSelector_Renderer(Font plain) {
            // Initialisation fonctionnelle
           ...
 
            //Initialisation graphique du panel
            layout = new BoxLayout(this, SwingConstants.VERTICAL);
            this.setLayout(layout);
 
            // Initialisation graphique du labLabel
            labLabel.setClosedIcon(null);
            labLabel.setOpenIcon(null);
            labLabel.setLeafIcon(null);
            this.add(labLabel);
 
            // Initialisation graphique des autres infos
            this.add(labAutre);
 
        }
 
        public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf,
                int row, boolean hasFocus) {
 
            labLabel.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);
 
            DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
            String d = node.getUserObject().toString();
 
            // 1) Les couleurs en fonction de la nature du noeud (titre, new, normal)
            labLabel.setFont(plain);
            if (node.getUserObject() instanceof MessageNode) {
                 ...
                 }
 
            // 2) Les autres info du panneau
            labAutre.setVisible(sel);
 
            // 3) La hauteur du panneau
            this.setMinimumSize(layout.minimumLayoutSize(this));
 
            return this;
        }
 
    }

[euyeusu]

Salut,

Je pense que tu n'as pas compris le principe du renderer

Il semblerait que j'avai tort

Tu verras que (je pense) je fais un usage correcte du Renderer.

Tu penses bien

Sinon pour en revenir à la dimension des tes "lignes" je penche plutôt sur

Code :

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

.setPreferredSize()

Par exemple ce petit code que j'ai essayé, double la hauteur de chaque ligne de ton tree.

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
class Renderer2 extends JPanel implements TreeCellRenderer {
 
        public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf,
                int row, boolean hasFocus) {
 
            DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
            String d = node.getUserObject().toString();
            JLabel labLabel = new JLabel(d);
 
            	labLabel.setPreferredSize(new Dimension(200, (row + 1) * 20));
 
            return labLabel;
        }
 
    }

[bouye]

Un sacre kiproco en effet.

La manque de reponses provient probablement du fait que peu pratiquent sans doute ce genre de manip ; je ne l'ai jamais fait moi-meme sur des JTree mais je me suis casse la tete avec des JList pour faire pareil il y a quelques temps (j'ai contourne le probleme en utilisant un panel avec un BoxLayout dans un JScrollPane, ce qui a l'apparence d'une JList).

[lvr]

Je crois que je vais opter pour une autre technique... C'est dommage car c'était prometteur. Merci quand même. Je ne mets pas "Résolu" tout de suite, dès fois que d'autres connaitraient la solution.