Guida: Abilitare il trascinamento della selezione su un controllo utente

2025-05-07

Questa procedura dettagliata mostra come creare un controllo utente personalizzato che partecipi al trasferimento di dati tramite trascinamento in Windows Presentation Foundation (WPF).

In questa procedura dettagliata, creerai un WPF UserControl personalizzato che rappresenta una forma circolare. Implementerai la funzionalità nel controllo per consentire il trasferimento dei dati tramite trascinamento della selezione. Ad esempio, se si trascina da un controllo Cerchio a un altro, i dati del colore di riempimento sono copiati dal cerchio di origine al cerchio di destinazione. Trascinando da un controllo Cerchio a un TextBox, la rappresentazione in stringa del colore di riempimento viene copiata nel TextBox. Si creerà anche una piccola applicazione che contiene due controlli pannello e un TextBox per testare la funzionalità di trascina e rilascia. Si scriverà codice che consente ai pannelli di elaborare i dati dei Cerchi trascinati, il che permetterà di spostare o copiare Cerchi dalla raccolta Children di un pannello all'altro.

Questa procedura dettagliata illustra le attività seguenti:

Creare un controllo utente personalizzato.
Abilitare il controllo utente come origine di trascinamento.
Abilitare il controllo utente come destinazione di rilascio.
Abilitare un pannello per ricevere i dati trasferiti dal controllo utente.

Prerequisiti

Per completare questa procedura dettagliata, è necessario Visual Studio.

Creare il progetto dell'applicazione

In questa sezione si creerà l'infrastruttura dell'applicazione, che include una pagina principale con due pannelli e un TextBox.

Creare un nuovo progetto applicazione WPF in Visual Basic o Visual C# denominato DragDropExample. Per ulteriori informazioni, consultare Procedura dettagliata: la mia prima applicazione desktop WPF.
Aprire MainWindow.xaml.

Aggiungere il markup seguente tra i tag di apertura e chiusura Grid.

Questo markup crea l'interfaccia utente per l'applicazione di test.

<Grid.ColumnDefinitions>
    <ColumnDefinition />
    <ColumnDefinition />
</Grid.ColumnDefinitions>
<StackPanel Grid.Column="0"
            Background="Beige">
    <TextBox Width="Auto" Margin="2"
             Text="green"/>
</StackPanel>
<StackPanel Grid.Column="1"
            Background="Bisque">
</StackPanel>

Aggiungere un nuovo controllo utente al progetto

In questa sezione verrà aggiunto un nuovo controllo utente al progetto.

Nel menu Progetto, seleziona Aggiungi Controllo Utente.
Nella finestra di dialogo Aggiungi nuovo elemento cambia il nome in Circle.xamle clicca su Aggiungi.

Circle.xaml e il codice associato vengono aggiunti al progetto.
Apri Circle.xaml.

Questo file conterrà gli elementi dell'interfaccia utente del controllo utente.
Aggiungere il seguente markup alla radice Grid per creare un semplice controllo utente con un cerchio blu come UI.
```
<Ellipse x:Name="circleUI" 
         Height="100" Width="100"
         Fill="Blue" />
```
Aprire Circle.xaml.cs o Circle.xaml.vb.

In C# aggiungere il codice seguente dopo il costruttore senza parametri per creare un costruttore di copia. In Visual Basic aggiungere il codice seguente per creare sia un costruttore senza parametri che un costruttore di copia.

Per consentire all'utente di copiare il controllo, aggiungi un metodo costruttore di copia nel file code-behind. Nel controllo utente Circle semplificato, si copiano solo il riempimento e le dimensioni del controllo utente.

public Circle(Circle c)
{
    InitializeComponent();
    this.circleUI.Height = c.circleUI.Height;
    this.circleUI.Width = c.circleUI.Height;
    this.circleUI.Fill = c.circleUI.Fill;
}

Public Sub New()
    ' This call is required by the designer.
    InitializeComponent()
End Sub

Public Sub New(ByVal c As Circle)
    InitializeComponent()
    Me.circleUI.Height = c.circleUI.Height
    Me.circleUI.Width = c.circleUI.Height
    Me.circleUI.Fill = c.circleUI.Fill
End Sub

Aggiungere il controllo utente alla finestra principale

Aprire MainWindow.xaml.
Aggiungere il seguente codice XAML al tag Window di apertura per creare un riferimento allo spazio dei nomi XML dell'applicazione corrente.
```
xmlns:local="clr-namespace:DragDropExample"
```

Nel primo StackPanel, aggiungere il codice XAML seguente per creare due istanze del controllo utente Circle nel primo pannello.

<local:Circle Margin="2" />
<local:Circle Margin="2" />

Il codice XAML completo per il pannello è simile al seguente.

<StackPanel Grid.Column="0"
            Background="Beige">
    <TextBox Width="Auto" Margin="2"
             Text="green"/>
    <local:Circle Margin="2" />
    <local:Circle Margin="2" />
</StackPanel>
<StackPanel Grid.Column="1"
            Background="Bisque">
</StackPanel>

Implementare gli eventi della sorgente di trascinamento nel controllo utente

In questa sezione si eseguirà l'override del metodo OnMouseMove e si avvierà l'operazione di trascinamento e rilascio.

Se inizi un trascinamento (premendo un pulsante del mouse e spostando il mouse), impacchetterai i dati da trasferire in un DataObject. In questo caso, il controllo Circle conterrà tre elementi di dati: una rappresentazione come stringa del suo colore di riempimento, una rappresentazione in formato double della sua altezza e una copia di se stesso.

Per avviare un'operazione di trascinamento della selezione

Aprire Circle.xaml.cs o Circle.xaml.vb.

Aggiungere il OnMouseMove override seguente per fornire la gestione delle classi per l'evento MouseMove.

protected override void OnMouseMove(MouseEventArgs e)
{
    base.OnMouseMove(e);
    if (e.LeftButton == MouseButtonState.Pressed)
    {
        // Package the data.
        DataObject data = new DataObject();
        data.SetData(DataFormats.StringFormat, circleUI.Fill.ToString());
        data.SetData("Double", circleUI.Height);
        data.SetData("Object", this);

        // Initiate the drag-and-drop operation.
        DragDrop.DoDragDrop(this, data, DragDropEffects.Copy | DragDropEffects.Move);
    }
}

Protected Overrides Sub OnMouseMove(ByVal e As System.Windows.Input.MouseEventArgs)
    MyBase.OnMouseMove(e)
    If e.LeftButton = MouseButtonState.Pressed Then
        ' Package the data.
        Dim data As New DataObject
        data.SetData(DataFormats.StringFormat, circleUI.Fill.ToString())
        data.SetData("Double", circleUI.Height)
        data.SetData("Object", Me)

        ' Inititate the drag-and-drop operation.
        DragDrop.DoDragDrop(Me, data, DragDropEffects.Copy Or DragDropEffects.Move)
    End If
End Sub

Questa OnMouseMove override esegue le attività seguenti:

Controlla se il pulsante sinistro del mouse viene premuto mentre il mouse è in movimento.
Inserisce i dati del Cerchio in un DataObject. In questo caso, il controllo Circle crea tre elementi di dati; una rappresentazione di stringa del suo colore di riempimento, una rappresentazione in formato double della sua altezza e una copia di se stesso.
Chiama il metodo statico DragDrop.DoDragDrop per avviare l'operazione di trascina e rilascia. Passare i tre parametri seguenti al metodo DoDragDrop:
- dragSource: riferimento a questo controllo.
- data: L'DataObject è stato creato nel codice precedente.
- allowedEffects: Le operazioni di trascinamento della selezione consentite sono Copy o Move.

Premere F5 per compilare ed eseguire l'applicazione.
Fare clic su uno dei controlli Circle e trascinarlo sui pannelli, sull'altro Circle e sul TextBox. Quando si trascina il TextBox, il cursore cambia per indicare uno spostamento.
Durante il trascinamento di un Cerchio sull'TextBox, premere il tasto Ctrl. Notare come il cursore cambi per indicare una copia.
Trascinare e rilasciare un cerchio sul TextBox. La rappresentazione in stringa del colore di riempimento del cerchio è aggiunta a TextBox.

Per impostazione predefinita, il cursore cambierà durante un'operazione di trascinamento della selezione per indicare quale effetto avrà l'eliminazione dei dati. È possibile personalizzare il feedback fornito all'utente gestendo l'evento GiveFeedback e impostando un cursore diverso.

Inviare commenti e suggerimenti all'utente

Aprire Circle.xaml.cs o Circle.xaml.vb.

Aggiungere il OnGiveFeedback override seguente per fornire la gestione delle classi per l'evento GiveFeedback.

protected override void OnGiveFeedback(GiveFeedbackEventArgs e)
{
    base.OnGiveFeedback(e);
    // These Effects values are set in the drop target's
    // DragOver event handler.
    if (e.Effects.HasFlag(DragDropEffects.Copy))
    {
        Mouse.SetCursor(Cursors.Cross);
    }
    else if (e.Effects.HasFlag(DragDropEffects.Move))
    {
        Mouse.SetCursor(Cursors.Pen);
    }
    else
    {
        Mouse.SetCursor(Cursors.No);
    }
    e.Handled = true;
}

Protected Overrides Sub OnGiveFeedback(ByVal e As System.Windows.GiveFeedbackEventArgs)
    MyBase.OnGiveFeedback(e)
    ' These Effects values are set in the drop target's
    ' DragOver event handler.
    If e.Effects.HasFlag(DragDropEffects.Copy) Then
        Mouse.SetCursor(Cursors.Cross)
    ElseIf e.Effects.HasFlag(DragDropEffects.Move) Then
        Mouse.SetCursor(Cursors.Pen)
    Else
        Mouse.SetCursor(Cursors.No)
    End If
    e.Handled = True
End Sub

Questa OnGiveFeedback override esegue le attività seguenti:

Controlla i valori Effects impostati nel gestore eventi DragOver della destinazione di rilascio.
Imposta un cursore personalizzato in base al valore Effects. Il cursore è progettato per fornire feedback visivo all'utente sull'effetto che avrà l'eliminazione dei dati.

Premere F5 per compilare ed eseguire l'applicazione.
Trascina uno dei controlli Circle sui pannelli, sull'altro Circle e sul TextBox. Si noti che i cursori sono ora i cursori personalizzati specificati nella OnGiveFeedback override.
Selezionare il testo green dal TextBox.
Trascina il testo green in un controllo cerchio. Si noti che i cursori predefiniti vengono visualizzati per indicare gli effetti dell'operazione di trascinamento. Il cursore di feedback viene sempre impostato dall'origine di trascinamento.

Implementare eventi di destinazione di rilascio nel controllo utente

In questa sezione, specificherai che il controllo utente è un destinatario di rilascio, eseguirai l'override dei metodi che consentono al controllo utente di essere un destinatario di rilascio ed elaborerai i dati rilasciati su di esso.

Per consentire al controllo utente di essere una destinazione di rilascio

Apri Circle.xaml.

Nel tag UserControl di apertura aggiungere la proprietà AllowDrop e impostarla su true.

<UserControl x:Class="DragDropWalkthrough.Circle"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             mc:Ignorable="d" 
             d:DesignHeight="300" d:DesignWidth="300"
             AllowDrop="True">

Il metodo OnDrop viene chiamato quando la proprietà AllowDrop è impostata su true e i dati dell'origine di trascinamento vengono rilasciati nel controllo utente Circle. In questo metodo elaborerai i dati che sono stati scartati e li applicherai al Circolo.

Per elaborare i dati scartati

Aprire Circle.xaml.cs o Circle.xaml.vb.

Aggiungere il OnDrop override seguente per fornire la gestione delle classi per l'evento Drop.

protected override void OnDrop(DragEventArgs e)
{
    base.OnDrop(e);

    // 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);
            circleUI.Fill = newFill;

            // Set Effects to notify the drag source what effect
            // the drag-and-drop operation had.
            // (Copy if CTRL is pressed; otherwise, move.)
            if (e.KeyStates.HasFlag(DragDropKeyStates.ControlKey))
            {
                e.Effects = DragDropEffects.Copy;
            }
            else
            {
                e.Effects = DragDropEffects.Move;
            }
        }
    }
    e.Handled = true;
}

Protected Overrides Sub OnDrop(ByVal e As System.Windows.DragEventArgs)
    MyBase.OnDrop(e)
    ' If the DataObject contains string data, extract it.
    If e.Data.GetDataPresent(DataFormats.StringFormat) Then
        Dim dataString As String = e.Data.GetData(DataFormats.StringFormat)

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

            ' Set Effects to notify the drag source what effect
            ' the drag-and-drop operation had.
            ' (Copy if CTRL is pressed; otherwise, move.)
            If e.KeyStates.HasFlag(DragDropKeyStates.ControlKey) Then
                e.Effects = DragDropEffects.Copy
            Else
                e.Effects = DragDropEffects.Move
            End If
        End If
    End If
    e.Handled = True
End Sub

Questa OnDrop override esegue le attività seguenti:

Usa il metodo GetDataPresent per verificare se i dati trascinati contengono un oggetto stringa.
Usa il metodo GetData per estrarre i dati di stringhe, se presenti.
Usa un BrushConverter per provare a convertire la stringa in un Brush.
Se la conversione ha esito positivo, applica il pennello al Fill del Ellipse che fornisce l'interfaccia utente del controllo Cerchio.
Contrassegna l'evento Drop come gestito. Devi contrassegnare l'evento di rilascio come gestito in modo che altri elementi che ricevono questo evento sappiano che il controllo utente Circle lo ha gestito.

Premere F5 per compilare ed eseguire l'applicazione.
Selezionare il testo green nel TextBox.
Trascina il testo su un controllo Circle e rilascialo. Il cerchio passa da blu a verde.
Digitare il testo green nel TextBox.
Selezionare il testo gre nel TextBox.
Trascinarlo in un controllo Circle e rilasciarlo. Si noti che il cursore cambia per indicare che la goccia è consentita, ma il colore del cerchio non cambia perché gre non è un colore valido.
Trascinare dal cerchio di controllo verde e rilasciare sul cerchio di controllo blu. Il cerchio passa da blu a verde. Si noti che il cursore visualizzato dipende dal fatto che il TextBox o il Circle è l'origine di trascinamento.

L'impostazione della proprietà AllowDrop su true ed elaborazione dei dati eliminati è tutto ciò che è necessario per consentire a un elemento di essere una destinazione di rilascio. Tuttavia, per offrire un'esperienza utente migliore, è consigliabile gestire anche gli eventi DragEnter, DragLeavee DragOver. In questi eventi è possibile eseguire controlli e fornire un feedback aggiuntivo all'utente prima dell'eliminazione dei dati.

Quando i dati vengono trascinati sul controllo utente Circle, il controllo deve notificare all'origine di trascinamento se è in grado di elaborare i dati trascinati. Se il controllo non sa come elaborare i dati, deve rifiutare l'eliminazione. A tale scopo, si gestirà l'evento DragOver e si imposterà la proprietà Effects.

Per verificare che l'eliminazione dei dati sia consentita

Aprire Circle.xaml.cs o Circle.xaml.vb.

Aggiungere il OnDragOver override seguente per fornire la gestione delle classi per l'evento DragOver.

protected override void OnDragOver(DragEventArgs e)
{
    base.OnDragOver(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 or moving.
        BrushConverter converter = new BrushConverter();
        if (converter.IsValid(dataString))
        {
            // Set Effects to notify the drag source what effect
            // the drag-and-drop operation will have. These values are
            // used by the drag source's GiveFeedback event handler.
            // (Copy if CTRL is pressed; otherwise, move.)
            if (e.KeyStates.HasFlag(DragDropKeyStates.ControlKey))
            {
                e.Effects = DragDropEffects.Copy;
            }
            else
            {
                e.Effects = DragDropEffects.Move;
            }
        }
    }
    e.Handled = true;
}

Protected Overrides Sub OnDragOver(ByVal e As System.Windows.DragEventArgs)
    MyBase.OnDragOver(e)
    e.Effects = DragDropEffects.None

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

        ' If the string can be converted into a Brush, allow copying or moving.
        Dim converter As New BrushConverter
        If converter.IsValid(dataString) Then
            ' Set Effects to notify the drag source what effect
            ' the drag-and-drop operation will have. These values are 
            ' used by the drag source's GiveFeedback event handler.
            ' (Copy if CTRL is pressed; otherwise, move.)
            If e.KeyStates.HasFlag(DragDropKeyStates.ControlKey) Then
                e.Effects = DragDropEffects.Copy
            Else
                e.Effects = DragDropEffects.Move
            End If
        End If
    End If
    e.Handled = True
End Sub

Questa OnDragOver override esegue le attività seguenti:

Imposta la proprietà Effects su None.
Esegue gli stessi controlli effettuati nel metodo OnDrop per determinare se il controllo utente Circle può elaborare i dati trascinati.
Se il controllo utente è in grado di elaborare i dati, la proprietà Effects viene impostata su Copy o Move.

Premere F5 per compilare ed eseguire l'applicazione.
Selezionare il testo gre nel TextBox.
Trascina il testo in un controllo di tipo cerchio. Nota che il cursore ora cambia per indicare che il trascinamento non è consentito perché gre non è un colore valido.

È possibile migliorare ulteriormente l'esperienza utente applicando un'anteprima dell'operazione di rilascio. Per il controllo utente Circle, eseguirai l'override dei metodi OnDragEnter e OnDragLeave. Quando i dati vengono trascinati sul controllo, lo sfondo corrente Fill viene salvato in una variabile temporanea. La stringa viene quindi convertita in un pennello e applicata a Ellipse, che fornisce l'interfaccia utente del cerchio. Se i dati vengono trascinati all'esterno dell'oggetto Circle senza essere eliminati, il valore originale Fill viene nuovamente applicato al circle.

Per anticipare gli effetti dell'operazione di drag-and-drop

Aprire Circle.xaml.cs o Circle.xaml.vb.

Nella classe Circle dichiarare una variabile Brush privata denominata _previousFill e inizializzarla in null.

public partial class Circle : UserControl
{
    private Brush _previousFill = null;

Public Class Circle
    Private _previousFill As Brush = Nothing

Aggiungere il OnDragEnter override seguente per fornire la gestione delle classi per l'evento DragEnter.

protected override void OnDragEnter(DragEventArgs e)
{
    base.OnDragEnter(e);
    // Save the current Fill brush so that you can revert back to this value in DragLeave.
    _previousFill = circleUI.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.ToString());
            circleUI.Fill = newFill;
        }
    }
}

Protected Overrides Sub OnDragEnter(ByVal e As System.Windows.DragEventArgs)
    MyBase.OnDragEnter(e)
    _previousFill = circleUI.Fill

    ' If the DataObject contains string data, extract it.
    If e.Data.GetDataPresent(DataFormats.StringFormat) Then
        Dim dataString As String = 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 = converter.ConvertFromString(dataString)
            circleUI.Fill = newFill
        End If
    End If
    e.Handled = True
End Sub

Questa OnDragEnter override esegue le attività seguenti:

Salva la proprietà Fill del Ellipse nella variabile _previousFill.
Esegue gli stessi controlli eseguiti nel metodo OnDrop per determinare se i dati possono essere convertiti in un Brush.
Se i dati vengono convertiti in un Brushvalido, essi vengono applicati al Fill del Ellipse.

Aggiungere il OnDragLeave override seguente per fornire la gestione delle classi per l'evento DragLeave.

protected override void OnDragLeave(DragEventArgs e)
{
    base.OnDragLeave(e);
    // Undo the preview that was applied in OnDragEnter.
    circleUI.Fill = _previousFill;
}

Protected Overrides Sub OnDragLeave(ByVal e As System.Windows.DragEventArgs)
    MyBase.OnDragLeave(e)
    ' Undo the preview that was applied in OnDragEnter.
    circleUI.Fill = _previousFill
End Sub

Questa OnDragLeave override esegue le attività seguenti:

Applica il Brush salvato nella variabile _previousFill al Fill del Ellipse che fornisce l'interfaccia utente del controllo utente Circle.

Premere F5 per compilare ed eseguire l'applicazione.
Selezionare il testo green nel TextBox.
Trascinare il testo su un controllo Cerchio senza lasciarlo cadere. Il cerchio passa da blu a verde.
Trascinare il testo lontano dal controllo Circle. Il cerchio passa dal verde al blu.

Abilitare un pannello per ricevere dati eliminati

In questa sezione, abiliti i pannelli che ospitano i controlli utente di Circle affinché possano servire come destinazioni di rilascio per i dati Circle trascinati. Implementerai il codice che ti consente di spostare un cerchio da un pannello a un altro o di creare una copia di un controllo Circle tenendo premuto il tasto Ctrl Ctrl durante il trascinamento e il rilascio di un cerchio.

Aprire MainWindow.xaml.

Come illustrato nel codice XAML seguente, in ognuno dei controlli StackPanel aggiungere gestori per gli eventi DragOver e Drop. Denominare il gestore eventi DragOver, panel_DragOvere denominare il gestore eventi Drop, panel_Drop.

Per impostazione predefinita, i pannelli non sono destinazioni di rilascio. Per abilitarle, aggiungere la proprietà AllowDrop a entrambi i pannelli e impostare il valore su true.

<StackPanel Grid.Column="0"
            Background="Beige"
            AllowDrop="True"
            DragOver="panel_DragOver"
            Drop="panel_Drop">
    <TextBox Width="Auto" Margin="2"
             Text="green"/>
    <local:Circle Margin="2" />
    <local:Circle Margin="2" />
</StackPanel>
<StackPanel Grid.Column="1"
            Background="Bisque"
            AllowDrop="True"
            DragOver="panel_DragOver"
            Drop="panel_Drop">
</StackPanel>

Aprire MainWindows.xaml.cs o MainWindow.xaml.vb.

Aggiungere il codice seguente per il gestore eventi DragOver.

private void panel_DragOver(object sender, DragEventArgs e)
{
    if (e.Data.GetDataPresent("Object"))
    {
        // These Effects values are used in the drag source's
        // GiveFeedback event handler to determine which cursor to display.
        if (e.KeyStates == DragDropKeyStates.ControlKey)
        {
            e.Effects = DragDropEffects.Copy;
        }
        else
        {
            e.Effects = DragDropEffects.Move;
        }
    }
}

Private Sub panel_DragOver(ByVal sender As System.Object, ByVal e As System.Windows.DragEventArgs)
    If e.Data.GetDataPresent("Object") Then
        ' These Effects values are used in the drag source's
        ' GiveFeedback event handler to determine which cursor to display.
        If e.KeyStates = DragDropKeyStates.ControlKey Then
            e.Effects = DragDropEffects.Copy
        Else
            e.Effects = DragDropEffects.Move
        End If
    End If
End Sub

Questo DragOver gestore eventi esegue le attività seguenti:

Verifica che i dati trascinati contengano i dati "Object" inseriti nel pacchetto nel DataObject dal controllo utente Circle e passati alla chiamata a DoDragDrop.
Se i dati "Object" sono presenti, controlla se il tasto Ctrl è premuto.
Se viene premuto il tasto CTRL, imposta la proprietà Effects su Copy. In caso contrario, impostare la proprietà Effects su Move.

Aggiungere il codice seguente per il gestore eventi Drop.

private void panel_Drop(object sender, DragEventArgs e)
{
    // If an element in the panel has already handled the drop,
    // the panel should not also handle it.
    if (e.Handled == false)
    {
        Panel _panel = (Panel)sender;
        UIElement _element = (UIElement)e.Data.GetData("Object");

        if (_panel != null && _element != null)
        {
            // Get the panel that the element currently belongs to,
            // then remove it from that panel and add it the Children of
            // the panel that its been dropped on.
            Panel _parent = (Panel)VisualTreeHelper.GetParent(_element);

            if (_parent != null)
            {
                if (e.KeyStates == DragDropKeyStates.ControlKey &&
                    e.AllowedEffects.HasFlag(DragDropEffects.Copy))
                {
                    Circle _circle = new Circle((Circle)_element);
                    _panel.Children.Add(_circle);
                    // set the value to return to the DoDragDrop call
                    e.Effects = DragDropEffects.Copy;
                }
                else if (e.AllowedEffects.HasFlag(DragDropEffects.Move))
                {
                    _parent.Children.Remove(_element);
                    _panel.Children.Add(_element);
                    // set the value to return to the DoDragDrop call
                    e.Effects = DragDropEffects.Move;
                }
            }
        }
    }
}

Private Sub panel_Drop(ByVal sender As System.Object, ByVal e As System.Windows.DragEventArgs)
    ' If an element in the panel has already handled the drop,
    ' the panel should not also handle it.
    If e.Handled = False Then
        Dim _panel As Panel = sender
        Dim _element As UIElement = e.Data.GetData("Object")

        If _panel IsNot Nothing And _element IsNot Nothing Then
            ' Get the panel that the element currently belongs to,
            ' then remove it from that panel and add it the Children of
            ' the panel that its been dropped on.

            Dim _parent As Panel = VisualTreeHelper.GetParent(_element)
            If _parent IsNot Nothing Then
                If e.KeyStates = DragDropKeyStates.ControlKey And _
                    e.AllowedEffects.HasFlag(DragDropEffects.Copy) Then
                    Dim _circle As New Circle(_element)
                    _panel.Children.Add(_circle)
                    ' set the value to return to the DoDragDrop call
                    e.Effects = DragDropEffects.Copy
                ElseIf e.AllowedEffects.HasFlag(DragDropEffects.Move) Then
                    _parent.Children.Remove(_element)
                    _panel.Children.Add(_element)
                    ' set the value to return to the DoDragDrop call
                    e.Effects = DragDropEffects.Move
                End If
            End If
        End If
    End If
End Sub

Questo Drop gestore eventi esegue le attività seguenti:

Controlla se l'evento Drop è già stato gestito. Ad esempio, se un oggetto Circle viene trascinato su un altro Circle che gestisce l'evento Drop, non si desidera che anche il pannello che contiene il primo Circle gestisca l'evento.
Se l'evento Drop non viene gestito, verifica se il tasto Ctrl è premuto.
Se si preme tasto CTRL quando si verifica il Drop, crea una copia del controllo Circle e la aggiunge all'insieme Children del StackPanel.
Se il tasto Ctrl non viene premuto, sposta il Circle dall'insieme Children del pannello padre all'insieme Children del pannello su cui è stato trascinato.
Imposta la proprietà Effects per notificare al metodo DoDragDrop se è stata eseguita un'operazione di spostamento o copia.

Premere F5 per compilare ed eseguire l'applicazione.
Selezionare il testo green dal TextBox.
Trascina il testo su un controllo Cerchio e rilascialo.
Trascina un controllo a forma di cerchio dal pannello sinistro al pannello destro e rilascialo. Circle viene rimosso dall'insieme Children del pannello sinistro e aggiunto all'insieme Children del pannello di destra.
Trascina il controllo Circle dal pannello in cui si trova all'altro pannello e rilascialo mentre premi il tasto Ctrl. Il Circle viene copiato e la copia viene aggiunta alla collezione Children del pannello ricevente.

Vedere anche

Panoramica delle funzionalità di trascinamento e rilascio

Condividi tramite