ca n'existe pas??!!

Bon, je sens que ca n'a pas motivé grand monde tout mon discours.
J'ai avancé un peu dans la conception de mon composant, mais c'est pas
encore ca.
ca rame un peu moins (mais encore pas mal), ca laisse le lecteur de
disquette tranquille, ca ne m'affiche plus les fichiers (à part ceux du
bureau, détail à régler), et tout n'est pas codé très proprement.

J'y vais franco, voici le code du composant, histoire que tout le monde
sache de quoi je parle. J'ai fait encore des recherches sur le net, mais je
n'ai toujours rien trouvé d'équivalent... bizarissime, ca me semble être un
composant "basique".

une idée?

import java.awt.Component;
import java.io.*;
import java.util.Date;
import java.util.Enumeration;
import java.util.Vector;
import javax.swing.event.TreeModelListener;
import javax.swing.filechooser.*;
import javax.swing.JTree;
import javax.swing.tree.*;

/**
* This component displays the computer's folders tree.
* @author Cédric Bourgeois
* @version 1.0
*/

public class FileTree extends JTree {
static FileSystemView fsView = FileSystemView.getFileSystemView();

public FileTree() {
setModel(new FileTreeModel());
setCellRenderer(new FileTreeCellRenderer());
super.setRootVisible(false);
}

/**
* This method does nothing.
*/
public void setRootVisible() {
;
}

public static FileSystemView getFileSystemView() {
return fsView;
}
}

class FileTreeModel implements TreeModel {
FileSystemView fsView;
Vector listeners;
FolderPropertiesMemory fpMemory;

public FileTreeModel() {
fsView = FileTree.getFileSystemView();
listeners = new Vector();
fpMemory = new FolderPropertiesMemory(10000);
}

public File createNewFolder(File containingDir) throws java.io.IOException
{
/**@todo Implémenter cette méthode
javax.swing.filechooser.FileSystemView abstract*/
throw new java.lang.UnsupportedOperationException(
"La méthode createNewFolder() n'est pas encore implémentée.");
}

/**
* return the root of all roots.
* @return the object returned is an array of <code>File</code>s whiwh are
* actually the file system roots.
*/
public Object getRoot() {
return fsView.getRoots();
}

/**
* returns the subfolder number i of a given folder.
* @param o the parent folder
* @param i the folder number
* @return the subfolder
*/
public Object getChild(Object o, int i) {
//sendLog("getChild: " + o);
if (o == fsView.getRoots())
return fsView.getRoots()[i];

return fpMemory.getChild((File) o, i, false);

}

/**
* returns the number of subfolders in this folder
* @param o this <code>File</code> is the parent folder.
* @return the number of subfolders.
*/
public int getChildCount(Object o) {
if (o == fsView.getRoots()) {
return fsView.getRoots().length;
}
return fpMemory.getChildCount((File) o, false);
}

/**
* indicates whether this folder contains subfolders.
* @param o this <code>File</code> is the parent folder.
* @return <code>true</code> if and only if this folder contains
subfolders.
*/
public boolean isLeaf(Object o) {
//sendLog("isLeaf: " + o);
if (o == fsView.getRoots())
return false;
return fpMemory.isLeaf((File) o, false);
}

public void valueForPathChanged(TreePath path, Object newValue) {
/**@todo Implémenter cette méthode
javax.swing.filechooser.FileSystemView abstract*/
throw new java.lang.UnsupportedOperationException(
"La méthode createNewFolder() n'est pas encore implémentée.");
}

public int getIndexOfChild(Object parent, Object child) {
File[] files = fsView.getFiles((File)parent, true);
int index = 0;
while (index < files.length && child != files[index]) {
index++;
}
return index;
}

public void addTreeModelListener(TreeModelListener l) {
listeners.add(l);
}

public void removeTreeModelListener(TreeModelListener l) {
listeners.remove(l);
}

void sendLog(String msg) {
System.out.println(
"[" + new java.util.Date(System.currentTimeMillis()) + "]t" +
System.currentTimeMillis() + "t" + msg);
}
}

class FileTreeCellRenderer extends DefaultTreeCellRenderer {
FileSystemView fsView = FileTree.getFileSystemView();

public Component getTreeCellRendererComponent(JTree tree, Object value,
boolean sel, boolean expanded, boolean leaf, int row, boolean
hasFocus) {

// call superclass method
super.getTreeCellRendererComponent(
tree, value, sel, expanded, leaf, row, hasFocus);

// identify icon
setIcon( fsView.getSystemIcon((File)value));

// override file name
setText(fsView.getSystemDisplayName((File)value));

// done
return this;

}

}

/**
* This class is intended to keep in memory the properties of folders. This
* allows a faster access when exploring the file system
* @author C&eacute;dric Bourgeois
* @version 1.0
*/
class FolderPropertiesMemory {
Vector foldersProperties;
FileSystemView fsView;
long refreshRate;
java.io.FileFilter folderFilter = new java.io.FileFilter(){
public boolean accept(File f) {
return f.isDirectory();
}
};

class FolderProperties {
File folder; // related folder
File[] children; // folder children
long nextUpdate; // next time properties must be updated

/**
* Empty constructor, does nothing;
*/
public FolderProperties() {}

/**
* Constructor that sets object's fields;
*/
public FolderProperties(File folder) {
this.folder = folder;
}

/**
* the comparison is based on the folder properties
* @param fp the <code>FolderProperties</code> to compare.
* @return <code>true</code> if this folder and fp folder are null or
* if folder.equals(fp.folder), <code>false</code> otherwise.
*/
public boolean equals(FolderProperties fp) {
return (folder == null? fp.folder == null : folder.equals(fp.folder));
}
}

public FolderPropertiesMemory(long refreshRateInMillis) {
foldersProperties = new Vector();
fsView = FileTree.getFileSystemView();
refreshRate = refreshRateInMillis;
}

public boolean isLeaf(File folder, boolean forceRefresh) {
return (getFolderProperties(folder, forceRefresh)).children.length == 0;
}

public int getChildCount(File folder, boolean forceRefresh) {
return (getFolderProperties(folder, forceRefresh)).children.length;
}

public File getChild(File folder, int index, boolean forceRefresh) {
return (getFolderProperties(folder, forceRefresh)).children[index];
}

FolderProperties getFolderProperties (File folder, boolean forceRefresh) {
FolderProperties returnedFP = null;
Enumeration enum = foldersProperties.elements();

// look for the folder in available properties
FolderProperties fp;
while (enum.hasMoreElements() && returnedFP == null) {
if ((fp = (FolderProperties)
enum.nextElement()).folder.equals(folder))
returnedFP = fp;
}

if(returnedFP != null && !forceRefresh)
// it's all good, we can return the properties in memory
return returnedFP;

if(returnedFP == null) {
returnedFP = new FolderProperties(folder);
foldersProperties.add(returnedFP);
}
refreshFolderProperties(returnedFP);
return returnedFP;
}

void refreshFolderProperties(FolderProperties fp) {
if (isNormal(fp.folder)) {
fp.children = fp.folder.listFiles(folderFilter);
} else {
fp.children = fsView.getFiles(fp.folder, true);
}
}

boolean isNormal(File file) {
return ((file.list() != null) &&
(file.list().length == fsView.getFiles(file, false).length));
}

}

"Ced" <slideb0y@yahoo.com> a écrit dans le message de
news:blmuvk$qmr$1@news-reader2.wanadoo.fr...

hello les javanais!

Je suis en train de me faire un ACDsee-like (pour ne pas le citer. Au
moins

tout le monde a compris.) et j'ai eu beau chercher dans la doc de l'API et
un peu partout, je n'ai RIEN trouve comme composant qui affiche
l'arborescence de fichiers. Bon, j'aurais pu me contenter d'un JTree avec
la

liste des disques durs, mais j'avais envie de tout le tralala Windows:
bureau, mes documents, voisinage reseau, ...
J'ai fini par combiner un JTree avec un
javax.swing.filechooser.FileSystemView, et je suis arrive à un quelque
chose

qui ressemble à ce que je cherche: adapté à l'environnement, tout joli
avec

des icones et tout... Mais:
1/ ca rame comme pas possible
2/ ca va fouiller le lecteur de disquette a chaque raffraichissement du
JTree
3/ ca m'affiche aussi les fichier
4/ je pense que je pourrais arranger tout ca, mais j'ai la flemme et
j'arrive pas a croire qu'ils ne l'aient pas fait avant moi chez Sun.

Quelqu'un sait-il où je me suis planté dans mes recherches, et où est ce
satané contrôle?

Merci d'avance pour votre aide!

Ced.