Drag and Drop entre JList et JTree

**bellemlih** · 19/02/2008, 16h35

Bonjour,
J'ai une JList de Panel et un JTree de Panel aussi et je souhaite faire un Drag and Drop de la liste vers le Tree, mais je ne sais pas comment s'y prendre, j'ai déja lu des tuto pour faire le Drag and drop entre list, et d'autres entre tree mais jamais entre les deux et encore moins avec des panel.
Merci de votre aide.

**bouye** · 20/02/2008, 05h21

Normalement le type de l'objet importe peu, ce qui est important c'est le DataFlavor utilise (il faut qu'il soit accepte des deux cotes) et comment le TransfertHandler fonctionne, nottament celui du JTree qui peut etre un peu plus complexe que celui de la JList a mettre en place.

**bellemlih** · 20/02/2008, 13h43

Merci pour votre reponse, mais quel DataFlavor dois je utiliser pour un JPanel??
Merci encore.

**sinok** · 20/02/2008, 16h30

Un JPanel n'est pas prévu pour faire de D&D
CF: http://java.sun.com/docs/books/tutor...dnd/intro.html

Pour gérer le D&D d'un JPanel il va falloir le gérer à la mano (MouseListener & ainsi de suite)

**bouye** · 20/02/2008, 23h20

Heu, la les JPanel ce sont les objets qu'il transfere. Les objets sur lesquels positionner le Transferable sont la JList et le JTree. Il faut faire un peu plus de boulot pour activer le DnD sur les arbres mais comme il dit qu'il en a deja fait c'est qu'il a deja du reussir a l'activer.

Apres bien sur il peut y avoir des considerations sur comment ces panels sont apparents dans l'arbre et la liste, mais par defaut on va supposer qu'on a a faire a des rendus "normaux" (simple affichage du nom du panel dans une chaine ou juste un rendu avec simple delegation dans des renderers specialises).

DataFlavor te permet de creer des nouvelles saveurs a partir de n'importe quelle classe : DataFlavor(Class<?> representationClass, String humanPresentableName)

ex :

Code :

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

DataFlavor myJPanelFlavor = new DataFlavor(JPanel.class, "JPanel");

**bellemlih** · 21/02/2008, 10h43

Oui, pour recupperer le Panel , ce n'est plus un probléme. Le probléme c'est au moment où je veux recupperer le noeud sur lequel je vais faire mon drop, au moment ou j'appel la méthode drop(), je veux recupperer le nouveau noeud parent avec :

Code :

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

1
2
3
 
Point pt = dtde.getLocation();
TreePath pathTarget = tree.getPathForLocation(pt.x, pt.y);

Mais le probleme c'est que j'ai un null dans mon pathTarget, et je sais pas pourquoi. dois je faire qlq chose au niveau de l'arbre pour recupperer ce noeud??
Merci encore.

**bouye** · 22/02/2008, 06h10

Moi je fais ca en fonction de la ligne selectionnee dans l'arbre et la liste. Apres pas mal de tatonnements pour m'y remettre, j'ai pu pondre ca :

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
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
 
import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.dnd.*;
import java.awt.event.*;
import java.awt.image.*;
import java.io.*;
import javax.swing.*;
import javax.swing.tree.*;
 
public class TestDragTreeList {
  private static final JPanel createPanel(String source, int i) {
    JPanel panel = new JPanel();
    panel.setName(source+" "+i);
    // For image export.
    panel.setBackground(new Color((float)Math.random(), (float)Math.random(), (float)Math.random()));
    panel.setSize(50, 50);
    return panel;
  }
 
  public static void main(String... args) {
    SwingUtilities.invokeLater(new Runnable() {
	public void run() {
	  DefaultMutableTreeNode root = new DefaultMutableTreeNode();
	  for (int i = 0 ; i < 10 ; i++) {
	    JPanel panel = createPanel("Tree", i);
	    root.add(new DefaultMutableTreeNode(panel));
	  }
	  DefaultTreeModel treeModel = new DefaultTreeModel(root);
	  JTree tree = new JTree(treeModel);
	  tree.setCellRenderer(new DefaultTreeCellRenderer() {
	      public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus) {
		super. getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);
		if (value instanceof DefaultMutableTreeNode) {
		  JPanel panel = (JPanel)((DefaultMutableTreeNode)value).getUserObject();
		  if (panel != null) {
		    setText(panel.getName());
		  }
		}
		return this;
	      }
	    });
	  tree.setTransferHandler(new PanelHandler());
	  tree.setDragEnabled(true);
	  DefaultListModel listModel = new DefaultListModel();
	  for (int i = 0 ; i < 10 ; i++) {
	    JPanel panel = createPanel("List", i);
	    listModel.addElement(panel);
	  }
	  JList list = new JList(listModel);
	  list.setCellRenderer(new DefaultListCellRenderer() {
	      public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
		super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
		if (value instanceof JPanel) {
		  setText(((JPanel)value).getName());
		}
		return this;
	      }
	    });
	  list.setTransferHandler(new PanelHandler());
	  list.setDragEnabled(true);
	  JScrollPane treeScroll = new JScrollPane(tree);
	  JScrollPane listScroll = new JScrollPane(list);
	  JSplitPane split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, treeScroll, listScroll);
	  JFrame frame = new JFrame("Test");
	  frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	  frame.setLayout(new BorderLayout());
	  frame.add(split);
	  //frame.pack();
	  frame.setSize(400, 400);
	  frame.setVisible(true);
	  split.setDividerLocation(.5f);
	}
      });
  }
 
  public static final DataFlavor PANEL_FLAVOR = new DataFlavor(JPanel.class, "JPanel");
 
  public static final class PanelHandler extends TransferHandler {
 
    private JComponent source;
    private JPanel panel;
    private int sourceRow;
 
    private JPanel exportPanel(JComponent c) {
      if (c instanceof JList) {
	System.out.println("export panel - list");
	JList list = (JList)c;
	source = c;
	JPanel panel = (JPanel)list.getSelectedValue();
	sourceRow = list.getSelectedIndex();
	return panel;
      }
      else if (c instanceof JTree) {
	System.out.println("export panel - tree");
	JTree tree = (JTree)c;
	source = c;
	TreePath path = tree.getSelectionPath();
	DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
	DefaultTreeModel treeModel = (DefaultTreeModel)tree.getModel();
	DefaultMutableTreeNode root = (DefaultMutableTreeNode)treeModel.getRoot();
	sourceRow = treeModel.getIndexOfChild(root, node);
	panel = (JPanel)node.getUserObject();
	return panel;
      }
      return null;
    }
 
    protected Transferable createTransferable(JComponent c) {
      JPanel panel = exportPanel(c);
      return (panel == null) ? null : new PanelTransferable(panel);
    }
 
    public int getSourceActions(JComponent c) {
      return COPY_OR_MOVE;
    }
 
    public boolean importData(JComponent c, Transferable t) {
      if (canImport(c, t.getTransferDataFlavors())) {
	try {
	  panel = (JPanel)t.getTransferData(PANEL_FLAVOR);
	  importPanel(c, panel);
	  return true;
	} 
	catch (UnsupportedFlavorException ufe) {
	} 
	catch (IOException ioe) {
	}
      }
      return false;
    }
 
    private void importPanel(JComponent c, JPanel panel) {
      if (c instanceof JList) {
	System.out.println("import panel - list");
	JList list = (JList)c;
	DefaultListModel listModel = (DefaultListModel)list.getModel();
	int insertRow = list.getSelectedIndex() + 1;
	System.out.println("Will insert in "+insertRow);
	if (source == list) {
	  sourceRow = (insertRow <= sourceRow) ? sourceRow+1 : sourceRow;
	}
	listModel.insertElementAt(panel, insertRow);
	list.repaint();
      }
      else if (c instanceof JTree) {
	System.out.println("import panel - tree");
	JTree tree = (JTree)c;
	DefaultTreeModel treeModel = (DefaultTreeModel)tree.getModel();
	DefaultMutableTreeNode root = (DefaultMutableTreeNode)treeModel.getRoot();
	int rootRow = tree.getRowForPath(new TreePath(root));
	int insertRow = tree.getSelectionRows()[0];
	insertRow = Math.max(0, insertRow-rootRow);
	System.out.println("Will insert in "+insertRow);
	if (source == tree) {
	  sourceRow = (insertRow <= sourceRow) ? sourceRow+1 : sourceRow;
	}
	treeModel.insertNodeInto(new DefaultMutableTreeNode(panel), root, insertRow);
	tree.repaint();
      }
    }
 
    protected void exportDone(JComponent c, Transferable data, int action) {
      cleanup(c, action == MOVE);
    }
 
    private void cleanup(JComponent c, boolean remove) {
      if (remove) {
	if (c instanceof JList) {
	  System.out.println("cleanup - list");
	  JList list = (JList)c;
	  DefaultListModel listModel = (DefaultListModel)list.getModel();
	  listModel.removeElementAt(sourceRow);
	  list.repaint();
	}
	else if (c instanceof JTree) {
	  System.out.println("cleanup - tree");
	  JTree tree = (JTree)c;
	  DefaultTreeModel treeModel = (DefaultTreeModel)tree.getModel();
	  DefaultMutableTreeNode root = (DefaultMutableTreeNode)treeModel.getRoot();
	  DefaultMutableTreeNode node = (DefaultMutableTreeNode)root.getChildAt(sourceRow);
	  treeModel.removeNodeFromParent(node);
	  tree.repaint();
	}
      }
    }
 
    /** {@inheritDoc}
     */
    @Override public boolean canImport(JComponent c, DataFlavor[] flavors) {
      for (int i = 0; i < flavors.length; i++) {
	if (PANEL_FLAVOR.equals(flavors[i])) {
	  return true;
	}
      }
      return false;
    }
  }
 
  public static final class PanelTransferable implements Transferable {
    public static final DataFlavor[] FLAVORS = {PANEL_FLAVOR, DataFlavor.imageFlavor, DataFlavor.stringFlavor};
 
    private JPanel target;
 
    public PanelTransferable(JPanel target) {
      this.target = target;
    }
 
    /** {@inheritDoc}
     */
    public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException {
      if (flavor.equals(PANEL_FLAVOR)) {
	return target;
      }
      else if (flavor.equals(DataFlavor.imageFlavor)) {
	Dimension size = target.getSize();
	BufferedImage image = new BufferedImage(target.getWidth(), target.getHeight(), target.isOpaque() ? BufferedImage.TYPE_INT_ARGB: BufferedImage.TYPE_INT_RGB);
	Graphics2D graphics = (Graphics2D)image.createGraphics();
	target.paint(graphics);
	graphics.dispose();
	return image;
      }
      else if (flavor.equals(DataFlavor.stringFlavor)) {
	return target.getName();
      }
      throw new UnsupportedFlavorException(flavor);
    }
 
    /** {@inheritDoc}
     */
    public DataFlavor[] getTransferDataFlavors() {
      return FLAVORS;
    }
 
    /** {@inheritDoc}
     */
    public boolean isDataFlavorSupported(DataFlavor flavor) {
      for (DataFlavor f : getTransferDataFlavors()) {
	if (f.equals(flavor)) {
	  return true;
	}
      }
      return false;
    }
  }
}

L'import-export fonction dans les cas suivants :

- JList => JList : JPanel, MOVE
- JList => Jtree : JPanel, MOVE
- JList => logiciel de dessin, etc... : Image, COPY
- JList => Word, Wordpad, etc... : String, COPY

- JTree => JTree : JPanel, MOVE
- JTree => JList : JPanel, MOVE
- JTree => logiciel de dessin, etc... : Image, COPY
- JTree => Word, Wordpad, etc... : String, COPY

Y a probablement encore qq bugs dedans mais le principe y est.

**bellemlih** · 25/02/2008, 13h14

Merci pour votre réponse,
En fait j'ai utilisé une solution pareil, j'ai crée une classe dragdrop.java qui a un constructeur qui prend comme parametre la liste et le tree, sur ce constructeur je precise que la liste est la source et que le tree est la cible, aprés j'utilise la méthode drop() pour avoir le noeud poibté (pour reccuperer le noeud parent) et je crée un nouveau noeud que je vais ajouter a mon tree(à partir de mon element d'origine selectionné sur la liste).
Ouf finalement ça marche.
Merci encore pour votre aide qui m'a etait d'une grande utilité.
Bonne journée.

Drag and Drop entre JList et JTree

Composants Java

Discussions similaires

Partager

Partager