Control.DoDragDrop Método

Definición

Espacio de nombres:

System.Windows.Forms

Ensamblado:

System.Windows.Forms.dll

Sobrecargas

DoDragDrop(Object, DragDropEffects, Bitmap, Point, Boolean)	Inicia una operación de arrastre.
DoDragDrop(Object, DragDropEffects)	Comienza una operación de arrastrar y colocar.

DoDragDrop(Object, DragDropEffects, Bitmap, Point, Boolean)

Inicia una operación de arrastre.

C#

public System.Windows.Forms.DragDropEffects DoDragDrop (object data, System.Windows.Forms.DragDropEffects allowedEffects, System.Drawing.Bitmap? dragImage, System.Drawing.Point cursorOffset, bool useDefaultDragImage);

Parámetros

data

Object

allowedEffects

DragDropEffects

dragImage

Bitmap

cursorOffset

Point

useDefaultDragImage

Boolean

Devoluciones

DragDropEffects

Valor de la enumeración DragDropEffects que representa el efecto final que se realizó durante la operación de arrastrar y colocar.

Comentarios

El parámetro allowedEffects determina qué operaciones de arrastre pueden producirse. Si la operación de arrastre necesita interoperabilidad con aplicaciones en otro proceso, data debe ser una clase administrada base (String, Bitmapo Metafile) o algunas Object que implementan ISerializable. data también puede ser cualquier Object que implemente IDataObject. dragImage es el mapa de bits que se mostrará durante la operación de arrastre y cursorOffset especifica la ubicación del cursor dentro de dragImage, que es un desplazamiento desde la esquina superior izquierda. Especifique true para useDefaultDragImage usar una imagen de arrastre de ventana superpuesta con un tamaño de 96 x 96; de lo contrario, false. Tenga en cuenta que los bordes exteriores de dragImage se mezclan si el ancho o alto de la imagen supera los 300 píxeles.

Dado que DoDragDrop(Object, DragDropEffects, Bitmap, Point, Boolean) siempre realiza el paso de multiplicación RGB al calcular el valor alfa, siempre debe pasar un Bitmap sin combinación alfa premultiplicada. No se producirá ningún error al pasar una Bitmap con combinación alfa premultipada, pero este método lo multiplicará de nuevo, duplicando el valor alfa resultante.

DoDragDrop(Object, DragDropEffects)

Comienza una operación de arrastrar y colocar.

C#

public System.Windows.Forms.DragDropEffects DoDragDrop (object data, System.Windows.Forms.DragDropEffects allowedEffects);

Parámetros

data

Object

Datos que se van a arrastrar.

allowedEffects

DragDropEffects

Uno de los valores de DragDropEffects.

Devoluciones

DragDropEffects

Valor de la enumeración DragDropEffects que representa el efecto final que se realizó durante la operación de arrastrar y colocar.

Ejemplos

En el ejemplo de código siguiente se muestra una operación de arrastrar y colocar entre dos controles ListBox. En el ejemplo se llama al método DoDragDrop cuando se inicia la acción de arrastrar. La acción de arrastrar se inicia si el mouse se ha movido más de SystemInformation.DragSize desde la ubicación del mouse durante el evento MouseDown. El método IndexFromPoint se usa para determinar el índice del elemento que se va a arrastrar durante el evento MouseDown.

En el ejemplo también se muestra el uso de cursores personalizados para la operación de arrastrar y colocar. El ejemplo requiere que dos archivos de cursor, 3dwarro.cur y 3dwno.cur, existan en el directorio de la aplicación, para los cursores de arrastrar y sin colocar personalizados, respectivamente. Los cursores personalizados se usarán si se comprueba el UseCustomCursorsCheckCheckBox. Los cursores personalizados se establecen en el controlador de eventos GiveFeedback.

El estado del teclado se evalúa en el controlador de eventos DragOver de la derecha ListBox, para determinar cuál será la operación de arrastre en función del estado de las teclas MAYÚS, CTRL, ALT o CTRL+ALT. La ubicación del ListBox donde se produciría la eliminación también se determina durante el evento DragOver. Si los datos que se van a quitar no son un String, el DragEventArgs.Effect se establece en None en DragDropEffects. Por último, el estado de la colocación se muestra en el DropLocationLabelLabel.

Los datos que se van a quitar de la ListBox derecha se determinan en el controlador de eventos DragDrop y el valor de String se agrega en el lugar adecuado de la ListBox. Si la operación de arrastre se mueve fuera de los límites del formulario, la operación de arrastrar y colocar se cancela en el controlador de eventos QueryContinueDrag.

C#

using System;
using System.Drawing;
using System.Windows.Forms;

namespace Snip_DragNDrop
{
    public class Form1 : Form
    {
        private ListBox ListDragSource;
        private ListBox ListDragTarget;
        private CheckBox UseCustomCursorsCheck;
        private Label DropLocationLabel;

        private int indexOfItemUnderMouseToDrag;
        private int indexOfItemUnderMouseToDrop;

        private Rectangle dragBoxFromMouseDown;
        private Point screenOffset;

        private Cursor MyNoDropCursor;
        private Cursor MyNormalCursor;

        // The main entry point for the application.
        [STAThread]
        static void Main()
        {
            Application.Run(new Form1());
        }

        public Form1()
        {
            this.ListDragSource = new ListBox();
            this.ListDragTarget = new ListBox();
            this.UseCustomCursorsCheck = new CheckBox();
            this.DropLocationLabel = new Label();

            this.SuspendLayout();

            // ListDragSource
            this.ListDragSource.Items.AddRange(new object[] {"one", "two", "three", "four",
                                                             "five", "six", "seven", "eight",
                                                             "nine", "ten"});
            this.ListDragSource.Location = new Point(10, 17);
            this.ListDragSource.Size = new Size(120, 225);
            this.ListDragSource.MouseDown += this.ListDragSource_MouseDown;
            this.ListDragSource.QueryContinueDrag += this.ListDragSource_QueryContinueDrag;
            this.ListDragSource.MouseUp += this.ListDragSource_MouseUp;
            this.ListDragSource.MouseMove += this.ListDragSource_MouseMove;
            this.ListDragSource.GiveFeedback += this.ListDragSource_GiveFeedback;

            // ListDragTarget
            this.ListDragTarget.AllowDrop = true;
            this.ListDragTarget.Location = new Point(154, 17);
            this.ListDragTarget.Size = new Size(120, 225);
            this.ListDragTarget.DragOver += this.ListDragTarget_DragOver;
            this.ListDragTarget.DragDrop += this.ListDragTarget_DragDrop;
            this.ListDragTarget.DragEnter += this.ListDragTarget_DragEnter;
            this.ListDragTarget.DragLeave += this.ListDragTarget_DragLeave;

            // UseCustomCursorsCheck
            this.UseCustomCursorsCheck.Location = new Point(10, 243);
            this.UseCustomCursorsCheck.Size = new Size(137, 24);
            this.UseCustomCursorsCheck.Text = "Use Custom Cursors";

            // DropLocationLabel
            this.DropLocationLabel.Location = new Point(154, 245);
            this.DropLocationLabel.Size = new Size(137, 24);
            this.DropLocationLabel.Text = "None";

            // Form1
            this.ClientSize = new Size(292, 270);
            this.Controls.AddRange(new Control[] {
                this.ListDragSource,
                this.ListDragTarget,
                this.UseCustomCursorsCheck,
                this.DropLocationLabel});
            this.Text = "drag-and-drop Example";

            this.ResumeLayout(false);
        }

        private void ListDragSource_MouseDown(object sender, MouseEventArgs e)
        {
            // Get the index of the item the mouse is below.
            indexOfItemUnderMouseToDrag = ListDragSource.IndexFromPoint(e.X, e.Y);

            if (indexOfItemUnderMouseToDrag != ListBox.NoMatches)
            {
                // Remember the point where the mouse down occurred. The DragSize indicates
                // the size that the mouse can move before a drag event should be started.
                Size dragSize = SystemInformation.DragSize;

                // Create a rectangle using the DragSize, with the mouse position being
                // at the center of the rectangle.
                dragBoxFromMouseDown = new Rectangle(
                    new Point(e.X - (dragSize.Width / 2),
                              e.Y - (dragSize.Height / 2)),
                    dragSize);
            }
            else
            {
                // Reset the rectangle if the mouse is not over an item in the ListBox.
                dragBoxFromMouseDown = Rectangle.Empty;
            }
        }

        private void ListDragSource_MouseUp(object sender, MouseEventArgs e)
        {
            // Reset the drag rectangle when the mouse button is raised.
            dragBoxFromMouseDown = Rectangle.Empty;
        }

        private void ListDragSource_MouseMove(object sender, MouseEventArgs e)
        {
            if ((e.Button & MouseButtons.Left) == MouseButtons.Left)
            {
                // If the mouse moves outside the rectangle, start the drag.
                if (dragBoxFromMouseDown != Rectangle.Empty &&
                    !dragBoxFromMouseDown.Contains(e.X, e.Y))
                {
                    // Create custom cursors for the drag-and-drop operation.
                    try
                    {
                        MyNormalCursor = new Cursor("3dwarro.cur");
                        MyNoDropCursor = new Cursor("3dwno.cur");
                    }
                    catch
                    {
                        // An error occurred while attempting to load the cursors, so use
                        // standard cursors.
                        UseCustomCursorsCheck.Checked = false;
                    }
                    finally
                    {
                        // The screenOffset is used to account for any desktop bands 
                        // that may be at the top or left side of the screen when 
                        // determining when to cancel the drag drop operation.
                        screenOffset = SystemInformation.WorkingArea.Location;

                        // Proceed with the drag-and-drop, passing in the list item.
                        DragDropEffects dropEffect = ListDragSource.DoDragDrop(ListDragSource.Items[indexOfItemUnderMouseToDrag], DragDropEffects.All | DragDropEffects.Link);

                        // If the drag operation was a move then remove the item.
                        if (dropEffect == DragDropEffects.Move)
                        {
                            ListDragSource.Items.RemoveAt(indexOfItemUnderMouseToDrag);

                            // Selects the previous item in the list as long as the list has an item.
                            if (indexOfItemUnderMouseToDrag > 0)
                                ListDragSource.SelectedIndex = indexOfItemUnderMouseToDrag - 1;

                            else if (ListDragSource.Items.Count > 0)
                                // Selects the first item.
                                ListDragSource.SelectedIndex = 0;
                        }

                        // Dispose of the cursors since they are no longer needed.
                        if (MyNormalCursor != null)
                            MyNormalCursor.Dispose();

                        if (MyNoDropCursor != null)
                            MyNoDropCursor.Dispose();
                    }
                }
            }
        }
        private void ListDragSource_GiveFeedback(object sender, GiveFeedbackEventArgs e)
        {
            // Use custom cursors if the check box is checked.
            if (UseCustomCursorsCheck.Checked)
            {
                // Sets the custom cursor based upon the effect.
                e.UseDefaultCursors = false;
                if ((e.Effect & DragDropEffects.Move) == DragDropEffects.Move)
                    Cursor.Current = MyNormalCursor;
                else
                    Cursor.Current = MyNoDropCursor;
            }
        }
        private void ListDragTarget_DragOver(object sender, DragEventArgs e)
        {
            // Determine whether string data exists in the drop data. If not, then
            // the drop effect reflects that the drop cannot occur.
            if (!e.Data.GetDataPresent(typeof(System.String)))
            {
                e.Effect = DragDropEffects.None;
                DropLocationLabel.Text = "None - no string data.";
                return;
            }

            // Set the effect based upon the KeyState.
            if ((e.KeyState & (8 + 32)) == (8 + 32) &&
                (e.AllowedEffect & DragDropEffects.Link) == DragDropEffects.Link)
            {
                // KeyState 8 + 32 = CTRL + ALT

                // Link drag-and-drop effect.
                e.Effect = DragDropEffects.Link;
            }
            else if ((e.KeyState & 32) == 32 &&
                (e.AllowedEffect & DragDropEffects.Link) == DragDropEffects.Link)
            {
                // ALT KeyState for link.
                e.Effect = DragDropEffects.Link;
            }
            else if ((e.KeyState & 4) == 4 &&
                (e.AllowedEffect & DragDropEffects.Move) == DragDropEffects.Move)
            {
                // SHIFT KeyState for move.
                e.Effect = DragDropEffects.Move;
            }
            else if ((e.KeyState & 8) == 8 &&
                (e.AllowedEffect & DragDropEffects.Copy) == DragDropEffects.Copy)
            {
                // CTRL KeyState for copy.
                e.Effect = DragDropEffects.Copy;
            }
            else if ((e.AllowedEffect & DragDropEffects.Move) == DragDropEffects.Move)
            {
                // By default, the drop action should be move, if allowed.
                e.Effect = DragDropEffects.Move;
            }
            else
            {
                e.Effect = DragDropEffects.None;
            }

            // Get the index of the item the mouse is below. 

            // The mouse locations are relative to the screen, so they must be 
            // converted to client coordinates.

            indexOfItemUnderMouseToDrop =
                ListDragTarget.IndexFromPoint(ListDragTarget.PointToClient(new Point(e.X, e.Y)));

            // Updates the label text.
            if (indexOfItemUnderMouseToDrop != ListBox.NoMatches)
            {
                DropLocationLabel.Text = "Drops before item #" + (indexOfItemUnderMouseToDrop + 1);
            }
            else
            {
                DropLocationLabel.Text = "Drops at the end.";
            }
        }
        private void ListDragTarget_DragDrop(object sender, DragEventArgs e)
        {
            // Ensure that the list item index is contained in the data.
            if (e.Data.GetDataPresent(typeof(System.String)))
            {
                Object item = e.Data.GetData(typeof(System.String));

                // Perform drag-and-drop, depending upon the effect.
                if (e.Effect == DragDropEffects.Copy ||
                    e.Effect == DragDropEffects.Move)
                {
                    // Insert the item.
                    if (indexOfItemUnderMouseToDrop != ListBox.NoMatches)
                        ListDragTarget.Items.Insert(indexOfItemUnderMouseToDrop, item);
                    else
                        ListDragTarget.Items.Add(item);
                }
            }
            // Reset the label text.
            DropLocationLabel.Text = "None";
        }
        private void ListDragSource_QueryContinueDrag(object sender, QueryContinueDragEventArgs e)
        {
            // Cancel the drag if the mouse moves off the form.
            ListBox lb = sender as ListBox;

            if (lb != null)
            {
                Form f = lb.FindForm();

                // Cancel the drag if the mouse moves off the form. The screenOffset
                // takes into account any desktop bands that may be at the top or left
                // side of the screen.
                if (((Control.MousePosition.X - screenOffset.X) < f.DesktopBounds.Left) ||
                    ((Control.MousePosition.X - screenOffset.X) > f.DesktopBounds.Right) ||
                    ((Control.MousePosition.Y - screenOffset.Y) < f.DesktopBounds.Top) ||
                    ((Control.MousePosition.Y - screenOffset.Y) > f.DesktopBounds.Bottom))
                {
                    e.Action = DragAction.Cancel;
                }
            }
        }
        private void ListDragTarget_DragEnter(object sender, DragEventArgs e)
        {
            // Reset the label text.
            DropLocationLabel.Text = "None";
        }
        private void ListDragTarget_DragLeave(object sender, EventArgs e)
        {
            // Reset the label text.
            DropLocationLabel.Text = "None";
        }
    }
}

En el ejemplo de código siguiente se muestra cómo usar la enumeración DragDropEffects para especificar cómo se deben transferir los datos entre los controles implicados en una operación de arrastrar y colocar. Este ejemplo requiere que el formulario incluya un control RichTextBox y un control ListBox y que el control ListBox se rellene con una lista de nombres de archivo válidos. Cuando el usuario arrastra un nombre de archivo al control RichTextBox, se genera el evento DragEnter del control. Dentro del controlador de eventos, la propiedad Effect del DragEventArgs se inicializa para DragDropEffects para indicar que los datos a los que hace referencia la ruta de acceso del archivo se deben copiar en el control RichTextBox.

C#

private void Form1_Load(object sender, EventArgs e) 
{
   // Sets the AllowDrop property so that data can be dragged onto the control.
   richTextBox1.AllowDrop = true;

   // Add code here to populate the ListBox1 with paths to text files.
}

private void listBox1_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
{
   // Determines which item was selected.
   ListBox lb =( (ListBox)sender);
   Point pt = new Point(e.X,e.Y);
   int index = lb.IndexFromPoint(pt);

   // Starts a drag-and-drop operation with that item.
   if(index>=0) 
   {
      lb.DoDragDrop(lb.Items[index].ToString(), DragDropEffects.Link);
   }
}

private void richTextBox1_DragEnter(object sender, DragEventArgs e) 
{
   // If the data is text, copy the data to the RichTextBox control.
   if(e.Data.GetDataPresent("Text"))
      e.Effect = DragDropEffects.Copy;
}

private void richTextBox1_DragDrop(object sender, DragEventArgs e) 
{
   // Loads the file into the control. 
   richTextBox1.LoadFile((String)e.Data.GetData("Text"), System.Windows.Forms.RichTextBoxStreamType.RichText);
}

Comentarios

El parámetro allowedEffects determina qué operaciones de arrastre pueden producirse. Si la operación de arrastre necesita interoperar con aplicaciones en otro proceso, los datos deben ser una clase administrada base (String, Bitmapo Metafile) o un objeto que implemente ISerializable o IDataObject.

A continuación se describe cómo y cuándo se generan eventos relacionados con las operaciones de arrastrar y colocar.

El método DoDragDrop determina el control bajo la ubicación actual del cursor. A continuación, comprueba si el control es un destino de colocación válido.

Si el control es un destino de colocación válido, el evento GiveFeedback se genera con el efecto de arrastrar y colocar especificado. Para obtener una lista de efectos de arrastrar y colocar, consulte la enumeración DragDropEffects.

Se realiza un seguimiento de los cambios en la posición del cursor del mouse, el estado del teclado y el estado del botón del mouse.

• Si el usuario sale de una ventana, se genera el evento DragLeave.

• Si el mouse entra en otro control, se genera el DragEnter de ese control.

• Si el mouse se mueve pero permanece dentro del mismo control, se genera el evento DragOver.

Si hay un cambio en el estado del teclado o del botón del mouse, se genera el evento QueryContinueDrag y determina si se va a continuar con la arrastrar, colocar los datos o cancelar la operación en función del valor de la propiedad Action del QueryContinueDragEventArgsdel evento.

• Si el valor de DragAction es Continue, se genera el evento DragOver para continuar con la operación y el evento GiveFeedback se genera con el nuevo efecto para que se puedan establecer los comentarios visuales adecuados. Para obtener una lista de efectos de colocación válidos, consulte la enumeración DragDropEffects.

  Nota

  Los eventos DragOver y GiveFeedback se emparejan para que, a medida que el mouse se mueva a través del destino de colocación, el usuario recibe los comentarios más up-to-date en la posición del mouse.

• Si el valor de DragAction es Drop, el valor de efecto de colocación se devuelve al origen, por lo que la aplicación de origen puede realizar la operación adecuada en los datos de origen; Por ejemplo, corte los datos si la operación era un movimiento.

• Si el valor de DragAction es Cancel, se genera el evento DragLeave.

Nota

El método DoDragDrop detecta todas las excepciones y vuelve a iniciar solo las siguientes excepciones de seguridad o críticas:

• SecurityException

• NullReferenceException

• StackOverflowException

• OutOfMemoryException

• ThreadAbortException

• ExecutionEngineException

• IndexOutOfRangeException

• AccessViolationException

Consulte también

• AllowDrop
• DragDrop