Drag & Drop Java 6

**damien77** · 16/09/2007, 09h43

Bonjour, j'aimerais savoir comment faire un drag & drop en java 6 ?
En effet, j'ai un JTree et je pensais que par défaut, on pouvais déplacer un élément mais non

.
Donc serais-il possibla d'avoir le nom d'une classe qui permettent de faire ce que je cherche ?

merci

**sinok** · 16/09/2007, 18h55

http://weblogs.java.net/blog/shan_ma...class_dra.html

**damien77** · 16/09/2007, 19h31

Oui mais moi je voudrais déplacer les noeuds... du JTree

**damien77** · 16/09/2007, 22h03

Voilà j'ai le code suivant.
Malheureusement, je ne peux toujours pas déplacer, des éléments... D'ou viens le problème ?

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
 
import java.awt.BorderLayout;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
 
import javax.swing.DropMode;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JTextField;
import javax.swing.JTree;
import javax.swing.TransferHandler;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;
 
 
public class Main extends JFrame {
 
    public Main() {
        DefaultMutableTreeNode node = new DefaultMutableTreeNode("1");
        DefaultMutableTreeNode node1 = new DefaultMutableTreeNode("2");
        DefaultMutableTreeNode node2 = new DefaultMutableTreeNode("3");
        DefaultMutableTreeNode node3 = new DefaultMutableTreeNode("4");
        DefaultMutableTreeNode node4 = new DefaultMutableTreeNode("5");
        DefaultMutableTreeNode node5 = new DefaultMutableTreeNode("6");
 
        node.add(node1);
        node.add(node2);
        node1.add(node3);
        node1.add(node4);
        node2.add(node5);
 
        JTree tree = new JTree(node);
        tree.setDragEnabled(true);
        tree.setTransferHandler(new MyTransferHandler());
        tree.setDropMode(DropMode.ON_OR_INSERT);
        add(tree, BorderLayout.CENTER);
 
 
        JTextField fiels = new JTextField();
        fiels.setDragEnabled(true);
        add(fiels, BorderLayout.NORTH);
        setSize(300, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }
 
    public static void main(String[] args) {
        new Main();
    }
 
    class MyTransferHandler extends TransferHandler {
 
 
        public boolean importData(JComponent comp, Transferable t) {
            return false;
        }
 
        public boolean importData(TransferSupport support) {
            if (support.isDataFlavorSupported(DataFlavor.stringFlavor)) {
 
                JTree.DropLocation dl = (JTree.DropLocation) support
                        .getDropLocation();
 
                TreePath path = dl.getPath();
                int childIndex = dl.getChildIndex();
 
                Transferable trans = support.getTransferable();
 
                String data;
                JTree tree = ((JTree) support.getComponent());
                DefaultTreeModel treeModel = (DefaultTreeModel) tree.getModel();
                try {
                    data = (String) trans
                            .getTransferData(DataFlavor.stringFlavor);
                } catch (UnsupportedFlavorException e) {
                    return false;
                } catch (IOException e) {
                    return false;
                }
 
                if (childIndex == -1) {
                    childIndex = treeModel.getChildCount(path
                            .getLastPathComponent());
                }
 
                DefaultMutableTreeNode newNode = new DefaultMutableTreeNode(
                        data);
                DefaultMutableTreeNode parentNode = (DefaultMutableTreeNode) path
                        .getLastPathComponent();
                treeModel.insertNodeInto(newNode, parentNode, childIndex);
 
                TreePath newPath = path.pathByAddingChild(newNode);
                tree.makeVisible(newPath);
                tree.scrollRectToVisible(tree.getPathBounds(newPath));
 
                return true;
 
            }
            return false;
        }
 
        public boolean canImport(JComponent comp, DataFlavor[] transferFlavors) {
            return false;
        }
 
        public boolean canImport(TransferSupport support) {
            if (support.isDataFlavorSupported(DataFlavor.stringFlavor)) {
                return true;
            }
            return false;
        }
 
    }
 
}

**Ginseng** · 18/09/2007, 10h05

Sur le forum tu as ça, sinon tu as toujours le tuto de sun, ou encore le lien de sinok.
Mais va falloir te dépatouiller un peu avec le TransferHandler si ça ne fonctionne pas...
D'autre part, si tu veux déplacer des noeuds, le DefaultMutableTreeNode n'implémente pas l'interface Transferable et donc n'est pas déplaçable par défaut...
Enfin, voilà une part du boulot qui t'attend.

**damien77** · 18/09/2007, 19h32

Donc d'après ce que je comprend.
Je doit dans un premier temps créer mes nodes.(MyNode)
qui hérite de DefaultMutableTreeNode et qui implements Transferable.
et dans un second temps modifier ma classe MyTransferHandler pour qu'elle accepte les objet de type MyNode ?

[EDIT]
Ou bien créer mon propre Transferable pour qu'il accepte et sache comment transferrer des Nodes ( DefaultMutableTreeNode ).
Ensuite modifier MyTransferHandler pour qu'il accepte les données, pour lui faire accepté mes données de mon Transferable ?

**Ginseng** · 19/09/2007, 09h49

+1 pour la première solution.
Enfin c'est peut-être pas la panacée...

**damien77** · 13/10/2007, 22h55

Après un long moment d'absence, je suis toujours bloqué.
Pour le moment, je fais des test en console et j'ai :

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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
import java.awt.BorderLayout;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
 
import javax.swing.DropMode;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextField;
import javax.swing.JTree;
import javax.swing.TransferHandler;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;
 
public class Main extends JFrame {
 
    public Main()
    {
        super("123");
        DefaultMutableTreeNode node = new DefaultMutableTreeNode("1");
        DefaultMutableTreeNode node2 = new DefaultMutableTreeNode("2");
        DefaultMutableTreeNode node3 = new DefaultMutableTreeNode("3");
        DefaultMutableTreeNode node4 = new DefaultMutableTreeNode("4");
        DefaultMutableTreeNode node5 = new DefaultMutableTreeNode("5");
        DefaultMutableTreeNode node6 = new DefaultMutableTreeNode("6");
 
        node.add(node2);
        node.add(node3);
 
        node2.add(node4);
        node3.add(node5);
 
        node3.add(node6);
 
        JTree tree = new JTree(new DefaultTreeModel(node));
        tree.setDropMode(DropMode.ON_OR_INSERT);
        tree.setDragEnabled(true);
        tree.setTransferHandler(new MyTransferHandler());
 
        JTextField field = new JTextField();
 
        field.setDragEnabled(true);
        field.setTransferHandler(new MyTransferHandler());
 
        add(new JScrollPane(tree),BorderLayout.NORTH);
        add(new JScrollPane(field),BorderLayout.SOUTH);
        pack();
        setVisible(true);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
 
    public static void main(String[] args) {
        new Main();
    }
 
    class MyTransferHandler extends TransferHandler {
 
        public boolean canImport(JComponent cp, DataFlavor[] df) {
            for (int i = 0; i < df.length; i++) {
                if (df[i].equals(MyTransferable.data)) {
                    return true;
                }
                if (df[i].equals(DataFlavor.stringFlavor)) {
                    return true;
                }
            }
            return false;
        }
 
        public boolean importData(JComponent cp, Transferable df) {
            if (df.isDataFlavorSupported(MyTransferable.data)) {
                if( cp instanceof JTree )
                {
                    JTree tree = (JTree)cp;
                    JTree.DropLocation location = tree.getDropLocation() ;
                    TreePath path = location.getPath() ;
                    int index = location.getChildIndex() ;
                    if(index==-1)
                        index= 0;
                    System.out.println(index);
                    DefaultMutableTreeNode node ;
                    try {
                        node = (DefaultMutableTreeNode)df.getTransferData(MyTransferable.data);
                        DefaultMutableTreeNode parent = (DefaultMutableTreeNode)path.getLastPathComponent();
                        DefaultTreeModel model = (DefaultTreeModel)tree.getModel() ;
                        model.removeNodeFromParent(node);
                        model.insertNodeInto(node, parent, index);
 
                        TreePath newPath = path.pathByAddingChild(node);
                        tree.makeVisible(newPath);
                        tree.scrollRectToVisible(tree.getPathBounds(newPath));
                    } catch (UnsupportedFlavorException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    return true ;
                }
                else if( cp instanceof JTextField )
                {
                    JTextField field = (JTextField)cp ;
                    DefaultMutableTreeNode chaine;
                    try {
                        chaine = (DefaultMutableTreeNode)df.getTransferData(MyTransferable.data);
                        field.setText(chaine.toString());
                    } catch (UnsupportedFlavorException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            } else if (df.isDataFlavorSupported(DataFlavor.stringFlavor)) {
                if( cp instanceof JTree )
                {
                    return false ;
                }
                else if( cp instanceof JTextField )
                {
                    JTextField field = (JTextField)cp ;
                    String chaine;
                    try {
                        chaine = (String)df.getTransferData(DataFlavor.stringFlavor);
                        field.setText(chaine);
                    } catch (UnsupportedFlavorException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return false;
        }
 
        @Override
        protected Transferable createTransferable(JComponent c) {
            JTree tree = (JTree)c;
            DefaultMutableTreeNode node = (DefaultMutableTreeNode)tree.getSelectionPath().getLastPathComponent();
            return new MyTransferable(node);
        }
 
        @Override
        public int getSourceActions(JComponent c) {
            return COPY_OR_MOVE ;
        }
 
    }
 
}
 
class MyTransferable implements Transferable {
 
    DefaultMutableTreeNode node;
 
    public DefaultMutableTreeNode getObject()
    {
        return node;
    }
 
    public static DataFlavor data = create();
 
    public static DataFlavor create() {
        String mimeType = DataFlavor.javaJVMLocalObjectMimeType + ";class="
                + DefaultMutableTreeNode.class.getName();
        try {
            return new DataFlavor(mimeType);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
 
    public MyTransferable(DefaultMutableTreeNode o) {
        node = o;
    }
 
    @Override
    public Object getTransferData(DataFlavor flavor)
            throws UnsupportedFlavorException, IOException {
        if( flavor.equals(DataFlavor.stringFlavor) )
        {
            return node.toString() ;
        }
        else
        {
            return node;
        }
    }
 
    @Override
    public DataFlavor[] getTransferDataFlavors() {
        return new DataFlavor[] { data, DataFlavor.stringFlavor };
    }
 
    @Override
    public boolean isDataFlavorSupported(DataFlavor flavor) {
        if (flavor.equals(data)) {
            return true;
        } else if (flavor.equals(DataFlavor.stringFlavor)) {
            return true;
        }
        return false;
    }
 
}

J'aimerais savoir quand les méthodes sont appelé mais je ne trouve rien.
Pouvez-vous m'aider...

**Ginseng** · 15/10/2007, 10h39

Qu'est-ce que tu entends par "je suis toujours bloqué" ?
Et qu'est-ce que te donnent tes tests console ?
De mémoire, il me semble que la première méthode du transferHandler appelée est getSourceAction() (enfin exportasDrag() doit être appelée avant mais inutile de la redéfinir si tu as mis setDragEnable() sur le composant) puis createTransferable(). Après il me semble que c'est canImport() puis importData() et enfin exportDone().

[EDIT]: et pourquoi n'utilises-tu pas les méthodes de la version 1.6 dans le transferHandler comme canImport(TransferHandler.TransferSupport support) ou encore importData(TransferHandler.TransferSupport support) puisque tu es en java 6 ?...

**damien77** · 15/10/2007, 16h22

NOn non, je ne suis plus bloqué.
J'ai oublié de le dire dans mon edit.

**smarties** · 15/03/2012, 15h20

Bonjour,

Je cherche à créer un JTree à partir de fichiers préalablement sélectionnés.

Si possible, je souhaite pouvoir ajouter des fichiers de l'explorateur vers mon JTree aussi.

Voici un bout de ma classe contenant l'interface graphique :

Code java :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class MainWindow extends javax.swing.JFrame implements ActionListener,Autoscroll {
	private final JTree treeFiles;
	private final model.FileDataModel fdm;
	mod.FileTreeDragSource ds;
	mod.FileTreeDropTarget dt;
	public MainWindow() {
		fdm=new model.FileDataModel(files);
		treeFiles=new JTree(fdm);
		treeFiles.setDragEnabled(true);
treeFiles.getSelectionModel().setSelectionMode(javax.swing.tree.TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
		treeFiles.setRootVisible(false);
		treeFiles.setCellRenderer(fileRenderer);
		ds = new mod.FileTreeDragSource(treeFiles, DnDConstants.ACTION_COPY_OR_MOVE);
	    dt = new mod.FileTreeDropTarget(treeFiles);
	}

Mon implémentation de transférable :

Code java :

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
public class FileTransferableTreeNode implements Transferable {
	public static DataFlavor FILE_TREE_PATH_FLAVOR = new DataFlavor(model.ExtendedFile.class,
			"Tree Path");
	DataFlavor flavors[] = { FILE_TREE_PATH_FLAVOR };
	model.ExtendedFile file;
	public FileTransferableTreeNode(model.ExtendedFile ef) {
		file = ef;
	}
	@Override
	public synchronized Object getTransferData(DataFlavor flavor)
			throws UnsupportedFlavorException, IOException {
		if (isDataFlavorSupported(flavor)) {
			return (Object) file;
		} else {
			throw new UnsupportedFlavorException(flavor);
		}
	}
	@Override
	public DataFlavor[] getTransferDataFlavors() {
		return flavors;
	}
	@Override
	public boolean isDataFlavorSupported(DataFlavor flavor) {
		return (flavor.getRepresentationClass() == model.ExtendedFile.class);
	}
}

L'objet dans l'arbre :

Code java :

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
public class ExtendedFile extends File {
	private static final long serialVersionUID = -4954098568310603926L;
	private ExtendedFile reference=null;
	public final Vector<model.ExtendedFile> childs=new Vector<model.ExtendedFile>();
	public ExtendedFile(String pathname) {
		super(pathname);
	}
	public ExtendedFile(File f) {
		super(f.getAbsolutePath());
	}
	public String toString() {
		return getName();
	}
	public ExtendedFile getReference() {return reference;}
	public boolean isLeaf() {
		return childs.size()==0;
	}
}

Un bout de mon DragSource :

Code java :

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
public class FileTreeDragSource implements DragSourceListener, DragGestureListener {
	DragSource source = new DragSource();
	DragGestureRecognizer recognizer;
	FileTransferableTreeNode transferable;
	model.ExtendedFile oldNode;
	JTree sourceTree;
	@Override
	public void dragGestureRecognized(DragGestureEvent dge) {
		TreePath path = sourceTree.getSelectionPath();
		if ((path == null) || (path.getPathCount() <= 1)) {
			return;
		}
		oldNode = (model.ExtendedFile) path.getLastPathComponent();
		transferable = new FileTransferableTreeNode(path); //PROBLEME ICI
		source.startDrag(dge, DragSource.DefaultMoveNoDrop, transferable, this);
	}
}

Ma classe FileTreeDropTarget qui implémente DropTargetListener ne semble pas avoir de problème pour le moment car j'ai une exception quand je commence à "dragger"

InvalidDnDOperationException je crois

**wax78** · 15/03/2012, 16h04

J'ai voulu compiler ton exemple la mais :

FileTreeDragSource contient une erreur (// PROBLEME ICI).
FileTreeDragSource n'implemente pas DragSourceListener on dirait.

FileDataModel inconnue ? (ca vient de java standard ca ?)

MainWindow manque des bouts on dirait.

**smarties** · 16/03/2012, 09h23

Envoyé par wax78

J'ai voulu compiler ton exemple la mais :

FileTreeDragSource contient une erreur (// PROBLEME ICI).
FileTreeDragSource n'implemente pas DragSourceListener on dirait.

FileDataModel inconnue ? (ca vient de java standard ca ?)

MainWindow manque des bouts on dirait.

Ou il y a problème ici, j'avais à la base un TreePath en argument et ça ne fonctionnait pas non plus

Pour MainWindow, j'ai mis que ce qui concernait le JTree, je vous ai fait grâce des 400 lignes de code.
Pour FileTreeDragSource, je ne vous ai pas tout mis.
Voici FileDataModel :

Code java :

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
public class FileDataModel implements TreeModel {
	private Vector<model.ExtendedFile> files=new Vector<ExtendedFile>();
	private Vector<TreeModelListener> treeModelListeners = new Vector<TreeModelListener>();
	private ExtendedFile root=new ExtendedFile("");
	public FileDataModel(Vector<model.ExtendedFile> v) {
		v.add(root);
		if(v!=null) files.addAll(v);
	}
	public void add(model.ExtendedFile ee) {
		if(files.contains(ee)) return;
		root.childs.add(ee);
		files.add(ee);
		fireTreeStructureChanged(ee);
	}
	/** Remove a file from the list and move child files in the parent element
         * @param ee ExtendedFile object
         */
	public void remove(model.ExtendedFile ee) {
		for(model.ExtendedFile ef : ee.childs) {
			files.add(ef);
			fireTreeStructureChanged(ef);
		}
		files.remove(ee);
	}
	public void removeNode(model.ExtendedFile ef) {
		files.remove(ef);
	}
	@Override
	public Object getChild(Object o, int i) {
		ExtendedFile ee=(ExtendedFile)o;
		return ee.childs.elementAt(i);
	}
	@Override
	public int getChildCount(Object o) {
		ExtendedFile ee=(ExtendedFile)o;
		return ee.childs.size();
	}
	@Override
	public int getIndexOfChild(Object parent, Object child) {
		ExtendedFile ee=(ExtendedFile)parent;
		return ee.childs.indexOf((ExtendedFile)child);
	}
	@Override
	public Object getRoot() {return root;}
	@Override
	public boolean isLeaf(Object o) {
		ExtendedFile ee=(ExtendedFile)o;
		return ee.childs.size()==0;
	}
	@Override
	public void addTreeModelListener(TreeModelListener l) {
		treeModelListeners.add(l);}
	@Override
	public void removeTreeModelListener(TreeModelListener l) {
		treeModelListeners.removeElement(l);}
	//events
	@Override
	public void valueForPathChanged(TreePath path, Object newVal) {}
	public void dragGestureRecognized(DragGestureEvent e) {
 
	}
	protected void fireTreeStructureChanged(model.ExtendedFile ee) {
		TreeModelEvent e = new TreeModelEvent(this, new Object[] { ee });
		for (int i = 0; i < treeModelListeners.size(); i++) ((TreeModelListener) treeModelListeners.elementAt(i)).treeStructureChanged(e);
	}
	public void insertNodeInto(ExtendedFile node, ExtendedFile parent, int i) {
		for (model.ExtendedFile ef : files) {
			if(ef.equals(parent)) {
				ef.childs.insertElementAt(node, i);
				break;
			}
		}
	}
}

Pour ExtendedFile, serait-ce plus simple d'implémenter MutableTreeNode ?
Par cette methode j'ai la même exception :

Exception in thread "AWT-EventQueue-0" java.awt.dnd.InvalidDnDOperationException: Drag and drop in progress
at sun.awt.dnd.SunDragSourceContextPeer.setDragDropInProgress(Unknown Source)
at java.awt.dnd.DragSource.startDrag(Unknown Source)
at java.awt.dnd.DragSource.startDrag(Unknown Source)
at mod.FileTreeDragSource.dragGestureRecognized(FileTreeDragSource.java:29)

C'est à dire cette ligne : source.startDrag(dge, DragSource.DefaultMoveNoDrop, transferable, this);

Drag & Drop Java 6

Composants Java

Discussions similaires

Partager

Partager