Bonjour, Bonsoir...
Quelques mois de méditation et quelques caractères plus gros que des maisons plus tard, j'ai eu l'opportunité de tomber sur un code qui permettait d'avoir l'interface d'un explorateur de fichiers en JAVA, déjà tout fait, et qui comprends notamment le fameux Favoris Réseau de Windows et donc, les racines des partages que je cherchais ci-dessus. Le but essentiel de mon application était de trouver ces partages plus vite que ne le fait Windows dans son propre explorateur : Dans un premier temps, donc, j'avais utilisé le résultat de la commande "netview.exe" pour y parvenir :
//**********************************************************************************
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import util.Vector;
//(...)
Vector SourceSharedFolders = new Vector();
try
{
Process process = Runtime.getRuntime().exec("net view \\\\" + PCname );
BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
String s=reader.readLine();
do
{
if ((s != null)&&( s.length() > 12))
{
for (int i = 0; i < (s.length() - 11); i++)
{
if ( (s.substring(i, i + 12)).compareTo(" Disque") == 0)
{
for (int j=i+13; j <s.length(); j++) { if (s.charAt(j)!=' ') break; }
s=s.substring(0,i);
for (int k=0; k < i; k++)
{ // Il va falloir purger certains caractères spéciaux mal convertis entre dos-windows et java
if ( s.charAt(k)=='‚' ) s = s.substring(0,k) + 'é' + s.substring(k+1,i);
else if ( s.charAt(k)=='š' ) s = s.substring(0,k) + 'è' + s.substring(k+1,i);
else if ( s.charAt(k)=='‡' ) s = s.substring(0,k) + 'ç' + s.substring(k+1,i);
else if ( s.charAt(k)=='…' ) s = s.substring(0,k) + 'à' + s.substring(k+1,i);
else if ( s.charAt(k)=='ù' ) s = s.substring(0,k) + '¨' + s.substring(k+1,i);
else if ( s.charAt(k)=='œ' ) s = s.substring(0,k) + '£' + s.substring(k+1,i);
else if ( s.charAt(k)=='Ï' ) s = s.substring(0,k) + '¤' + s.substring(k+1,i);
else if ( s.charAt(k)=='—' ) s = s.substring(0,k) + 'ù' + s.substring(k+1,i);
else if ( s.charAt(k)=='æ' ) s = s.substring(0,k) + 'µ' + s.substring(k+1,i);
else if ( s.charAt(k)=='õ' ) s = s.substring(0,k) + '§' + s.substring(k+1,i);
} // Une exception sera levée en cas d'un autre caractère spécial non pris en compte ici...
SourceSharedFolders.addElement(s);
System.out.println(s);
}
}
}
}
while (s != null);
reader = null;
}
catch (IOException ioE)
{
ioE.printStackTrace();
System.out.println("ERRREUR durant l'éxécution de la commande \" Net View \" de windows.");
}
//**********************************************************************************
Cela fonctionne nickel, mais vous en conviendrez, cela ressemble à un bricolage dangereux avec du scotch !!! Et de plus, JAVA étant multiplateforme, on pouvait regretter l'utilisation d'un code natif pour parvenir àca résultat... Donc j'ai essayé avec le code suivant, de récupérer les String/URL correspondant aux dossiers racines des partages de chaque machine ( "PCname" corresponds au nom du PC surlequel on veut faire la recherche, et s'obtient avec un PING sur IP :
namePC = InetAddress.getByName(IP).getHostName().toString();
if (!namePC.startsWith(ip.toString())) { // PING OK, le PC à cette IP a un nom et donc existe }
) Bref, voici une alternative à NetView.exe pour les partages de fichiers en JAVA :
//**********************************************************************************
import javax.swing.filechooser.FileSystemView;
//(...)
Vector SourceSharedFolders = new Vector();
File[] rootsOS = FileSystemView.getFileSystemView().getRoots();
rootsOS = rootsOS[0].listFiles();
for (int lfr = 0; lfr < rootsOS.length; lfr++)
{ // Sous windows, donc , l'un des premiers ROOTS présent sur le Bureau est "Favoris réseau" :
if (rootsOS[lfr].toString().compareTo("Favoris réseau") == 0)
{
rootsOS = rootsOS[lfr].listFiles();
for (int ltr = 0; ltr < rootsOS.length; ltr++)
{ // Dans "Favoris réseau", on trouve des raccourcis et notamment "Tout le réseau"
if (rootsOS[ltr].toString().compareTo("Tout le réseau") == 0)
{ //System.out.println(rootsOS[ltr] + " OK ! Recherche du réseau MS Windows... ");
rootsOS = rootsOS[ltr].listFiles();
for (int lrW = 0; lrW < rootsOS.length; lrW++)
{ // Dans "Tout le réseau", on trouve des raccourcis et notamment "Réseau Microsoft Windows"
if (rootsOS[lrW].toString().compareTo("Réseau Microsoft Windows") == 0)
{
rootsOS = rootsOS[lrW].listFiles();
for (int lD = 0; lD < rootsOS.length; lD++)
{ // Dans "Réseau Microsoft Windows", on on cherche dans chaque Domaine,
File[] rootsDOM = rootsOS[lD].listFiles();
for (int lh = 0; lh < rootsDOM.length; lh++)
{ // Dans chaque domaine, on va chercher PCName
if (rootsDOM[lh].toString().length() < PCname.length())return;
if (rootsDOM[lh].toString().substring( (rootsDOM[lh].
toString().length() - 1 - PCname.length()),
(rootsDOM[lh].toString().length() - 1)).toUpperCase().
compareTo(PCname) == 0)
{ // En cas de succès, on continue la recherche au cas où plusieurs PC présenteraient le même nom dans des Domaines différents.
rootsDOM = rootsDOM[lh].listFiles();
if (rootsDOM.length > 0) {
for (int ls = 0; ls < rootsDOM.length; ls++) {
SourceSharedFolders.addElement(rootsDOM[ls].
toString());
//System.out.println(rootsDOM[ls].toString());
}
}
else { System.out.print(" Aucun partage trouvé pour " + PCname); }
}
}
}
break; // Fin d'étude des domaines : Pas besoin de voir pour le reste...
}
}
}
}
}
}
//**********************************************************************************
Mais là encore, le résultat ressemble à un vilain bricolage de IF imbriqués, et je ne suis pas sûr, qui plus est, que le résultat soit plus performant que dans l'explorateur de windows ( Je n'ai pas encore eu l'opportunité de l'essayer dans une grande LAN de 300 personnes... ) Si le "javax.swing.filechooser.FileSystemView" va chercher ce qu'il y a sur le réseau dans l'Explorateur Windows au lieu d'interroger à sa façon l'API de base qui doit servir aussi à ce dernier, le résultat ne sera alors pas intéressant ( NetView.exe est d'ores et déjà, en effet, plus performant que l'Explorateur Windows, pour cela )
Pour ceux que cela intéresse, voici le code de base de l'interface d'un explorateur de fichiers JAVA avec filechooser ( Il doit s'agir de la façon d'implémenter ce dernier qui doit répondre à l'attente originale de ce POST. Manque ce qui concerne les parties à cacher et celles à montrer, si j'ai bien compris... Mais vu le grand âge du POST en question et l'absence de réponse, je crois que ce sera amplement suffisant pour le moment ) Je ne sais plus du tout où j'ai trouvé le code suivant qui n'est pas de moi, mais il est (!Vive!)GNUTELLA, donc vous pouvez y aller !!!
//**********************************************************************************
import java.awt.*;
import java.io.File;
import java.io.FileFilter;
import java.util.Comparator;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.ArrayList;
import java.util.List;
import javax.swing.*;
import javax.swing.event.TreeSelectionListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.filechooser.FileSystemView;
import javax.swing.tree.*;
public class jfilechooser extends JPanel
{
private static JFrame mf;
private JTree mTree;
private DefaultTreeModel mModel;
private JList mFileView;
public static void main(String[] args)
{
try
{
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
}
catch (Exception err)
{
err.printStackTrace();
}
mf=new JFrame("File System Icon Bug");
mf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
mf.setBounds(200, 20, 500, 400);
mf.getContentPane().add(new jfilechooser());
mf.show();
}
jfilechooser()
{
super(new BorderLayout());
File[] roots=FileSystemView.getFileSystemView().getRoots();
FileRow root=new FileRow(roots);
mModel=new DefaultTreeModel(root);
mTree=new JTree(mModel);
mTree.setEditable(false);
mTree.setRootVisible(false);
mTree.setCellRenderer(new FileTreeRenderer());
mTree.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
JScrollPane scr=new JScrollPane(mTree);
JSplitPane split=new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
split.setLeftComponent(scr);
mFileView=new JList();
JScrollPane lstScr=new JScrollPane(mFileView);
split.setRightComponent(lstScr);
TreeSelectionListener tEar=new TreeSelectionListener()
{
public void valueChanged(TreeSelectionEvent e)
{
FileRow fr=(FileRow) e.getNewLeadSelectionPath().getLastPathComponent();
File[] contents=fr.getFile().listFiles();
mFileView.setListData(contents);
}
};
mTree.addTreeSelectionListener(tEar);
mFileView.setCellRenderer(new FileListRenderer());
add(split, BorderLayout.CENTER);
}
private static boolean isDirectory(File fl)
{
FileSystemView fsv=FileSystemView.getFileSystemView();
if(fl.isDirectory())
return fsv.isTraversable(fl).booleanValue();
return fsv.isComputerNode(fl) || fsv.isDrive(fl) || fsv.isFileSystemRoot(fl);
}
private class FileRow
implements
FileFilter,
Comparator,
TreeNode
{
private File mDir;
private String mName;
private FileRow[] mChildren;
private FileRow mParent;
FileRow(File fl, FileRow parent)
{
mDir=fl;
mName=fl.getName();
mParent=parent;
if(mName.length()==0) // file roots have no name
mName=mDir.toString();
}
FileRow(File[] roots)
{
mName="Root";
mChildren=new FileRow[roots.length];
makeChildren(roots);
}
public int getChildCount()
{
if(mChildren==null)
makeChildrenFromDir();
return mChildren.length;
}
public TreeNode getChildAt(int index)
{
if(mChildren==null)
makeChildrenFromDir();
return mChildren[index];
}
private File getFile()
{
return mDir;
}
/**
* Workaround to bug 4701462
*/
private File[] filterFiles(File mDir, FileFilter fltr)
{
File[] children=mDir.listFiles();
List passed=new ArrayList();
for(int ii=0; ii<children.length; ++ii)
if(fltr.accept(children[ii]))
passed.add(children[ii]);
return (File[]) passed.toArray(new File[0]);
}
private void makeChildrenFromDir()
{
// We don't call listFiles(FileFilter), due to bug 4701462
// File[] kids = mDir.listFiles(this);
File[] kids=filterFiles(mDir, this);
if(kids!=null)
{
Arrays.sort(kids, this);
mChildren=new FileRow[kids.length];
makeChildren(kids);
}
else // this happens sometimes, like when the volume doesn't exist (a:)
mChildren=new FileRow[0];
}
private void makeChildren(File[] kids)
{
for(int ii=0; ii<kids.length; ++ii)
mChildren[ii]=new FileRow(kids[ii], this);
}
public boolean accept(File fl)
{
return isDirectory(fl);
}
public int compare(Object o1, Object o2)
{
return ((File) o1).compareTo((File) o2);
}
public String toString()
{
return mName;
}
public TreeNode getParent()
{
return mParent;
}
public int getIndex(TreeNode node)
{
for(int ii=0; ii<mChildren.length; ++ii)
if(mChildren[ii]==node)
return ii;
return -1;
}
public boolean getAllowsChildren()
{
return true;
}
public boolean isLeaf()
{
return false;
}
public Enumeration children()
{
Enumeration enum=new Enumeration()
{
int ii=0;
public boolean hasMoreElements()
{
return ii<mChildren.length;
}
public Object nextElement()
{
return mChildren[ii++];
}
};
return enum;
}
}
private class FileListRenderer extends DefaultListCellRenderer
{
public Component getListCellRendererComponent(
JList list,
Object value,
int index,
boolean isSelected,
boolean cellHasFocus)
{
Component cmp=super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
Icon sysIcon=FileSystemView.getFileSystemView().getSystemIcon((File) value);
((JLabel) cmp).setIcon(sysIcon);
return cmp;
}
}
private class FileTreeRenderer extends DefaultTreeCellRenderer
{
public Component getTreeCellRendererComponent(JTree tree, Object value,
boolean sel,
boolean expanded,
boolean leaf, int row,
boolean hasFocus)
{
File fl=((FileRow) value).getFile();
String name=FileSystemView.getFileSystemView().getSystemDisplayName(fl);
Component cmp=super.getTreeCellRendererComponent(tree, name, sel, expanded, leaf, row, hasFocus);
JLabel jc=(JLabel) cmp;
Icon fileIcon=FileSystemView.getFileSystemView().getSystemIcon(fl);
jc.setIcon(fileIcon);
return jc;
}
}
}