Drag and Drop d'un JTree vers un JPanel

Bonjour à tous :)

Je suis entrain de développer une appli Java où l'on peut ajouter/modifier/supprimer des éléments.
Sur la partie gauche de mon IHM j'ai mis sous forme de JTree mes éléments
Sur la partie droite j'ai mis les formulaire pour ajouter/modifier/supprimer, ... les éléments
Pour le moment tout fonctionne... l'ajout,modif, ... mon JTree se mets à jour et tout et tout...
Maintenant j'aimerai pouvoir placer mes éléments sur un "plan"
Donc j'aurai :
- A gauche : L'arbre avec les élements
- A droite : le plan d'une maison

Et j'aimerai faire un Drag & Drop de l'arbre vers le plan et pouvoir déposer l'élement à l'endroit précis où je lache la souris !

Auriez-vous des pistes pour que je puisse faire ça :D
Pour le moment je suis entrain de lire le tuto : http://java.sun.com/docs/books/tutor...dnd/intro.html mais c'est un peu complexe et un peu flou encore....

Merci d'avance :)

pas de réponse? o_O

Salut,

pour simplifier la notion de dnd, considère trois choses :

- la source de ton drag (ton JTree)
- les données à transférer (géré par un TransferHandler)
- la destination du drop (ton JPanel)

je vais supposer que ta classe d'objet s'appelle MyObject

pour ce qui est de la source, un moyen simple de gérer rapidement ça :

Code:

1
2
3
DragSource ds = new DragSource();
        ds.createDefaultDragGestureRecognizer(jtree,
            DnDConstants.ACTION_COPY, draggesturelistener);

draggesturelistener est une instance de classe implémentant DragGestureListener, interface ayant une méthode, dans laquelle :

- tu vas déterminer quel noeud de ton arbre va être glissé (celui qui est sélectionné par exemple)
- comment le transférer

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void dragGestureRecognized(DragGestureEvent event) {
        Cursor cursor = null;
        JTree tree = (JTree) event.getComponent();
 
        TreePath treepath = tree.getSelectionPath();
 
        if (event.getDragAction() == DnDConstants.ACTION_COPY) {
            cursor = DragSource.DefaultCopyDrop;
        }
 
        event.startDrag(cursor, new MyObjectTransferable( (MyObject)((DefaultMutableTreeNode)selectedPath.getLastPathComponent()).
       getUserObject();));
    }
 
}

Pour la destination, tu peux créer une classe qui étend DropTargetAdapter

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
public class PanelDropTargetListener extends DropTargetAdapter {
 
        private DropTarget dropTarget;
        private JPanel panel;
 
     public PanelDropTargetListener(JPanel panel) {
        this.panel = panel;
 
        dropTarget = new DropTarget(panel, DnDConstants.ACTION_COPY, 
            this, true, null);
      }
 
 
      public void drop(DropTargetDropEvent event) {
        try {
 
            // on regarde si ce qui est "droppé" est bien du type qu'on veut
            if (event.isDataFlavorSupported(MyObjectTransferable.myObjectFlavor) {
 
          Transferable tr = event.getTransferable();
          MyObject object = (MyObject) tr.getTransferData(MyObjectTransferable.myObjectFlavor);
 
              event.acceptDrop(DnDConstants.ACTION_COPY);
 
              // ici tu fais le placement à la position (que je te laisse implémenter)
              placeObject(object,event.getLocation());
 
              // on accepte le drop
              event.dropComplete(true);
              return;
            }
          // on rejète le drop
          event.rejectDrop();
        } catch (Exception e) {
          e.printStackTrace();
          event.rejectDrop();
        }
      }
    }

Pour le TransferHandler, :

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
public class MyObjectTransferable implements Transferable {
 
    // le type d'objet à transférer
    public final static DataFlavor myObjectFlavor =
        new DataFlavor(MyObject.class, "Un élément de plan de maison");
 
    // les types d'objet transférable qu'on sait gérer avec ce Transferable
    private static DataFlavor[] supportedFlavors = {
        myObjectFlavor
    };
 
    private MyObject object;
 
    public MyObjectTransferable (MyObject object) { this.object = object; }
 
    public DataFlavor[] getTransferDataFlavors() { return supportedFlavors; }
 
    public boolean isDataFlavorSupported(DataFlavor flavor) {
        for(DataFlavor flavor : supportedFlavor ) {
             f (flavor.equals(myObjectFlavor) ) return true;
        }
        return false;
    }
 
 
   public Object getTransferData(DataFlavor flavor) 
        throws UnsupportedFlavorException
   {
     if (flavor.equals(myObjectFlavor))
         return object;
     else 
         throw new UnsupportedFlavorException(flavor);
   }
}

voilà pour commencer.