Drag and drop jtree

**jose.hello** · 09/05/2010, 18h40

Bonjour ,

je cherche à savoir comment obtenir le nom d'un élément parent "droper" dans un Jtable depuis un Jtree j'ai trouvé la solution pour l'élément courant mais pas pour le noeud parent de l'élément courant dnd. Si vous avez une solution ou même si on peut éventuellement avoir l'instance de cet élément ce serai déjà bien.

Merci pour vos réponses

**uhrand** · 10/05/2010, 01h33

Je suppose que le nom est unique. Alors tu peux faire une recherche récursive de ce nom dans le JTree. Ensuite tu n'as plus qu'à appeler "TreeNode#getParent" pour le noeud trouvé. Alternativement tu pourrais transférer par "drag-and-drop" directement la référence du noeud, au lieu de transférer seulement son nom.

**jose.hello** · 15/05/2010, 18h21

Envoyé par uhrand

Je suppose que le nom est unique. Alors tu peux faire une recherche récursive de ce nom dans le JTree. Ensuite tu n'as plus qu'à appeler "TreeNode#getParent" pour le noeud trouvé. Alternativement tu pourrais transférer par "drag-and-drop" directement la référence du noeud, au lieu de transférer seulement son nom.

Le nom est unique mais pas dans tout l'arbre uniquement dans un sous arbre de l'arbre. Sinon comment faire pour transférer directement la référence du noeud ?

**uhrand** · 16/05/2010, 11h08

Envoyé par jose.hello

comment faire pour transférer directement la référence du noeud ?

Voici un exemple:

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
import java.awt.*;
import java.awt.datatransfer.*;
import java.io.*;
import javax.swing.*;
import javax.swing.tree.*;
public class DragDropTree extends JFrame {
    private JTree tree;
    public DragDropTree() {
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setSize(400, 300);
        setLocationRelativeTo(null);
        tree = new JTree();
        add(new JScrollPane(tree));
        tree.setDragEnabled(true);
        tree.setTransferHandler(new MyTransferHandler());
        tree.setDropMode(DropMode.INSERT);
    }
    public static void main(final String args[]) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                new DragDropTree().setVisible(true);
            }
        });
    }
}
class MyTransferHandler extends TransferHandler {
    private int ACTION = TransferHandler.MOVE;
    private MutableTreeNode draggedNode;
    public MyTransferHandler() {
        super();
    }
    @Override
    protected Transferable createTransferable(final JComponent c) {
        Transferable t = null;
        draggedNode = null;
        if (c instanceof JTree) {
            JTree tree = (JTree) c;
            TreePath dragPath = tree.getSelectionPath();
            if (dragPath != null) {
                draggedNode = (MutableTreeNode) dragPath.getLastPathComponent();
            }
            t = new MyTransferable(draggedNode);
        }
        return t;
    }
    @Override
    public boolean importData(final TransferSupport support) {
        Component source = support.getComponent();
        if (source instanceof JTree) {
            JTree tree = (JTree) source;
            JTree.DropLocation loc = (JTree.DropLocation) support.getDropLocation();
            MutableTreeNode movedNode = null;
            try {
                movedNode = (MutableTreeNode) support.getTransferable().getTransferData(DataFlavor.stringFlavor);
            } catch (UnsupportedFlavorException ex) {
                ex.printStackTrace();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            if (loc != null) {
                TreeNode currenParent = (TreeNode) loc.getPath().getLastPathComponent();
                DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode) currenParent.getChildAt(loc.getChildIndex());
                addNode(tree, movedNode, currentNode);
                return true;
            }
        }
        draggedNode = null;
        return false;
    }
    @Override
    protected void exportDone(final JComponent source, final Transferable data, final int action) {
        MutableTreeNode movedNode = null;
        try {
            movedNode = (MutableTreeNode) data.getTransferData(DataFlavor.stringFlavor);
        } catch (UnsupportedFlavorException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        if (source instanceof JTree && action == MOVE) {
            JTree tree = (JTree) source;
            DefaultTreeModel model = (DefaultTreeModel) tree.getModel();
            model.removeNodeFromParent(movedNode);
        }
    }
    private void addNode(final JTree tree, final MutableTreeNode movedNode, final MutableTreeNode targetNode) {
        DefaultTreeModel model = (DefaultTreeModel) tree.getModel();
        MutableTreeNode parent = (MutableTreeNode) targetNode.getParent();
        if (!movedNode.equals(targetNode)) {
            MutableTreeNode oldParent = (MutableTreeNode) movedNode.getParent();
            if (oldParent == null) {
                return;
            }
            try {
                String m = "'" + oldParent + "-" + movedNode + "'->'" + parent + "-" + targetNode + "'";
                JOptionPane.showMessageDialog(tree, m);
                model.insertNodeInto(movedNode, parent, model.getIndexOfChild(parent, targetNode));
            } catch (IllegalArgumentException ex) {
                ex.printStackTrace();
            }
        }
    }
    @Override
    public int getSourceActions(final JComponent c) {
        return ACTION;
    }
    @Override
    public boolean canImport(final TransferSupport supp) {
        if (!supp.isDataFlavorSupported(DataFlavor.stringFlavor)) {
            return false;
        }
        DropLocation loc = supp.getDropLocation();
        return loc != null;
    }
    class MyTransferable implements Transferable {
        private Object data;
        private DataFlavor[] flavors = new DataFlavor[1];
        public MyTransferable(final Object data) {
            super();
            this.data = data;
            flavors[0] = DataFlavor.stringFlavor;
        }
        public DataFlavor[] getTransferDataFlavors() {
            return flavors;
        }
        public boolean isDataFlavorSupported(final DataFlavor flavor) {
            return true;
        }
        public Object getTransferData(final DataFlavor flavor) throws UnsupportedFlavorException, IOException {
            return data;
        }
    }
}

**jose.hello** · 25/05/2010, 13h58

Envoyé par uhrand

Voici un exemple:

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
import java.awt.*;
import java.awt.datatransfer.*;
import java.io.*;
import javax.swing.*;
import javax.swing.tree.*;
public class DragDropTree extends JFrame {
    private JTree tree;
    public DragDropTree() {
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setSize(400, 300);
        setLocationRelativeTo(null);
        tree = new JTree();
        add(new JScrollPane(tree));
        tree.setDragEnabled(true);
        tree.setTransferHandler(new MyTransferHandler());
        tree.setDropMode(DropMode.INSERT);
    }
    public static void main(final String args[]) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                new DragDropTree().setVisible(true);
            }
        });
    }
}
class MyTransferHandler extends TransferHandler {
    private int ACTION = TransferHandler.MOVE;
    private MutableTreeNode draggedNode;
    public MyTransferHandler() {
        super();
    }
    @Override
    protected Transferable createTransferable(final JComponent c) {
        Transferable t = null;
        draggedNode = null;
        if (c instanceof JTree) {
            JTree tree = (JTree) c;
            TreePath dragPath = tree.getSelectionPath();
            if (dragPath != null) {
                draggedNode = (MutableTreeNode) dragPath.getLastPathComponent();
            }
            t = new MyTransferable(draggedNode);
        }
        return t;
    }
    @Override
    public boolean importData(final TransferSupport support) {
        Component source = support.getComponent();
        if (source instanceof JTree) {
            JTree tree = (JTree) source;
            JTree.DropLocation loc = (JTree.DropLocation) support.getDropLocation();
            MutableTreeNode movedNode = null;
            try {
                movedNode = (MutableTreeNode) support.getTransferable().getTransferData(DataFlavor.stringFlavor);
            } catch (UnsupportedFlavorException ex) {
                ex.printStackTrace();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            if (loc != null) {
                TreeNode currenParent = (TreeNode) loc.getPath().getLastPathComponent();
                DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode) currenParent.getChildAt(loc.getChildIndex());
                addNode(tree, movedNode, currentNode);
                return true;
            }
        }
        draggedNode = null;
        return false;
    }
    @Override
    protected void exportDone(final JComponent source, final Transferable data, final int action) {
        MutableTreeNode movedNode = null;
        try {
            movedNode = (MutableTreeNode) data.getTransferData(DataFlavor.stringFlavor);
        } catch (UnsupportedFlavorException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        if (source instanceof JTree && action == MOVE) {
            JTree tree = (JTree) source;
            DefaultTreeModel model = (DefaultTreeModel) tree.getModel();
            model.removeNodeFromParent(movedNode);
        }
    }
    private void addNode(final JTree tree, final MutableTreeNode movedNode, final MutableTreeNode targetNode) {
        DefaultTreeModel model = (DefaultTreeModel) tree.getModel();
        MutableTreeNode parent = (MutableTreeNode) targetNode.getParent();
        if (!movedNode.equals(targetNode)) {
            MutableTreeNode oldParent = (MutableTreeNode) movedNode.getParent();
            if (oldParent == null) {
                return;
            }
            try {
                String m = "'" + oldParent + "-" + movedNode + "'->'" + parent + "-" + targetNode + "'";
                JOptionPane.showMessageDialog(tree, m);
                model.insertNodeInto(movedNode, parent, model.getIndexOfChild(parent, targetNode));
            } catch (IllegalArgumentException ex) {
                ex.printStackTrace();
            }
        }
    }
    @Override
    public int getSourceActions(final JComponent c) {
        return ACTION;
    }
    @Override
    public boolean canImport(final TransferSupport supp) {
        if (!supp.isDataFlavorSupported(DataFlavor.stringFlavor)) {
            return false;
        }
        DropLocation loc = supp.getDropLocation();
        return loc != null;
    }
    class MyTransferable implements Transferable {
        private Object data;
        private DataFlavor[] flavors = new DataFlavor[1];
        public MyTransferable(final Object data) {
            super();
            this.data = data;
            flavors[0] = DataFlavor.stringFlavor;
        }
        public DataFlavor[] getTransferDataFlavors() {
            return flavors;
        }
        public boolean isDataFlavorSupported(final DataFlavor flavor) {
            return true;
        }
        public Object getTransferData(final DataFlavor flavor) throws UnsupportedFlavorException, IOException {
            return data;
        }
    }
}

Cela marche très bien avec un arbre mais si l'on veut le dropper dans un Jtable peut-on avoir le jtree transférer

public boolean importData(final TransferSupport support) {
Component source = support.getComponent();
if (source instanceof JTree) {

il ne passera jamais dans le if car c'est une Jtable

Il faudrait que depuis une jtable on puisse récupérer l'instance du noeud du Jtree et faire un noeud.getParent().getParent() pour avoir l'instance du noeud supérieur au noeud supérieur à celui sélectionner.

Voir les pièces jointes

(il faut que si je drop Analog input 1017 dans le tableau (voir drop.png) il faut que j'ai le nom Analog Input 1017 et aussi device 525) J'ai réussi à avoir le nom par exemple analog Input 1017 mais pas le nom de la device (ici device 525 que j'ai mis en dur pour le moment).

**uhrand** · 28/05/2010, 04h17

Essaie avec un DropTarget:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
table.setFillsViewportHeight(true);
table.setDropTarget(new DropTarget(){
    @Override
    public synchronized void drop(final DropTargetDropEvent dtde) {
        ...
    }
});

Dans la méthode drop tu as accès au Transferable et donc également au noeud: dtde.getTransferable().getTransferData(DataFlavor.stringFlavor)

**jose.hello** · 28/05/2010, 11h30

Effectivement
J'ai trouvé une solution concrète ici :

http://www.comscigate.com/JDJ/source/6-9/63.html

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
public synchronized void drop (DropTargetDropEvent dropTargetDropEvent)
  {
    Point location = dropTargetDropEvent.getLocation();
    try
    {
     Transferable tr = dropTargetDropEvent.getTransferable();
      if (tr.isDataFlavorSupported(TransferableDataItem.DEFAULT_MUTABLE_DATAITEM_FLAVOR))
      {
        dropTargetDropEvent.acceptDrop (DnDConstants.ACTION_COPY_OR_MOVE);
        Object userObject = tr.getTransferData(TransferableDataItem.DEFAULT_MUTABLE_DATAITEM_FLAVOR);
        addElement(location, userObject);
        dropTargetDropEvent.getDropTargetContext().dropComplete(true);
      }

Comme cela on peut transférer n'importe quel objet sérialisable
par contre le synchronized ?

Drag and drop jtree

Composants Java

Discussions similaires

Partager

Partager