Panoramica del trascinamento della selezione

Questo argomento offre una panoramica del supporto per il drag-and-drop nelle applicazioni Windows Presentation Foundation (WPF). Il trascinamento si riferisce in genere a un metodo di trasferimento di dati che prevede l'uso di un mouse (o di un altro dispositivo di puntamento) per selezionare uno o più oggetti, trascinandoli su un punto di rilascio desiderato nell'interfaccia utente e rilasciandoli.

Supporto trascinamento della selezione in WPF

Le operazioni di trascinamento della selezione in genere coinvolgono due parti: una sorgente di trascinamento da cui ha origine l'oggetto trascinato e una destinazione di rilascio che riceve l'oggetto rilasciato. La sorgente di trascinamento e la destinazione di rilascio possono essere elementi dell'interfaccia utente nella stessa applicazione o in un'applicazione diversa.

Il tipo e il numero di oggetti che possono essere manipolati con il trascinamento sono completamente arbitrari. Ad esempio, file, cartelle e selezioni di contenuto sono alcuni degli oggetti più comuni manipolati tramite operazioni di trascina e rilascia.

Le azioni specifiche eseguite durante un'operazione di trascinamento della selezione sono specifiche dell'applicazione e spesso determinate 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 drag-and-drop fornite da WPF sono progettate per essere molto flessibili e personalizzabili, supportando una vasta gamma di scenari differenti. Il trascinamento e rilascio supporta la manipolazione di oggetti all'interno di una singola applicazione o tra applicazioni diverse. Anche il trascinamento tra applicazioni WPF e altre applicazioni Windows è completamente supportato.

In WPF, ogni UIElement o ContentElement può partecipare al trascina e rilascia. Gli eventi e i metodi necessari per le operazioni di trascinamento e rilascio vengono definiti nella classe DragDrop. Le classi UIElement e ContentElement contengono alias per gli eventi associati DragDrop in modo che gli eventi vengano visualizzati nell'elenco dei membri della classe quando un UIElement o un ContentElement viene ereditato come elemento di base. I gestori di eventi che sono associati a questi eventi vengono collegati all'evento collegato sottostante DragDrop e ricevono la stessa istanza dei dati di evento. Per ulteriori informazioni, consultare l'evento UIElement.Drop.

Trasferimento dati

Il trascina e rilascia fa parte dell'area più generale del trasferimento dei dati. Il trasferimento dei dati include operazioni di trascinamento e 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 la clipboard di sistema. Entrambi i tipi di operazioni richiedono:

• Oggetto di origine che fornisce i dati.

• Un modo per archiviare temporaneamente i dati trasferiti.

• Oggetto di destinazione che riceve i dati.

In un'operazione di copia e incolla, gli Appunti di sistema vengono usati per archiviare temporaneamente i dati trasferiti; in un'operazione di drag and drop viene usato un DataObject per archiviare i dati. Concettualmente, un oggetto dati è costituito da una o più coppie di un Object che contiene i dati effettivi e da un identificatore di formato dati corrispondente.

L'origine di trascinamento avvia un'operazione di trascina e rilascia chiamando il metodo statico DragDrop.DoDragDrop e passandogli i dati da trasferire. Il metodo DoDragDrop avvolgerà automaticamente i dati in un 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. La destinazione di rilascio è responsabile dell'estrazione dei dati dal DataObject. Per altre informazioni sull'uso di oggetti dati, vedere Data and Data Objects.

L'origine e la destinazione di un'operazione di trascina e rilascia sono elementi dell'interfaccia utente; tuttavia, i dati effettivamente trasferiti in genere non hanno una rappresentazione visiva. È possibile scrivere codice per fornire una rappresentazione visiva dei dati trascinati, ad esempio quando si trascinano i file in Esplora risorse. Per impostazione predefinita, il feedback viene dato all'utente modificando il cursore per rappresentare l'effetto del trascinamento sui dati, ad esempio se i dati verranno spostati o copiati.

Effetti di trascinamento e rilascio

Le operazioni di trascinamento della selezione possono avere effetti diversi sui dati trasferiti. Ad esempio, è possibile copiare i dati oppure spostare i dati. WPF definisce un'enumerazione DragDropEffects che è possibile usare per specificare l'effetto di un'operazione di trascinamento della selezione. Nell'origine di trascinamento, puoi specificare gli effetti che l'origine consentirà nel metodo DoDragDrop. Nella destinazione di rilascio, è possibile specificare l'effetto che la destinazione intende nella proprietà Effects della classe DragEventArgs. Quando la destinazione di rilascio specifica l'effetto previsto nell'evento DragOver, tali informazioni vengono passate alla sorgente di trascinamento nell'evento GiveFeedback. L'origine di trascinamento usa queste informazioni per informare l'utente dell'effetto che la destinazione di rilascio intende avere sui dati. Quando i dati vengono rilasciati, la destinazione di rilascio specifica il loro effetto reale nell'evento Drop. Le informazioni vengono restituite alla fonte di trascinamento come valore di ritorno del metodo DoDragDrop. Se la destinazione di rilascio restituisce un effetto che non si trova nell'elenco delle sorgenti di trascinamento di allowedEffects, l'operazione di drag-and-drop viene annullata senza alcun trasferimento di dati.

È importante ricordare che in WPF i valori DragDropEffects 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 e rilascio. L'effetto reale dell'operazione di trascinamento dipende da te scrivere il codice appropriato nella tua applicazione.

Ad esempio, la destinazione di rilascio potrebbe specificare che l'effetto del rilascio dei dati è quello di spostarli. Tuttavia, per spostare i dati, è necessario aggiungerli all'elemento di destinazione e 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, il risultato finale sarà che i dati vengono copiati e non spostati.

Eventi di Drag-and-Drop

Le operazioni di trascina e rilascia supportano un modello a eventi. Sia l'origine di trascinamento che la destinazione di rilascio usano un set standard di eventi per gestire le operazioni di trascinamento e rilascio. Le tabelle seguenti riepilogano gli eventi di drag and drop standard. Si tratta di eventi collegati nella classe DragDrop. Per altre informazioni sugli eventi associati, vedere Panoramica degli eventi associati.

Trascinare gli eventi di origine

Eliminare gli eventi di destinazione

Per gestire gli eventi di trascinamento e rilascio per le istanze di un oggetto, aggiungere gestori per gli eventi elencati nelle tabelle precedenti. Per gestire gli eventi di drag-and-drop a livello di classe, sovrascrivere i metodi virtuali On*Event e On*PreviewEvent corrispondenti. Per ulteriori informazioni, vedere la gestione degli eventi indirizzati dalle classi base di controllo .

Implementazione del drag-and-drop

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

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

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

• Creare un gestore eventi sulla sorgente di trascinamento che avvierà l'operazione di trascinamento. L'evento è in genere l'evento MouseMove.

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

• Identificare l'elemento che sarà una destinazione di rilascio. Una destinazione di rilascio può essere UIElement o una ContentElement.

• Nella destinazione di rilascio impostare la proprietà AllowDrop su true.

• Nella destinazione di rilascio, creare un gestore eventi Drop per elaborare i dati rilasciati.

• Nel gestore eventi Drop estrarre i dati dal DragEventArgs usando i metodi GetDataPresent e GetData.

• Nel gestore degli eventi Drop, utilizzare 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 facoltativi della sorgente di trascinamento e della destinazione di rilascio, come illustrato 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, DragOvere DragLeave nella destinazione di rilascio.

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

• Per modificare la modalità di annullamento dell'operazione di trascinamento e rilascio, gestire l'evento QueryContinueDrag sull'origine di trascinamento.

Esempio di trascina e rilascia

Questa sezione descrive come implementare il trascina e rilascia per un elemento Ellipse. Il Ellipse è sia un'origine di trascinamento che una destinazione di rilascio. I dati trasferiti sono la rappresentazione di stringa della proprietà Fill dell'ellisse. Il seguente XAML mostra l'elemento Ellipse e gli eventi di trascinamento e rilascio che gestisce. Per una guida completa su come implementare il trascina e rilascia, vedere Procedura dettagliata: Abilitazione del trascina e rilascia 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" />

Abilitazione di un elemento a essere una sorgente di trascinamento

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

• Identificazione di quando si verifica un trascinamento.

• Avvio dell'operazione di trascinamento.

• Identificazione dei dati da trasferire.

• Specificando gli effetti che l'operazione di drag-and-drop può avere sui dati trasferiti.

L'origine di trascinamento può anche fornire feedback all'utente per quanto riguarda le azioni consentite (spostamento, copia, nessuno) e può annullare l'operazione di trascinamento in base all'input utente aggiuntivo, ad esempio premendo il tasto ESC durante il trascinamento.

È responsabilità dell'applicazione determinare quando si verifica un trascinamento e quindi avviare l'operazione di drag-and-drop chiamando il metodo DoDragDrop. In genere, si tratta di quando si verifica un evento MouseMove sull'elemento da trascinare mentre viene premuto un pulsante del mouse. Nell'esempio seguente viene illustrato come iniziare un'operazione di trascinamento dal gestore eventi MouseMove di un elemento Ellipse per renderlo una sorgente 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

All'interno del gestore eventi 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 rappresenta l'origine dei dati trasferiti; si tratta in genere dell'origine dell'evento MouseMove.

• Un data – un oggetto che contiene i dati trasferiti, avvolti in un DataObject.

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

Qualsiasi oggetto serializzabile può essere passato nel parametro data. Sei i dati non sono già avvolti in un DataObject, saranno automaticamente avvolti in un nuovo DataObject. Per passare più elementi di dati, è necessario creare il DataObject manualmente e passarlo al metodo DoDragDrop. Per altre informazioni, vedere Data and Data Objects.

Il parametro allowedEffects viene usato per specificare cosa la sorgente di trascinamento permetterà alla destinazione di rilascio di fare con i dati trasferiti. I valori comuni per un'origine di trascinamento sono Copy, Movee All.

Un'origine di trascinamento può facoltativamente gestire gli eventi GiveFeedback e QueryContinueDrag. Questi eventi hanno gestori predefiniti usati a meno che non si contrassegnino gli eventi come gestiti. Questi eventi verranno in genere ignorati, a meno che non sia necessario modificare il comportamento predefinito.

L'evento GiveFeedback viene generato continuamente mentre la sorgente di trascinamento viene trascinata. Il gestore predefinito per questo evento controlla se la sorgente di trascinamento è sopra una destinazione valida per il rilascio. In caso affermativo, controlla gli effetti consentiti della destinazione di rilascio. Fornisce quindi commenti e suggerimenti all'utente finale per quanto riguarda gli effetti di rilascio consentiti. Questa operazione viene in genere eseguita modificando il cursore del mouse su un cursore di divieto di rilascio, copia o spostamento. È consigliabile gestire questo evento solo se è necessario usare cursori personalizzati per fornire commenti e suggerimenti all'utente. Se gestisci questo evento, assicurati di segnarlo come gestito in modo che il gestore predefinito non esegua l'override del tuo gestore.

L'evento QueryContinueDrag viene generato continuamente mentre l'elemento di trascinamento viene trascinato. Puoi gestire questo evento per determinare quale azione pone fine all'operazione di trascinamento della selezione, tenendo conto dello stato dei tasti ESC, MAIUSC, CTRL e ALT, così come dello stato dei pulsanti del mouse. Il gestore predefinito per questo evento annulla l'operazione di trascinamento della selezione se viene premuto il tasto ESC e rilascia i dati se viene rilasciato il pulsante del mouse.

Abilitazione di un elemento come destinazione di rilascio

Un oggetto che è una destinazione di rilascio è responsabile di:

• Specificando che si tratta di una destinazione di rilascio valida.

• Rispondere alla sorgente di trascinamento quando si trascina sulla destinazione.

• Verifica che i dati trasferiti siano in un formato che possa ricevere.

• Elaborazione dei dati eliminati.

Per specificare che un elemento è una destinazione di rilascio, impostare la relativa proprietà AllowDrop su true. Gli eventi di destinazione di rilascio verranno quindi generati sull'elemento in modo che sia possibile gestirli. Durante un'operazione di trascinamento e rilascio, la sequenza di eventi seguente si verifica sull'obiettivo di rilascio.

1. DragEnter

2. DragOver

3. DragLeave o Drop

L'evento DragEnter si verifica quando i dati vengono trascinati nel limite della destinazione di rilascio. Questo evento viene in genere gestito per fornire un'anteprima degli effetti dell'operazione di trascinamento della selezione, se appropriato per la tua applicazione. Non impostare la proprietà DragEventArgs.Effects nell'evento DragEnter, perché verrà sovrascritta nell'evento DragOver.

Nell'esempio seguente viene illustrato il gestore eventi DragEnter per un elemento Ellipse. Questo codice visualizza in anteprima gli effetti dell'operazione di trascina e rilascia salvando il pennello corrente del Fill. Usa quindi il metodo GetDataPresent per verificare se il DataObject trascinato sull'ellisse contiene dati stringa che possono essere convertiti in un Brush. In tal caso, i dati vengono estratti usando il metodo GetData. Viene quindi convertito in un Brush e applicato all'ellisse. La modifica viene ripristinata nel gestore eventi 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 continuamente mentre i dati vengono trascinati sulla destinazione di rilascio. Questo evento è associato all'evento GiveFeedback sulla sorgente di trascinamento. Nel gestore eventi DragOver si usano in genere i metodi GetDataPresent e GetData per verificare se i dati trasferiti sono in un formato che la destinazione di rilascio può elaborare. È anche possibile controllare se vengono premuti i tasti di modifica, che in genere indicano se l'utente intende eseguire un'azione di spostamento o copia. Dopo l'esecuzione di questi controlli, impostare la proprietà DragEventArgs.Effects per notificare all'origine di trascinamento quale effetto avrà l'eliminazione dei dati. L'origine di trascinamento riceve queste informazioni negli argomenti dell'evento GiveFeedback e può impostare un cursore appropriato per inviare commenti e suggerimenti all'utente.

Nell'esempio seguente viene illustrato il gestore eventi DragOver per un elemento Ellipse. Questo codice verifica se il DataObject trascinato sull'ellisse contiene dati stringa che possono essere convertiti in un Brush. In tal caso, imposta la proprietà DragEventArgs.Effects su Copy. 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 è impostata su None. Indica alla sorgente di trascinamento che l'ellisse non costituisce una destinazione valida di rilascio 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 fuori dai confini dell'obiettivo senza essere rilasciati. Gestisci questo evento per annullare tutto ciò che hai fatto nel gestore eventi DragEnter.

Nell'esempio seguente viene illustrato il gestore eventi DragLeave per un elemento Ellipse. Questo codice annulla l'anteprima eseguita nel gestore eventi DragEnter applicando il 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 sulla destinazione di rilascio; di default, ciò accade quando viene rilasciato il pulsante del mouse. Nel gestore eventi Drop si usa il metodo GetData per estrarre i dati trasferiti dal DataObject ed eseguire qualsiasi elaborazione dati richiesta dall'applicazione. L'evento Drop termina l'operazione di trascinamento e rilascio.

Nell'esempio seguente viene illustrato il gestore eventi Drop per un elemento Ellipse. Questo codice applica gli effetti dell'operazione di drag-and-drop ed è simile al codice nel handler dell'evento DragEnter. Verifica se il DataObject trascinato sull'ellisse contiene dati stringa che possono essere convertiti in un Brush. In tal caso, il 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

Vedere anche

• Clipboard
• Guida: Abilitazione del trascinamento della selezione in un controllo utente
• Argomenti su come fare
• trascinare e rilasciare