[JTree] Icônes des noeuds

Version imprimable

31/08/2005, 17h15
seiryujay

[JTree] Icônes des noeuds
J'aimerai pouvoir changer les icônes des noeuds d'un JTree.
J'ai donc regardé la doc et j'ai vu les méthodes :
Code:

1 2 3 4 5 6 setLeafIcon() setClosedIcon() setOpenIcon() setDisabledIcon() setIcon()
Mais je n'arrive pas à faire exactement ce que je veux.
Le comportement de base est que
- quand on a une feuille, l'icone est un rond gris
- quand on est sur un dossier fermé (qui n'a pas été "expanded", désolé, je ne connais pas le mot français qui convient), l'icône est un dossier ouvert
- quand on est sur un dossier ouvert (expanded), l'icône est un dossier ouvert

Ce que j'aimerai, c'est la même chose sauf que j'aimerai avoir une icône en forme de dossier fermé quand le dossier est fermé (non-expanded).

Quelqu'un peut-il m'aider?
Merci.

Tiens, voila une petite note que je m'étais fait, ca t'aidera peut être:

Gestion des icones utilisés dans le Jtree

Pour cela il faut utiliser un Renderer:
Le plus simple est de surcharger la classe DefaultTreeCellRenderer

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
 
MyRenderer myRenderer = new MyRenderer();
jtree.setCellRenderer(myRrr);
public class MyRenderer extends DefaultTreeCellRenderer {
	public MyRenderer() {
		super();
	}
	//Redéfini la méthode getTreeCellRendererComponent
	public Component getTreeCellRendererComponent(JTree tree, Object value,boolean sel, boolean expanded, 							boolean leaf, int row,boolean hasFocus) {
		ImageIcon fold = new ImageIcon("../lib/file.png");
		DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;	
		//test si c'est une feuille
		if(leaf){
			//Peux tester le type d'objet sélectionné dans le Jtree 
			if (node.getUserObject() instanceof type_de_classe) {
				//Permet de définir l'icone pour le type de classe trouvé...
				this.setLeafIcon(fold);
			}
		}
		//noeud avec enfants
		if(expanded){
			//Cas du noeud « ouvert »
			this.setOpenIcon(fold);
		}
		else{
			//Cas du noeud « fermé »
			this.setClosedIcon(fold);
		}	
		//on appelle ensuite la classe de base
		super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf,row, hasFocus);
		return this;
	}
}

Je te montre ce que j'ai, mais d'abord quelques explications :

J'utilise le composant JTreeTable qui correspond à une JTable dont le CellRenderer de la première colonne est un JTree.
Pour cela, j'ai une classe TreeTableCellRenderer qui étend JTree et implémente TableCellRenderer.

Dans la méthode updateUI(), on récupère le CellRenderer et on le caste en DefaultTreeCellRenderer, si c'est bien son type.

Et donc à partir de là, j'aimerai fixer les icônes à utiliser. J'ai essayé ce qui est en commentaire (juste en dessous des étoiles), mais ça ne me donne pas le résultat escompté.
Je fais quelque chose de mal, ou c'est juste que je dois faire autrement?

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
 
	public class TreeTableCellRenderer extends JTree implements TableCellRenderer {
		/** Last table/tree row asked to renderer. */
		protected int visibleRow;
 
 
		public TreeTableCellRenderer(TreeModel model) {
			super(model);
		}
 
		/**
                 * updateUI is overridden to set the colors of the Tree's renderer to
                 * match that of the table.
                 */
		public void updateUI() {
			super.updateUI();
			// Make the tree's cell renderer use the table's cell selection
			// colors.
			TreeCellRenderer tcr = getCellRenderer();
			if (tcr instanceof DefaultTreeCellRenderer) {
				DefaultTreeCellRenderer dtcr = ((DefaultTreeCellRenderer) tcr);
				//*********************
				// pour changer l'icone des feuilles
				Icon leafIcon = dtcr.getLeafIcon();
				Icon closedIcon = dtcr.getClosedIcon();
				Icon openIcon = dtcr.getOpenIcon();
				Icon defaultClosedIcon = dtcr.getDefaultClosedIcon();
				Icon disabledIcon = dtcr.getDisabledIcon();
				Icon icon = dtcr.getIcon();
 
//				dtcr.setLeafIcon(null);
				dtcr.setClosedIcon(defaultClosedIcon);
//				dtcr.setOpenIcon(defaultClosedIcon);
				dtcr.setDisabledIcon(closedIcon);
//				dtcr.setIcon(closedIcon);
//				dtcr.setOpenIcon(closedIcon);
 
 
				// For 1.1 uncomment this, 1.2 has a bug that will cause an
				// exception to be thrown if the border selection color is
				// null.
				// dtcr.setBorderSelectionColor(null);
				dtcr.setTextSelectionColor(UIManager.getColor("Table.selectionForeground"));
				dtcr.setBackgroundSelectionColor(UIManager.getColor("Table.selectionBackground"));
			}
		}
 
		/**
                 * Sets the row height of the tree, and forwards the row height to the
                 * table.
                 */
		public void setRowHeight(int rowHeight) {
			if (rowHeight > 0) {
				super.setRowHeight(rowHeight);
				if (JTreeTable.this != null
						&& JTreeTable.this.getRowHeight() != rowHeight) {
					JTreeTable.this.setRowHeight(getRowHeight());
				}
			}
		}
 
		/**
                 * This is overridden to set the height to match that of the JTable.
                 */
		public void setBounds(int x, int y, int w, int h) {
			super.setBounds(x, 0, w, JTreeTable.this.getHeight());
		}
 
		/**
                 * Sublcassed to translate the graphics such that the last visible row
                 * will be drawn at 0,0.
                 */
		public void paint(Graphics g) {
			g.translate(0, -visibleRow * getRowHeight());
			super.paint(g);
		}
 
		/**
                 * TreeCellRenderer method. Overridden to update the visible row.
                 */
		public Component getTableCellRendererComponent(JTable table,
				Object value, boolean isSelected, boolean hasFocus, int row,
				int column) {
			if (isSelected)
				setBackground(table.getSelectionBackground());
			else
				setBackground(table.getBackground());
 
			visibleRow = row;
 
			return this;
		}
 
		public void removeNode(DefectNode node) {
			DefectNode parent = node.getParent();
			parent.removeChild(node);
 
			// if the node is a sub-node, update the group is a son of.
			parent.refresh();
		}
	}

01/09/2005, 11h21
seiryujay

Euh, je suis en train de reprendre ton code, et je me pose une question : comment on fait pour savoir si un noeud est "expanded"?
01/09/2005, 12h22
seiryujay

En fait, c'est bon...
J'ai utilisé ton bout de code et ça marche. J'avais peur qu'il y ait des conflits avec les autres renderer que j'utilisais sur le même composant, mais pas du tout, donc merci! :D