Información general sobre la función de arrastrar y colocar
Actualización: noviembre 2007
En este tema se proporciona información general sobre la compatibilidad con la operación de arrastrar y colocar en las aplicaciones de Windows Presentation Foundation (WPF). Arrastrar y colocar suele referirse a un método de interacción con la interfaz de usuario (UI) que implica utilizar un mouse (u otro dispositivo señalador) para seleccionar uno o más objetos, arrastrarlos hasta un destino de colocación deseado de la interfaz de usuario y colocarlos.
Este tema contiene las secciones siguientes.
- Compatibilidad con arrastrar y colocar en WPF
- Datos y objetos de datos
- Eventos de arrastrar y colocar
- Trabajar con objetos de datos
- Temas relacionados
Compatibilidad con arrastrar y colocar en WPF
En las operaciones de arrastrar y colocar suelen participar dos partes: un origen de arrastre, donde se origina el objeto que se arrastra, y un destino de colocación, que recibe el objeto al colocarlo. El origen de arrastre y el destino de colocación pueden pertenecer a la misma aplicación o a distintas aplicaciones.
El tipo y número de objetos que se pueden manipular con arrastrar y colocar son completamente arbitrarios; uno o más archivos o carpetas y selecciones de contenido son algunos de los objetos más comunes que se manipulan mediante este tipo de operaciones. La acción o acciones concretas que se realizan durante una operación de arrastrar y colocar son específicas de la aplicación y, a menudo, vienen determinadas por el contexto. Por ejemplo, al arrastrar una selección de archivos desde una carpeta hasta otra dentro del mismo dispositivo de almacenamiento, de manera predeterminada los archivos se mueven; en cambio, al arrastrar archivos desde un recurso compartido Convención de nomenclatura universal (UNC) hasta una carpeta local, de manera predeterminada los archivos se copian. Las funciones de arrastrar y colocar proporcionadas por WPF se han diseñado para ser extremadamente flexibles y personalizables, a fin de admitir gran variedad de escenarios de arrastrar y colocar. La función de arrastrar y colocar permite manipular los objetos dentro de una misma aplicación o entre aplicaciones diferentes; también se proporciona compatibilidad plena con la función de arrastrar y colocar entre aplicaciones de WPF y otras aplicaciones de Windows. La función de arrastrar y colocar constituye un aspecto de la transferencia de datos, que es un área más general; además de arrastrar y colocar, la transferencia de datos incluye utilizar el portapapeles del sistema para las operaciones de copiar y pegar.
Nota de seguridad: la función de arrastrar y colocar de OLE no funciona en la zona de Internet.
Datos y objetos de datos
Los datos que se transfieren como parte de una operación de arrastrar y colocar se almacenan en un objeto de datos. Conceptualmente, un objeto de datos está compuesto de uno o más pares de:
una clase Object que contiene los datos reales, y
un identificador del formato de datos correspondiente.
Los datos en sí pueden estar compuestos de cualquier elemento que se puede representar como una clase base Object. El formato de datos correspondiente es una cadena o Type que proporciona información sobre el formato de los datos. Los objetos de datos permiten hospedar varios pares de datos-(formato de datos); esto permite que un mismo objeto de datos proporcione los datos en varios formatos.
Todos los objetos de datos deben implementar la interfaz IDataObject, que proporciona el siguiente conjunto de métodos estándar que habilitan y facilitan la transferencia de datos.
Método |
Resumen |
|---|---|
Recupera un objeto de datos en un formato de datos especificado. |
|
Comprueba si los datos están disponibles en un formato especificado o se pueden convertir a él. |
|
Devuelve una lista de formatos en los que se almacenan los datos de este objeto de datos; o bien, a los que se pueden convertir. |
|
Almacena los datos especificados en este objeto de datos. |
WPF proporciona una implementación básica de IDataObject en la clase DataObject; la clase DataObject estándar es suficiente para numerosos escenarios de transferencia de datos.
Para obtener información sobre formatos de datos predefinidos proporcionados con WPF, consulte el tema de referencia de la clase DataFormats.
Los objetos de datos suelen incluir una función para convertir automáticamente datos almacenados en un formato a un formato diferente al extraer los datos; esta función se denomina autoconversión.
Al consultar los formatos de datos disponibles en un objeto de datos, los formatos de datos autoconvertibles se pueden filtrar para distinguirlos de los formatos de datos nativos; para ello, se llama al método GetFormats(Boolean) o GetDataPresent(String, Boolean) y se establece el parámetro autoConvert en falso. Al agregar datos a un objeto de datos con el método SetData(String, Object, Boolean), se puede prohibir la autoconversión de los datos estableciendo el parámetro autoConvert en falso.
Eventos de arrastrar y colocar
Las operaciones de arrastrar y colocar admiten un modelo basado en eventos. Tanto el origen de arrastre como el destino de colocación utilizan un conjunto estándar de eventos para controlar las operaciones de arrastrar y colocar. En las tablas siguientes se resumen los eventos de arrastrar y colocar estándar.
Eventos del origen de arrastre
Evento |
Resumen |
|---|---|
Este evento se produce cuando se inicia una operación de arrastrar y colocar, y se permite que el destino de colocación envíe información de comentarios al origen de arrastre; este último suele utilizar estos comentarios para ajustar dinámicamente el aspecto del puntero del mouse a fin de proporcionar información al usuario. Se trata de un evento de propagación. |
|
Este evento se produce cuando hay un cambio en el estado del teclado o del botón del mouse durante una operación de arrastrar y colocar, y permite al origen de colocación cancelar la operación de arrastrar y colocar en función de ese estado. Se trata de un evento de propagación. |
|
Versión de túnel de GiveFeedback. |
|
Versión de túnel de QueryContinueDrag. |
Eventos del destino de colocación
Evento |
Resumen |
|---|---|
Este evento se produce cuando se arrastra un objeto a los límites del destino de colocación. Se trata de un evento de propagación. |
|
Este evento se produce cuando se arrastra un objeto fuera de los límites del destino de colocación. Se trata de un evento de propagación. |
|
Este evento se produce cuando se arrastra (mueve) un objeto dentro de los límites del destino de colocación. Se trata de un evento de propagación. |
|
Este evento se produce cuando un objeto se coloca en el destino de colocación. Se trata de un evento de propagación. |
|
Versión de túnel de DragEnter. |
|
Versión de túnel de DragLeave. |
|
Versión de túnel de DragOver. |
|
Versión de túnel de Drop. |
Trabajar con objetos de datos
En esta sección se describen las técnicas comunes para crear objetos de datos y trabajar con ellos.
Utilizar constructores DataObject
La clase DataObject proporciona varios constructores sobrecargados que facilitan la operación de rellenar una nueva instancia de DataObject con un solo par de datos-(formato de datos).
En el ejemplo de código siguiente se crea un nuevo objeto de datos y se utiliza uno de los constructores sobrecargados (DataObject(String, Object)) para inicializar el objeto de datos con una cadena y un formato de datos especificado. En este caso, el formato de los datos lo especifica una cadena; la clase DataFormats proporciona un conjunto de cadenas de tipo predefinidas. Se permite la autoconversión de los datos almacenados de forma predeterminada.
string stringData = "Some string data to store...";
string dataFormat = DataFormats.UnicodeText;
DataObject dataObject = new DataObject(dataFormat, stringData);
Para obtener más ejemplos de código en los que se crean objetos de datos, consulte Cómo: Crear un objeto de datos.
Almacenar datos en varios formatos
Un mismo objeto de datos puede almacenar los datos en varios formatos. El uso estratégico de varios formatos de datos dentro de un mismo objeto de datos hace que el objeto de datos se pueda utilizar potencialmente por una mayor diversidad de destinos de colocación que si únicamente fuese posible representar un formato de datos. En general, tenga en cuenta que un origen de arrastre debe ser válido con respecto a los formatos de datos los destinos potenciales pueden utilizar.
En el ejemplo siguiente se muestra cómo utilizar el método SetData(String, Object) para agregar datos a un objeto de datos en varios formatos.
DataObject dataObject = new DataObject();
string sourceData = "Some string data to store...";
// Encode the source string into Unicode byte arrays.
byte[] unicodeText = Encoding.Unicode.GetBytes(sourceData); // UTF-16
byte[] utf8Text = Encoding.UTF8.GetBytes(sourceData);
byte[] utf32Text = Encoding.UTF32.GetBytes(sourceData);
// The DataFormats class does not provide data format fields for denoting
// UTF-32 and UTF-8, which are seldom used in practice; the following strings
// will be used to identify these "custom" data formats.
string utf32DataFormat = "UTF-32";
string utf8DataFormat = "UTF-8";
// Store the text in the data object, letting the data object choose
// the data format (which will be DataFormats.Text in this case).
dataObject.SetData(sourceData);
// Store the Unicode text in the data object. Text data can be automatically
// converted to Unicode (UTF-16 / UCS-2) format on extraction from the data object;
// Therefore, explicitly converting the source text to Unicode is generally unnecessary, and
// is done here as an exercise only.
dataObject.SetData(DataFormats.UnicodeText, unicodeText);
// Store the UTF-8 text in the data object...
dataObject.SetData(utf8DataFormat, utf8Text);
// Store the UTF-32 text in the data object...
dataObject.SetData(utf32DataFormat, utf32Text);
Consultar los formatos disponibles en un objeto de datos
Dado que un mismo objeto de datos puede contener un número arbitrario de formatos de datos, los objetos de datos incluyen medios para recuperar una lista de los formatos de datos disponibles.
En el ejemplo de código siguiente se utiliza la sobrecarga de GetFormats para obtener una matriz de cadenas que representan todos los formatos de datos disponibles en un objeto de datos (tanto nativos como autoconvertibles).
DataObject dataObject = new DataObject("Some string data to store...");
// Get an array of strings, each string denoting a data format
// that is available in the data object. This overload of GetDataFormats
// returns all available data formats, native and auto-convertible.
string[] dataFormats = dataObject.GetFormats();
// Get the number of data formats present in the data object, including both
// auto-convertible and native data formats.
int numberOfDataFormats = dataFormats.Length;
// To enumerate the resulting array of data formats, and take some action when
// a particular data format is found, use a code structure similar to the following.
foreach (string dataFormat in dataFormats)
{
if (dataFormat == DataFormats.Text)
{
// Take some action if/when data in the Text data format is found.
break;
}
else if(dataFormat == DataFormats.StringFormat)
{
// Take some action if/when data in the string data format is found.
break;
}
}
Para obtener más ejemplos de código en que se consultan los formatos de datos disponibles en un objeto de datos, consulte Cómo: Mostrar los formatos de datos en un objeto de datos. Para obtener ejemplos sobre cómo consultar un objeto de datos para comprobar si está presente en él un formato de datos determinado, consulte Cómo: Determinar si un formato de datos está presente en un objeto de datos.
Recuperar datos de un objeto de datos
Para recuperar los datos de un objeto de datos en un formato concreto basta con llamar a uno de los métodos GetData y especificar el formato de datos deseado. Uno de los métodos GetDataPresent se puede utilizar para comprobar la presencia de un formato de datos determinado. GetData devuelve los datos de una clase Object; según cuál sea el formato de datos, este objeto se puede convertir a un contenedor específico del tipo.
En el ejemplo de código siguiente se utiliza la sobrecarga de GetDataPresent(String) para comprobar, en primer lugar, si está disponible un formato de datos concreto (nativo o por autoconversión). Si el formato especificado está disponible, entonces el ejemplo recupera los datos mediante el método GetData(String).
DataObject dataObject = new DataObject("Some string data to store...");
string desiredFormat = DataFormats.UnicodeText;
byte[] data = null;
// Use the GetDataPresent method to check for the presence of a desired data format.
// This particular overload of GetDataPresent looks for both native and auto-convertible
// data formats.
if (dataObject.GetDataPresent(desiredFormat))
{
// If the desired data format is present, use one of the GetData methods to retrieve the
// data from the data object.
data = dataObject.GetData(desiredFormat) as byte[];
}
Para obtener más ejemplos de código en que se recuperan datos de un objeto de datos, consulte Cómo: Recuperar datos en un formato concreto.
Quitar datos de un objeto de datos
No es posible quitar directamente los datos de un objeto de datos. Para quitar de manera efectiva los datos de un objeto de datos, siga los pasos que se proponen a continuación:
Cree un nuevo objeto de datos que únicamente contendrá los datos que desea conservar.
"Copie" los datos deseados de del objeto de datos anterior al nuevo. Para copiar los datos, utilice uno de los métodos GetData para recuperar una clase Object que contiene los datos sin procesar y, a continuación, utilice uno de los métodos SetData para agregar los datos al nuevo objeto de datos.
Reemplace el objeto de datos anterior por el nuevo.
Nota
Los métodos SetData únicamente agregan datos a un objeto de datos; no reemplazan esos datos, aunque los datos y el formato de datos sean exactamente iguales que en una llamada anterior. Al llamar dos veces a SetData para obtener los mismos datos con idéntico formato de datos hará que el par de datos y formato de datos esté presente dos veces en el objeto de datos.