Déplacer et lâcher (drag and drop)

Lorsque vous utilisez le copier-coller pour transmettre des informations entre deux programmes, comme nous l'avons découvert dans l'étude précédente, le Presse-papiers sert d'intermédiaire. La méthaphore déplacer et lâcher supprime cet intermédiaire et permet à deux programmes de communiquer directement.

La plate-forme Java fournit un support simple du déplacer-lâcher, entre des applications Java et des applications natives. Cette étude vous montre comment écrire une application Java qui sert de cible (pour le "lâcher"), avec une autre application servant de source (pour le "déplacer").

Qu'est-ce que le déplacer et lâcher ?

Avant d'étudier plus en détail le support de la plate-forme Java pour le déplacer et lâcher, examinons rapidement son interface utilisateur. Nous utiliserons comme exemples l'explorateur de Windows et le programme WordPad.

Sur une autre plate-forme, vous pouvez faire les mêmes expériences sur des programmes natifs disposant des capacités de déplacer-lâcher.
§

Une opération "déplacer" est initiée par un mouvement à l'intérieur d'une source de déplacement. Traditionnellement, cela revient à sélectionner un ou plusieurs éléments, puis à les éloigner de leur position d'origine.

Lorsque vous relâchez le bouton de la souris au-dessus d'une cible qui accepte les opérations de "lâcher", cette cible demande à la source certaines opérations concernant les éléments déplacés, et elle commence diverses opérations :

Si vous lâchez une icône de fichier de l'explorateur de Windows dans Wordpad, ce dernier ouvre le fichier correspondant.
De même si vous amenez l'icône d'un fichier sur l'icône d'un répertoire dans l'explorateur, le fichier sera déplacé vers ce répertoire.
Si vous maintenez enfoncé la touche "Maj" ou "Ctrl" lorsque vous déplacez le curseur de la souris, le type de l'action passe d'un déplacement à une copie, et une copie de fichier est placée dans le répertoire.
Si vous maintenez enfoncées les touches "Maj" et "Ctrl", un raccourci vers ce fichier sera placé dans le répertoire.
Les autres plates-formes se servent éventuellement d'autres combinaisons de touches pour ces opérations.
§

Types d'actions

Par conséquent, il existe trois types d'actions, correspondant à trois mouvements :

Le but d'une création de raccourci est d'établir une référence vers l'élément sélectionné. Ces liens ont typiquement besoin d'un support du système d'exploitation hôte (comme des liens symboliques pour des fichiers, ou des liens objets pour les composants d'un document). De plus, ces liens ne sont généralement pas très intéressants pour des programmes travaillant sur plusieurs plates-formes. Pour cette étude, nous nous concentrerons sur l'utilisation du déplacer-lâcher pour copier et déplacer des données.

Tous les programmes ne permettent pas ces types d'actions. Par exemple, si vous amenez un fichier sur WordPad, ce dernier ignore le type d'action et se contente d'ouvrir le fichier.

Il existe généralement un indice visuel indiquant le type d'opération en cours. Au minimum, le curseur de la souris changera. Lorsque le curseur passe au-dessus de cibles éventuelles, sa forme indique si l'opération de lâcher est posible ou non. Si un lâcher est possible, la forme du curseur indique également le type d'action :

Il est également possible de déplacer des éléments en dehors des icônes de fichiers. Par exemple, vous pouvez sélectionner du texte dans WordPad et le déplacer. Essayer de déplacer des fragments de texte dans des cibles acceptant ces fragments et observez leur réaction.

Cette expérience montre un inconvénient du déplacer-lâcher comme mécanisme d'une interface utilisateur. Il peut être difficile de deviner quels éléments vous pouvez déplacer, les endroits sur lesquels vous pouvez les lâcher et ce qui se passe lorsque vous le faites. Comme l'action par défaut "déplacer" peut supprimer l'original, il est normal que la plupart des utilisateurs soient méfiants quant aux expériences de déplacer-lâcher.

Cibles de lâcher

Dans ce chapitre, nous allons construire une application Java simple qui sera la cible d'un lâcher. Le programme d'exemple ne fait rien de très élaboré, il démontre simplement comment détecter qu'un utilisateur veut initier une action de lâcher, comment accepter cette action et comment analyser les données lâchées.

Création de la cible

Pour cela, vous devez construire un objet java.awt.dnd.DropTarget et passer au constructeur le composant ainsi qu'un écouteur de cible de lâcher. Le constructeur enregistre alors l'objet avec le système de déplacer-lâcher :

Activation ou désactivation de la cible

Vous pouvez activer ou désactiver la cible avec la méthode setActive() de la classe DropTarget. Par défaut, la cible est active :

Définir le type d'action

Vous pouvez appeler la méthode setDefaultActions() de la classe DropTarget pour définir les opérations de lâcher que vous souhaitez accepter par défaut. Les opérations sont les suivantes :

Implémenter un écouteur sur le lâcher

Vous devez maintenant implémenter un écouteur de cible de lâcher. L'interface DropTargetListener possède cinq méthodes :

Les paramètres des méthodes de l'interface DropTargetListener

Examinez attentivement les paramètres des méthodes de l'interface DropTargetListener. Trois d'entre eux sont un DropTargetDragEvent. Cependant, la méthode drop() reçoit un DropTargetDroptEvent et la méthode dragExit() reçoit un DropTargetEvent.

Résumé sur la mise en oeuvre d'un écouteur de lâcher

Codage correspondant

Récupération des données

Une fois que vous avez accepté un lâcher, vous devez analyser les données de la source de déplacement. La méthode getTransferable() de la classe DropTargetDropEvent renvoie une référence vers un objet Transferable. C'est exactement la même interface que celle que nous avons utilisée pour le copier-coller.

Mise en oeuvre d'un lâcher de texte

Notre programme d'exemple ne fait rien de très élaboré. Il se contente de vous permettre de lâcher des éléments dans une zone de texte. Lorsque vous commencez à déplacer du texte au-dessus de la zone de texte, l'action de lâcher est affichée. Une fois que vous avez initié un lâcher, les données lâchées sont affichées. Si les données sont dans un format de texte, le programme lit à la fois les encodages ascii et unicode.

Dans notre programme d'exemple, nous ne fournissons aucun indice visuel, à part un curseur d'avertissement qui apparaît automatiquement lorsque vous appelez la méthode rejectDrag(). Par ailleurs, la zone de texte est implémentée par la classe JTextArea qui affiche automatiquement une icône spécifique au lâcher si les données sont acceptées, sans avoir à écrire une seule ligne de code particulière.

Le but de ce programme est simplement de vous fournir une cible de lâcher pour vos expérimentations. Essayez de lâcher un ensemble de fichiers texte ou un fragment de texte à partir d'un autre éditeur. Observez aussi comment une tentative de création de lien est rejetée. Si vous relâchez les touches "Maj" et "Ctrl", l'icône d'avertissement apparaît lorsque vous déplacez un élément vers la zone de texte.

A noter que la classe JTexteArea est déjà capable de faire un lâcher de texte issue d'un autre éditeur sans avoir rien à écrire de spécial. Par contre, le lâcher d'un fichier texte au-dessus de la zone d'édition n'est pas pris en compte.

codage correspondant

Autre exemple de mise en oeuvre

Un deuxième exemple permet de placer un fichier image sur la zone centrale de la fenêtre. Cette zone centrale est représentée par un JLabel qui est capable de gérer une icône, et par là une image.

codage correspondant

Sources de déplacement

Maintenant que nous savons comment implémenter un programme contenant une cible de lâcher, nous allons découvrir comment implémenter une source de déplacement.

Pour transformer un composant en source de déplacement, vous devez obtenir un objet de type java.awt.dnd.DragSource. Pour cela, il suffit d'appeler la méthode statique getDefaultDragSource() de cette classe DragSource. Ensuite, appelez la méthode createDefaultDragGestureReconizer() de cette même classe et passez-lui :

Le composant que vous souhaitez transformer en source de déplacement ;
les actions de lâcher que vous désirez autoriser ;
un objet qui implémente l'interface DragGestureListener.

DragSource source = DragSource.getDefaultDragSource();
source.createDefaultDragGestureReconizer(composant, DnDConstants.ACTION_COPY_OR_MOVE, écouteurGesture);

Interface DragGestureListener

L'interface DragGestureListener possède une seule méthode, dragGestureReconized(). L'identificateur de geste appelle cette méthode dès qu'il a remarqué que l'utilisateur souhaite initier une opération de déplacement.

Dans cette méthode, vous devez construire le Transferable qui sera la cible du lâcher dans sa méthode drop(). Une fois que vous avez assemblé le Tranferable, il suffit d'appeler la méthode startDrag() de la classe DragGestureEvent. Un curseur optionnel peut être fourni, ou null si vous préférez le curseur par défaut, suivi par le Transferable et par l'objet qui implémente l'interface DragSourceListener :

événement.startDrag(null, tranférable, écouteurSource);

Vous devez effectuer les opérations habituelles de définition d'une enveloppe Transferable.
§

L'écouteur de source du déplacement DragSourceListener

L'écouteur de la source du déplacement est averti à plusieurs reprises au cours de l'opération de déplacement. L'interface DragSourceListener possède cinq méthodes :

Les quatres premières méthodes peuvent être utilisées pour fournir des indices visuels quant aux opérations de déplacement. Cependant, de manière générale, ces indices reviennent à la cible du lâcher. Seule, la dernière méthode, dragDropEnd(), est très importante. Cette méthode est appelée lorsque la méthode drop() est terminée.

Pour une opération de déplacement, vous devrez vérifier que le lâcher s'est bien déroulé au moyen de la méthode getDropSuccess() de la classe DragSourceDropEvent. Dans ce cas, il faut mettre à jour la source du déplacement.
Pour une opération de copie, vous n'aurez probablement rien à faire.
Dans cette méthode dragDropEnd(), nous devons nous fonder sur la méthode drop() pour indiquer quel type de lâcher s'est réellement produit. Rappelez-vous que la méthode drop() peut modifier une action de déplacement en action de copie, si la source permet ces deux actions. La méthode getDropAction() de la classe DragSourceDropEvent renvoie alors l'action que la cible de lâcher a reçue lors de l'appel à la méthode acceptDrop() de la classe DropTargetDropEvent.
```
public void dragDropEnd(DragSourceDropEvent événement) {
   if (événement.getDropSuccess()) {
      int action = événement.getDropAction();
      if (action == DndConstanst.ACTION_MOVE)
         ...
   }
}
```

Attention : L'action par défaut est un déplacement. Si vous déplacez, par exemple, un fichier d'un composant de liste et que vous le lachiez dans l'explorateur, ce dernier déplace le fichier dans le répertoire cible et n'existe plus dans la source.

Java introduit une classe d'aide intitulé DragSourceAdapter qui implémente toutes les méthodes de l'interface DragSourceListener comme des méthodes inactives.
§

Exemple de mise en oeuvre

Je vous propose de reprendre l'ossature de l'application précédente. Cette fois-ci, il est possible de récupérer l'image qui se trouve sur la partie centrale de la fenêtre afin qu'elle puisse être utilisée par un autre programme capable de prendre en compte une image par glisser-déposer.

codage correspondant

Les composants Swing

Les composants Swing possèdent un support intégré pour le transfert de données qui permet de libérer les programmeurs d'une grande partie de la tâche consistant à implémenter le copier-coller ou le déplacer-lâcher.

Le tableau ci-dessous résume les composants Swing qui sont sources et cibles du transfert de données. Les raccourcis clavier standards pour "Couper", "Copier" et "Coller" sont activés pour tous les composants à l'exception de JColorChooser. Le déplacement n'est pas activé par défaut. Vous devez appeler la méthode setDragEnabled() pour l'activer.

Composant	Source de transfert	Cible de transfert
JFileChooser	Exporte la liste des fichiers	Non admis.
JColorChooser	Exporte la référence locale à l'objet Color	Accepte n'importe quel objet Color
JTextField JFormattedTextField	Exporte le texte sélectionné	Accepte le texte
JPasswordField	Non admis (pour des raisons de sécurité)	Accepte le texte
JTextArea JTextPane JEditorPane	Exporte le texte sélectionné	Accepte le texte et les listes de fichiers. Le texte est inséré. Les fichiers sont ouverts.
JList	Exporte la description HTML d'une sélection	Non admis.

Le paquetage de Swing fournit un mécanisme assez utile pour transformer rapidement un composant en cible de lâcher. Si le composant possède une méthode :

void setName(Type t)

Vous la transformez ensuite en cible de lâcher pour les types de données avec une classe de représentation Type en appelant simplement la méthode :

composant.setTransferHandler("nom"); // "nom" représente le nom de la propriété du composant que l'on désire utiliser

Au moment du lâcher, le gestionnaire vérifie alors si l'un des types de données possède une classe de représentation Type. Si c'est le cas, il appelle la méthode setName().

Supposons, par exemple, que vous souhaitiez utiliser le déplacer-lâcher pour modifier la couleur de fond d'un champ de texte. Vous avez besoin d'un gestionnaire de transfert qui invoque la méthode :

void setBackground(Color couleur)

lorsqu'un objet Color est déplacé sur le champ de texte. Appelez simplement :

champTexte.setTransferHandler(new TransferHandler("background"));

Attention, en installant ce gestionnaire de transfert dans le champ de texte, vous désactivez le gestionnaire de transfert standard. Vous ne pouvez plus couper, copier, déplacer ou lâcher du texte dans le champ de texte. Un composant Swing peut uniquement disposer d'un gestionnaire de transfert.

L'exemple suivant montre ce comportement. Comme nous pouvons le voir, le haut du bloc contient un sélecteur de couleur, alors qu'un champ de texte se trouve en bas du bloc contenant le message "Faites glisser la couleur ici". Vous devez faire glisser la couleur depuis l'intérieur du panneau "Aperçu", et non à partir des nuances des couleurs. Lorsque vous la faites glisser dans le champ de texte, son fond change de couleur.

codage correspondant

package déplacer;

import java.awt.*;
import javax.swing.*;

public class Lâcher extends JFrame {
   private JTextField saisie = new JTextField("Faites glisser la couleur ici");
   private JColorChooser choix = new JColorChooser();
   
   public Lâcher() {
      super("Lâcher de couleur");      
      choix.setDragEnabled(true);
      add(choix);
      saisie.setDragEnabled(true);
      saisie.setTransferHandler(new TransferHandler("background"));
      add(saisie, BorderLayout.SOUTH);
      pack();
      setDefaultCloseOperation(EXIT_ON_CLOSE);
      setVisible(true);
   }

   public static void main(String[] args) { new Lâcher(); }
}