Affichage d'un JPane dans un JFrame

Version imprimable

Voir 40 message(s) de cette discussion en une page

19/09/2012, 15h41
Népomucène

Bonjour Junior222

J'ai chargé dans toutes tes classes dans NetBeans.
Bon, il y a de l'idée mais ça patauge dur. C'est normal car c'est difficile au début. ;)

un détail à régler tout de suite : private DataFlavor img = new DataFlavor("image/pnng", null);
il y a un "n" en trop.

A faire :

1.1) le listener de souris DragAndDropListener doit être placé sur le composant ComposantTransferable et non pas sur PanneauComposant
en effet, le panneau ne sert que de support (d'ailleurs, il peut comporter des JButton qui ne doivent pas bouger eux)

1.2) dans le même ordre d'idée, setTransferHandler(new ComposantTransfertHandler()) doit être placé dans le constructeur de ComposantTransferable (il ne concerne pas le PanneauComposant)

1.3) abandonne tout de suite le paintComponent du PanneauComposant :
il faut ajouter les ComposantTransferable sur le panneau (méthode add) et non pas les dessiner.
En effet, une fois dessiné tes composants ne sont plus que des dessins et non pas des objets qu'on "draguer"
(quel jeux de mots j'ai honte)

Pour la suite :
2.1) Tu crées un panneau qui servira à "dropper" ton composant ComposantTransferable.
Appelons ce panneau DropZone
Au début, ce panneau n'a strictement rien de particulier (aucun code spécifique).

2.2) Tu crées un nouveau TransfertHandler qui sera chargé de gérer le drop de ComposantTransferable sur DropZone.
Appelons cette classe DropTransfertHandler.
Les méthodes à surcharger sont :
- public boolean canImport : indiquera, lors du survol de la souris qu'on est bien à un endroit où on peut poser un ComposantTransferable
- public boolean importData : se déclenche lors du drop. C'est ce qui te permets de récupérer les données transférées

2.3) Tu ajoutes setTransferHandler(new DropTransfertHandler()) au constructeur de DropZone.
Tu n'as aucun évènement souris à créer.

Poste ton code quand tu auras avancé.
19/09/2012, 17h57
junior222

merci pour toutes ces précisions mais il se pose un problème
1.1) pour ajouter le listener de souris au ComposantTransferable il faut qu'il herite de JComponent. et idem pour la méthode setTransfertHandler. De plus je ne comprend pas comment mes composants vont s'ajouter au panneauComposant si j'utilise la méthode add.
19/09/2012, 19h02
Népomucène

C'est là où je voulais en venir. Avec le choix de Canvas c'est très difficile de faire du DnD.
Plutôt que d'utiliser Canvas qui vient d'AWT, il vaut mieux tout faire en SWING.

Pour faire ta classe ComposantTransferable, tu dois étendre un JPanel et tu implémentes Transferable
comme ça tu peux y placer ton image (en surchargeant paintComponent)
et tu as toutes les méthodes de Transferable
(la classe Composant ne sert plus)

Après, tu peux utiliser la méthode add pour ajouter Composant au JPanel qui sert à présenter les ComposantTransferable

bon j'ai fini les modifications que tu m'a demandé de faire voila mes codes:

Code:

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
 
package monpackage;
 
import java.awt.Canvas;
import java.awt.Image;
import java.io.Serializable;
 
public class Composant extends Canvas implements Serializable{
	private static final long serialVersionUID = 1L;
	private String nom;
	public int x;
	public int y;
	public Image image;
	public Composant(String no,Image img)
	{
		this.nom=no;
		this.image=img;
	}
	public String getname()
	{
		return nom;
	}
	public void setPositioon(int px,int py)
	{
		x=px;
		y=py;
	}
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
package monpackage;
 
import java.awt.datatransfer.DataFlavor;
 
 
public class ComposantFlavor {
	private static String mimeType = DataFlavor.javaJVMLocalObjectMimeType +
			";class=" + Composant.class.getName();
	private static DataFlavor composantFlavor= null;
	public static DataFlavor getComposantFlavor()
	{
        try {
            composantFlavor = new DataFlavor(mimeType);
        } catch (ClassNotFoundException e) { }
        return composantFlavor;
	}
 
}

Code:

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
 
package monpackage;
 
import java.awt.Graphics;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
 
import javax.swing.JPanel;
import javax.swing.TransferHandler;
 
public class ComposantTransferable extends JPanel implements Transferable{
private DataFlavor img=new DataFlavor("image/png",null);
private Composant composant;
public ComposantTransferable(Composant c)
{
	setTransferHandler(new ComposantTransfertHandler());
	composant=c;
}
public void enableDrag(){
	addMouseListener(new DragAndDropListener());
}
public void paintComponent(Graphics g){
		super.paintComponent(g);					
		g.drawImage(composant.image, composant.x, composant.y, null);
}
	@Override
	public Object getTransferData(DataFlavor arg0)
			throws UnsupportedFlavorException, IOException {
			if(ComposantFlavor.getComposantFlavor().equals(arg0))
			{
				return composant;
			}
			else throw new UnsupportedFlavorException(arg0);
	}
 
	@Override
	public DataFlavor[] getTransferDataFlavors() {
		ArrayList l= new ArrayList();
		l.add(ComposantFlavor.getComposantFlavor());
		l.add(img);
		return (DataFlavor[]) l.toArray(new DataFlavor[l.size()]);
	}
 
	@Override
	public boolean isDataFlavorSupported(DataFlavor arg0) {
		// TODO Auto-generated method stub
		return ComposantFlavor.getComposantFlavor().equals(arg0);
	}
 
}

Code:

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
 
package monpackage;
 
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
 
import javax.swing.JComponent;
import javax.swing.TransferHandler;
 
public class ComposantTransfertHandler extends TransferHandler{
 
	public boolean importData(JComponent c,Transferable t){
		if(hasComposantFlavor(t.getTransferDataFlavors())){
			try{
				Composant comp=(Composant)t.getTransferData(ComposantFlavor.getComposantFlavor());
				//PanneauComposant
				return true;
			}catch (UnsupportedFlavorException ufe) {
                ufe.printStackTrace();
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
		}
		return false;
	}
	public int getSourceAction(JComponent c){
		return COPY;
	}
	public boolean hasComposantFlavor(DataFlavor[] flavors){
		if(ComposantFlavor.getComposantFlavor()==null){
			return false;
		}else{
		if(ComposantFlavor.getComposantFlavor().equals(flavors[0])){
			return true;
		}
		}
		return false;
	}
	public boolean canImport(JComponent c, DataFlavor[] flavors){
		return hasComposantFlavor(flavors);
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
package monpackage;
 
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
 
import javax.swing.TransferHandler;
 
public class DragAndDropListener extends MouseAdapter{
	public void mousePressed(MouseEvent e){
		PanneauComposant pc=(PanneauComposant)e.getSource();
		pc.getTransferHandler().exportAsDrag(pc, e, TransferHandler.COPY);
		e.consume();
	}
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
package monpackage;
 
import java.awt.datatransfer.DataFlavor;
import javax.swing.TransferHandler;
 
public class DropTransfertHandler extends TransferHandler{
	public boolean canImport(TransferHandler.TransferSupport info) {
		  if (!info.isDataFlavorSupported(DataFlavor.imageFlavor)) {
			   return false;
		   }
		   return true;
	}
	public boolean importData(TransferHandler.TransferSupport support){
		  if(!canImport(support))
			  return false;
		ComposantTransferable comp=(ComposantTransferable) support.getTransferable();
		return true;
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
 
package monpackage;
 
import javax.swing.JComponent;
 
public class DropZone extends JComponent{
	public DropZone()	{
		setTransferHandler(new DropTransfertHandler());
	}
}

Code:

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
 
package monpackage;
 
import java.awt.Color;
import java.awt.Graphics;
import java.util.ArrayList;
import java.util.Iterator;
 
import javax.swing.JPanel;
 
public class PanneauComposant extends JPanel{
	ArrayList<Composant> listecomp;
	public PanneauComposant(){
		setBackground(Color.white);
		for(Iterator<Composant> it=listecomp.iterator();it.hasNext();)
		{
			Composant c=(Composant)it.next();					
			add(c);
		}
	}
public void ajouterComposant(Composant c){
	listecomp.add(c);
}
 
}

C'est pas mal, on avance bien.

Tout d'abord, une bonne cure d'amaigrissement pour le ComposantTransfertHandler
seul le code suivant est nécessaire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 import java.awt.datatransfer.Transferable; import javax.swing.JComponent; import javax.swing.TransferHandler; public class ComposantTransfertHandler extends TransferHandler { // ----------------- POUR LE DRAG --------------------------------------------------------- // Indication du type de transfert : ici, on ne fait que de la copie (pas de déplacement) public int getSourceAction(JComponent c) { return COPY; } // Cette méthode prépare l'objet à tranférer (objet qui doit implémenter Transferable) @Override public Transferable createTransferable(JComponent c) { return (Transferable) c; } }
pour la DropZone, je préconise un JPanel plutôt qu'un JComponent

Pour le DropTransfertHandler il manque le système de récupération du composant transféré.
Le principe que j'utilise est de récupérer les données et de les copier dans un nouveau composant
Pour cela :
- il faudra implémenter clonable dans la classe Composant (qui finalement va nous servir)
- il faut que Composant étende JPanel ou JLabel (pour pouvoir être ajouté à DropZone)
- il faut rendre accessible le champ composant contenu dans ComposantTransferable (en le rendant public ou bien en créant une méthode getComposant dans la classe ComposantTransferable )
- il faut créer une méthode "insert" dans la classe DropZone. Cette méthode doit être capable de placer un objet Composant à un point précis.

ceci fait, il faut ajouter la création d'un composant récupéré dans la méthode importData :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 public boolean importData(TransferHandler.TransferSupport support){ if(!canimport(support)) return false; ComposantTransferable comp=(ComposantTransferable) support.getTransferable(); // création d'un nouveau composant à partir du clone Composant copie = comp.getComposant.clone(); // recuperation de la drop-zone DropZone destination = (DropZone) support.getComponent(); // coordonnées du largage Point p = support.getDropLocation().getDropPoint(); destination.insert(copie,p); return true; }
Bon, j'ai survolé certains points (la méthode insert par exemple).
Après avoir fait tes essais, tu me diras ce qu'on doit approfondir.

bon la j'ai fait des petites modifications comme tu m'as dit mais apparemment la méthode clone la classe cloneable n'est pas public donc j'ai fais des ajustements et pour la classe DropZone j'aimerais qu'on puisse déplacer les composants. Ceci dit on doit être capable a la fin de porter un composant du panneau composant, le déposer sur le dropZone (éventuellement le déplacer sur le dropzone) et par exemple cliquer sur lui pour l'éditer. voila mes modifications:

Code:

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
 
package monpackage;
import java.awt.Image;
import java.io.Serializable;
import javax.swing.JPanel;
 
public class Composant extends JPanel implements Serializable,Cloneable{
	private static final long serialVersionUID = 1L;
	private String nom;
	public int x;
	public int y;
	public Image image;
	public Composant(String no,Image img)
	{
		this.nom=no;
		this.image=img;
	}
	public String getname()
	{
		return nom;
	}
	public void setPositioon(int px,int py)
	{
		x=px;
		y=py;
	}
	public Composant getClone(){
		return this.getClone();
	}
}

Code:

1
2
3
 
public class ComposantTransferable extends JPanel implements Transferable{
public Composant composant;

Code:

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
 
package monpackage;
import java.awt.Point;
import java.awt.datatransfer.DataFlavor;
 
import javax.swing.JPanel;
import javax.swing.TransferHandler;
 
public class DropZone extends JPanel{
	public DropZone()	{
		setTransferHandler(new DropTransfertHandler());
	}
	public void insert(Composant c,Point p){
		add(c,p.x,p.y);
	}
	public boolean importData(TransferHandler.TransferSupport support){
		  if(!canImport(support))
			  return false;
		ComposantTransferable comp=(ComposantTransferable) support.getTransferable();
 
              // création d'un nouveau composant à partir du clone
              Composant copie = comp.composant.getClone();
 
              //  recuperation de la drop-zone
              DropZone destination = (DropZone) support.getComponent();
 
              //  coordonnées du largage
              Point p = support.getDropLocation().getDropPoint();
 
              destination.insert(copie,p);
		return true;
	}
	public boolean canImport(TransferHandler.TransferSupport info) {
		   //Nous contrôlons si les données reçues
		   //sont d'un type autorisé, ici le type String 		
		   if (!info.isDataFlavorSupported(DataFlavor.imageFlavor)) {
			   return false;
		   }
		   return true;
		}
}

et pour les autres classes c'est sans changement a savoir: composantflavor, draganddroplistener et panneacomposant.

bon j'ai essayer de tester tout ceci mais le composant ne s'affiche pas dans le panneaucomposant comme je le presentais voila le code:

Code:

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
 
package monpackage;
 
import java.awt.BorderLayout;
import java.awt.Image;
import java.io.IOException;
 
import javax.imageio.ImageIO;
import javax.swing.JPanel;
import javax.swing.JFrame;
 
public class Acceuil extends JFrame {
 
	private static final long serialVersionUID = 1L;
	private JPanel jContentPane = null;
 
	/**
         * This is the default constructor
         * @throws IOException 
         */
	public Acceuil() throws IOException {
		super();
		initialize();
	}
 
	/**
         * This method initializes this
         * 
         * @return void
         * @throws IOException 
         */
	private void initialize() throws IOException {
		this.setSize(300, 200);
		this.setContentPane(getJContentPane());
		this.setTitle("JFrame");
	}
 
	/**
         * This method initializes jContentPane
         * 
         * @return javax.swing.JPanel
         * @throws IOException 
         */
	private JPanel getJContentPane() throws IOException {
		if (jContentPane == null) {
			jContentPane = new JPanel();
			jContentPane.setLayout(new BorderLayout());
			Image image = ImageIO.read(Acceuil.class.getResource("/composants/lignes.png"));
			Composant c=new Composant("texte", image);
			PanneauComposant pc = new PanneauComposant();
			pc.listecomp.add(c);
			DropZone dz=new DropZone();
			dz.setPreferredSize(new java.awt.Dimension(500,500));
			pc.setPreferredSize(new java.awt.Dimension(100,500));
			jContentPane.add(pc,BorderLayout.WEST);
			jContentPane.add(dz,BorderLayout.CENTER);
		}
		return jContentPane;
	}
 
}

20/09/2012, 08h14
Népomucène

Je n'ai pas été clair dans la méthode importData (qui est propre à la classe TransfertHandler)
la modification doit être apportée dans la classe DropTransfertHandler
mais ne doit pas être créée dans la classe DropZone

ok voila les modifications apportées:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
package monpackage;
import java.awt.Color;
import java.awt.Point;
import java.awt.datatransfer.DataFlavor;
 
import javax.swing.JPanel;
import javax.swing.TransferHandler;
 
public class DropZone extends JPanel{
	public DropZone()	{
		setTransferHandler(new DropTransfertHandler());
		this.setBackground(Color.red);
	}
	public void insert(Composant c,Point p){
		add(c,p.x,p.y);
	}
 
}

Code:

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
 
package monpackage;
 
import java.awt.Point;
import java.awt.datatransfer.DataFlavor;
import javax.swing.TransferHandler;
 
public class DropTransfertHandler extends TransferHandler{
	public boolean importData(TransferHandler.TransferSupport support){
		  if(!canImport(support))
			  return false;
		ComposantTransferable comp=(ComposantTransferable) support.getTransferable();
 
            // création d'un nouveau composant à partir du clone
            Composant copie = comp.composant.getClone();
 
            //  recuperation de la drop-zone
            DropZone destination = (DropZone) support.getComponent();
 
            //  coordonnées du largage
            Point p = support.getDropLocation().getDropPoint();
 
            destination.insert(copie,p);
		return true;
	}
	public boolean canImport(TransferHandler.TransferSupport info) {
		   //Nous contrôlons si les données reçues
		   //sont d'un type autorisé, ici le type String 		
		   if (!info.isDataFlavorSupported(DataFlavor.imageFlavor)) {
			   return false;
		   }
		   return true;
		}
}

Maintenant voyons la méthode insert de la classe DropZone.
Elle doit permettre de placer un composant (un JPanel) à un endroit précis (le point p)

2 possibilités :

1) Utiliser un NullLayout pour DropZone. Avec ce Layout ou plutôt cette absence de Layout, il est possible de spécifier au pixel près l'endroit où doit se trouver le composant et sa dimension.
DropZone devient :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class DropZone extends JPanel{ public DropZone() { setTransferHandler(new DropTransfertHandler()); this.setBackground(Color.red); setLayout(null); } public void insert(Composant c,Point p){ add(c); // d'abord on ajoute c à DropZone int largeur = 230; int hauteur = 160; c.setBounds(p.x, p.y, largeur , hauteur ); // on place le composant } }
Bien entendu il faudra mettre largeur et hauteur dans la classe Composant (en tout cas autre part qu'en dur dans la méthode insert !)

2) Si tu développes avec NetBeans, tu peux utiliser AbsoluteLayout pour la classe DropZone
cela donne :
Code:

1 2 3 4 5 6 7 8 9 10 11 public class DropZone extends JPanel{ public DropZone() { setTransferHandler(new DropTransfertHandler()); this.setBackground(Color.red); setLayout(new org.netbeans.lib.awtextra.AbsoluteLayout()); } public void insert(Composant c,Point p){ add(c, new org.netbeans.lib.awtextra.AbsoluteConstraints(p.x, p.y, 230, 160)); // ajout et placement en une seule fois. } }
Bon voilà. Avant d'aller plus loin, tu dois tester l'ensemble et bien vérifier que le drag and drop fonctionne.
Dès que ça marche, on reparle de la classe Composant dans DropZone.

Le problème c'est que le composant ne s'affiche pas dans le panneaucomposant donc pas moyen de tester le drag and drop voila même les modifications que j'ai apporté:

Code:

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
 
package monpackage;
import java.awt.Image;
import java.io.Serializable;
import javax.swing.JPanel;
 
public class Composant extends JPanel implements Serializable,Cloneable{
	private static final long serialVersionUID = 1L;
	private String nom;
	public int x;
	public int y;
	public Image image;
	public int longueur;
	public int largeur;
	public Composant(String no,Image img)
	{
		this.nom=no;
		this.image=img;
		this.longueur=image.getWidth(null);
		this.largeur=image.getHeight(null);
	}
	public String getname()
	{
		return nom;
	}
	public void setPositioon(int px,int py)
	{
		x=px;
		y=py;
	}
	public Composant getClone(){
		return this.getClone();
	}
}

Code:

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
 
package monpackage;
 
import java.awt.Color;
import java.awt.Graphics;
import java.util.ArrayList;
import java.util.Iterator;
 
import javax.swing.JPanel;
 
public class PanneauComposant extends JPanel{
	ArrayList<Composant> listecomp;
	public PanneauComposant(){
		listecomp=new ArrayList<>();
		setBackground(Color.white);
		for(Iterator<Composant> it=listecomp.iterator();it.hasNext();)
		{
			Composant c=(Composant)it.next();					
			add(c);
			c.setBounds(c.x, c.y, 50, 50);
		}
	}
public void ajouterComposant(Composant c){
	listecomp.add(c);
}
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
package monpackage;
import java.awt.Color;
import java.awt.Point;
import java.awt.datatransfer.DataFlavor;
 
import javax.swing.JPanel;
import javax.swing.TransferHandler;
 
public class DropZone extends JPanel{
	public DropZone()	{
		setTransferHandler(new DropTransfertHandler());
		this.setBackground(Color.red);
		setLayout(null);
	}
	public void insert(Composant c,Point p){
		add(c,p.x,p.y);
        c.setBounds(p.x, p.y, c.longueur , c.largeur );
	}
 
}

En passant j'utilise eclipse

Je viens de regarder la dernière version de ta classe PanneauComposant
au moment de la construction, ton ArrayList listecomp est vide.
Donc aucune chance qu'il affiche quoi que ce soit

Après quand tu ajoutes des composants par la méthode ajouterComposant,
ça ajoute le composant à ton ArrayList listecomp mais rien n'est prévu pour afficher listecomp.

proposition de rectification :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 public class PanneauComposant extends JPanel{ ArrayList<Composant> listecomp; public PanneauComposant(){ setBackground(Color.white); /* ne sert à rien for(Iterator<Composant> it=listecomp.iterator();it.hasNext();) { Composant c=(Composant)it.next(); add(c); } */ } public void ajouterComposant(Composant c){ listecomp.add(c); this.removeAll(); // raz car sinon il y a cumul !!! for(Iterator<Composant> it=listecomp.iterator();it.hasNext();) { Composant c=(Composant)it.next(); add(c); } } }

jusque la rien toujours comment le composant doit s'afficher avec l'image que j'ai définit voila mon code:

Code:

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
 
package monpackage;
 
import java.awt.BorderLayout;
import java.awt.Image;
import java.io.IOException;
 
import javax.imageio.ImageIO;
import javax.swing.JPanel;
import javax.swing.JFrame;
 
public class Acceuil extends JFrame {
 
	private static final long serialVersionUID = 1L;
	private JPanel jContentPane = null;
 
	/**
         * This is the default constructor
         * @throws IOException 
         */
	public Acceuil() throws IOException {
		super();
		initialize();
	}
 
	/**
         * This method initializes this
         * 
         * @return void
         * @throws IOException 
         */
	private void initialize() throws IOException {
		this.setSize(300, 200);
		this.setContentPane(getJContentPane());
		this.setTitle("JFrame");
	}
 
	/**
         * This method initializes jContentPane
         * 
         * @return javax.swing.JPanel
         * @throws IOException 
         */
	private JPanel getJContentPane() throws IOException {
		if (jContentPane == null) {
			jContentPane = new JPanel();
			jContentPane.setLayout(new BorderLayout());
			Image image = ImageIO.read(Acceuil.class.getResource("/composants/lignes.png"));
			Composant c=new Composant("texte", image);
			c.x=100; c.y=100;
			PanneauComposant pc = new PanneauComposant();
			pc.ajouterComposant(c);
			DropZone dz=new DropZone();
			dz.setPreferredSize(new java.awt.Dimension(500,500));
			pc.setPreferredSize(new java.awt.Dimension(100,500));
			jContentPane.add(pc,BorderLayout.WEST);
			jContentPane.add(dz,BorderLayout.CENTER);
		}
		return jContentPane;
	}
 
}

20/09/2012, 18h07
Népomucène

Nan nan, on est tous les deux à côté de la plaque depuis deux heures !
dans le panneauComposant il faut mettre des objets ComposantTransferable et non pas Composant (sinon tout ça ne sert à rien)

ok voila le code du panneaucomposant:

Code:

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
 
package monpackage;
 
import java.awt.Color;
import java.awt.Graphics;
import java.util.ArrayList;
import java.util.Iterator;
 
import javax.swing.JPanel;
 
public class PanneauComposant extends JPanel{
	ArrayList<ComposantTransferable> listecomp;
	public PanneauComposant(){
		listecomp=new ArrayList<>();
		setBackground(Color.white);
 
	}
public void ajouterComposant(ComposantTransferable c){
	listecomp.add(c);
	for(Iterator<ComposantTransferable> it=listecomp.iterator();it.hasNext();)
	{
		ComposantTransferable ce=(ComposantTransferable)it.next();					
		add(ce);
		c.setBounds(ce.composant.x, ce.composant.y, 50, 50);
	}
}
 
}

Code:

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
 
package monpackage;
 
import java.awt.BorderLayout;
import java.awt.Image;
import java.io.IOException;
 
import javax.imageio.ImageIO;
import javax.swing.JPanel;
import javax.swing.JFrame;
 
public class Acceuil extends JFrame {
 
	private static final long serialVersionUID = 1L;
	private JPanel jContentPane = null;
 
	/**
         * This is the default constructor
         * @throws IOException 
         */
	public Acceuil() throws IOException {
		super();
		initialize();
	}
 
	/**
         * This method initializes this
         * 
         * @return void
         * @throws IOException 
         */
	private void initialize() throws IOException {
		this.setSize(300, 200);
		this.setContentPane(getJContentPane());
		this.setTitle("JFrame");
	}
 
	/**
         * This method initializes jContentPane
         * 
         * @return javax.swing.JPanel
         * @throws IOException 
         */
	private JPanel getJContentPane() throws IOException {
		if (jContentPane == null) {
			jContentPane = new JPanel();
			jContentPane.setLayout(new BorderLayout());
			Image image = ImageIO.read(Acceuil.class.getResource("/composants/lignes.png"));
			Composant c=new Composant("texte", image);
			c.x=100; c.y=100;
			PanneauComposant pc = new PanneauComposant();
			ComposantTransferable cp=new ComposantTransferable(c);
			pc.ajouterComposant(cp);
			DropZone dz=new DropZone();
			dz.setPreferredSize(new java.awt.Dimension(500,500));
			pc.setPreferredSize(new java.awt.Dimension(100,500));
			jContentPane.add(pc,BorderLayout.WEST);
			jContentPane.add(dz,BorderLayout.CENTER);
		}
		return jContentPane;
	}
 
}

mais rien ne s'affiche toujours dans le panneaucomposant

20/09/2012, 21h53
Népomucène

Plusieurs erreurs dans ComposantTransferable :
1) il n'a pas de PreferredSize
ajoute dans son constructeur : setPreferredSize(new Dimension(100, 100));
2) la méthode enableDrag n'est pas appelée donc ton listener n'est pas ajouté
ajoute dans le constructeur : addMouseListener(new DragAndDropListener());
3) le drawImage ne dessine pas il faut écrire :
g.drawImage(composant.image, composant.x, composant.y, 100,100, null);

c'est comme pour l'ajout dans l'ArrayList de tout à l'heure
tu fais du code ... qui n'est pas appelé !

4) le DragAndDropListener ne doit pas porter sur le PanneauComposant mais sur le ComposantTransferable

Il y a encore d'autres problèmes sur lesquels je travaille

bon j'ai comme tu m'a dit et le composanttransferable s'affiche dans le panneaucomposant comme un panel et sans l'image que j'ai defintis, de plus le drag and drop ne marche pas. voila les modifications:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
package monpackage;
 
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
 
import javax.swing.TransferHandler;
 
public class DragAndDropListener extends MouseAdapter{
	public void mousePressed(MouseEvent e){
		/*PanneauComposant pc=(PanneauComposant)e.getSource();
		pc.getTransferHandler().exportAsDrag(pc, e, TransferHandler.COPY);*/
		ComposantTransferable ct=(ComposantTransferable)e.getSource();
		ct.getTransferHandler().exportAsDrag(ct, e, TransferHandler.COPY);
		e.consume();
	}
 
}

Code:

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
 
package monpackage;
 
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
 
import javax.swing.JPanel;
import javax.swing.TransferHandler;
 
public class ComposantTransferable extends JPanel implements Transferable{
private DataFlavor img=new DataFlavor("image/png",null);
public Composant composant;
public ComposantTransferable(Composant c)
{
	setTransferHandler(new ComposantTransfertHandler());
 composant=c;
}
public void enableDrag(){
	addMouseListener(new DragAndDropListener());
}
public void paintComponent(Graphics g){
		super.paintComponent(g);					
		g.drawImage(composant.image, composant.x, composant.y,100,100,null);
		setPreferredSize(new Dimension(100,100));
		addMouseListener(new DragAndDropListener());
}
	@Override
	public Object getTransferData(DataFlavor arg0)
			throws UnsupportedFlavorException, IOException {
			if(ComposantFlavor.getComposantFlavor().equals(arg0))
			{
				return composant;
			}
			else throw new UnsupportedFlavorException(arg0);
	}
 
	@Override
	public DataFlavor[] getTransferDataFlavors() {
		ArrayList l= new ArrayList();
		l.add(ComposantFlavor.getComposantFlavor());
		l.add(img);
		return (DataFlavor[]) l.toArray(new DataFlavor[l.size()]);
	}
 
	@Override
	public boolean isDataFlavorSupported(DataFlavor arg0) {
		// TODO Auto-generated method stub
		return ComposantFlavor.getComposantFlavor().equals(arg0);
	}
 
}

21/09/2012, 11h23
Népomucène

Citation:

de plus le drag and drop ne marche pas

Oui j'ai vu. Pour le moment je n'ai pas encore trouvé l'erreur. Je suppose qu'il s'agit d'un DataFlavor qui ne doit pas être bien paramétré quelque part.
Cherche aussi de ton côté parce qu'aujourd'hui je n'aurais pas le temps.
22/09/2012, 05h34
junior222

bon j'ai essayé de parcourir certains tuto et j'ai remarqué qu'en général c'est le panneauComposant a qui on ajoute le listener et le transferthandler
22/09/2012, 17h19
Népomucène

Citation:

en général c'est le panneauComposant a qui on ajoute le listener et le transferthandler

Non, c'est le ComposantTransferable qu'on transfère, pas le panneau sur lequel il est assis !

J'ai fini par trouver par comparaison avec mon propre code (on fait à peu près la même application)
Là je dois dire que l'erreur tenait dans un détail que je n'hésite pas à qualifier de diabolique !
Elle se situe dans le ComposantTransfertHandler qui étend la classe TransferHandler et dont on doit redéfinir les méthodes
- getSourceActions
- createTransferable
Seulement voilà, au lieu de taper :

Code:

public int getSourceActions(JComponent c) { ...

tu as tapé :

Code:

public int getSourceAction(JComponent c) {

--> il manque le "s" à la fin de "getSourceAction"
Résultat : il y avait une méthode getSourceAction dans ton TransHandler qui ne servait à rien car jamais appelée
le système de "Drag" utilisait en fait la méthode de la classe mère (qui existait toujours) et qui ne faisait donc rien
car on ne l'avait pas redéfinie (par défaut elle ne fait rien !)

Tout ça pour dire qu'il faut ajouter un "s" à getSourceAction

et ça marche !

Voir 40 message(s) de cette discussion en une page