Vue d'ensemble du glisser-déplacer

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.

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énements de cible de déplacement

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 :

1. Créez un nouvel objet de données qui contiendra uniquement les données vous souhaitez conserver.

2. "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.

3. 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.

Voir aussi

Référence

Clipboard

Autres ressources

Exemples de glisser-déplacer

Rubriques Comment relatives au glisser-déplacer

Glisser-déplacer