Vue d'ensemble du glisser-déplacer

Article
08/22/2008

Mise à jour : novembre 2007

Cette rubrique fournit une vue d'ensemble de la prise en charge du glisser-déplacer dans les applications Windows Presentation Foundation (WPF). Le glisser-déplacer fait généralement référence à une méthode d'interaction interface utilisateur (UI) qui implique l'utilisation d'une souris (ou d'un autre dispositif de pointage) pour sélectionner un ou plusieurs objets, les faire glisser sur une cible de déplacement souhaitée dans l'interface utilisateur, et les y déplacer.

Cette rubrique comprend les sections suivantes.

Prise en charge du glisser-déplacer dans WPF
Données et objets de données
Événements glisser-déplacer
Utilisation d'objets de données
Rubriques connexes

Prise en charge du glisser-déplacer dans WPF

Les opérations de glisser-déplacer impliquent en général deux parties : une source de glissement d'où provient l'objet déplacé, et une cible de déplacement qui reçoit l'objet glissé. La source de glissement et la cible de déplacement peuvent être la même application ou une application différente.

Le type et le nombre d'objets pouvant être manipulés avec le glisser-déplacer sont complètement arbitraires ; un ou plusieurs fichiers ou dossiers, et les sélections de contenu sont quelques-uns des objets les plus courants manipulés à travers des opérations de glisser-déplacer. La ou les actions particulières exécutées pendant une opération de glisser-déplacer sont spécifiques à une application, et souvent déterminées par contexte. Par exemple, le glissement d'une sélection de fichiers d'un dossier vers un autre sur les mêmes périphériques de stockage déplace les fichiers par défaut, alors que le glissement des fichiers d'un partage UNC (Universal Naming Convention) vers un dossier local copie les fichiers par défaut. Les fonctionnalités de glisser-déplacer fournies par le WPF sont conçues pour être très flexibles et personnalisables afin de prendre en charge une large gamme de scénarios de glisser-déplacer. Le glisser-déplacer prend en charge la manipulation d'objets dans une seule application, ou entre plusieurs applications ; le glisser-déplacer entre les applications WPF et d'autres applications Windows sont également prises en charge intégralement. Le glisser-déplacer tombe dans le domaine plus général du transfert de données ; en plus du glisser-déplacer, le transfert de données comprend également l'utilisation du Presse-papiers du système pour les opérations de copier-coller.

Remarque de sécurité : le glisser-déplacer OLE ne fonctionne pas dans la zone Internet.

Données et objets de données

Les données transférées dans le cadre d'une opération de glisser-déplacer sont stockées dans un objet de données. Conceptuellement, un objet de données se compose d'une ou plusieurs paires :

d'Object contenant les données actuelles et
d'identificateurs de format de données correspondants.

Les données en elle-même peuvent se composer de tout ce qui peut être représenté comme un Objectde base. Le format de données correspondant est une chaîne ou Type qui fournit un conseil à propos du format dans lequel se trouvent les données. Les objets de données prennent en charge l'hébergement de paires de données (format de données) ; cela permet à un objet de données unique de fournir des données dans de multiples formats.

Tous les objets de données doivent implémenter l'interface IDataObject qui fournit le jeu standard de méthodes suivant qui activent et facilitent le transfert de données.

Méthode	Résumé
GetData	Récupère un objet de données dans un format de données spécifié.
GetDataPresent	Vérifie si les données sont disponibles dans un format spécifié ou peuvent être converties en un format spécifié.
GetFormats	Retourne une liste de formats dans lesquels sont stockées les données de cet objet de données ou vers lesquels elles peuvent être converties.
SetData	Stocke les données spécifiées dans cet objet de données.

WPF fournit une implémentation de base de IDataObject dans la classe DataObject ; la classe stock DataObject est suffisante pour de nombreux scénarios de transfert de données courants.

Pour plus d'informations sur les formats de données prédéfinis fournis avec WPF, consultez la rubrique de référence de la classe DataFormats.

Les objets de données incluent couramment une fonctionnalité pour convertir automatiquement les données stockées dans un format vers un format différent pendant l'extraction des données ; cette fonctionnalité est appelée conversion automatique.

Lors de l'interrogation des formats de données disponibles dans un objet de données, les formats de données convertibles automatiquement peuvent être filtrés à partir des formats de données natifs en appelant le GetFormats(Boolean) ou la méthode GetDataPresent(String, Boolean) en spécifiant pour le paramètre autoConvert la valeur false. Lors de l'ajout de données à un objet de données avec la méthode SetData(String, Object, Boolean), la conversion de données automatique peut être interdite en définissant le paramètre autoConvert avec la valeur false.

Événements glisser-déplacer

Les opérations de glisser-déplacer prennent en charge un modèle piloté par un événement. La source de glissement et la cible de déplacement utilisent tous deux un ensemble standard d'événements pour gérer les opérations de glisser-déplacer. Les tables suivantes résument les événements glisser-déplacer standard.

Événements de source de glissement

Événement	Résumé
GiveFeedback	Cet événement se produit lorsqu'une opération de glisser-déplacer est démarrée, et permet à la cible de déplacement d'envoyer des informations de commentaires à la source de glissement ; ces commentaires sont couramment utilisés par la source de glissement pour ajuster dynamiquement l'apparence du pointeur de la souris pour que l'utilisateur dispose des commentaires. Il s'agit d'une propagation d'événements.
QueryContinueDrag	Cet événement se produit lorsqu'il y a une modification dans les états du clavier ou du bouton de la souris pendant une opération de glisser-déplacer, et permet à la source de déplacement d'annuler l'opération de glisser-déplacer selon les états de la touche/du bouton. Il s'agit d'une propagation d'événements.
PreviewGiveFeedback	Version tunneling de GiveFeedback.
PreviewQueryContinueDrag	Version tunneling de QueryContinueDrag.

Événements de cible de déplacement

Événement	Résumé
DragEnter	Cet événement se produit lorsque vous faites glisser un objet dans les limites de la cible de déplacement. Il s'agit d'une propagation d'événements.
DragLeave	Cet événement se produit lorsque vous faites glisser un objet hors des limites de la cible de déplacement. Il s'agit d'une propagation d'événements.
DragOver	Cet événement se produit lorsque vous faites glisser (déplacer) un objet à l'intérieur des limites de la cible de déplacement. Il s'agit d'une propagation d'événements.
Drop	Cet événement se produit lorsqu'un objet est déplacé sur la cible de déplacement. Il s'agit d'une propagation d'événements.
PreviewDragEnter	Version tunneling de DragEnter.
PreviewDragLeave	Version tunneling de DragLeave.
PreviewDragOver	Version tunneling de DragOver.
PreviewDrop	Version tunneling de Drop.

Utilisation d'objets de données

Cette section décrit les techniques courantes permettant de créer et d'utiliser des objets de données.

Utilisation des constructeurs DataObject

La classe DataObject fournit plusieurs constructeurs surchargés qui facilitent le remplissage d'une nouvelle instance DataObject avec une paire de données (format de données) unique.

L'exemple de code suivant crée un nouvel objet de données et utilise l'un des constructeurs surchargés (DataObject(String, Object)) pour initialiser l'objet de données à l'aide d'une chaîne et d'un format de données spécifié. Dans ce cas, le format de données est spécifié par une chaîne ; la classe DataFormats fournit un ensemble de chaînes de type prédéfinies. La conversion automatique des données stockées est autorisée par défaut.

string stringData = "Some string data to store...";
string dataFormat = DataFormats.UnicodeText;
DataObject dataObject = new DataObject(dataFormat, stringData);

Pour obtenir plus d'exemples de code créant un objet de donnée, consultez Comment : créer un objet de données.

Stockage de données dans plusieurs formats

Un objet de données unique est en mesure de stocker des données dans plusieurs formats. L'utilisation stratégique de plusieurs formats de données dans un objet de données unique rend potentiellement l'objet de données utilisable par une variété plus large de cibles de déplacement, seulement si un format de données unique pouvait être représenté. Notez qu'en général, une source de glissement doit être agnostique concernant les formats de données utilisables par des cibles de déplacement potentielles.

L'exemple suivant indique comment utiliser la méthode SetData(String, Object) pour ajouter des données à un objet de données dans plusieurs formats.

DataObject dataObject = new DataObject();
string sourceData = "Some string data to store...";

// Encode the source string into Unicode byte arrays.
byte[] unicodeText = Encoding.Unicode.GetBytes(sourceData); // UTF-16
byte[] utf8Text = Encoding.UTF8.GetBytes(sourceData);
byte[] utf32Text = Encoding.UTF32.GetBytes(sourceData);

// The DataFormats class does not provide data format fields for denoting
// UTF-32 and UTF-8, which are seldom used in practice; the following strings 
// will be used to identify these "custom" data formats.
string utf32DataFormat = "UTF-32";
string utf8DataFormat  = "UTF-8";

// Store the text in the data object, letting the data object choose
// the data format (which will be DataFormats.Text in this case).
dataObject.SetData(sourceData);
// Store the Unicode text in the data object.  Text data can be automatically
// converted to Unicode (UTF-16 / UCS-2) format on extraction from the data object; 
// Therefore, explicitly converting the source text to Unicode is generally unnecessary, and
// is done here as an exercise only.
dataObject.SetData(DataFormats.UnicodeText, unicodeText);
// Store the UTF-8 text in the data object...
dataObject.SetData(utf8DataFormat, utf8Text);
// Store the UTF-32 text in the data object...
dataObject.SetData(utf32DataFormat, utf32Text);

Interrogation d'un objet de données pour les formats disponibles

Du fait qu'un objet de données unique peut contenir un nombre arbitraire de formats de données, les objets de données comportent des fonctionnalités pour la récupération d'une liste de formats de données disponibles.

L'exemple de code la surcharge GetFormats pour obtenir un tableau de chaînes qui dénote tous les formats de données disponibles dans un objet de données (à la fois natif et convertible automatiquement).

DataObject dataObject = new DataObject("Some string data to store...");

// Get an array of strings, each string denoting a data format
// that is available in the data object.  This overload of GetDataFormats
// returns all available data formats, native and auto-convertible.
string[] dataFormats = dataObject.GetFormats();

// Get the number of data formats present in the data object, including both
// auto-convertible and native data formats.
int numberOfDataFormats = dataFormats.Length;

// To enumerate the resulting array of data formats, and take some action when
// a particular data format is found, use a code structure similar to the following.
foreach (string dataFormat in dataFormats)
{
    if (dataFormat == DataFormats.Text)
    {
        // Take some action if/when data in the Text data format is found.
        break;
    }
    else if(dataFormat == DataFormats.StringFormat)
    {
        // Take some action if/when data in the string data format is found.
        break;
    }
}

Pour obtenir plus d'exemples de code interrogeant un objet de données pour les formats de données disponibles, consultez Comment : répertorier les formats de données dans un objet de données. Pour les exemples d'interrogation d'un objet de données pour la présence d'un format de données particulier, consultez Comment : déterminer si un format de données est présent dans un objet de données.

Récupération des données d'un objet de données

La récupération des données d'un objet de donnée dans un format particulier implique simplement l'appel de l'une des méthodes GetData et la spécification du format de données désiré. L'une des méthodes GetDataPresent peut être utilisée pour vérifier la présence d'un format de données particulier. GetData retourne les données dans un Object ; selon le format de données, cet objet peut faire l'objet d'un cast sur un conteneur de type spécifique.

L'exemple de code suivant utilise la surcharge GetDataPresent(String) pour vérifier en premier si un format de données spécifié est disponible (en mode natif ou par conversion automatique). Si le format spécifié est disponible, l'exemple récupère les données en utilisant la méthode GetData(String).

DataObject dataObject = new DataObject("Some string data to store...");

string desiredFormat = DataFormats.UnicodeText;
byte[] data = null;

// Use the GetDataPresent method to check for the presence of a desired data format.
// This particular overload of GetDataPresent looks for both native and auto-convertible 
// data formats.
if (dataObject.GetDataPresent(desiredFormat))
{
    // If the desired data format is present, use one of the GetData methods to retrieve the
    // data from the data object.
    data = dataObject.GetData(desiredFormat) as byte[];
}

Pour obtenir plus d'exemples de code récupérant des données d'un objet de données, consultez Comment : récupérer des données dans un format de données particulier.

Suppression de données d'un objet de données

Les données ne peuvent pas être supprimées directement d'un objet de données. Pour supprimer efficacement des données d'un objet de données, suivez les étapes suggérées suivantes :

Créez un nouvel objet de données qui contiendra uniquement les données vous souhaitez conserver.
"Copiez" les données désirées de l'ancien vers le nouvel objet de données. Pour copier les données, utilisez l'une des méthodes GetData pour récupérer un Object qui contient les données brutes, puis utilisez l'une des méthodes SetData pour ajouter les données au nouvel objet de données.
Remplacez l'ancien objet de données par le nouveau.

Remarque :
Les méthodes SetData ajoutent seulement des données à un objet de données ; ils ne remplacent pas de données, même si les données et le format de données sont exactement les mêmes qu'un appel précédent. Appeler deux fois SetData pour les mêmes données et format de données provoquera un format de données-données en double dans l'objet de données.