Affichage d'un JPane dans un JFrame

Version imprimable

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

27/09/2012, 17h44
Népomucène

Bon je ne connais pas Eclipse (j'utilise NetBeans)
mais je pense qu'il doit avoir une option de run avec debug.
Essaye de l'exécuter ligne à ligne pour voir où il s'arrête.

Sinon, place des System.out.println("instruction exécutée") après chaque instruction (méthode de bourin mais bon ...)
27/09/2012, 17h58
junior222

bon moi je pense que le problème se trouve au niveau de la ligne:

Code:

comp = (ComposantTransferable) support.getTransferable().getTransferData(ComposantFlavor.getComposantFlavor());

est ce qu'elle retourne vraiment le composant transféré?

Es-tu sûr que la ligne est exécutée ?
modifie ton code :

Code:

1
2
3
4
5
6
7
8
9
10
11
		try {
			comp = (ComposantTransferable) support.getTransferable().getTransferData(ComposantFlavor.getComposantFlavor());
		} catch (UnsupportedFlavorException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
System.out.print("récupéré "+comp.getClass().getName());

27/09/2012, 18h21
junior222
de plus voila l'erreur du debug:
Code:

1 2 3 ERROR: JDWP Unable to get JNI 1.2 environment, jvm->GetEnv() return code = -2 JDWP exit error AGENT_ERROR_NO_JNI_ENV(183): [../../../src/share/back/util.c:838]
rien ne s'affiche après l'ajout de

Code:

System.out.print("récupéré "+comp.getClass().getName());

lors du drop
28/09/2012, 00h42
junior222

je crois que j'ai trouvé le problème la variable comp est null donc l'instruction

Code:

comp = (ComposantTransferable) support.getTransferable().getTransferData(ComposantFlavor.getComposantFlavor());

n'est pas exécuté
28/09/2012, 10h10
Népomucène

Non. La variable est simplement initialisée à null ; ensuite l'instruction est exécutée.
De mon côté, j'ai la même instruction qui fonctionne parfaitement.
ajoute @Override avant les deux méthodes comme j'ai expliqué dans le post du 26/09/2012 09h58
ensuite fait une compilation du code

je ne comprends toujours pas pourquoi

Code:

public boolean canimport(TransferHandler.TransferSupport info) { ...

est écrit avec un "i" minuscule.

après compilation et ajout du @Override, poste le nouveau code que je puisse le tester de mon côté.

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
 
package monpackage;
import java.awt.Point;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
 
import javax.swing.TransferHandler;
 
public class DropTransfertHandler extends TransferHandler{
	@Override
	public boolean importData(TransferHandler.TransferSupport support){
		  if(!canImport(support))
			  return false;
		  ComposantTransferable comp = null;
		  		try {
			comp = (ComposantTransferable) support.getTransferable().getTransferData(ComposantFlavor.getComposantFlavor());
			System.out.print("récupéré "+comp.getClass().getName());
		} catch (UnsupportedFlavorException e) {
			System.out.print(e);
			e.printStackTrace();
		} catch (IOException e) {
			System.out.print(e);
			e.printStackTrace();
		}
        // 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();
 
        copie.x=p.x;
        copie.y=p.y;
        System.out.print("vous avez collé "+copie.nom);
        destination.insert(copie);
		System.out.print("récupéré "+comp.getClass().getName());
		return true;
	}
	@Override
	public boolean canImport(TransferHandler.TransferSupport info) {
		  if (!info.isDataFlavorSupported(ComposantFlavor.getComposantFlavor())) {
			   return false;
		   }
		   return true;
		}
}

28/09/2012, 11h06
Népomucène

et ça compile avec le "i" du "canimport" en minuscule ?
28/09/2012, 12h12
junior222

oui puisque dans mon environnement c'est en majuscule
28/09/2012, 12h28
Népomucène

Bon, peux-tu re-poster toutes tes classes exactement comme elles sont.
Je vais les importer dans NetBeans et voir le message d'erreur (ce soir).

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
 
package monpackage;
import java.awt.Dimension;
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;
	public 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);
		setPreferredSize(new Dimension(longueur,largeur));
	}
	public String getName()
	{
		return nom;
	}
	public void setPositioon(int px,int py)
	{
		x=px;
		y=py;
	}
	public Composant getClone(){
		//return this.getClone();
		Composant c=new Composant(nom, image);
		return c;
	}
}

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
 
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)
{
composant=c;
setTransferHandler(new ComposantTransfertHandler());
 addMouseListener(new DragAndDropListener());
 setPreferredSize(new Dimension(composant.longueur,composant.largeur));
}
public void enableDrag(){
	addMouseListener(new DragAndDropListener());
}
public void paintComponent(Graphics g){
		super.paintComponent(g);					
		g.drawImage(composant.image, composant.x, composant.y,composant.longueur,composant.largeur,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) {
		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
 
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
 
package monpackage;
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 getSourceActions(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;
    }
}

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){
		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
 
package monpackage;
import java.awt.Point;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
 
import javax.swing.TransferHandler;
 
public class DropTransfertHandler extends TransferHandler{
	@Override
	public boolean importData(TransferHandler.TransferSupport support){
		  if(!canImport(support))
			  return false;
		  ComposantTransferable comp = null;
		  		try {
			comp = (ComposantTransferable) support.getTransferable().getTransferData(ComposantFlavor.getComposantFlavor());
			System.out.print("récupéré "+comp.getClass().getName());
		} catch (UnsupportedFlavorException e) {
			System.out.print(e);
			e.printStackTrace();
		} catch (IOException e) {
			System.out.print(e);
			e.printStackTrace();
		}
        // 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();
 
        copie.x=p.x;
        copie.y=p.y;
        System.out.print("vous avez collé "+copie.nom);
        destination.insert(copie);
		System.out.print("récupéré "+comp.getClass().getName());
		return true;
	}
	@Override
	public boolean canImport(TransferHandler.TransferSupport info) {
		  if (!info.isDataFlavorSupported(ComposantFlavor.getComposantFlavor())) {
			   return false;
		   }
		   return true;
		}
}

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.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.datatransfer.DataFlavor;
import java.util.ArrayList;
import java.util.Iterator;
 
import javax.swing.JPanel;
import javax.swing.TransferHandler;
 
public class DropZone extends JPanel{
	ArrayList<Composant> liste;
	public DropZone()	{
		setTransferHandler(new DropTransfertHandler());
		this.setBackground(Color.white);
		setLayout(null);
		liste=new ArrayList<>();
	}
	public void insert(Composant c){
		liste.add(c);
		repaint();
	}
	public void paintComponent(Graphics g){
		super.paintComponent(g);
		for(Iterator<Composant> it=liste.iterator();it.hasNext();)
		{
			Composant ce=(Composant)it.next();
			g.drawImage(ce.image,ce.x,ce.y,ce.longueur,ce.largeur,null);
		}
	}
}

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<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();
		ce.setBounds(ce.composant.x, ce.composant.y,ce.composant.longueur,ce.composant.largeur);
		add(ce);
	}
}
}

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
64
65
66
 
package monpackage;
 
import java.awt.BorderLayout;
import java.awt.Image;
import java.awt.Point;
import java.io.IOException;
 
import javax.imageio.ImageIO;
import javax.swing.JPanel;
import javax.swing.JFrame;
import java.awt.Dimension;
 
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(1000, 550);
		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();
			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(300,500));
			pc.add(c, null);
			//dz.insert(c);
			jContentPane.add(pc,BorderLayout.WEST);
			jContentPane.add(dz,BorderLayout.CENTER);
		}
		return jContentPane;
	}
 
}  //  @jve:decl-index=0:visual-constraint="14,15"

28/09/2012, 14h21
Népomucène
Je n'ai pas trouvé comment tu fais pour démarrer l'application.
Il faut que dans une de tes classes il y ait :
Code:

1 2 3 public static void main(String args[]) { .... le code qui lance l'application }
28/09/2012, 14h58
junior222
c'est la classe acceuil qui lance l'application donc c'est elle qui contient le:
Code:

1 2 3 4 public static void main(String args[]) { .... le code qui lance l'application }
28/09/2012, 15h03
Népomucène

Ah bon ? j'ai beau regarder dans le code de la classe, je ne vois pas la méthode main

désolé 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
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
 
package monpackage;
 
import java.awt.BorderLayout;
import java.awt.Image;
import java.awt.Point;
import java.io.IOException;
 
import javax.imageio.ImageIO;
import javax.swing.JPanel;
import javax.swing.JFrame;
import java.awt.Dimension;
 
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();
	}
public static void main(String args[]){
	try {
		new Acceuil();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}
	/**
         * This method initializes this
         * 
         * @return void
         * @throws IOException 
         */
	private void initialize() throws IOException {
		this.setSize(1000, 550);
		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();
			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(300,500));
			pc.add(c, null);
			//dz.insert(c);
			jContentPane.add(pc,BorderLayout.WEST);
			jContentPane.add(dz,BorderLayout.CENTER);
		}
		return jContentPane;
	}
 
}  //  @jve:decl-index=0:visual-constraint="14,15"

Ce n'est pas le code que tu utilises car ton JFrame Acceuil ne s'affiche pas :
Code:

1 2 3 4 5 6 7 8 public static void main(String args[]){ try { new Acceuil(); // n'affiche pas } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }

28/09/2012, 20h15
junior222

si chez moi j'ai même eu besoin de mettre la méthode main
28/09/2012, 20h21
junior222

remplace donc

Code:

new Acceuil();

par

Code:

new Acceuil().setVisible(true);
28/09/2012, 20h36
junior222

En passant puisque pour l'instant je peux ajouter les composants manuellement tu peux me donner les indications pour la suit?
a savoir:
- comment déplacer un composant sur le dropzone
- comment relier les composants
- comment gérer les événements sur les composants (clic, sélection,...)
comme sa on avance un peux car depuis un bout on bloc et j'aimerais un peux avancer s'il te plait on trouvera la solution en chemin je pense.

Voilà la classe DropTransfertHandler qui correspond aux autres classes de ton application.
Je n'avais pas la même version que toi des autres classes (que j'avais un peu remaniées à ma sauce)
C'est pourquoi je t'ai demandé de poster toutes les classes.

La confusion venait de l'utilisation de ComposantTransferable au lieu de Composant

Les lignes à corriger sont en rouge, les corrections sont en vert.

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
package monpackage;
import java.awt.Point;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;

import javax.swing.TransferHandler;

public class DropTransfertHandler extends TransferHandler{
	@Override
	public boolean importData(TransferHandler.TransferSupport support){
		  if(!canImport(support))
			  return false;
//		  ComposantTransferable comp = null;        // ANCIENNE LIGNE
		  Composant comp = null;                    // MODIFICATION
		  		try {
//			comp = (ComposantTransferable) support.getTransferable().getTransferData(ComposantFlavor.getComposantFlavor()); // ANCIENNE LIGNE
			comp = (Composant) support.getTransferable().getTransferData(ComposantFlavor.getComposantFlavor());             // MODIFICATION
			System.out.print("récupéré "+comp.getClass().getName());
		} catch (UnsupportedFlavorException e) {
			System.out.print(e);
			e.printStackTrace();
		} catch (IOException e) {
			System.out.print(e);
			e.printStackTrace();
		}
        // création d'un nouveau composant à partir du clone
//        Composant copie = comp.composant.getClone();  // ANCIENNE LIGNE
        Composant copie = comp.getClone();              // MODIFICATION

        //  recuperation de la drop-zone
        DropZone destination = (DropZone) support.getComponent();

        //  coordonnées du largage
        Point p = support.getDropLocation().getDropPoint();

        copie.x=p.x;
        copie.y=p.y;
        System.out.print("vous avez collé "+copie.nom);
        destination.insert(copie);
		System.out.print("récupéré "+comp.getClass().getName());
		return true;
	}
	@Override
	public boolean canImport(TransferHandler.TransferSupport info) {
		  if (!info.isDataFlavorSupported(ComposantFlavor.getComposantFlavor())) {
			   return false;
		   }
		   return true;
		}
}

par ailleurs, ajoute dans la classe Acceuil :
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
dans le constructeur

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