Discussion :

[damien77]

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]

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

[damien77]

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

[damien77]

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]

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]

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 ?

[smarties]

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]

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]

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);