Le Drag'n Drop

//CTRL + SHIFT + O pour générer les imports
public class Test1 extends JFrame{

  public Test1(){
    super("Test de Drag'n Drop");
    setSize(300, 200);

    JPanel pan = new JPanel();
    pan.setBackground(Color.white);
    pan.setLayout(new BorderLayout());

    //Notre textearea avec son contenu déplaçable
    JTextArea label = new JTextArea("Texte déplaçable !");
    label.setPreferredSize(new Dimension(300, 130));
    //--------------------------------------------------
    //C'est cette instruction qui permet le déplacement de son contenu
    label.setDragEnabled(true);
    //--------------------------------------------------

    pan.add(new JScrollPane(label), BorderLayout.NORTH);

    JPanel pan2 = new JPanel();
    pan2.setBackground(Color.white);
    pan2.setLayout(new BorderLayout());

    //On crée le premier textfield avec contenu déplaçable
    JTextField text = new JTextField();
    //--------------------------------------------------
    text.setDragEnabled(true);
    //--------------------------------------------------
    //Et le second, sans
    JTextField text2 = new JTextField();

    pan2.add(text2, BorderLayout.SOUTH);
    pan2.add(text, BorderLayout.NORTH);

    pan.add(pan2, BorderLayout.SOUTH);
    add(pan, BorderLayout.CENTER);

    setVisible(true);
  }

  public static void main(String[] args){
    new Test1();
  }  
}

//CTRL + SHIFT + O pour générer les imports
public class LabelContentDemo extends JFrame{

  public LabelContentDemo(){
    setTitle("Drag'n Drop avec un JLabel !");
    setSize(300, 100);
    setLocationRelativeTo(null);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    JPanel pan = new JPanel();
    pan.setLayout(new GridLayout(2,2));
    pan.setBackground(Color.white);

    JLabel srcLib = new JLabel("Source de drag : ", JLabel.RIGHT);
    JLabel src = new JLabel("Texte à déplacer !");

    //-------------------------------------------------------------------
    //On crée le nouvel objet pour activer le drag'n drop 
    src.setTransferHandler(new TransferHandler("text"));

    //On spécifie au composant qu'il doit envoyer ses données via son objet TransferHandler
    src.addMouseListener(new MouseAdapter(){
      //On utilise cet événement pour que les actions soient visibles dès le clic de souris…
      //Nous aurions pu utiliser mouseReleased, mais, niveau IHM, nous n'aurions rien vu
      public void mousePressed(MouseEvent e){
        //On récupère le JComponent            
        JComponent lab = (JComponent)e.getSource();
        //Du composant, on récupère l'objet de transfert : le nôtre
        TransferHandler handle = lab.getTransferHandler();
        //On lui ordonne d'amorcer la procédure de drag'n drop
        handle.exportAsDrag(lab, e, TransferHandler.COPY);
      }
    });
    //-------------------------------------------------------------------

    JLabel destLib = new JLabel("Destination de drag : ", JLabel.RIGHT);
    JTextField dest = new JTextField();
    //On active le comportement par défaut de ce composant
    dest.setDragEnabled(true);

    pan.add(srcLib);
    pan.add(src);
    pan.add(destLib);
    pan.add(dest);

    setContentPane(pan);
    setVisible(true);
  }

  public static void main(String[] args){
    new LabelContentDemo();
  }   
}

import javax.swing.TransferHandler;

public class MyTransferHandler extends TransferHandler{

  /**
  * Méthode permettant à l'objet de savoir si les données reçues
  * via un drop sont autorisées à être importées
  * @param info
  * @return boolean
  */
  public boolean canImport(TransferHandler.TransferSupport info) {}

  /**
  * C'est ici que l'insertion des données dans notre composant est réalisée
  * @param support
  * @return boolean
  */
  public boolean importData(TransferHandler.TransferSupport support){}

  /**
  * Cette méthode est invoquée à la fin de l'action DROP
  * Si des actions sont à faire ensuite, c'est ici qu'il faudra coder le comportement désiré
  * @param c
  * @param t
  * @param action
  */
  protected void exportDone(JComponent c, Transferable t, int action){}

  /**
  * Dans cette méthode, nous allons créer l'objet utilisé par le système de drag'n drop
  * afin de faire circuler les données entre les composants
  * Vous pouvez voir qu'il s'agit d'un objet de type Transferable
  * @param c
  * @return
  */
  protected Transferable createTransferable(JComponent c) {}

  /**
  * Cette méthode est utilisée afin de déterminer le comportement 
  * du composant vis-à-vis du drag'n drop : nous retrouverons
  * nos variables statiques COPY, MOVE, COPY_OR_MOVE, LINK ou NONE 
  * @param c
  * @return int
  */
  public int getSourceActions(JComponent c) {}

}

public int getSourceActions(JComponent c) {
  //Nous n'autorisons donc que le déplacement ici
  return MOVE;
}

public boolean canImport(TransferHandler.TransferSupport info) {
  //Nous contrôlons si les données reçues sont d'un type autorisé, ici String       
  if (!info.isDataFlavorSupported(DataFlavor.stringFlavor)) {
    return false;
  }
  return true;
}

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
  JLabel lab = (JLabel)support.getComponent();
  //Afin de lui affecter sa nouvelle valeur
  lab.setText(str);

  return true;
}

//CTRL + SHIFT + O pour générer les imports
public class LabelContentDemo extends JFrame{

  public LabelContentDemo(){
    setTitle("Drag'n Drop avec un JLabel !");
    setSize(300, 100);
    setLocationRelativeTo(null);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    JPanel pan = new JPanel();
    pan.setLayout(new GridLayout(2,2));
    pan.setBackground(Color.white);

    JLabel srcLib = new JLabel("Source de drag : ", JLabel.RIGHT);
    JLabel src = new JLabel("Texte à déplacer !");

    //--------------------------------------------------------
    //On utilise notre nouvel objet MyTransferHandle 
    src.setTransferHandler(new MyTransferHandler());      

    src.addMouseListener(new MouseAdapter(){

      public void mousePressed(MouseEvent e){
        System.out.println("EVENT !");
        JComponent lab = (JComponent)e.getSource();
        TransferHandler handle = lab.getTransferHandler();
        handle.exportAsDrag(lab, e, TransferHandler.COPY);
      }
    });
    //--------------------------------------------------------

    JLabel destLib = new JLabel("Destination de drag : ", JLabel.RIGHT);
    JTextField dest = new JTextField();

    dest.setDragEnabled(true);

    pan.add(srcLib);
    pan.add(src);
    pan.add(destLib);
    pan.add(dest);

    setContentPane(pan);
    setVisible(true);
  }

  public static void main(String[] args){
    new LabelContentDemo();
  }   
}

//CTRL + SHIFT + O pour générer les imports
public class MyTransferHandler extends TransferHandler{

  public boolean canImport(TransferHandler.TransferSupport info) {
    if (!info.isDataFlavorSupported(DataFlavor.stringFlavor)) {
      return false;
    }
    return true;
  }

  public boolean importData(TransferHandler.TransferSupport support){
    if(!canImport(support))
      return false;

    Transferable data = support.getTransferable();
    String str = "";

    try {
      str = (String)data.getTransferData(DataFlavor.stringFlavor);
    } catch (UnsupportedFlavorException e){
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }

    JLabel lab = (JLabel)support.getComponent();
    lab.setText(str);

    return false;
  }

  protected void exportDone(JComponent c, Transferable t, int action){
    //Une fois le drop effectué nous effaçons le contenu de notre JLabel
    if(action == MOVE)
      ((JLabel)c).setText("");
  }

  protected Transferable createTransferable(JComponent c) {
    //On retourne un nouvel objet implémentant l'interface Transferable
    //StringSelection implémente cette interface,  nous l'utilisons donc
    return new StringSelection(((JLabel)c).getText());
  }

  public int getSourceActions(JComponent c) {
    return MOVE;
  }   
}

//Pour récupérer les infos importantes sur un JTree
JTree.DropLocation dl = (JTree.DropLocation)myTransfertSupport.getDropLocation();
//Pour récupérer les infos importantes sur un JTable
JTable.DropLocation dl = (JTable.DropLocation)myTransfertSupport.getDropLocation();
//Pour récupérer les infos importantes sur un JList
JList.DropLocation dl = (JList.DropLocation)myTransfertSupport.getDropLocation();

//CTRL + SHIFT + O pour générer les imports
public class MyTransferHandler extends TransferHandler{

  public boolean canImport(TransferHandler.TransferSupport info) {
    if (!info.isDataFlavorSupported(DataFlavor.stringFlavor)) {
      return false;
    }
    return true;
  }

  public boolean importData(TransferHandler.TransferSupport support){
    if(!canImport(support))
      return false;

    Transferable data = support.getTransferable();
    String str = "";

    try {
      str = (String)data.getTransferData(DataFlavor.stringFlavor);
    } catch (UnsupportedFlavorException e){
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }

    JLabel lab = (JLabel)support.getComponent();
    lab.setText(str);

    return false;
  }

  protected void exportDone(JComponent c, Transferable t, int action){
    if(action == MOVE){
      JLabel lab = (JLabel)c; 
      String text = lab.getText();
      int indice = Integer.parseInt(text.substring(text.length()-1, text.length()));
      lab.setText(text.substring(0, text.length()-1) + (++indice));
    }
  }

  protected Transferable createTransferable(JComponent c) {
    return new StringSelection(((JLabel)c).getText());
  }

  public int getSourceActions(JComponent c) {
    return MOVE;
  }   
}

//CTRL + SHIFT + O pour générer les imports
public class TreeTransferHandler extends TransferHandler{

  JTree tree;
  public TreeTransferHandler(JTree tree){
    this.tree = tree;
  }

  public boolean canImport(TransferHandler.TransferSupport info) {
    if (!info.isDataFlavorSupported(DataFlavor.stringFlavor))
      return false;

    return true;
  }

  public boolean importData(TransferHandler.TransferSupport support){
    if(!canImport(support))
      return false;

    //On récupère l'endroit du drop via un objet approprié
    JTree.DropLocation dl = (JTree.DropLocation)support.getDropLocation();
    //Les informations afin de pouvoir créer un nouvel élément
    TreePath path = dl.getPath();
    int index = dl.getChildIndex();

    //Comme pour le JLabel, on récupère les données
    Transferable data = support.getTransferable();
    String str = "";

    try {
      str = (String)data.getTransferData(DataFlavor.stringFlavor);
    } catch (UnsupportedFlavorException e){
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }   

    //On peut maintenant ajouter le nœud
    DefaultMutableTreeNode nouveau = new DefaultMutableTreeNode(str);
    //On déduit le nœud parent via le chemin
    DefaultMutableTreeNode parent = (DefaultMutableTreeNode)path.getLastPathComponent();

    DefaultTreeModel model = (DefaultTreeModel)this.tree.getModel();
    index = (index == -1) ? model.getChildCount(path.getLastPathComponent()) : index ;
    model.insertNodeInto(nouveau, parent, index);

    tree.makeVisible(path.pathByAddingChild(nouveau));
    tree.scrollPathToVisible(path);

    return true;
  }

  public int getSourceActions(JComponent c) {
    return COPY_OR_MOVE;
  }   
}

//CTRL + SHIFT + O pour générer les imports
public class TreeDragDemo extends JFrame{
  JTree tree;
  public TreeDragDemo(){
    setTitle("Drag'n Drop avec un JLabel !");
    setSize(400, 200);
    setLocationRelativeTo(null);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    JPanel pan = new JPanel();
    pan.setLayout(new GridLayout(1, 1));
    pan.setBackground(Color.white);

    JLabel srcLib = new JLabel("Source de drag : ", JLabel.RIGHT);
    JLabel src = new JLabel("Noeud 1");

    //------------------------------------------------------
    //On utilise notre nouvel objet MyTransferHandle 
    src.setTransferHandler(new MyTransferHandler());      
    src.addMouseListener(new MouseAdapter(){

      public void mousePressed(MouseEvent e){
        JComponent lab = (JComponent)e.getSource();
        TransferHandler handle = lab.getTransferHandler();
        handle.exportAsDrag(lab, e, TransferHandler.MOVE);
      }
    });
    //------------------------------------------------------

    JLabel destLib = new JLabel("Destination de drag : ", JLabel.RIGHT);
    JTextField dest = new JTextField();

    dest.setDragEnabled(true);
    tree = new JTree(getModel());
    tree.setDragEnabled(true);
    tree.setTransferHandler(new TreeTransferHandler(tree));

    pan.add(src);

    pan.add(new JScrollPane(tree));

    //Pour le choix des actions
    JComboBox combo = new JComboBox();
    combo.addItem("USE_SELECTION");
    combo.addItem("ON");
    combo.addItem("INSERT");
    combo.addItem("ON_OR_INSERT");

    combo.addItemListener(new ItemListener(){

      public void itemStateChanged(ItemEvent event) {
        String value = event.getItem().toString();

        if(value.equals("USE_SELECTION"))
          tree.setDropMode(DropMode.USE_SELECTION);

        if(value.equals("ON"))
          tree.setDropMode(DropMode.ON);            

        if(value.equals("INSERT"))
          tree.setDropMode(DropMode.INSERT);

        if(value.equals("ON_OR_INSERT"))
          tree.setDropMode(DropMode.ON_OR_INSERT);

      }         
    });

    add(pan, BorderLayout.CENTER);
    add(combo, BorderLayout.SOUTH);
    setVisible(true);
  }

  private TreeModel getModel(){

    DefaultMutableTreeNode root = new DefaultMutableTreeNode("SDZ");

    DefaultMutableTreeNode forum = new DefaultMutableTreeNode("Forum");
    forum.add(new DefaultMutableTreeNode("C++"));
    forum.add(new DefaultMutableTreeNode("Java"));
    forum.add(new DefaultMutableTreeNode("PHP"));

    DefaultMutableTreeNode tuto = new DefaultMutableTreeNode("Tutoriel");
    tuto.add(new DefaultMutableTreeNode("Tutoriel"));
    tuto.add(new DefaultMutableTreeNode("Programmation"));
    tuto.add(new DefaultMutableTreeNode("Mapping"));

    root.add(tuto);
    root.add(forum);

    return new DefaultTreeModel(root);
  }

  public static void main(String[] args){
    new TreeDragDemo();
  }   
}

//CTRL + SHIFT + O pour générer les imports
public class MyGlassPane extends JPanel{

  //L'image qui sera dessinée
  private BufferedImage img;
  //Les coordonnées de l'image
  private Point location;
  //La transparence de notre glace
  private Composite transparence;

  public MyGlassPane(){
    //Afin de ne peindre que ce qui nous intéresse
    setOpaque(false);
    //On définit la transparence
    transparence = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.55f);
  }   

  public void setLocation(Point location){
    this.location = location;        
  }

  public void setImage(BufferedImage image){
    img = image;
  }

  public void paintComponent(Graphics g){
    //Si on n'a pas d'image à dessiner, on ne fait rien…
    if(img == null)
      return;

    //Dans le cas contraire, on dessine l'image souhaitée
    Graphics2D g2d = (Graphics2D)g;
    g2d.setComposite(transparence);
    g2d.drawImage(img, (int) (location.getX() - (img.getWidth(this)  / 2)), (int) (location.getY() - (img.getHeight(this) / 2)), null);
  }   
}

//CTRL + SHIFT + O pour générer les imports
public class MouseGlassListener extends MouseAdapter{

  private MyGlassPane myGlass;
  private BufferedImage image;

  public MouseGlassListener(MyGlassPane glass){
    myGlass = glass;
  }

  public void mousePressed(MouseEvent event) {
    //On récupère le composant pour en déduire sa position
    Component composant = event.getComponent();
    Point location = (Point)event.getPoint().clone();

    //Les méthodes ci-dessous permettent, dans l'ordre, 
    //de convertir un point en coordonnées d'écran
    //et de reconvertir ce point en coordonnées fenêtres
    SwingUtilities.convertPointToScreen(location, composant);
    SwingUtilities.convertPointFromScreen(location, myGlass);

    //Les instructions ci-dessous permettent de redessiner le composant
    image = new BufferedImage(composant.getWidth(), composant.getHeight(), BufferedImage.TYPE_INT_ARGB);
    Graphics g = image.getGraphics();
    composant.paint(g);

    //On passe les données qui vont bien à notre GlassPane
    myGlass.setLocation(location);
    myGlass.setImage(image);

    //On n'oublie pas de dire à notre GlassPane de s'afficher
    myGlass.setVisible(true);
  }

  public void mouseReleased(MouseEvent event) {
    //---------------------------------------------------------------------
    //On implémente le transfert lorsqu'on relâche le bouton de souris
    //Ceci afin de ne pas supplanter le fonctionnement du déplacement
    JComponent lab = (JComponent)event.getSource();
    TransferHandler handle = lab.getTransferHandler();
    handle.exportAsDrag(lab, event, TransferHandler.COPY);
    //---------------------------------------------------------------------

    //On récupère le composant pour en déduire sa position
    Component composant = event.getComponent();
    Point location = (Point)event.getPoint().clone();
    //Les méthodes ci-dessous permettent, dans l'ordre, 
    //de convertir un point en coordonnées d'écran
    //et de reconvertir ce point en coordonnées fenêtre
    SwingUtilities.convertPointToScreen(location, composant);
    SwingUtilities.convertPointFromScreen(location, myGlass);

    //On passe les données qui vont bien à notre GlassPane
    myGlass.setLocation(location);
    myGlass.setImage(null);
    //On n'oublie pas de ne plus l'afficher
    myGlass.setVisible(false);

  }
}

//CTRL + SHIFT + O pour générer les imports
public class MouseGlassMotionListener extends MouseAdapter{

  private MyGlassPane myGlass;

  public MouseGlassMotionListener(MyGlassPane glass){
    myGlass = glass;
  }

  /**
  * Méthode fonctionnant sur le même principe que la classe précédente
  * mais cette fois sur l'action de déplacement
  */
  public void mouseDragged(MouseEvent event) {
    //Vous connaissez maintenant…
    Component c = event.getComponent();

    Point p = (Point) event.getPoint().clone();
    SwingUtilities.convertPointToScreen(p, c);
    SwingUtilities.convertPointFromScreen(p, myGlass);
    myGlass.setLocation(p);
    myGlass.repaint();
  }
}

//CTRL + SHIFT + O pour générer les imports
public class Fenetre extends JFrame{

  private MyGlassPane glass = new MyGlassPane();

  public Fenetre(){
    super("Test de GlassPane");
    setSize(400, 200);
    setLocationRelativeTo(null);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    JPanel pan = new JPanel();
    JPanel pan2 = new JPanel();

    //On crée un composant
    JButton bouton1 = new JButton("Bouton N°1");
    //On y attache les écouteurs qui auront pour rôle
    //d'initialiser notre glace et d'y affecter les données
    //qui permettront de simuler le déplacement
    bouton1.addMouseListener(new MouseGlassListener(glass));
    bouton1.addMouseMotionListener(new MouseGlassMotionListener(glass));
    //On affecte maintenant un TranferHandler spécifique
    //initialisé avec la propriété JavaBean "text" 
    bouton1.setTransferHandler(new TransferHandler("text"));

    JButton bouton2 = new JButton("Bouton N°2");
    bouton2.addMouseListener(new MouseGlassListener(glass));
    bouton2.addMouseMotionListener(new MouseGlassMotionListener(glass));
    bouton2.setTransferHandler(new TransferHandler("text"));

    JLabel text = new JLabel("Deuxième texte statique");
    text.addMouseListener(new MouseGlassListener(glass));
    text.addMouseMotionListener(new MouseGlassMotionListener(glass));
    text.setTransferHandler(new TransferHandler("text"));

    JLabel label = new JLabel("Texte statique !");
    label.addMouseListener(new MouseGlassListener(glass));
    label.addMouseMotionListener(new MouseGlassMotionListener(glass));
    label.setTransferHandler(new TransferHandler("text"));

    pan.add(bouton1);
    pan.add(label);
    add(pan, BorderLayout.NORTH);

    pan2.add(text);
    pan2.add(bouton2);
    add(pan2, BorderLayout.SOUTH);

    setGlassPane(glass);
    setLocationRelativeTo(null);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    setVisible(true);
  }

  public static void main(String[] args){
    new Fenetre();
  }   
}