Discussion :

[spiky33]

bonjour tout le monde,

Je cherche à faire du DnD entre un Jtree et une JList. D'après ce que j'ai compris, ce mécanisme n'est pas implémenté par défaut dans la JList.Il faut redéfinir les classes Transferable et TransferHandler voir carrement fair un JList personnalisé en héritant de cet objet.

Je n'ai pas très bien compris le fonctionnement avec les classes Tansferable et TransferHandler. Je pense (corrigé moi si je me trompe) que le Drag d'un noeud de l'arbre (DefaultMutaulTreeNode) revoit une string il faudrait donc transformer celle-ci en objet accepté par la JList, les fameux DataFlavor.

Si par hasard quelqu'un a déjà fait ce type de DnD, merci de m'expliquer le mécanisme car la je bloque et ce projet doit être rapidement finit !!!

[visiwi]

Salut,

Le DataFlavor est simplement un type particulier (il peut aussi avoir plusieurs type). Si tu veux glisser/coller un objet MonObjet alors le DataFlavor recensera le type MonObjet.

Si tu veux seulement dragger un type String, je crois (à vérifier) que c'est déjà impélmenté de base dans pas mal d'objet Swing. Va voir une méthode qui doit ressembler à setDragEnabled(boolean b) et setDropMode(DropMode dropMode) .

Le mécanisme de drag'n drop personnalisé Java est un peu galère au début. Voici un lien, j'espère qu'il t'aidera :
http://webperso.iut.univ-paris8.fr/~...e/dragAndDrop/

[bouye]

Transferable et TransferHandler voir carrement fair un JList personnalisé en héritant de cet objet.

Qui herite non pas vraiment, mais qui en a un oui.

Je n'ai pas très bien compris le fonctionnement avec les classes Tansferable et TransferHandler.

Transferable est une envelloppe qui package les differentes saveurs de l'objet (String, Image, <ce-que-tu-veux>... ordonnees dans le sens contenu riche -> contenu pauvre (generalement le plus pauvre est DataFlavor stringFlavor) et s'occupe des conversions depuis le type reel de l'objet depuis le type reel de l'objet vers la saveur (DataFlavor) demandee (ex : conversion d'une Color en sa representation de chaine hexadecimale).

TransfertHandler est la classe qui s'occupe des mecanismes de couper/couper et coller.
Ainsi tu peux faire un TransfertHandler #1 qui s'occupe de determiner quel noeud dans l'arbre source doit etre exporte et un TransfertHandler #2 qui s'occupe de determiner comment inserer cette donnee dans la liste destination. Une fois que c'est fait, dans le cas d'un couper, le TransfertHandler #1 retirera le noued en question de l'arbre. Il est commun de fusionner les deux TransfertHandler mais parfois ca rend la chose un peu moins comprehensible pour les debutants.

Je pense (corrigé moi si je me trompe) que le Drag d'un noeud de l'arbre (DefaultMutaulTreeNode) revoit une string il faudrait donc transformer celle-ci en objet accepté par la JList, les fameux DataFlavor.

Une String je ne sais pas, en fait tu peux transferer tout et n'importe quoi tu moment que tu utilises les bonnes saveurs. Mais c'est a toi d'indiquer dans le Transferable la liste des DataFlavor possibles et apres dans le TransfertHandler #2 de traiter celles acceptables a la reception et ensuite de faire les traitements appropries pour transformer la donnee...

L'interret de ce mecanisme est qu'il permet egalement de faire du DnD avec l'OS sans modifier quoi que ce soit. Ainsi un Transferable qui prend en charge DataFlavor(java.io.File.class, "") ou une liste de fichier DataFlavor.javaFileListFlavor peut-elle interragir avec Explorer, etc..
De meme en utilisant DataFlavor.imageFlavor, on peut par exemple exporter une image vers Word, etc...

[spiky33]

Donc au final je dois juste regarder le drop mode de ma JList pour pouvoir y déposer mes nœuds? Car je suppose que le stringDataFlavor est implémenté dans la JList.

[spiky33]

Yes ok ça fonctionne....
Merci à tous je pense avoir bien compris le mécanisme.

Maintenant le second probléme est dû au multi drop (si je drop plusieur noeuds).
Je ne sais pas comment ça marche.

[bouye]

Ben faut tester !

Probablement que tu devras apposer un formattage special a la String (pour indiquer qu'il y a plusieurs noeuds) et faire un traitement approprie.

[barbiche]

J'ai déjà implémenté un système équivalent (DnD entre JList et JTree et inversement). Voici le cheminement d'un DnD :

Il faut d'abord posséder un objet de type "Transférable". Comme son nom l'indique il sert à transférer des données entre plusieurs éléments. L'exemple suivant représente le transfert de fichiers (entre un JTree et une JList par exemple, mais ca s'applique à tout !) :

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
public class MyTransferable implements Transferable {    
 
    private DataFlavor[] flavors = {new DataFlavor(), new DataFlavor()};  // flavor à personnaliser
 
    private List<File>   listFiles = new ArrayList<File>();
    private File[] files;
 
 
 
    public MyTransferable(File[] files) {
        setFiles(files);
    }
 
    public void setFiles(File[] files) {
        this.files = files;
 
        listFiles.clear();
        for(int i=0; i<files.length; i++)
            listFiles.add(files[i]);
    }
 
    @Override
    public DataFlavor[] getTransferDataFlavors() {
        return flavors;
    }
 
    @Override
    public boolean isDataFlavorSupported(DataFlavor flavor) {
        for (int i = 0; i < flavors.length; i++) {
	    if (flavor instanceof EkDataFlavor) {
	        return true;
	    }
	}
	return false;
    }
 
    @Override
    public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
        for(int i=0; i<flavors.length; i++) {
            if(flavor.equals(flavors[i]))
                return listFiles;
        }
        throw new UnsupportedFlavorException(flavor);
    }
 
 
}

Ensuite il faut se servir de cette classe dans un TransferHandler :

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
public class MyTransferHandler extends javax.swing.TransferHandler {
 
 
    private MyTransferHandler() {
        super();
    }
 
 
 
 
 
    public int getSourceActions(JComponent comp) {
        // Ici tu indique comment tu veux déplacer un élément
        // copier = return COPY;
        // coller = return MOVE;
        // ne rien faire = return NONE;
    }
 
    @Override
    public Transferable createTransferable(JComponent comp) {
        // Ici tu créé ton objet "Transférable" qui contient les éléments à déplacer
    }
 
    @Override
    public boolean canImport(TransferSupport support) {        
        // Ici tu mets la condition pour laquelle on peut dropper un objet dans ta JList ou ton JTree
    }
 
    @Override
    public boolean importData(TransferSupport support) {
        // Ici tu mets tes méthodes d'insertion dans ta JList ou JTree
    }
 
 
    @Override
    public void exportDone(JComponent source, Transferable data, int action) {
        // Méthode exécutée une fois le transfert terminé (facultatif)
    }
 
}

Le cheminement est le suivant :
1) vérification du type d'action à effectuer
2) création du Transferable
3) vérification que l'on peut dropper dans le composant de destination
4) utilisation du Transferable dans le composant de destination
5) faire une action facultative pour cloturer le cycle


Suis-je clair ??