[JTree]Utilisation d'un JTree

Salut à tous,
Je vous expose ce que je doit faire.
Je dois représenter l'arboressance d'un répertoire dans un Jtree.
Pour le moment, je suis arrivé a lister tout les répertoires et tout les fichier contenus dans le répertoire racine.

mais ce que j'aimerais c'est que lorsque l'on déplie un répertoire, le programme liste le contenu du répertoire pour l'afficher dans le Jtree.

pour définir que le répertoire à été déplier j'utilise:
Code:

1 2 3 4 public void treeExpanded(TreeExpansionEvent arg0) { //c'est juste pour voire si ca marchais System.out.println("treeExpanded"); }
voila, si je n'est pas été assé claire faite le moi savoir.
sur ce bonne journée

C'est un truc de oufs, bon courage!

euh... j'ai pas du bien comprendre. C'est quoi qui te manque techniquement?

re

C'est bon j'ai trouver.
Je vous file la source!

Class exécutable : MainWindow

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
 
/*
 * Created on 9 mars 2005
 *
 * TODO To change the template for this generated file go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
 
import java.awt.BorderLayout;
import java.awt.HeadlessException;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTree;
 
import fr.ca.greencam.IR2.Interface;
 
/**
 * @author G909248
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
public class MainWindow extends JFrame {
 
	/**
         * @throws java.awt.HeadlessException
         */
	public MainWindow() throws HeadlessException {
		//titre de l'application
		super("Ré-édition");
		//initialisation des composants
		initComponent();
	}
 
	/**
         * 
         */
	private void initComponent() {
		//arrete l'application java lorsque lon quite la fenètre
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		//Instanciation de la Class Jtree
		//On passe en paramètre un Model
		//MyTreeModel est une classe qui hérite de DefaultTreeModel
		JTree myTree = new JTree(new MyTreeModel());
 
		//Ajout de l'arboressenece lorsqu'un répertoire est ouvert
		myTree.addTreeExpansionListener(new myExpensionListener());
		//Instantiation de La Class JScrollPanne afin de pouvoir bénéficier des ascenceur.		
		JScrollPane scrollPane = new JScrollPane(myTree);
		//Integration du composant JScrollPane dans la fenètre
		getContentPane().add(scrollPane,BorderLayout.CENTER);
 
		setSize(300,400);
 
		setVisible(true);	
	}
	public static void main(String[] args) {
		//instanciation de la fenêtre
		new MainWindow();
	}	
}

Une autre classe :myExpensionListener

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
import javax.swing.JTree;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.plaf.basic.DefaultMenuLayout;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
 
/**
 * @author G909248
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
public class myExpensionListener implements TreeExpansionListener {
 
	/**
         * Constructeur de la Class
         */
	public myExpensionListener() {
		super();
		// TODO Auto-generated constructor stub
	}
 
	//S'exécute lorsque lorsque qu'un dossier est ouvert
	public void treeExpanded(TreeExpansionEvent arg0) {
		//Appele de la fonction addChildren de la classe TreeUtil
		//Elle demande en paramètre DefaultTreeModel, DefaultMutableTreeNode
		TreeUtil.addChildren((DefaultTreeModel)((JTree)arg0.getSource()).getModel(),(DefaultMutableTreeNode)arg0.getPath().getLastPathComponent());
	}
/*getSource est une Instance de JTree, ce qui va nous permetre de pouvoir utiliser getModel qui retourne un TreeModel 
 * qui lui pourras être casté en DefaultTreeModel.
 * getPath donne le chemin complet du répertoire ouvert depuis la racine.
 * getLastPathComponent retourne le nom du dernier répertoire
 */
 
	//on n'effectue aucune action lorsque qu'un répertoire est fermé 
	public void treeCollapsed(TreeExpansionEvent arg0) {
 
	}
 
}

encore une autre class : MyFile

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
import java.io.File;
 
/**
 * @author G909248
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
public class MyFile extends File {
 
	/**
         * @param arg0
         */
	public MyFile(String arg0) {
		super(arg0);
	}
 
	public String toString() {
		return getName();
	}
}

autre class : MyTreeModel

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
 
import java.io.File;
 
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
 
/**
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
public class MyTreeModel extends DefaultTreeModel {
 
	/**
         * 
         */
	public MyTreeModel() {
		//création du premier neux
		super(new DefaultMutableTreeNode(new MyFile("c:/TEMP")));
 
//		Appele de la fonction addChildren de la classe TreeUtil
		//Elle demande en paramètre DefaultTreeModel, DefaultMutableTreeNode
		TreeUtil.addChildren(this,(DefaultMutableTreeNode)getRoot());
		/*
		 * This représente cette class
		 * getRoot est une méthode de la classe DefaultTreeModel
		 */
	}
 
	public boolean isLeaf(Object arg0) {
		return !((File)((DefaultMutableTreeNode)arg0).getUserObject()).isDirectory();
		/*
		 * isLeaf permet de savoir si l'objet passé en paramètre est une feuille ou non.
		 * Et ici on va testé si cette objet est un répertoire ou non
		 * on caste notre argument en File afin d'utiliser la methode isDirectory()
		 */
	}
}

autre class : TreeUtil

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
 
import java.io.File;
 
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
 
/**
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
public class TreeUtil {
	/**
         * 
         */
	protected static void addChildren(DefaultTreeModel treeModel,DefaultMutableTreeNode parentNode) {
		//Création d'un Fichier avec le nom du répertoire ouvert
		File selectedFile = (File)parentNode.getUserObject();
 
		//on supprime tout les enfants du répertoire ouvert
		parentNode.removeAllChildren();
		//On informe le treeModel que sa Structure à changé
		treeModel.nodeStructureChanged(parentNode);
 
		//Listage du répertoire
		File[] children = selectedFile.listFiles();
 
		int x = 0;
 
		//On crée en premier les répertoire
		for(int i=0;i<children.length;i++){
			if(children[i].isDirectory()){
				//On insert de nouveaux neux dans le treeModel
				treeModel.insertNodeInto(new DefaultMutableTreeNode(new MyFile(children[i].getAbsolutePath())),parentNode,x);
				/*MyFile est une classe qui hérite de File
				 * new MyFile(children[i].getAbsolutePath())) on crée un Fichier avec le chemin complet des fichiers qui on été listé.
				 * Et grâce a ce chemin complet on va pouvoir créer un DefaultMutableTreeNode
				 * 				 
				 */
				x++;
			}
		}
		//On crée les fichiers
		for(int i=0;i<children.length;i++){
			if(!children[i].isDirectory()){
				treeModel.insertNodeInto(new DefaultMutableTreeNode(new MyFile(children[i].getAbsolutePath())),parentNode,x);
				x++;
			}
		}
	}
}

Explication finale : pour indiquer le répertoire à partir du quel vous voulez afficher une arbressance, diriger vous vers la class "MyTreeModel" et remplacer cette partie "c:/TEMP" par le répertoire que vous voulez lister.

Je souhaiterais Remercier Guillaume un Collègue qui à fait ce code (Lui c'est une bète pas comme moi!)
sur ce bonne journée!

Plus simple ...

Bonjour,

si ta méthode marche c'est très bien.

Je suis en train de faire presque la même chose, mais j'ai beaucoup moins de classes et donc de code. Je ne veux pas dire que ca peut remplacer ce qu'a fait ton collègue Guillaume, mais peut être ca peut aider d'autre personne.

J'ai tout d'abord créé deux méthodes : constructTree() et foundSubDirectory().

La première méthode permet de créer la racine de l'arbre : iRoot.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
private DefaultMutableTreeNode iRoot;
 
/**
 * Permet de construire l'arbre des différents lecteurs
 */
private void constructTree() {
	File directoryRoot[] = File.listRoots();
	// J'ai supprimer le parcours du 1er lecteur (A:)
	//Pour le remettre, il suffit de faire démarrer i à 0
	for (int i = 1; i < directoryRoot.length; i++) {
		DefaultMutableTreeNode tempNode =
			new DefaultMutableTreeNode(directoryRoot[i]);
		foundSubDirectory(tempNode, directoryRoot[i]);
		iRoot.add(tempNode);
	}
	// On redéfinie l'arbre
	iDirectoryTree.setModel(new DefaultTreeModel(iRoot));
	// Et on le met à jour 
        SwingUtilities.updateComponentTreeUI(iDirectoryTree);
}

La deuxième méthode permet d'explorer un noeud pour vérifier s'il ne contient pas de fils (sous répertoires).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
/**
 * Ajoute au noeud courrant les sous noeuds qu'il possède (ne va pas jusqu'au bout de la branche, mais
 * seulement au niveau N-1).
 * @param currentNode
 * @param directory
 */
private void foundSubDirectory(	DefaultMutableTreeNode currentNode, File directory) {
	File fileList[] = directory.listFiles();
	if (fileList == null)
		return;
	for (int i = 0; i < fileList.length; i++)
		if (fileList[i].isDirectory())
			currentNode.add(new DefaultMutableTreeNode(fileList[i]) {
			// On redéfinie la méthode toString pour l'affiche dans l'arbre
			public String toString() {
				return ((File) getUserObject()).getName();
			}
		});
	}
}

Ensuite, il ne reste plus qu'a redéfinir la méthode treeExpanded :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public void treeExpanded(TreeExpansionEvent event) {
	// Met le courseur en mode "wait"
	setCursor(new Cursor(3));
	DefaultMutableTreeNode selectedNode =	(DefaultMutableTreeNode)  event.getPath().getLastPathComponent();
	for (int i = 0; i < selectedNode.getChildCount(); i++) {
		DefaultMutableTreeNode childNode = (DefaultMutableTreeNode) selectedNode.getChildAt(i);
		if (childNode.isLeaf())
			foundSubDirectory(childNode, (File) childNode.getUserObject());
	}
	// retire le curseur du mode "Wait"
	setCursor(new Cursor(0));
}

Voilà, à partir de là, vous pouvez rajouter ce que vous voulez dans l'arbre, ou bien l'afficher.

Ben