Visão geral de arrastar e soltar

Este tópico fornece uma visão geral do suporte de arrastar e soltar em aplicativos do WPF (Windows Presentation Foundation). Arrastar e soltar geralmente se refere a um método de transferência de dados que envolve o uso de um mouse (ou algum outro dispositivo apontador) para selecionar um ou mais objetos, arrastá-los para um alvo de soltura desejado na interface do usuário e soltá-los.

Suporte a arrastar e soltar no WPF

Normalmente, as operações do tipo "arrastar e soltar" envolvem duas partes: uma origem da qual o objeto arrastado se origina e um destino de soltura que recebe o objeto solto. A origem do arrasto e o destino de soltura podem ser elementos de interface do usuário no mesmo ou em outro aplicativo.

O tipo e o número de objetos que podem ser manipulados com arrastar e soltar é completamente arbitrário. Por exemplo, arquivos, pastas e seleções de conteúdo são alguns dos objetos mais comuns manipulados por meio de operações de arrastar e soltar.

As ações específicas executadas durante uma operação de arrastar e soltar são específicas do aplicativo e geralmente determinadas pelo contexto. Por exemplo, arrastar uma seleção de arquivos de uma pasta para outra no mesmo dispositivo de armazenamento move os arquivos por padrão, enquanto arrastar arquivos de um compartilhamento UNC (Convenção Universal de Nomenclatura) para uma pasta local copia os arquivos por padrão.

As instalações de arrastar e soltar fornecidas pelo WPF foram projetadas para serem altamente flexíveis e personalizáveis para dar suporte a uma ampla variedade de cenários de arrastar e soltar. O arrastar e soltar dá suporte à manipulação de objetos em um único aplicativo ou entre aplicativos diferentes. Também há suporte total para arrastar e soltar entre aplicativos WPF e outros aplicativos do Windows.

No WPF, qualquer UIElement ou ContentElement pode participar do recurso de arrastar e soltar. Os eventos e métodos necessários para operações de arrastar e soltar são definidos na classe DragDrop. As classes UIElement e ContentElement contêm aliases para os eventos anexados DragDrop para que os eventos apareçam na lista de membros da classe quando um UIElement ou ContentElement é herdado como um elemento base. Os manipuladores de eventos conectados a esses eventos são vinculados ao evento subjacente DragDrop e recebem a mesma instância de dados do evento. Para obter mais informações, consulte o evento UIElement.Drop.

Importante

O arrastar e soltar OLE não funciona enquanto estiver na zona da Internet.

Transferência de dados

Arrastar e soltar faz parte da área mais geral de transferência de dados. A transferência de dados inclui operações de arrastar e soltar e copiar e colar. Uma operação do tipo "arrastar e soltar" é análoga a uma operação de copiar e colar ou de recortar e colar, que é usada para transferir dados de um objeto ou aplicativo para outro usando a área de transferência do sistema. Ambos os tipos de operações exigem:

• Um objeto de origem que fornece os dados.

• Uma maneira de armazenar temporariamente os dados transferidos.

• Um objeto de destino que recebe os dados.

Em uma operação de copiar e colar, a área de transferência do sistema é usada para armazenar temporariamente os dados transferidos; em uma operação do tipo "arrastar e soltar", um DataObject é usado para armazenar os dados. Conceitualmente, um objeto de dados consiste em um ou mais pares de um Object que contém os dados reais e um identificador de formato de dados correspondente.

A fonte de arrasto inicia uma ação de arrastar e soltar chamando o método estático DragDrop.DoDragDrop e passando a ele os dados a serem transferidos. O método DoDragDrop encapsulará automaticamente os dados em um DataObject, se necessário. Para obter maior controle sobre o formato de dados, você pode encapsular os dados em uma DataObject antes de passá-los para o método DoDragDrop. O destino de soltura é responsável por extrair os dados de DataObject. Para obter mais informações sobre como trabalhar com objetos de dados, consulte Dados e Objetos de Dados.

A origem e o destino de uma operação de arrastar e soltar são elementos de interface do usuário; no entanto, os dados que estão sendo transferidos normalmente não têm uma representação visual. Você pode escrever código para fornecer uma representação visual dos dados que são arrastados, como ocorre ao arrastar arquivos no Windows Explorer. Por padrão, os comentários são fornecidos ao usuário alterando o cursor para representar o efeito que a operação de arrastar e soltar terá nos dados, como se os dados serão movidos ou copiados.

Efeitos das operações do tipo "arrastar e soltar"

As operações de arrastar e soltar podem ter efeitos diferentes nos dados transferidos. Por exemplo, você pode copiar os dados ou mover os dados. O WPF define uma enumeração DragDropEffects que você pode usar para especificar o efeito de uma operação de arrastar e soltar. Na origem do arrasto, é possível especificar os efeitos que a origem permitirá no método DoDragDrop. No destino de soltura, você pode especificar o efeito que o destino pretende na propriedade Effects da classe DragEventArgs. Quando o destino de soltura especifica seu efeito pretendido no evento DragOver, essas informações são passadas de volta para a origem de arrastar no evento GiveFeedback. A origem do arrasto usa essas informações para informar ao usuário o efeito que o destino de soltura pretende ter sobre os dados. Quando os dados são soltos, o destino de soltura especifica seu efeito real no evento Drop. Essas informações são passadas de volta para a fonte de arrasto como o valor de retorno do método DoDragDrop. Se o destino de soltura retornar um efeito que não esteja na lista de fontes de arraste de allowedEffects, a operação de arrastar e soltar é cancelada sem que ocorra qualquer transferência de dados.

É importante lembrar que, no WPF, os valores de DragDropEffects são usados apenas para fornecer a comunicação entre a origem do arrasto e o destino de soltura em relação aos efeitos da operação do tipo "arrastar e soltar". O efeito real da operação de arrastar e soltar depende de você escrever o código apropriado em seu aplicativo.

Por exemplo, o destino de soltura pode especificar que o efeito de soltar dados nele é mover os dados. No entanto, para mover os dados, eles devem ser adicionados ao elemento de destino e removidos do elemento de origem. O elemento de origem pode indicar que ele permite mover os dados, mas se você não fornecer o código para remover os dados do elemento de origem, o resultado final será que os dados são copiados e não movidos.

Eventos do tipo "arrastar e soltar"

As operações de arrastar e soltar dão suporte a um modelo controlado por eventos. A origem do arrasto e o destino de soltura usam um conjunto padrão de eventos para manipular operações do tipo "arrastar e soltar". As tabelas a seguir resumem os eventos padrão de arrastar e soltar. Estes são eventos associados à classe DragDrop. Para obter mais informações sobre eventos anexados, consulte Visão geral de eventos anexados.

Eventos de origem do arrasto

Acontecimento	Resumo
GiveFeedback	Esse evento ocorre continuamente durante uma operação do tipo "arrastar e soltar" e permite que a origem de soltar forneça informações de comentários ao usuário. Geralmente, esses comentários são fornecidos com a alteração da aparência do ponteiro do mouse para indicar os efeitos permitidos pelo destino de soltura. Este é um evento efervescente.
QueryContinueDrag	Esse evento ocorre quando há uma alteração nos estados do teclado ou do botão do mouse durante uma operação do tipo "arrastar e soltar" e permite que a origem de soltar cancele a operação do tipo "arrastar e soltar", dependendo dos estados da tecla e do botão. Este é um evento efervescente.
PreviewGiveFeedback	Versão de túnel do GiveFeedback.
PreviewQueryContinueDrag	Versão de túnel do QueryContinueDrag.

Eventos do destino de soltura

Acontecimento	Resumo
DragEnter	Esse evento ocorre quando um objeto é arrastado para os limites do destino de soltura. Este é um evento efervescente.
DragLeave	Esse evento ocorre quando um objeto é arrastado para fora dos limites do destino de soltura. Este é um evento efervescente.
DragOver	Esse evento ocorre continuamente enquanto um objeto é arrastado (movido) dentro do limite do destino de soltura. Este é um evento efervescente.
Drop	Esse evento ocorre quando um objeto é solto no destino de soltura. Este é um evento efervescente.
PreviewDragEnter	Versão de túnel do DragEnter.
PreviewDragLeave	Versão de túnel do DragLeave.
PreviewDragOver	Versão de túnel do DragOver.
PreviewDrop	Versão de túnel do Drop.

Para manipular eventos de arrastar e soltar para instâncias de um objeto, adicione manipuladores para os eventos listados nas tabelas anteriores. Para manipular eventos das operações do tipo "arrastar e soltar" no nível de classe, substitua os métodos virtuais On*Event e On*PreviewEvent correspondentes.

Implementando operações do tipo "arrastar e soltar"

Um elemento de interface do usuário pode ser uma origem do arrasto, um destino de soltura ou ambos. Para implementar o arrastar e soltar básico, você escreve código para iniciar a operação de arrastar e soltar e processar os dados descartados. É possível melhorar essa experiência de "arrastar e soltar" manipulando eventos opcionais das operações do tipo "arrastar e soltar".

Para implementar o arrastar e soltar básico, você concluirá as seguintes tarefas:

• Identifique o elemento que será uma origem de arraste. Uma origem de arrasto pode ser um UIElement ou um ContentElement.

• Crie um manipulador de eventos na origem do arrasto que iniciará a operação do tipo "arrastar e soltar". O evento normalmente é MouseMove.

• No manipulador de eventos de origem de arrasto, chame o método DoDragDrop para iniciar a operação de arrastar e soltar. Na chamada DoDragDrop, especifique a fonte de arrastar, os dados a serem transferidos e os efeitos permitidos.

• Identificar o elemento que será um destino de soltura. Um destino de soltura pode ser UIElement ou um ContentElement.

• No destino de soltura, configure a propriedade AllowDrop para true.

• No destino de soltura, crie um manipulador de eventos Drop para processar os dados soltos.

• No manipulador de eventos Drop, extraia os dados do DragEventArgs usando os métodos GetDataPresent e GetData.

• No manipulador de eventos Drop, use os dados para executar a operação de arrastar e soltar desejada.

Você pode aprimorar sua implementação de arrastar e soltar criando uma DataObject personalizada e manipulando eventos opcionais da origem de arrasto e do destino de soltura, conforme mostrado nas seguintes tarefas:

• Para transferir dados personalizados ou vários itens de dados, crie uma DataObject para passar para o método DoDragDrop.

• Para executar ações adicionais durante uma operação de arrastar, manipule os eventos DragEnter, DragOver e DragLeave no destino de soltura.

• Para alterar a aparência do ponteiro do mouse, manipule o evento GiveFeedback na origem do arrasto.

• Para alterar como a operação do tipo "arrastar e soltar" é cancelada, manipule o evento QueryContinueDrag na origem do arrasto.

Exemplo de operação do tipo "arrastar e soltar"

Esta seção descreve como implementar arrastar e soltar para um elemento Ellipse. O Ellipse é tanto uma origem de arrasto quanto um destino de soltura. Os dados transferidos são a representação em cadeia de texto da propriedade Fill da elipse. O XAML a seguir mostra o elemento Ellipse e os eventos relacionados a arrastar e soltar que ele manipula. Para obter etapas completas sobre como implementar o arrastar e soltar, consulte Passo a passo: habilitando arrastar e soltar em um controle de usuário.

<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" />

Habilitando um elemento como fonte de arrasto

Um objeto que é uma origem de arraste é responsável por:

• Identificar quando ocorre uma operação de arrasto.

• Iniciar a operação do tipo "arrastar e soltar".

• Identificando os dados a serem transferidos.

• Especificando os efeitos permitidos da operação de arrastar e soltar nos dados transferidos.

A fonte de arrasto também pode fornecer retorno ao usuário sobre as ações permitidas (mover, copiar, nenhuma) e pode cancelar a operação de arrastar e soltar com base em entradas adicionais do usuário, como pressionar a tecla ESC durante o arrasto.

É responsabilidade do seu aplicativo determinar quando ocorre um arraste e, em seguida, iniciar a operação de arrastar e soltar chamando o método DoDragDrop. Normalmente, é quando um evento MouseMove ocorre sobre o elemento a ser arrastado enquanto um botão do mouse é pressionado. O exemplo a seguir mostra como iniciar uma operação de arrastar e soltar do manipulador de eventos MouseMove de um elemento Ellipse para torná-la uma origem de arrasto. Os dados transferidos são a representação em cadeia de texto da propriedade Fill da elipse.

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

Dentro do manipulador de eventos MouseMove, chame o método DoDragDrop para iniciar a operação de arrastar e soltar. O método DoDragDrop usa três parâmetros:

• dragSource – uma referência ao objeto de dependência que é a fonte dos dados transferidos; normalmente, essa é a origem do evento MouseMove.

• data - Um objeto que contém os dados transferidos, encapsulados em um DataObject.

• allowedEffects – um dos valores de enumeração DragDropEffects que especifica os efeitos permitidos da operação de arrastar e soltar.

Qualquer objeto serializável pode ser passado no parâmetro data. Se os dados ainda não estiverem encapsulados em um DataObject, eles serão encapsulados automaticamente em um novo DataObject. Para passar vários itens de dados, você deve criar a DataObject por conta própria e passá-la para o método DoDragDrop. Para obter mais informações, consulte Dados e Objetos de Dados.

O parâmetro allowedEffects é usado para especificar o que a origem do arrasto permitirá que o destino de soltura faça com os dados transferidos. Os valores comuns de uma origem de arrasto são Copy, Movee All.

Observação

O destino de soltura também pode especificar quais efeitos ele pretende ter em resposta aos dados soltos. Por exemplo, se o destino de soltar não reconhecer o tipo de dados a ser solto, ele poderá recusar os dados configurando seus efeitos permitidos em None. Normalmente, ele faz isso em seu manipulador de eventos DragOver.

Uma origem de arrasto também pode manipular os eventos GiveFeedback e QueryContinueDrag. Esses eventos têm manipuladores padrão que são usados, a menos que você marque os eventos como manipulados. Normalmente, você ignorará esses eventos, a menos que tenha uma necessidade específica de alterar seu comportamento padrão.

O evento GiveFeedback é gerado continuamente enquanto a origem de arrasto está sendo arrastada. O manipulador padrão para esse evento verifica se a origem do arrasto está sobre um destino de soltura válido. Se estiver, ela verificará os efeitos permitidos do destino de soltar. Em seguida, ela fornece comentários ao usuário final sobre os efeitos de soltar permitidos. Geralmente, isso é feito com a alteração do cursor do mouse para não soltar, copiar ou mover cursor. Você só deve lidar com esse evento se precisar usar cursores personalizados para fornecer comentários ao usuário. Se você manipular esse evento, lembre-se de marcá-lo como manipulado para que o manipulador padrão não substitua o manipulador.

O evento QueryContinueDrag é gerado continuamente enquanto a origem de arrasto está sendo arrastada. Você pode manipular esse evento para determinar qual ação encerra a operação de arrastar e soltar com base no estado das teclas ESC, SHIFT, CTRL e ALT, bem como o estado dos botões do mouse. O manipulador padrão desse evento cancela a operação de arrastar e soltar se a tecla ESC for pressionada e removerá os dados se o botão do mouse for liberado.

Cuidado

Esses eventos são acionados continuamente durante a operação do tipo "arrastar e soltar". Portanto, você deve evitar tarefas com uso intensivo de recursos nos manipuladores de eventos. Por exemplo, use um cursor armazenado em cache em vez de criar um novo cursor sempre que o evento GiveFeedback for gerado.

Habilitando um elemento a ser um destino de soltura

Um objeto que é um destino de soltar é responsável por:

• Especificar se ele é um destino de soltar válido.

• Responder à origem do arrasto quando ele é arrastado para o destino.

• Verificando se os dados transferidos estão em um formato que ele possa receber.

• Processar os dados soltos.

Para especificar que um elemento é um destino de descarte, defina sua propriedade AllowDrop como true. Em seguida, os eventos de destino de soltar serão acionados no elemento para que você possa manipulá-los.

Quando um destino de soltar é avaliado, um teste de ocorrência é executado para identificar se o cursor está sobre o visual do elemento. Alguns controles, como Canvas, não têm uma representação visual e não podem ser usados como destino de soltura, a menos que uma representação visual seja adicionada. Defina a propriedade Canvas.Background para qualquer cor para criar um visual que preencha a Canvas com cor. Para manter a Canvas transparente, mas habilitá-la como um destino de soltura, defina a propriedade Background como Transparent.

Durante uma operação de arrastar e soltar, a seguinte sequência de eventos ocorre no alvo de soltura:

1. DragEnter

2. DragOver

3. DragLeave ou Drop

O evento DragEnter ocorre quando os dados são arrastados para o limite do destino de soltura. Normalmente, você manipula esse evento para fornecer uma visualização dos efeitos da operação de arrastar e soltar, se apropriado para seu aplicativo. Não defina a propriedade DragEventArgs.Effects no evento DragEnter, pois ela será substituída no evento DragOver.

O exemplo a seguir mostra o manipulador de eventos DragEnter para um elemento Ellipse. Esse código visualiza os efeitos da operação do tipo "arrastar e soltar" salvando o pincel Fill atual. Em seguida, ele usa o método GetDataPresent para verificar se o DataObject sendo arrastado sobre a elipse contém dados de string que podem ser convertidos em um Brush. Nesse caso, os dados são extraídos usando o método GetData. Em seguida, ele é convertido em um Brush e aplicado à elipse. A alteração é revertida no manipulador de eventos DragLeave. Se os dados não puderem ser convertidos em um Brush, nenhuma ação será executada.

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

O evento DragOver ocorre continuamente enquanto os dados são arrastados sobre o destino de soltura. Esse evento é emparelhado com o evento GiveFeedback na origem de arrasto. No manipulador de eventos DragOver, normalmente você usa os métodos GetDataPresent e GetData para verificar se os dados transferidos estão em um formato que o destino de descarte pode processar. Você também pode verificar se as teclas modificadoras são pressionadas, o que normalmente indicará se o usuário pretende mover ou copiar uma ação. Depois de realizar essas verificações, defina a propriedade DragEventArgs.Effects para notificar a origem do arrasto do efeito de soltar os dados. A fonte de arrastar recebe essas informações nos argumentos do evento GiveFeedback e pode definir um cursor apropriado para fornecer feedback ao usuário.

O exemplo a seguir mostra o manipulador de eventos DragOver para um elemento Ellipse. Esse código verifica se o DataObject que está sendo arrastado sobre a elipse contém dados string que podem ser convertidos em um Brush. Em caso afirmativo, ele define a propriedade DragEventArgs.Effects como Copy. Isso indica à origem de arrasto que os dados podem ser copiados para a elipse. Se os dados não puderem ser convertidos em um Brush, a propriedade DragEventArgs.Effects será definida como None. Isso indica à origem do arrasto que a elipse não é um destino de soltura válido para os dados.

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

O evento DragLeave ocorre quando os dados são arrastados para fora do limite do destino sem que sejam soltos. Você manipula esse evento para desfazer tudo que você fez no manipulador de eventos DragEnter.

O exemplo a seguir mostra o manipulador de eventos DragLeave para um elemento Ellipse. Esse código reverte a pré-visualização realizada no manipulador de eventos DragEnter, aplicando à elipse o Brush salvo.

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

O evento Drop ocorre quando os dados são soltos no destino de soltar; por padrão, isso ocorre quando o botão do mouse é liberado. No manipulador de eventos Drop, use o método GetData para extrair os dados transferidos do DataObject e executar qualquer processamento de dados exigido pelo aplicativo. O evento Drop encerra a operação de arrastar e soltar.

O exemplo a seguir mostra o manipulador de eventos Drop para um elemento Ellipse. Esse código aplica os efeitos da operação de arrastar e soltar e é semelhante ao código no manipulador de eventos DragEnter. Ele verifica se o DataObject que está sendo arrastado sobre a elipse contém dados de cadeia de caracteres que podem ser convertidos em um Brush. Nesse caso, o Brush será aplicado à elipse. Se os dados não puderem ser convertidos em um Brush, nenhuma ação será executada.

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

Consulte também

• Clipboard
• Passo a passo: habilitando arrastar e soltar em um controle de usuário
• Tópicos "Como Fazer"
• Arrastar e soltar