Discussion :

[Patrice Henrio]

J'ai donc réussi à mettre en place un drag and drop entre deux JInternalFrame.
Cependant cela nécessite de créer un processus pour une source et une cible particulière. Or je dispose de plusieurs JInternalFrame dans mon appli et je souhaite pouvoir faire du drag and drop entre chacune des ces Fenetres.
Ainsi à l'instant t je lance un drag and drop de la fenêtre 1 vers l'une des autres fenêtres. L'action lors du drop dépend de la cible. Mais quelques instants plus tard je peux lancer un drag de la fenêtre 3 vers une autre ...
Je ne vois pas comment coder cela. Je ne veux pas en particulier créer autant de dropTarget que j'ai de fenêtres potentielles pour la cible.
Je ne suis peut-être pas très clair. N'hésitez pas à me demander des explications si mon problème vous intéresse.

[tchize_]

Chaque élément cible d'un drop doit avoir un dropTarget, qui recevra les events liés au DragAndDrop.

Maintenant, tu ne dois pas créer une classe à chaque fois, tu peux simplement utiliser la classe de base DropTarget, en lui passant juste un DragListener qui recevra les events. Donc tu n'aura au final qu'un listener par target.

Quand au fait qu'il faut coder un processus par paire source -> destination, c'est faux. C'est à ça que servent les DataFlavor dans le DnD. La source précise les "dataFlavor" qu'elle peux fournir, la cible précise le DataFlavor qu'elle accepte. Le Drop n'est possible que si il y a un point commun.

Vu que tu peux transférer entre toutes tes fenetres je suppose que ce n'est que du texte ou un truc identique de chaque coté que tu drop (une image, un document, que sais-je). Tu n'a pas une fenetre A qui fournis du texte, une fenetre B qui n'accepte que des images et une fenetre C qui fournis du son

[Patrice Henrio]

En fait j'ai sans doute mal expliqué ce que je voulais. Tout d'abord les DataFlavors utilisés entre fenêtres sont uniquement des Strings qui décrivent l'info à utiliser. En fait j'ai résolu mon problème plus facilement que je ne le pensais. Je le poste ici pour ceux qui auraient le même genre de 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
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
 
 
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.StringSelection;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.event.InputEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.io.IOException;
 
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.TransferHandler;
import javax.swing.UIManager;
 
import fr.histoiremondiale.utiles.igraphique.swing.Messages;
 
public class DndMultiple extends JPanel implements MouseMotionListener
 
{
	public static void main(String[] args) 
	{
	    SwingUtilities.invokeLater(new Runnable() 
	    {
	        public void run() 
	        {
	          UIManager.put("swing.boldMetal", Boolean.FALSE);
	          createAndShowGUI();
	        }
	      });
	}
 
	protected static void createAndShowGUI()
	{
	    JFrame f = new JFrame("demo");
	    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	    f.setSize(1200,500);
	    f.add(new DndMultiple());
	    f.setLayout(new FlowLayout());
	    f.setVisible(true);
	}
 
	protected MonTransferHandler mth = new MonTransferHandler();
 
	public DndMultiple()
	{
		Dimension d = new Dimension(350,350);
		JInternalFrame src1 = new JInternalFrame("frame 1");
		JInternalFrame src2 = new JInternalFrame("frame 2");
		JInternalFrame src3 = new JInternalFrame("frame 3");
 
		src1.setPreferredSize(d);
		src2.setPreferredSize(d);
		src3.setPreferredSize(d);
 
		src1.setBackground(Color.BLUE);
		src2.setBackground(Color.RED);
		src3.setBackground(Color.GREEN);
 
		src1.setVisible(true);
		src2.setVisible(true);
		src3.setVisible(true);
 
		src1.addMouseMotionListener(this);
		src2.addMouseMotionListener(this);
		src3.addMouseMotionListener(this);	
 
		src1.setTransferHandler(mth);
		src2.setTransferHandler(mth);
		src3.setTransferHandler(mth);
 
		this.add(src1);
		this.add(src2);
		this.add(src3);
	}
 
	@Override
	public void mouseDragged(MouseEvent e) 
	{
		JInternalFrame src = (JInternalFrame) e.getSource();
		mth.exportAsDrag(src, e, TransferHandler.COPY);
	}
 
	@Override
	public void mouseMoved(MouseEvent e) {}
 
	protected class MonTransferHandler extends TransferHandler
	{
		JComponent source = null;
		public void exportAsDrag(JComponent comp, InputEvent e, int action)
		{
			super.exportAsDrag(comp, e, action);
			source = comp;
		}
 
		public int getSourceActions(JComponent c) 
		{
			return TransferHandler.COPY;
		}
 
		public boolean canImport(TransferHandler.TransferSupport info) 
		{
			  return info.isDataFlavorSupported(DataFlavor.stringFlavor);
		}
 
		public boolean importData(TransferHandler.TransferSupport support) 
		{
			  //Nous contrôlons si les données reçues sont d'un type autorisé
			  if(!canImport(support)) return false;
 
			  //On récupère notre objet Transferable, celui qui contient les données en transit
			  Transferable data = support.getTransferable();
			  String str = "";
 
			  try 
			  {
			    //Nous récupérons nos données en spécifiant ce que nous attendons       
			    str = (String)data.getTransferData(DataFlavor.stringFlavor);
			  } 
			  catch (UnsupportedFlavorException e)
			  {
			    e.printStackTrace();
			  } 
			  catch (IOException e) 
			  {
			    e.printStackTrace();
			  }
 
			  //Via le TransferSupport, nous pouvons récupérer notre composant cible
			  JComponent c = (JComponent) support.getComponent();
			  if (c instanceof JInternalFrame) 
			  {
				  JInternalFrame cible = (JInternalFrame)c;
				  JInternalFrame src = (JInternalFrame)source;
				  Messages.messageInfo("source = " + src.getTitle() + "\ncible = " +cible.getTitle()
						  +"\ninfo = " + str);
				  return true;
			  }
			  return false;
			}
		protected Transferable createTransferable(JComponent c) 
		{
			String info = ((JInternalFrame)c).getBackground().toString();
		    return new StringSelection(info);
		}
	}
}

Finalement l'important est qu'on utilise un seul TransferHandler pour toute l'application et qu'on soit capable de définir la source et la cible du DnD ce qui doit permettre de personnaliser le transfert d'infos en fonction de ces deux composants.
Merci à Tchize pour sa réponse mais je me suis tellement battu avec ce problèmes que maintenant que j'ai trouvé une méthode qui fonctionne je ne vais pas approfondir d'autres voies.

[Patrice Henrio]

J'ai crée une sous-classe de JInternalFrame que j'appelle Document. J'ai créé aussi un certain nombre de sous-classes de Document selon ce que contenait la fenêtre. J'ai ainsi une classe DocumentTexte lorsque le Document contient une JtextArea dans un JScrollPane, une classe DocumentTable lorsqu'il contient une Jtable dans un JScrollPane.
L'exemple précédent marche très bien avec un Document générique (comme d'ailleurs avec un JInternalFrame) mais plus avec des DocumentTexte ou des DocumentTable. Comme si le drag de la souris ne concernait pas l'objet Document mais plutôt le JScrollPane ou le composant qu'il contient.
Je ne vois pas comment régler cela.