Cenni preliminari sul trascinamento della selezione

Questo argomento offre una panoramica del supporto per il trascinamento della selezione nelle applicazioni Windows Presentation Foundation (WPF). Il trascinamento della selezione si riferisce in genere a un metodo di trasferimento dei dati che prevede l'uso di un mouse (o di un altro dispositivo di puntamento) per selezionare uno o più oggetti, trascinando questi oggetti su una destinazione di rilascio desiderata nell'interfaccia utente e rilasciandoli.

Supporto del trascinamento della selezione in WPF

Nelle operazioni di trascinamento della selezione in genere sono coinvolte due parti: un'origine di trascinamento da cui ha origine l'oggetto trascinato e un obiettivo di rilascio che riceve l'oggetto rilasciato. L'origine di trascinamento e l'obiettivo di rilascio possono essere elementi dell'interfaccia utente della stessa applicazione o di un'applicazione diversa.

Il tipo e il numero di oggetti che possono essere manipolati con un trascinamento della selezione sono del tutto arbitrari. Ad esempio file, cartelle e selezioni di contenuto sono alcuni degli oggetti più comuni manipolati con operazioni di trascinamento della selezione.

Le particolari azioni eseguite durante un'operazione di trascinamento della selezione sono specifiche dell'applicazione e spesso dipendono dal contesto. Ad esempio, il trascinamento di una selezione di file da una cartella a un'altra nello stesso dispositivo di archiviazione sposta i file per impostazione predefinita, mentre il trascinamento dei file da una condivisione UNC (Universal Naming Convention) in una cartella locale copia i file per impostazione predefinita.

Le funzionalità di trascinamento della selezione fornite da WPF sono progettate per essere altamente flessibili e personalizzabili per supportare un'ampia gamma di scenari di trascinamento della selezione. Il trascinamento della selezione supporta la manipolazione di oggetti in una sola applicazione o tra applicazioni diverse. Anche il trascinamento della selezione tra applicazioni WPF e altre applicazioni Windows è completamente supportato.

In WPF qualsiasi UIElement elemento o ContentElement può partecipare al trascinamento della selezione. Gli eventi e i metodi necessari per le operazioni di trascinamento della selezione vengono definiti nella classe DragDrop. Le classi UIElement e ContentElement contengono alias per gli eventi associati DragDrop in modo che gli eventi appaiano nell'elenco dei membri della classe quando un oggetto UIElement o ContentElement viene ereditato come elemento di base. I gestori eventi associati a questi eventi vengono associati all'evento associato DragDrop sottostante e ricevono la stessa istanza di dati dell'evento. Per altre informazioni, vedere l'evento UIElement.Drop.

Trasferimento dati

Il trascinamento della selezione rientra nell'ambito del trasferimento dei dati. Il trasferimento dei dati include operazioni di trascinamento della selezione e di copia e incolla. Un'operazione di trascinamento della selezione è analoga a un'operazione di copia e incolla o taglia e incolla usata per trasferire dati da un oggetto o un'applicazione a un'altra usando gli Appunti di sistema. Entrambi i tipi di operazioni richiedono:

• Un oggetto di origine che fornisce i dati.

• Un modo per archiviare temporaneamente i dati trasferiti.

• Un oggetto di destinazione che riceve i dati.

In un'operazione di copia e incolla, vengono usati gli Appunti di sistema per archiviare temporaneamente i dati trasferiti. In un'operazione di trascinamento della selezione, viene usato un oggetto DataObject per archiviare i dati. Concettualmente, un oggetto dati è costituito da una o più coppie di un Object contenente i dati effettivi e dal corrispondente identificatore di formato dati.

L'origine di trascinamento avvia un'operazione di trascinamento della selezione chiamando il metodo DragDrop.DoDragDrop statico e passandogli i dati trasferiti. Il metodo DoDragDrop eseguirà il wrapping automatico dei dati in DataObject, se necessario. Per un maggiore controllo sul formato dei dati, è possibile eseguire il wrapping dei dati in un DataObject prima di passarli al metodo DoDragDrop. L'obiettivo di rilascio è responsabile dell'estrazione dei dati dal DataObject. Per altre informazioni sull'uso degli oggetti dati, vedere Dati e oggetti dati.

L'origine e la destinazione di un'operazione di trascinamento della selezione sono elementi dell'interfaccia utente, ma i dati effettivamente trasferiti non hanno di solito una rappresentazione visiva. È possibile scrivere il codice per fornire una rappresentazione visiva dei dati trascinati, come accade quando si trascinano i file in Esplora risorse. Per impostazione predefinita, viene fornito un feedback all'utente modificando il cursore per rappresentare l'effetto che l'operazione di trascinamento della selezione avrà sui dati, ad esempio se i dati verranno spostati o copiati.

Effetti di trascinamento della selezione

Le operazioni di trascinamento della selezione possono avere effetti diversi sui dati trasferiti. Ad esempio, è possibile copiare i dati oppure spostarli. WPF definisce un'enumerazione DragDropEffects che è possibile usare per specificare l'effetto di un'operazione di trascinamento della selezione. Nell'origine di trascinamento, è possibile specificare gli effetti che verranno consentiti dall'origine nel metodo DoDragDrop. Nell'obiettivo di rilascio, è possibile specificare l'effetto previsto per la destinazione nella proprietà Effects della classe DragEventArgs. Quando l'obiettivo di rilascio specifica l'effetto previsto nell'evento DragOver, queste informazioni vengono passate nuovamente all'origine di trascinamento nell'evento GiveFeedback. L'origine di trascinamento usa queste informazioni per informare l'utente dell'effetto sui dati previsto per l'obiettivo di rilascio. Quando i dati vengono rilasciati, l'obiettivo di rilascio specifica il vero e proprio effetto nell'evento Drop. Queste informazioni vengono passate all'origine di trascinamento come valore restituito del metodo DoDragDrop. Se l'obiettivo di trascinamento restituisce un effetto non presente nell'elenco di origini di trascinamento di allowedEffects, l'operazione di trascinamento della selezione viene annullata e il trasferimento dati non viene eseguito.

È importante ricordare che in WPF i DragDropEffects valori vengono usati solo per fornire la comunicazione tra l'origine di trascinamento e la destinazione di rilascio per quanto riguarda gli effetti dell'operazione di trascinamento della selezione. L'effetto vero e proprio dell'operazione di trascinamento della selezione dipende dal codice scritto nell'applicazione.

L'obiettivo di rilascio, ad esempio, potrebbe specificare che l'effetto di rilascio dei dati è lo spostamento dei dati. Tuttavia, per spostare i dati, è necessario sia aggiungerli all'elemento di destinazione che rimuoverli dall'elemento di origine. L'elemento di origine potrebbe indicare che consente lo spostamento dei dati, ma, se non si specifica il codice per rimuovere i dati dall'elemento di origine, come risultato finale i dati verranno copiati e non spostati.

Eventi del trascinamento della selezione

Le operazioni di trascinamento della selezione supportano un modello basato sugli eventi. Sia l'origine di trascinamento che l'obiettivo di rilascio usano un set standard di eventi per gestire le operazioni di trascinamento della selezione. Le tabelle seguenti riepilogano gli eventi di trascinamento della selezione standard. Sono eventi associati nella DragDrop classe. Per altre informazioni sugli eventi associati, vedere Cenni preliminari sugli eventi associati.

Eventi di origine di trascinamento

Eventi dell'obiettivo di rilascio

Per gestire gli eventi di trascinamento della selezione per le istanze di un oggetto, aggiungere i gestori per gli eventi elencati nelle tabelle precedenti. Per gestire gli eventi di trascinamento della selezione a livello di classe, eseguire l'override dei metodi On*Event e On*PreviewEvent corrispondenti. Per altre informazioni, vedere Gestione delle classi degli eventi indirizzati tramite classi di base dei controlli.

Implementazione del trascinamento della selezione

Un elemento dell'interfaccia utente può essere un'origine di trascinamento, un obiettivo di rilascio o entrambi. Per implementare il trascinamento della selezione di base, è necessario scrivere il codice per avviare l'operazione di trascinamento e per elaborare i dati rilasciati. È possibile migliorare l'esperienza di trascinamento della selezione gestendo gli eventi di trascinamento facoltativi.

Per implementare il trascinamento della selezione di base, completare le seguenti attività:

• Identificare l'elemento che sarà un'origine di trascinamento. Un'origine di trascinamento può essere un oggetto UIElement o ContentElement.

• Creare un gestore eventi nell'origine di trascinamento che avvierà l'operazione di trascinamento della selezione. L'evento è in genere MouseMove.

• Nel gestore eventi dell'origine di trascinamento chiamare il metodo DoDragDrop per avviare l'operazione di trascinamento della selezione. Nella chiamata a DoDragDrop specificare l'origine di trascinamento, i dati da trasferire e gli effetti consentiti.

• Identificare l'elemento che sarà un obiettivo di rilascio. Un obiettivo di rilascio può essere un oggetto UIElement o ContentElement.

• Nell'obiettivo di rilascio impostare la proprietà AllowDrop su true.

• Nell'obiettivo di rilascio creare un gestore dell'evento Drop per elaborare i dati rilasciati.

• Nel gestore dell'evento Drop estrarre i dati da DragEventArgs usando i metodi GetDataPresent e GetData.

• Nel gestore dell'evento Drop usare i dati per eseguire l'operazione di trascinamento della selezione desiderata.

È possibile migliorare l'implementazione del trascinamento della selezione creando un DataObject personalizzato e gestendo eventi di origine di trascinamento e obiettivo di rilascio facoltativi, come mostrato nelle attività seguenti:

• Per trasferire dati personalizzati o più elementi di dati, creare un DataObject da passare al metodo DoDragDrop.

• Per eseguire azioni aggiuntive durante un trascinamento, gestire gli eventi DragEnter, DragOver e DragLeave nell'obiettivo di rilascio.

• Per modificare l'aspetto del puntatore del mouse, gestire l'evento GiveFeedback nell'origine di trascinamento.

• Per modificare la modalità con cui annullare l'operazione di trascinamento della selezione, gestire l'evento QueryContinueDrag nell'origine di trascinamento.

Esempi di trascinamento della selezione

Questa sezione descrive come implementare il trascinamento della selezione per un elemento Ellipse. Ellipse è sia un'origine di trascinamento che un obiettivo di rilascio. I dati trasferiti sono la rappresentazione di stringa della proprietà Fill dell'ellisse. Il codice XAML seguente mostra l'elemento Ellipse e gli eventi relativi al trascinamento della selezione gestiti. Per i passaggi completi per implementare il trascinamento della selezione, vedere Procedura dettagliata: abilitare il trascinamento della selezione in un controllo utente.

<Ellipse Height="50" Width="50" Fill="Green"
     MouseMove="ellipse_MouseMove"
     GiveFeedback="ellipse_GiveFeedback"
     AllowDrop="True"
     DragEnter="ellipse_DragEnter" DragLeave="ellipse_DragLeave"
     DragOver="ellipse_DragOver" Drop="ellipse_Drop" />

Impostazione di un elemento come origine di trascinamento

Un oggetto che è un'origine di trascinamento è responsabile di:

• Identificare quando si verifica un trascinamento.

• Avviare l'operazione di trascinamento della selezione.

• Identificare i dati da trasferire.

• Specificare gli effetti che l'operazione di trascinamento della selezione può avere sui dati trasferiti.

L'origine di trascinamento può anche fornire all'utente feedback relativo alle azioni consentite (spostamento, copia, nessuna) e può annullare l'operazione di trascinamento della selezione in base a un input utente aggiuntivo, ad esempio la pressione di ESC durante il trascinamento.

È responsabilità dell'applicazione determinare quando si verifica un trascinamento e quindi avviare l'operazione di trascinamento della selezione chiamando il metodo DoDragDrop. Questo di solito avviene quando si verifica un evento MouseMove sull'elemento da trascinare mentre viene premuto un pulsante del mouse. Il seguente esempio mostra come avviare un'operazione di trascinamento e rilascio dal gestore dell'evento MouseMove di un elemento Ellipse per impostarlo come origine di trascinamento. I dati trasferiti sono la rappresentazione di stringa della proprietà Fill dell'ellisse.

private void ellipse_MouseMove(object sender, MouseEventArgs e)
{
    Ellipse ellipse = sender as Ellipse;
    if (ellipse != null && e.LeftButton == MouseButtonState.Pressed)
    {
        DragDrop.DoDragDrop( ellipse,
                             ellipse.Fill.ToString(),
                             DragDropEffects.Copy);
    }
}

Private Sub Ellipse_MouseMove(ByVal sender As System.Object, ByVal e As System.Windows.Input.MouseEventArgs)
    Dim ellipse = TryCast(sender, Ellipse)
    If ellipse IsNot Nothing AndAlso e.LeftButton = MouseButtonState.Pressed Then
        DragDrop.DoDragDrop(ellipse, ellipse.Fill.ToString(), DragDropEffects.Copy)
    End If
End Sub

Nel gestore dell'evento MouseMove chiamare il metodo DoDragDrop per avviare l'operazione di trascinamento della selezione. Il metodo DoDragDrop accetta tre parametri:

• dragSource: riferimento all'oggetto dipendenza che è l'origine dei dati trasferiti. Di solito è l'origine dell'evento MouseMove.

• data: oggetto contenente i dati trasferiti, di cui è stato eseguito il wrapping in un DataObject.

• allowedEffects: uno dei valori dell'enumerazione DragDropEffects, che specifica gli effetti consentiti dell'operazione di trascinamento della selezione.

Qualsiasi oggetto serializzabile può essere passato nel parametro data. Se il wrapping dei dati non è già stato eseguito in un DataObject, verrà eseguito automaticamente in un nuovo DataObject. Per passare più elementi di dati, è necessario creare il DataObject manualmente e passarlo al metodo DoDragDrop. Per altre informazioni, vedere Dati e oggetti dati.

Il parametro allowedEffects viene usato per specificare quali azioni l'origine di trascinamento consentirà di eseguire all'obiettivo di rilascio con i dati trasferiti. I valori comuni per un'origine di trascinamento sono Copy, Move e All.

Un'origine di trascinamento può facoltativamente gestire gli eventi GiveFeedback e QueryContinueDrag. Questi eventi hanno gestori predefiniti che vengono usati solo se non si contrassegnano gli eventi come gestiti. In genere si ignorano questi eventi a meno che non esista un'esigenza specifica di modificarne il comportamento predefinito.

L'evento GiveFeedback viene generato continuamente mentre l'origine di trascinamento viene trascinata. Il gestore predefinito per questo evento controlla se l'origine di trascinamento sia su un obiettivo di rilascio valido. Se lo è, controlla gli effetti consentiti dell'obiettivo di rilascio. Fornisce quindi feedback all'utente finale sugli effetti di rilascio consentiti. A questo scopo il cursore del mouse viene in genere sostituito con un cursore di non rilascio, di copia o di spostamento. Si dovrebbe gestire questo evento solo se è necessario usare cursori personalizzati per fornire feedback all'utente. Se si gestisce questo evento, assicurarsi di contrassegnarlo come gestito in modo che il gestore predefinito non esegua l'override del gestore.

L'evento QueryContinueDrag viene generato continuamente mentre l'origine di trascinamento viene trascinata. È possibile gestire questo evento per determinare quale azione termina l'operazione di trascinamento e rilascio in base allo stato dei tasti ESC, MAIUSC, CTRL e ALT, oltre che allo stato dei pulsanti del mouse. Il gestore predefinito per questo evento annulla l'operazione di trascinamento della selezione se viene premuto ESC e rilascia i dati se il pulsante del mouse viene rilasciato.

Impostazione di un elemento come obiettivo di rilascio

Un oggetto che è un obiettivo di rilascio è responsabile di:

• Specificare che è un obiettivo di rilascio valido.

• Rispondere all'origine di trascinamento quando viene trascinata sulla destinazione.

• Controllare che i dati trasferiti siano in un formato che può ricevere.

• Elaborare i dati rilasciati.

Per specificare che un elemento è un obiettivo di rilascio, si imposta la proprietà AllowDrop su true. Gli eventi dell'obiettivo di rilascio verranno quindi generati nell'elemento per poterli gestire. Durante un'operazione di trascinamento della selezione, nell'obiettivo di rilascio si verifica la sequenza di eventi seguente:

1. DragEnter

2. DragOver

3. DragLeave oppure Drop

L'evento DragEnter si verifica quando i dati vengono trascinati entro il limite dell'obiettivo di rilascio. In genere si gestisce questo evento per fornire un'anteprima degli effetti dell'operazione di trascinamento e rilascio, se appropriato per l'applicazione. Non impostare la proprietà DragEventArgs.Effects nell'evento DragEnter, perché verrà sovrascritta nell'evento DragOver.

Il seguente esempio mostra il gestore dell'evento DragEnter per un elemento Ellipse. Questo codice visualizza in anteprima gli effetti dell'operazione di trascinamento della selezione salvando il pennello Fill corrente. Usa quindi il metodo GetDataPresent per controllare se il DataObject che viene trascinato sull'ellisse contiene dati stringa convertibili in un Brush. In tal caso, i dati vengono estratti con il metodo GetData. Vengono quindi convertiti in un Brush e applicati all'ellisse. La modifica viene ripristinata nel gestore dell'evento DragLeave. Se i dati non possono essere convertiti in un Brush, non viene eseguita alcuna azione.

private Brush _previousFill = null;
private void ellipse_DragEnter(object sender, DragEventArgs e)
{
    Ellipse ellipse = sender as Ellipse;
    if (ellipse != null)
    {
        // Save the current Fill brush so that you can revert back to this value in DragLeave.
        _previousFill = ellipse.Fill;

        // If the DataObject contains string data, extract it.
        if (e.Data.GetDataPresent(DataFormats.StringFormat))
        {
            string dataString = (string)e.Data.GetData(DataFormats.StringFormat);

            // If the string can be converted into a Brush, convert it.
            BrushConverter converter = new BrushConverter();
            if (converter.IsValid(dataString))
            {
                Brush newFill = (Brush)converter.ConvertFromString(dataString);
                ellipse.Fill = newFill;
            }
        }
    }
}

Private _previousFill As Brush = Nothing
Private Sub Ellipse_DragEnter(ByVal sender As System.Object, ByVal e As System.Windows.DragEventArgs)
    Dim ellipse = TryCast(sender, Ellipse)
    If ellipse IsNot Nothing Then
        ' Save the current Fill brush so that you can revert back to this value in DragLeave.
        _previousFill = ellipse.Fill

        ' If the DataObject contains string data, extract it.
        If e.Data.GetDataPresent(DataFormats.StringFormat) Then
            Dim dataString = e.Data.GetData(DataFormats.StringFormat)

            ' If the string can be converted into a Brush, convert it.
            Dim converter As New BrushConverter()
            If converter.IsValid(dataString) Then
                Dim newFill As Brush = CType(converter.ConvertFromString(dataString), Brush)
                ellipse.Fill = newFill
            End If
        End If
    End If
End Sub

L'evento DragOver si verifica in modo continuo mentre i dati vengono trascinati sull'obiettivo di rilascio. Questo evento è associato all'evento GiveFeedback nell'origine di trascinamento. Nel gestore dell'evento DragOver, si usano di solito i metodi GetDataPresent e GetData per controllare se i dati trasferiti sono in un formato che l'obiettivo di rilascio può elaborare. È anche possibile controllare se vengono premuti tasti di modifica, che in genere indicano se l'utente intende eseguire un'azione di copia o spostamento. Dopo questi controlli, si imposta la proprietà DragEventArgs.Effects per notificare all'origine di trascinamento quale effetto avrà il rilascio dei dati. L'origine di trascinamento riceve queste informazioni negli argomenti dell'evento GiveFeedback e può impostare un cursore appropriato per fornire feedback all'utente.

Il seguente esempio mostra il gestore dell'evento DragOver per un elemento Ellipse. Questo codice verifica se il DataObject che viene trascinato sull'ellisse contiene dati stringa convertibili in un Brush. In tal caso, imposta la proprietà DragEventArgs.Effects su Copy. Questo indica all'origine di trascinamento che i dati possono essere copiati nell'ellisse. Se i dati non possono essere convertiti in un Brush, la proprietà DragEventArgs.Effects viene impostata su None. Questo indica all'origine di trascinamento che l'ellisse non è un obiettivo di rilascio valido per i dati.

private void ellipse_DragOver(object sender, DragEventArgs e)
{
    e.Effects = DragDropEffects.None;

    // If the DataObject contains string data, extract it.
    if (e.Data.GetDataPresent(DataFormats.StringFormat))
    {
        string dataString = (string)e.Data.GetData(DataFormats.StringFormat);

        // If the string can be converted into a Brush, allow copying.
        BrushConverter converter = new BrushConverter();
        if (converter.IsValid(dataString))
        {
            e.Effects = DragDropEffects.Copy | DragDropEffects.Move;
        }
    }
}

Private Sub Ellipse_DragOver(ByVal sender As System.Object, ByVal e As System.Windows.DragEventArgs)
    e.Effects = DragDropEffects.None

    ' If the DataObject contains string data, extract it.
    If e.Data.GetDataPresent(DataFormats.StringFormat) Then
        Dim dataString = e.Data.GetData(DataFormats.StringFormat)

        ' If the string can be converted into a Brush, convert it.
        Dim converter As New BrushConverter()
        If converter.IsValid(dataString) Then
            e.Effects = DragDropEffects.Copy Or DragDropEffects.Move
        End If
    End If
End Sub

L'evento DragLeave si verifica quando i dati vengono trascinati all'esterno del limite della destinazione senza essere rilasciati. Si gestisce questo evento per annullare qualsiasi operazione eseguita nel gestore dell'evento DragEnter.

Il seguente esempio mostra il gestore dell'evento DragLeave per un elemento Ellipse. Questo codice annulla l'anteprima eseguita nel gestore dell'evento DragEnter applicando l'oggetto Brush salvato all'ellisse.

private void ellipse_DragLeave(object sender, DragEventArgs e)
{
    Ellipse ellipse = sender as Ellipse;
    if (ellipse != null)
    {
        ellipse.Fill = _previousFill;
    }
}

Private Sub Ellipse_DragLeave(ByVal sender As System.Object, ByVal e As System.Windows.DragEventArgs)
    Dim ellipse = TryCast(sender, Ellipse)
    If ellipse IsNot Nothing Then
        ellipse.Fill = _previousFill
    End If
End Sub

L'evento Drop si verifica quando i dati vengono rilasciati sull'obiettivo di rilascio. Per impostazione predefinita, questo avviene quando viene rilasciato il pulsante del mouse. Nel gestore dell'evento Drop, si usa il metodo GetData per estrarre i dati trasferiti dal DataObject ed eseguire l'elaborazione dati richiesta dall'applicazione. L'evento Drop termina l'operazione di trascinamento della selezione.

Il seguente esempio mostra il gestore dell'evento Drop per un elemento Ellipse. Questo codice applica gli effetti dell'operazione di trascinamento della selezione ed è simile al codice nel gestore dell'evento DragEnter. Verifica se il DataObject che viene trascinato sull'ellisse contiene dati stringa convertibili in un Brush. In tal caso, Brush viene applicato all'ellisse. Se i dati non possono essere convertiti in un Brush, non viene eseguita alcuna azione.

private void ellipse_Drop(object sender, DragEventArgs e)
{
    Ellipse ellipse = sender as Ellipse;
    if (ellipse != null)
    {
        // If the DataObject contains string data, extract it.
        if (e.Data.GetDataPresent(DataFormats.StringFormat))
        {
            string dataString = (string)e.Data.GetData(DataFormats.StringFormat);

            // If the string can be converted into a Brush,
            // convert it and apply it to the ellipse.
            BrushConverter converter = new BrushConverter();
            if (converter.IsValid(dataString))
            {
                Brush newFill = (Brush)converter.ConvertFromString(dataString);
                ellipse.Fill = newFill;
            }
        }
    }
}

Private Sub Ellipse_Drop(ByVal sender As System.Object, ByVal e As System.Windows.DragEventArgs)
    Dim ellipse = TryCast(sender, Ellipse)
    If ellipse IsNot Nothing Then

        ' If the DataObject contains string data, extract it.
        If e.Data.GetDataPresent(DataFormats.StringFormat) Then
            Dim dataString = e.Data.GetData(DataFormats.StringFormat)

            ' If the string can be converted into a Brush, convert it.
            Dim converter As New BrushConverter()
            If converter.IsValid(dataString) Then
                Dim newFill As Brush = CType(converter.ConvertFromString(dataString), Brush)
                ellipse.Fill = newFill
            End If
        End If
    End If
End Sub

Vedi anche

• Clipboard
• Procedura dettagliata: Abilitare il trascinamento della selezione in un controllo utente
• Procedure relative alle risorse
• Trascinamento della selezione