diff options
Diffstat (limited to 'bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse')
16 files changed, 3017 insertions, 0 deletions
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/ByteArrayTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/ByteArrayTransfer.java new file mode 100644 index 0000000000..10d2c87e59 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/ByteArrayTransfer.java @@ -0,0 +1,198 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + +import org.eclipse.swt.internal.wpf.*; + + +/** + * The class <code>ByteArrayTransfer</code> provides a platform specific + * mechanism for converting a java <code>byte[]</code> to a platform + * specific representation of the byte array and vice versa. + * + * <p><code>ByteArrayTransfer</code> is never used directly but is sub-classed + * by transfer agents that convert between data in a java format such as a + * <code>String</code> and a platform specific byte array. + * + * <p>If the data you are converting <b>does not</b> map to a + * <code>byte[]</code>, you should sub-class <code>Transfer</code> directly + * and do your own mapping to a platform data type.</p> + * + * <p>The following snippet shows a subclass of ByteArrayTransfer that transfers + * data defined by the class <code>MyType</code>.</p> + * + * <pre><code> + * public class MyType { + * public String fileName; + * public long fileLength; + * public long lastModified; + * } + * </code></pre> + * + * <pre><code> + * public class MyTypeTransfer extends ByteArrayTransfer { + * + * private static final String MYTYPENAME = "my_type_name"; + * private static final int MYTYPEID = registerType(MYTYPENAME); + * private static MyTypeTransfer _instance = new MyTypeTransfer(); + * + * private MyTypeTransfer() {} + * + * public static MyTypeTransfer getInstance () { + * return _instance; + * } + * public void javaToNative (Object object, TransferData transferData) { + * if (object == null || !(object instanceof MyType[])) return; + * + * if (isSupportedType(transferData)) { + * MyType[] myTypes = (MyType[]) object; + * try { + * // write data to a byte array and then ask super to convert to pMedium + * ByteArrayOutputStream out = new ByteArrayOutputStream(); + * DataOutputStream writeOut = new DataOutputStream(out); + * for (int i = 0, length = myTypes.length; i < length; i++){ + * byte[] buffer = myTypes[i].fileName.getBytes(); + * writeOut.writeInt(buffer.length); + * writeOut.write(buffer); + * writeOut.writeLong(myTypes[i].fileLength); + * writeOut.writeLong(myTypes[i].lastModified); + * } + * byte[] buffer = out.toByteArray(); + * writeOut.close(); + * + * super.javaToNative(buffer, transferData); + * + * } catch (IOException e) { + * } + * } + * } + * public Object nativeToJava(TransferData transferData){ + * + * if (isSupportedType(transferData)) { + * + * byte[] buffer = (byte[])super.nativeToJava(transferData); + * if (buffer == null) return null; + * + * MyType[] myData = new MyType[0]; + * try { + * ByteArrayInputStream in = new ByteArrayInputStream(buffer); + * DataInputStream readIn = new DataInputStream(in); + * while(readIn.available() > 20) { + * MyType datum = new MyType(); + * int size = readIn.readInt(); + * byte[] name = new byte[size]; + * readIn.read(name); + * datum.fileName = new String(name); + * datum.fileLength = readIn.readLong(); + * datum.lastModified = readIn.readLong(); + * MyType[] newMyData = new MyType[myData.length + 1]; + * System.arraycopy(myData, 0, newMyData, 0, myData.length); + * newMyData[myData.length] = datum; + * myData = newMyData; + * } + * readIn.close(); + * } catch (IOException ex) { + * return null; + * } + * return myData; + * } + * + * return null; + * } + * protected String[] getTypeNames(){ + * return new String[]{MYTYPENAME}; + * } + * protected int[] getTypeIds(){ + * return new int[] {MYTYPEID}; + * } + * } + * </code></pre> + * + * @see Transfer + */ +public abstract class ByteArrayTransfer extends Transfer { + +boolean checkByteArray(Object object) { + return (object != null && object instanceof byte[] && ((byte[])object).length > 0); +} + +public TransferData[] getSupportedTypes(){ + int[] ids = getTypeIds(); + TransferData[] result = new TransferData[ids.length]; + for (int i = 0; i < result.length; i++) { + result[i] = new TransferData(); + result[i].type = ids[i]; + } + return result; +} + +protected String[] getTypeNames(){ + int[] ids = getTypeIds(); + String[] result = new String[ids.length]; + for (int i = 0; i < result.length; i++) { + result[i] = getTypeName(ids[i]); + } + return result; +} + +public boolean isSupportedType(TransferData transferData){ + if (transferData == null) return false; + int[] ids = getTypeIds(); + for (int i = 0; i < ids.length; i++) { + if (transferData.type == ids[i]) return true; + } + return false; +} + +/** + * This implementation of <code>javaToNative</code> converts a java + * <code>byte[]</code> to a platform specific representation. + * + * @param object a java <code>byte[]</code> containing the data to be converted + * @param transferData an empty <code>TransferData</code> object that will + * be filled in on return with the platform specific format of the data + * + * @see Transfer#nativeToJava + */ +protected void javaToNative (Object object, TransferData transferData) { + if (!checkByteArray(object) || !isSupportedType(transferData)) { + DND.error(DND.ERROR_INVALID_DATA); + } + byte[] buffer = (byte[])object; + if (buffer.length == 0) return; + int typeid = OS.Byte_typeid(); + int pValue = OS.Array_CreateInstance(typeid, buffer.length); + OS.GCHandle_Free(typeid); + if (pValue == 0) return; + OS.memcpy(pValue, buffer, buffer.length); + transferData.pValue = pValue; +} + +/** + * This implementation of <code>nativeToJava</code> converts a platform specific + * representation of a byte array to a java <code>byte[]</code>. + * + * @param transferData the platform specific representation of the data to be converted + * @return a java <code>byte[]</code> containing the converted data if the conversion was + * successful; otherwise null + * + * @see Transfer#javaToNative + */ +protected Object nativeToJava(TransferData transferData) { + if ( !isSupportedType(transferData) || transferData.pValue == 0) return null; + int byteArray = transferData.pValue; + int length = OS.Array_GetLength(byteArray, 0); + byte[] buffer = new byte[length]; + if (length == 0) return buffer; + OS.memcpy(buffer, transferData.pValue, length); + return buffer; +} +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/Clipboard.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/Clipboard.java new file mode 100644 index 0000000000..3ea522a328 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/Clipboard.java @@ -0,0 +1,546 @@ +/******************************************************************************* + * Copyright (c) 2000, 2009 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + + +import org.eclipse.swt.internal.wpf.*; +import org.eclipse.swt.*; +import org.eclipse.swt.widgets.*; + +/** + * The <code>Clipboard</code> provides a mechanism for transferring data from one + * application to another or within an application. + * + * <p>IMPORTANT: This class is <em>not</em> intended to be subclassed.</p> + * + * @see <a href="http://www.eclipse.org/swt/snippets/#clipboard">Clipboard snippets</a> + * @see <a href="http://www.eclipse.org/swt/examples.php">SWT Example: ClipboardExample</a> + * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a> + * @noextend This class is not intended to be subclassed by clients. + */ +public class Clipboard { + + private Display display; + +/** + * Constructs a new instance of this class. Creating an instance of a Clipboard + * may cause system resources to be allocated depending on the platform. It is therefore + * mandatory that the Clipboard instance be disposed when no longer required. + * + * @param display the display on which to allocate the clipboard + * + * @exception SWTException <ul> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li> + * <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li> + * </ul> + * + * @see Clipboard#dispose + * @see Clipboard#checkSubclass + */ +public Clipboard(Display display) { + checkSubclass (); + if (display == null) { + display = Display.getCurrent(); + if (display == null) { + display = Display.getDefault(); + } + } + if (display.getThread() != Thread.currentThread()) { + DND.error(SWT.ERROR_THREAD_INVALID_ACCESS); + } + this.display = display; +} + +/** + * Checks that this class can be subclassed. + * <p> + * The SWT class library is intended to be subclassed + * only at specific, controlled points. This method enforces this + * rule unless it is overridden. + * </p><p> + * <em>IMPORTANT:</em> By providing an implementation of this + * method that allows a subclass of a class which does not + * normally allow subclassing to be created, the implementer + * agrees to be fully responsible for the fact that any such + * subclass will likely fail between SWT releases and will be + * strongly platform specific. No support is provided for + * user-written classes which are implemented in this fashion. + * </p><p> + * The ability to subclass outside of the allowed SWT classes + * is intended purely to enable those not on the SWT development + * team to implement patches in order to get around specific + * limitations in advance of when those limitations can be + * addressed by the team. Subclassing should not be attempted + * without an intimate and detailed understanding of the hierarchy. + * </p> + * + * @exception SWTException <ul> + * <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li> + * </ul> + */ +protected void checkSubclass () { + String name = getClass().getName (); + String validName = Clipboard.class.getName(); + if (!validName.equals(name)) { + DND.error (SWT.ERROR_INVALID_SUBCLASS); + } +} + +/** + * Throws an <code>SWTException</code> if the receiver can not + * be accessed by the caller. This may include both checks on + * the state of the receiver and more generally on the entire + * execution context. This method <em>should</em> be called by + * widget implementors to enforce the standard SWT invariants. + * <p> + * Currently, it is an error to invoke any method (other than + * <code>isDisposed()</code>) on a widget that has had its + * <code>dispose()</code> method called. It is also an error + * to call widget methods from any thread that is different + * from the thread that created the widget. + * </p><p> + * In future releases of SWT, there may be more or fewer error + * checks and exceptions may be thrown for different reasons. + * </p> + * + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + */ +protected void checkWidget () { + Display display = this.display; + if (display == null) DND.error (SWT.ERROR_WIDGET_DISPOSED); + if (display.getThread() != Thread.currentThread ()) DND.error (SWT.ERROR_THREAD_INVALID_ACCESS); + if (display.isDisposed()) DND.error(SWT.ERROR_WIDGET_DISPOSED); +} + +/** + * If this clipboard is currently the owner of the data on the system clipboard, + * clear the contents. If this clipboard is not the owner, then nothing is done. + * Note that there are clipboard assistant applications that take ownership of + * data or make copies of data when it is placed on the clipboard. In these + * cases, it may not be possible to clear the clipboard. + * + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + * + * @since 3.1 + */ +public void clearContents() { + clearContents(DND.CLIPBOARD); +} + +/** + * If this clipboard is currently the owner of the data on the specified + * clipboard, clear the contents. If this clipboard is not the owner, then + * nothing is done. + * + * <p>Note that there are clipboard assistant applications that take ownership + * of data or make copies of data when it is placed on the clipboard. In these + * cases, it may not be possible to clear the clipboard.</p> + * + * <p>The clipboards value is either one of the clipboard constants defined in + * class <code>DND</code>, or must be built by <em>bitwise OR</em>'ing together + * (that is, using the <code>int</code> "|" operator) two or more + * of those <code>DND</code> clipboard constants.</p> + * + * @param clipboards to be cleared + * + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + * + * @see DND#CLIPBOARD + * @see DND#SELECTION_CLIPBOARD + * + * @since 3.1 + */ +public void clearContents(int clipboards) { + checkWidget(); + if ((clipboards & DND.CLIPBOARD) != 0) { + OS.Clipboard_Clear(); + } +} + +/** + * Disposes of the operating system resources associated with the clipboard. + * The data will still be available on the system clipboard after the dispose + * method is called. + * + * <p>NOTE: On some platforms the data will not be available once the application + * has exited or the display has been disposed.</p> + * + * @exception SWTException <ul> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li> + * </ul> + */ +public void dispose () { + if (isDisposed()) return; + if (display.getThread() != Thread.currentThread()) DND.error(SWT.ERROR_THREAD_INVALID_ACCESS); + display = null; +} + +/** + * Returns a platform specific list of the data types currently available on the + * system clipboard. + * + * <p>Note: <code>getAvailableTypeNames</code> is a utility for writing a Transfer + * sub-class. It should NOT be used within an application because it provides + * platform specific information.</p> + * + * @return a platform specific list of the data types currently available on the + * system clipboard + * + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + */ +public String[] getAvailableTypeNames() { + checkWidget(); + + int pDataObject = OS.Clipboard_GetDataObject(); + int pFormats = OS.DataObject_GetFormats(pDataObject, true); + int length = OS.Array_GetLength(pFormats, 0); + String[] result = new String [length]; + for (int i = 0; i < length; i++) { + int pFormat = OS.Array_GetValue(pFormats, i); + result[i] = Transfer.createJavaString(pFormat); + OS.GCHandle_Free(pFormat); + } + OS.GCHandle_Free(pDataObject); + OS.GCHandle_Free(pFormats); + return result; +} + +/** + * Returns an array of the data types currently available on the system + * clipboard. Use with Transfer.isSupportedType. + * + * @return array of data types currently available on the system clipboard + * + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + * + * @see Transfer#isSupportedType + * + * @since 3.0 + */ +public TransferData[] getAvailableTypes() { + return getAvailableTypes(DND.CLIPBOARD); +} + +/** + * Returns an array of the data types currently available on the specified + * clipboard. Use with Transfer.isSupportedType. + * + * <p>The clipboards value is either one of the clipboard constants defined in + * class <code>DND</code>, or must be built by <em>bitwise OR</em>'ing together + * (that is, using the <code>int</code> "|" operator) two or more + * of those <code>DND</code> clipboard constants.</p> + * + * @param clipboards from which to get the data types + * @return array of data types currently available on the specified clipboard + * + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + * + * @see Transfer#isSupportedType + * @see DND#CLIPBOARD + * @see DND#SELECTION_CLIPBOARD + * + * @since 3.1 + */ +public TransferData[] getAvailableTypes(int clipboards) { + checkWidget(); + if ((clipboards & DND.CLIPBOARD) == 0) return new TransferData[0]; + + String[] typeNames = getAvailableTypeNames(); + int length = typeNames.length; + TransferData[] result = new TransferData [length]; + for (int i = 0; i < length; i++) { + int type = Transfer.registerType(typeNames[i]); + TransferData transferData = new TransferData(); + transferData.type = type; + result[i++] = transferData; + } + return result; +} + +/** + * Retrieve the data of the specified type currently available on the system + * clipboard. Refer to the specific subclass of <code>Transfer</code> to + * determine the type of object returned. + * + * <p>The following snippet shows text and RTF text being retrieved from the + * clipboard:</p> + * + * <code><pre> + * Clipboard clipboard = new Clipboard(display); + * TextTransfer textTransfer = TextTransfer.getInstance(); + * String textData = (String)clipboard.getContents(textTransfer); + * if (textData != null) System.out.println("Text is "+textData); + * RTFTransfer rtfTransfer = RTFTransfer.getInstance(); + * String rtfData = (String)clipboard.getContents(rtfTransfer); + * if (rtfData != null) System.out.println("RTF Text is "+rtfData); + * clipboard.dispose(); + * </code></pre> + * + * @param transfer the transfer agent for the type of data being requested + * @return the data obtained from the clipboard or null if no data of this type is available + * + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + * @exception IllegalArgumentException <ul> + * <li>ERROR_NULL_ARGUMENT - if transfer is null</li> + * </ul> + * + * @see Transfer + */ +public Object getContents(Transfer transfer) { + return getContents(transfer, DND.CLIPBOARD); +} + +/** + * Retrieve the data of the specified type currently available on the specified + * clipboard. Refer to the specific subclass of <code>Transfer</code> to + * determine the type of object returned. + * + * <p>The following snippet shows text and RTF text being retrieved from the + * clipboard:</p> + * + * <code><pre> + * Clipboard clipboard = new Clipboard(display); + * TextTransfer textTransfer = TextTransfer.getInstance(); + * String textData = (String)clipboard.getContents(textTransfer); + * if (textData != null) System.out.println("Text is "+textData); + * RTFTransfer rtfTransfer = RTFTransfer.getInstance(); + * String rtfData = (String)clipboard.getContents(rtfTransfer, DND.CLIPBOARD); + * if (rtfData != null) System.out.println("RTF Text is "+rtfData); + * clipboard.dispose(); + * </code></pre> + * + * <p>The clipboards value is either one of the clipboard constants defined in + * class <code>DND</code>, or must be built by <em>bitwise OR</em>'ing together + * (that is, using the <code>int</code> "|" operator) two or more + * of those <code>DND</code> clipboard constants.</p> + * + * @param transfer the transfer agent for the type of data being requested + * @param clipboards on which to look for data + * + * @return the data obtained from the clipboard or null if no data of this type is available + * + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + * @exception IllegalArgumentException <ul> + * <li>ERROR_NULL_ARGUMENT - if transfer is null</li> + * </ul> + * + * @see Transfer + * @see DND#CLIPBOARD + * @see DND#SELECTION_CLIPBOARD + * + * @since 3.1 + */ +public Object getContents(Transfer transfer, int clipboards) { + checkWidget(); + if (transfer == null) DND.error(SWT.ERROR_NULL_ARGUMENT); + int[] types = transfer.getTypeIds(); + for (int i = 0; i < types.length; i++) { + int pValue = getData(types[i]); + if (pValue != 0) { + TransferData data = new TransferData(); + data.type = types[i]; + data.pValue = pValue; + Object result = transfer.nativeToJava(data); + OS.GCHandle_Free(pValue); + return result; + } + } + return null; +} + +int getData(int type) { + int pFormat = Transfer.getWPFFormat(type); + int result = 0; + if (OS.Clipboard_ContainsData(pFormat)) { + result = OS.Clipboard_GetData(pFormat); + } + OS.GCHandle_Free (pFormat); + return result; +} + +/** + * Returns <code>true</code> if the clipboard has been disposed, + * and <code>false</code> otherwise. + * <p> + * This method gets the dispose state for the clipboard. + * When a clipboard has been disposed, it is an error to + * invoke any other method using the clipboard. + * </p> + * + * @return <code>true</code> when the widget is disposed and <code>false</code> otherwise + * + * @since 3.0 + */ +public boolean isDisposed () { + return (display == null); +} + +/** + * Place data of the specified type on the system clipboard. More than one type + * of data can be placed on the system clipboard at the same time. Setting the + * data clears any previous data from the system clipboard, regardless of type. + * + * <p>NOTE: On some platforms, the data is immediately copied to the system + * clipboard but on other platforms it is provided upon request. As a result, + * if the application modifies the data object it has set on the clipboard, that + * modification may or may not be available when the data is subsequently + * requested.</p> + * + * <p>The following snippet shows text and RTF text being set on the copy/paste + * clipboard: + * </p> + * + * <code><pre> + * Clipboard clipboard = new Clipboard(display); + * String textData = "Hello World"; + * String rtfData = "{\\rtf1\\b\\i Hello World}"; + * TextTransfer textTransfer = TextTransfer.getInstance(); + * RTFTransfer rtfTransfer = RTFTransfer.getInstance(); + * Transfer[] transfers = new Transfer[]{textTransfer, rtfTransfer}; + * Object[] data = new Object[]{textData, rtfData}; + * clipboard.setContents(data, transfers); + * clipboard.dispose(); + * </code></pre> + * + * @param data the data to be set in the clipboard + * @param dataTypes the transfer agents that will convert the data to its + * platform specific format; each entry in the data array must have a + * corresponding dataType + * + * @exception IllegalArgumentException <ul> + * <li>ERROR_INVALID_ARGUMENT - if data is null or datatypes is null + * or the length of data is not the same as the length of dataTypes</li> + * </ul> + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + * @exception SWTError <ul> + * <li>ERROR_CANNOT_SET_CLIPBOARD - if the clipboard is locked or otherwise unavailable</li> + * </ul> + * + * <p>NOTE: ERROR_CANNOT_SET_CLIPBOARD should be an SWTException, since it is a + * recoverable error, but can not be changed due to backward compatibility.</p> + */ +public void setContents(Object[] data, Transfer[] dataTypes) { + setContents(data, dataTypes, DND.CLIPBOARD); +} + +/** + * Place data of the specified type on the specified clipboard. More than one + * type of data can be placed on the specified clipboard at the same time. + * Setting the data clears any previous data from the specified + * clipboard, regardless of type. + * + * <p>NOTE: On some platforms, the data is immediately copied to the specified + * clipboard but on other platforms it is provided upon request. As a result, + * if the application modifies the data object it has set on the clipboard, that + * modification may or may not be available when the data is subsequently + * requested.</p> + * + * <p>The clipboards value is either one of the clipboard constants defined in + * class <code>DND</code>, or must be built by <em>bitwise OR</em>'ing together + * (that is, using the <code>int</code> "|" operator) two or more + * of those <code>DND</code> clipboard constants.</p> + * + * <p>The following snippet shows text and RTF text being set on the copy/paste + * clipboard: + * </p> + * + * <code><pre> + * Clipboard clipboard = new Clipboard(display); + * String textData = "Hello World"; + * String rtfData = "{\\rtf1\\b\\i Hello World}"; + * TextTransfer textTransfer = TextTransfer.getInstance(); + * RTFTransfer rtfTransfer = RTFTransfer.getInstance(); + * Transfer[] transfers = new Transfer[]{textTransfer, rtfTransfer}; + * Object[] data = new Object[]{textData, rtfData}; + * clipboard.setContents(data, transfers, DND.CLIPBOARD); + * clipboard.dispose(); + * </code></pre> + * + * @param data the data to be set in the clipboard + * @param dataTypes the transfer agents that will convert the data to its + * platform specific format; each entry in the data array must have a + * corresponding dataType + * @param clipboards on which to set the data + * + * @exception IllegalArgumentException <ul> + * <li>ERROR_INVALID_ARGUMENT - if data is null or datatypes is null + * or the length of data is not the same as the length of dataTypes</li> + * </ul> + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + * @exception SWTError <ul> + * <li>ERROR_CANNOT_SET_CLIPBOARD - if the clipboard is locked or otherwise unavailable</li> + * </ul> + * + * <p>NOTE: ERROR_CANNOT_SET_CLIPBOARD should be an SWTException, since it is a + * recoverable error, but can not be changed due to backward compatibility.</p> + * + * @see DND#CLIPBOARD + * @see DND#SELECTION_CLIPBOARD + * + * @since 3.1 + */ +public void setContents(Object[] data, Transfer[] dataTypes, int clipboards) { + checkWidget(); + if (data == null || dataTypes == null || data.length != dataTypes.length) { + DND.error(SWT.ERROR_INVALID_ARGUMENT); + } + + int pDataObject = OS.gcnew_DataObject(); + for (int i = 0; i < dataTypes.length; i++) { + Transfer transfer = dataTypes[i]; + Object value = data[i]; + int[] types = transfer.getTypeIds(); + for (int j = 0; j < types.length; j++) { + TransferData transferData = new TransferData(); + transferData.type = types[j]; + transfer.javaToNative(value, transferData); + if (transferData.pValue != 0) { + int pFormat = Transfer.getWPFFormat(transferData.type); + OS.DataObject_SetData(pDataObject, pFormat, transferData.pValue, true); + OS.GCHandle_Free(pFormat); + OS.GCHandle_Free(transferData.pValue); + } + } + } + OS.Clipboard_SetDataObject(pDataObject, false); + OS.GCHandle_Free(pDataObject); +} +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/DragSource.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/DragSource.java new file mode 100644 index 0000000000..8c28d3dd26 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/DragSource.java @@ -0,0 +1,452 @@ +/******************************************************************************* + * Copyright (c) 2000, 2009 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + + +import org.eclipse.swt.internal.wpf.*; +import org.eclipse.swt.*; +import org.eclipse.swt.widgets.*; + +/** + * + * <code>DragSource</code> defines the source object for a drag and drop transfer. + * + * <p>IMPORTANT: This class is <em>not</em> intended to be subclassed.</p> + * + * <p>A drag source is the object which originates a drag and drop operation. For the specified widget, + * it defines the type of data that is available for dragging and the set of operations that can + * be performed on that data. The operations can be any bit-wise combination of DND.MOVE, DND.COPY or + * DND.LINK. The type of data that can be transferred is specified by subclasses of Transfer such as + * TextTransfer or FileTransfer. The type of data transferred can be a predefined system type or it + * can be a type defined by the application. For instructions on how to define your own transfer type, + * refer to <code>ByteArrayTransfer</code>.</p> + * + * <p>You may have several DragSources in an application but you can only have one DragSource + * per Control. Data dragged from this DragSource can be dropped on a site within this application + * or it can be dropped on another application such as an external Text editor.</p> + * + * <p>The application supplies the content of the data being transferred by implementing the + * <code>DragSourceListener</code> and associating it with the DragSource via DragSource#addDragListener.</p> + * + * <p>When a successful move operation occurs, the application is required to take the appropriate + * action to remove the data from its display and remove any associated operating system resources or + * internal references. Typically in a move operation, the drop target makes a copy of the data + * and the drag source deletes the original. However, sometimes copying the data can take a long + * time (such as copying a large file). Therefore, on some platforms, the drop target may actually + * move the data in the operating system rather than make a copy. This is usually only done in + * file transfers. In this case, the drag source is informed in the DragEnd event that a + * DROP_TARGET_MOVE was performed. It is the responsibility of the drag source at this point to clean + * up its displayed information. No action needs to be taken on the operating system resources.</p> + * + * <p> The following example shows a Label widget that allows text to be dragged from it.</p> + * + * <code><pre> + * // Enable a label as a Drag Source + * Label label = new Label(shell, SWT.NONE); + * // This example will allow text to be dragged + * Transfer[] types = new Transfer[] {TextTransfer.getInstance()}; + * // This example will allow the text to be copied or moved to the drop target + * int operations = DND.DROP_MOVE | DND.DROP_COPY; + * + * DragSource source = new DragSource(label, operations); + * source.setTransfer(types); + * source.addDragListener(new DragSourceListener() { + * public void dragStart(DragSourceEvent e) { + * // Only start the drag if there is actually text in the + * // label - this text will be what is dropped on the target. + * if (label.getText().length() == 0) { + * event.doit = false; + * } + * }; + * public void dragSetData(DragSourceEvent event) { + * // A drop has been performed, so provide the data of the + * // requested type. + * // (Checking the type of the requested data is only + * // necessary if the drag source supports more than + * // one data type but is shown here as an example). + * if (TextTransfer.getInstance().isSupportedType(event.dataType)){ + * event.data = label.getText(); + * } + * } + * public void dragFinished(DragSourceEvent event) { + * // A Move operation has been performed so remove the data + * // from the source + * if (event.detail == DND.DROP_MOVE) + * label.setText(""); + * } + * }); + * </pre></code> + * + * + * <dl> + * <dt><b>Styles</b></dt> <dd>DND.DROP_NONE, DND.DROP_COPY, DND.DROP_MOVE, DND.DROP_LINK</dd> + * <dt><b>Events</b></dt> <dd>DND.DragStart, DND.DragSetData, DND.DragEnd</dd> + * </dl> + * + * @see <a href="http://www.eclipse.org/swt/snippets/#dnd">Drag and Drop snippets</a> + * @see <a href="http://www.eclipse.org/swt/examples.php">SWT Example: DNDExample</a> + * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a> + * @noextend This class is not intended to be subclassed by clients. + */ +public class DragSource extends Widget { + + private static final String DEFAULT_DRAG_SOURCE_EFFECT = "DEFAULT_DRAG_SOURCE_EFFECT"; //$NON-NLS-1$ + static int checkStyle (int style) { + if (style == SWT.NONE) return DND.DROP_MOVE; + return style; + } + // info for registering as a drag source + private Control control; + private Listener controlListener; + + private Transfer[] transferAgents = new Transfer[0]; + private DragSourceEffect dragEffect; + + private int jniRef; + +/** + * Creates a new <code>DragSource</code> to handle dragging from the specified <code>Control</code>. + * Creating an instance of a DragSource may cause system resources to be allocated depending on the platform. + * It is therefore mandatory that the DragSource instance be disposed when no longer required. + * + * @param control the <code>Control</code> that the user clicks on to initiate the drag + * @param style the bitwise OR'ing of allowed operations; this may be a combination of any of + * DND.DROP_NONE, DND.DROP_COPY, DND.DROP_MOVE, DND.DROP_LINK + * + * @exception SWTException <ul> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li> + * <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li> + * </ul> + * @exception SWTError <ul> + * <li>ERROR_CANNOT_INIT_DRAG - unable to initiate drag source; this will occur if more than one + * drag source is created for a control or if the operating system will not allow the creation + * of the drag source</li> + * </ul> + * + * <p>NOTE: ERROR_CANNOT_INIT_DRAG should be an SWTException, since it is a + * recoverable error, but can not be changed due to backward compatibility.</p> + * + * @see Widget#dispose + * @see DragSource#checkSubclass + * @see DND#DROP_NONE + * @see DND#DROP_COPY + * @see DND#DROP_MOVE + * @see DND#DROP_LINK + */ +public DragSource(Control control, int style) { + super (control, checkStyle(style)); + this.control = control; + if (control.getData(DND.DRAG_SOURCE_KEY) != null) + DND.error(DND.ERROR_CANNOT_INIT_DRAG); + control.setData(DND.DRAG_SOURCE_KEY, this); + + jniRef = OS.NewGlobalRef (this); + if (jniRef == 0) SWT.error(SWT.ERROR_NO_HANDLES); + + hookEventHandlers(); + + controlListener = new Listener () { + public void handleEvent (Event event) { + if (event.type == SWT.Dispose) { + if (!DragSource.this.isDisposed()) { + DragSource.this.dispose(); + } + } + if (event.type == SWT.DragDetect) { + if (!DragSource.this.isDisposed()) { + DragSource.this.drag(event); + } + } + } + }; + control.addListener (SWT.Dispose, controlListener); + control.addListener (SWT.DragDetect, controlListener); + + this.addListener(SWT.Dispose, new Listener() { + public void handleEvent(Event e) { + onDispose(); + } + }); + + Object effect = control.getData(DEFAULT_DRAG_SOURCE_EFFECT); + if (effect instanceof DragSourceEffect) { + dragEffect = (DragSourceEffect) effect; + } else if (control instanceof Tree) { + dragEffect = new TreeDragSourceEffect((Tree) control); + } else if (control instanceof Table) { + dragEffect = new TableDragSourceEffect((Table) control); + } +} + +/** + * Adds the listener to the collection of listeners who will + * be notified when a drag and drop operation is in progress, by sending + * it one of the messages defined in the <code>DragSourceListener</code> + * interface. + * + * <p><ul> + * <li><code>dragStart</code> is called when the user has begun the actions required to drag the widget. + * This event gives the application the chance to decide if a drag should be started. + * <li><code>dragSetData</code> is called when the data is required from the drag source. + * <li><code>dragFinished</code> is called when the drop has successfully completed (mouse up + * over a valid target) or has been terminated (such as hitting the ESC key). Perform cleanup + * such as removing data from the source side on a successful move operation. + * </ul></p> + * + * @param listener the listener which should be notified + * + * @exception IllegalArgumentException <ul> + * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> + * </ul> + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + * + * @see DragSourceListener + * @see #getDragListeners + * @see #removeDragListener + * @see DragSourceEvent + */ +public void addDragListener(DragSourceListener listener) { + if (listener == null) DND.error (SWT.ERROR_NULL_ARGUMENT); + DNDListener typedListener = new DNDListener (listener); + typedListener.dndWidget = this; + addListener (DND.DragStart, typedListener); + addListener (DND.DragSetData, typedListener); + addListener (DND.DragEnd, typedListener); +} + +protected void checkSubclass () { + String name = getClass().getName (); + String validName = DragSource.class.getName(); + if (!validName.equals(name)) { + DND.error (SWT.ERROR_INVALID_SUBCLASS); + } +} + +void drag(Event dragEvent) { + DNDEvent event = new DNDEvent(); + event.widget = this; + event.x = dragEvent.x; + event.y = dragEvent.y; + event.time = (int)System.currentTimeMillis(); + event.doit = true; + notifyListeners(DND.DragStart,event); + if (!event.doit || transferAgents == null || transferAgents.length == 0 ) return; + + int pDataObject = OS.gcnew_DataObject(); + for (int i = 0; i < transferAgents.length; i++) { + Transfer transfer = transferAgents[i]; + if (transfer != null) { + TransferData supportedTypes[] = transfer.getSupportedTypes(); + for (int j = 0; j < supportedTypes.length; j++) { + TransferData transferData = supportedTypes[j]; + event = new DNDEvent(); + event.widget = this; + event.time = (int)System.currentTimeMillis(); + event.dataType = transferData; + notifyListeners(DND.DragSetData, event); + if (!event.doit) return; + transfer.javaToNative(event.data, transferData); + if (transferData.pValue != 0) { + int pFormat = Transfer.getWPFFormat(transferData.type); + OS.DataObject_SetData(pDataObject, pFormat, transferData.pValue, true); + OS.GCHandle_Free(transferData.pValue); + OS.GCHandle_Free(pFormat); + } + } + } + } + + int operations = opToOsOp(getStyle()); + int result = OS.DragDrop_DoDragDrop(control.handle, pDataObject, operations); + OS.GCHandle_Free(pDataObject); + + event = new DNDEvent(); + event.widget = this; + event.time = (int)System.currentTimeMillis(); + event.doit = (result != OS.DragDropEffects_None); + event.detail = osOpToOp(result); + notifyListeners(DND.DragEnd,event); +} + +/** + * Returns the Control which is registered for this DragSource. This is the control that the + * user clicks in to initiate dragging. + * + * @return the Control which is registered for this DragSource + */ +public Control getControl () { + return control; +} + +/** + * Returns an array of listeners who will be notified when a drag and drop + * operation is in progress, by sending it one of the messages defined in + * the <code>DragSourceListener</code> interface. + * + * @return the listeners who will be notified when a drag and drop + * operation is in progress + * + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + * + * @see DragSourceListener + * @see #addDragListener + * @see #removeDragListener + * @see DragSourceEvent + * + * @since 3.4 + */ +public DragSourceListener[] getDragListeners() { + Listener[] listeners = getListeners(DND.DragStart); + int length = listeners.length; + DragSourceListener[] dragListeners = new DragSourceListener[length]; + int count = 0; + for (int i = 0; i < length; i++) { + Listener listener = listeners[i]; + if (listener instanceof DNDListener) { + dragListeners[count] = (DragSourceListener) ((DNDListener) listener).getEventListener(); + count++; + } + } + if (count == length) return dragListeners; + DragSourceListener[] result = new DragSourceListener[count]; + System.arraycopy(dragListeners, 0, result, 0, count); + return result; +} + +/** + * Returns the drag effect that is registered for this DragSource. This drag + * effect will be used during a drag and drop operation. + * + * @return the drag effect that is registered for this DragSource + * + * @since 3.3 + */ +public DragSourceEffect getDragSourceEffect() { + return dragEffect; +} + +/** + * Returns the list of data types that can be transferred by this DragSource. + * + * @return the list of data types that can be transferred by this DragSource + */ +public Transfer[] getTransfer(){ + return transferAgents; +} + +void hookEventHandlers () { +} + +void onDispose() { + if (control == null) + return; + if (controlListener != null) { + control.removeListener(SWT.Dispose, controlListener); + control.removeListener(SWT.DragDetect, controlListener); + } + + unhookEventHandlers(); + if (jniRef != 0) OS.DeleteGlobalRef (jniRef); + jniRef = 0; + + controlListener = null; + control.setData(DND.DRAG_SOURCE_KEY, null); + control = null; + transferAgents = null; +} + +int opToOsOp(int operation){ + int osOperation = 0; + if ((operation & DND.DROP_COPY) != 0){ + osOperation |= OS.DragDropEffects_Copy; + } + if ((operation & DND.DROP_LINK) != 0) { + osOperation |= OS.DragDropEffects_Link; + } + if ((operation & DND.DROP_MOVE) != 0) { + osOperation |= OS.DragDropEffects_Move; + } + return osOperation; +} + +int osOpToOp(int osOperation){ + int operation = 0; + if ((osOperation & OS.DragDropEffects_Copy) != 0){ + operation |= DND.DROP_COPY; + } + if ((osOperation & OS.DragDropEffects_Link) != 0) { + operation |= DND.DROP_LINK; + } + if ((osOperation & OS.DragDropEffects_Move) != 0) { + operation |= DND.DROP_MOVE; + } + return operation; +} + +/** + * Removes the listener from the collection of listeners who will + * be notified when a drag and drop operation is in progress. + * + * @param listener the listener which should no longer be notified + * + * @exception IllegalArgumentException <ul> + * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> + * </ul> + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + * + * @see DragSourceListener + * @see #addDragListener + * @see #getDragListeners + */ +public void removeDragListener(DragSourceListener listener) { + if (listener == null) DND.error (SWT.ERROR_NULL_ARGUMENT); + removeListener (DND.DragStart, listener); + removeListener (DND.DragSetData, listener); + removeListener (DND.DragEnd, listener); +} + +/** + * Specifies the drag effect for this DragSource. This drag effect will be + * used during a drag and drop operation. + * + * @param effect the drag effect that is registered for this DragSource + * + * @since 3.3 + */ +public void setDragSourceEffect(DragSourceEffect effect) { + dragEffect = effect; +} + +/** + * Specifies the list of data types that can be transferred by this DragSource. + * The application must be able to provide data to match each of these types when + * a successful drop has occurred. + * + * @param transferAgents a list of Transfer objects which define the types of data that can be + * dragged from this source + */ +public void setTransfer(Transfer[] transferAgents){ + this.transferAgents = transferAgents; +} + +void unhookEventHandlers () { +} + +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/DropTarget.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/DropTarget.java new file mode 100644 index 0000000000..bb38acdf25 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/DropTarget.java @@ -0,0 +1,740 @@ +/******************************************************************************* + * Copyright (c) 2000, 2009 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + + +import org.eclipse.swt.internal.wpf.*; +import org.eclipse.swt.*; +import org.eclipse.swt.graphics.*; +import org.eclipse.swt.widgets.*; + +/** + * + * Class <code>DropTarget</code> defines the target object for a drag and drop transfer. + * + * <p>IMPORTANT: This class is <em>not</em> intended to be subclassed.</p> + * + * <p>This class identifies the <code>Control</code> over which the user must position the cursor + * in order to drop the data being transferred. It also specifies what data types can be dropped on + * this control and what operations can be performed. You may have several DropTragets in an + * application but there can only be a one to one mapping between a <code>Control</code> and a <code>DropTarget</code>. + * The DropTarget can receive data from within the same application or from other applications + * (such as text dragged from a text editor like Word).</p> + * + * <code><pre> + * int operations = DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK; + * Transfer[] types = new Transfer[] {TextTransfer.getInstance()}; + * DropTarget target = new DropTarget(label, operations); + * target.setTransfer(types); + * </code></pre> + * + * <p>The application is notified of data being dragged over this control and of when a drop occurs by + * implementing the interface <code>DropTargetListener</code> which uses the class + * <code>DropTargetEvent</code>. The application can modify the type of drag being performed + * on this Control at any stage of the drag by modifying the <code>event.detail</code> field or the + * <code>event.currentDataType</code> field. When the data is dropped, it is the responsibility of + * the application to copy this data for its own purposes. + * + * <code><pre> + * target.addDropListener (new DropTargetListener() { + * public void dragEnter(DropTargetEvent event) {}; + * public void dragOver(DropTargetEvent event) {}; + * public void dragLeave(DropTargetEvent event) {}; + * public void dragOperationChanged(DropTargetEvent event) {}; + * public void dropAccept(DropTargetEvent event) {} + * public void drop(DropTargetEvent event) { + * // A drop has occurred, copy over the data + * if (event.data == null) { // no data to copy, indicate failure in event.detail + * event.detail = DND.DROP_NONE; + * return; + * } + * label.setText ((String) event.data); // data copied to label text + * } + * }); + * </pre></code> + * + * <dl> + * <dt><b>Styles</b></dt> <dd>DND.DROP_NONE, DND.DROP_COPY, DND.DROP_MOVE, DND.DROP_LINK</dd> + * <dt><b>Events</b></dt> <dd>DND.DragEnter, DND.DragLeave, DND.DragOver, DND.DragOperationChanged, + * DND.DropAccept, DND.Drop </dd> + * </dl> + * + * @see <a href="http://www.eclipse.org/swt/snippets/#dnd">Drag and Drop snippets</a> + * @see <a href="http://www.eclipse.org/swt/examples.php">SWT Example: DNDExample</a> + * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a> + * @noextend This class is not intended to be subclassed by clients. + */ +public class DropTarget extends Widget { + + static final String DEFAULT_DROP_TARGET_EFFECT = "DEFAULT_DROP_TARGET_EFFECT"; //$NON-NLS-1$ + static int checkStyle (int style) { + if (style == SWT.NONE) return DND.DROP_MOVE; + return style; + } + // info for registering as a droptarget + Control control; + Listener controlListener; + Transfer[] transferAgents = new Transfer[0]; + DropTargetEffect dropEffect; + + int jniRef; + int dragEnterEventHandler; + int dragLeaveEventHandler; + int dragOverEventHandler; + int dropEventHandler; + + // Track application selections + TransferData selectedDataType; + int selectedOperation; + + // workaround - There is no event for "operation changed" so track operation based on key state + int keyOperation = -1; + +/** + * Creates a new <code>DropTarget</code> to allow data to be dropped on the specified + * <code>Control</code>. + * Creating an instance of a DropTarget may cause system resources to be allocated + * depending on the platform. It is therefore mandatory that the DropTarget instance + * be disposed when no longer required. + * + * @param control the <code>Control</code> over which the user positions the cursor to drop the data + * @param style the bitwise OR'ing of allowed operations; this may be a combination of any of + * DND.DROP_NONE, DND.DROP_COPY, DND.DROP_MOVE, DND.DROP_LINK + * + * @exception SWTException <ul> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li> + * <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li> + * </ul> + * @exception SWTError <ul> + * <li>ERROR_CANNOT_INIT_DROP - unable to initiate drop target; this will occur if more than one + * drop target is created for a control or if the operating system will not allow the creation + * of the drop target</li> + * </ul> + * + * <p>NOTE: ERROR_CANNOT_INIT_DROP should be an SWTException, since it is a + * recoverable error, but can not be changed due to backward compatibility.</p> + * + * @see Widget#dispose + * @see DropTarget#checkSubclass + * @see DND#DROP_NONE + * @see DND#DROP_COPY + * @see DND#DROP_MOVE + * @see DND#DROP_LINK + */ +public DropTarget(Control control, int style) { + super (control, checkStyle(style)); + this.control = control; + if (control.getData(DND.DROP_TARGET_KEY) != null) + DND.error(DND.ERROR_CANNOT_INIT_DROP); + control.setData(DND.DROP_TARGET_KEY, this); + + jniRef = OS.NewGlobalRef (this); + if (jniRef == 0) SWT.error(SWT.ERROR_NO_HANDLES); + + hookEventHandlers(); + + controlListener = new Listener () { + public void handleEvent (Event event) { + if (!DropTarget.this.isDisposed()){ + DropTarget.this.dispose(); + } + } + }; + control.addListener (SWT.Dispose, controlListener); + + this.addListener(SWT.Dispose, new Listener() { + public void handleEvent (Event event) { + onDispose(); + } + }); + + Object effect = control.getData(DEFAULT_DROP_TARGET_EFFECT); + if (effect instanceof DropTargetEffect) { + dropEffect = (DropTargetEffect) effect; + } else if (control instanceof Table) { + dropEffect = new TableDropTargetEffect((Table) control); + } else if (control instanceof Tree) { + dropEffect = new TreeDropTargetEffect((Tree) control); + } +} + +/** + * Adds the listener to the collection of listeners who will + * be notified when a drag and drop operation is in progress, by sending + * it one of the messages defined in the <code>DropTargetListener</code> + * interface. + * + * <p><ul> + * <li><code>dragEnter</code> is called when the cursor has entered the drop target boundaries + * <li><code>dragLeave</code> is called when the cursor has left the drop target boundaries and just before + * the drop occurs or is cancelled. + * <li><code>dragOperationChanged</code> is called when the operation being performed has changed + * (usually due to the user changing the selected modifier key(s) while dragging) + * <li><code>dragOver</code> is called when the cursor is moving over the drop target + * <li><code>dropAccept</code> is called just before the drop is performed. The drop target is given + * the chance to change the nature of the drop or veto the drop by setting the <code>event.detail</code> field + * <li><code>drop</code> is called when the data is being dropped + * </ul></p> + * + * @param listener the listener which should be notified + * + * @exception IllegalArgumentException <ul> + * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> + * </ul> + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + * + * @see DropTargetListener + * @see #getDropListeners + * @see #removeDropListener + * @see DropTargetEvent + */ +public void addDropListener(DropTargetListener listener) { + if (listener == null) DND.error (SWT.ERROR_NULL_ARGUMENT); + DNDListener typedListener = new DNDListener (listener); + typedListener.dndWidget = this; + addListener (DND.DragEnter, typedListener); + addListener (DND.DragLeave, typedListener); + addListener (DND.DragOver, typedListener); + addListener (DND.DragOperationChanged, typedListener); + addListener (DND.Drop, typedListener); + addListener (DND.DropAccept, typedListener); +} + +boolean checkEventArgs (int eventArgs) { + if (isDisposed ()) return false; + int routedEventType = OS.RoutedEventArgs_typeid (); + int source = 0; + if (OS.Type_IsInstanceOfType (routedEventType, eventArgs)) { + source = OS.RoutedEventArgs_OriginalSource (eventArgs); + } + OS.GCHandle_Free (routedEventType); + if (source == 0) return true; + if (OS.Object_Equals (source, control.handle)) { + OS.GCHandle_Free (source); + return true; + } + Widget widget = getDisplay().findWidget (source); + OS.GCHandle_Free (source); + if (widget == control) return true; + + if (widget instanceof TreeItem) { + Composite parent = ((TreeItem) widget).getParent(); + if (parent == control) return true; + } else if (widget instanceof TableItem) { + Composite parent = ((TableItem) widget).getParent(); + if (parent == control) return true; + } + return false; +} + +protected void checkSubclass () { + String name = getClass().getName (); + String validName = DropTarget.class.getName(); + if (!validName.equals(name)) { + DND.error (SWT.ERROR_INVALID_SUBCLASS); + } +} + +void DragEnter(int sender, int dragEventArgs) { + if (!checkEventArgs (dragEventArgs)) return; + + selectedDataType = null; + selectedOperation = DND.DROP_NONE; + keyOperation = -1; + + DNDEvent event = new DNDEvent(); + if (!setEventData(event, dragEventArgs)) { + freeData(event.dataTypes); + return; + } + + int allowedOperations = event.operations; + TransferData[] allowedDataTypes = new TransferData[event.dataTypes.length]; + System.arraycopy(event.dataTypes, 0, allowedDataTypes, 0, allowedDataTypes.length); + notifyListeners(DND.DragEnter, event); + + if (event.detail == DND.DROP_DEFAULT) { + event.detail = (allowedOperations & DND.DROP_MOVE) != 0 ? DND.DROP_MOVE : DND.DROP_NONE; + } + + selectedDataType = null; + for (int i = 0; i < allowedDataTypes.length; i++) { + if (sameType(allowedDataTypes[i], event.dataType)) { + selectedDataType = allowedDataTypes[i]; + break; + } + } + + selectedOperation = DND.DROP_NONE; + if (selectedDataType != null && ((allowedOperations & event.detail) != 0)) { + selectedOperation = event.detail; + } + + freeData(event.dataTypes); + OS.RoutedEventArgs_Handled (dragEventArgs, true); +} + +void DragLeave(int sender, int dragEventArgs) { + if (!checkEventArgs (dragEventArgs)) return; + + keyOperation = -1; + DNDEvent event = new DNDEvent(); + event.widget = this; + event.time = (int)System.currentTimeMillis(); + event.detail = DND.DROP_NONE; + notifyListeners(DND.DragLeave, event); + OS.RoutedEventArgs_Handled (dragEventArgs, true); +} + +void DragOver(int sender, int dragEventArgs) { + if (!checkEventArgs (dragEventArgs)) return; + + int oldKeyOperation = keyOperation; + DNDEvent event = new DNDEvent(); + if (!setEventData(event, dragEventArgs)) { + freeData(event.dataTypes); + keyOperation = -1; + OS.DragEventArgs_Effects(dragEventArgs, OS.DragDropEffects_None); + return; + } + + int allowedOperations = event.operations; + TransferData[] allowedDataTypes = new TransferData[event.dataTypes.length]; + System.arraycopy(event.dataTypes, 0, allowedDataTypes, 0, allowedDataTypes.length); + + if (keyOperation == oldKeyOperation) { + event.type = DND.DragOver; + event.dataType = selectedDataType; + event.detail = selectedOperation; + } else { + event.type = DND.DragOperationChanged; + event.dataType = selectedDataType; + } + notifyListeners(event.type, event); + + if (event.detail == DND.DROP_DEFAULT) { + event.detail = (allowedOperations & DND.DROP_MOVE) != 0 ? DND.DROP_MOVE : DND.DROP_NONE; + } + + selectedDataType = null; + for (int i = 0; i < allowedDataTypes.length; i++) { + if (sameType(allowedDataTypes[i], event.dataType)){ + selectedDataType = allowedDataTypes[i]; + break; + } + } + + selectedOperation = DND.DROP_NONE; + if (selectedDataType != null && ((allowedOperations & event.detail) == event.detail)) { + selectedOperation = event.detail; + } + + freeData(event.dataTypes); + OS.DragEventArgs_Effects(dragEventArgs, opToOsOp(selectedOperation)); + OS.RoutedEventArgs_Handled (dragEventArgs, true); +} + +void Drop(int sender, int dragEventArgs) { + if (!checkEventArgs (dragEventArgs)) return; + + DNDEvent event = new DNDEvent(); + event.widget = this; + event.time = (int)System.currentTimeMillis(); + if (dropEffect != null) { + Point position = getPosition(dragEventArgs); + event.item = dropEffect.getItem(position.x, position.y); + } + event.detail = DND.DROP_NONE; + notifyListeners(DND.DragLeave, event); + + event = new DNDEvent(); + if (!setEventData(event, dragEventArgs)) { + keyOperation = -1; + freeData(event.dataTypes); + return; + } + keyOperation = -1; + int allowedOperations = event.operations; + TransferData[] allowedDataTypes = new TransferData[event.dataTypes.length]; + System.arraycopy(event.dataTypes, 0, allowedDataTypes, 0, allowedDataTypes.length); + event.dataType = selectedDataType; + event.detail = selectedOperation; + notifyListeners(DND.DropAccept,event); + + selectedDataType = null; + for (int i = 0; i < allowedDataTypes.length; i++) { + if (sameType(allowedDataTypes[i], event.dataType)){ + selectedDataType = allowedDataTypes[i]; + break; + } + } + selectedOperation = DND.DROP_NONE; + if (selectedDataType != null && (allowedOperations & event.detail) == event.detail) { + selectedOperation = event.detail; + } + + if (selectedOperation == DND.DROP_NONE) { + freeData(event.dataTypes); + return; + } + + // Get Data in a Java format + Object object = null; + for (int i = 0; i < transferAgents.length; i++){ + Transfer transfer = transferAgents[i]; + if (transfer != null && transfer.isSupportedType(selectedDataType)){ + object = transfer.nativeToJava(selectedDataType); + break; + } + } + if (object == null){ + selectedOperation = DND.DROP_NONE; + } + + event.detail = selectedOperation; + event.dataType = selectedDataType; + event.data = object; + notifyListeners(DND.Drop,event); + + selectedOperation = DND.DROP_NONE; + if ((allowedOperations & event.detail) == event.detail) { + selectedOperation = event.detail; + } + + freeData(event.dataTypes); + OS.DragEventArgs_Effects(dragEventArgs, opToOsOp(selectedOperation)); + OS.RoutedEventArgs_Handled (dragEventArgs, true); +} + +void freeData(TransferData[] dataTypes) { + if (dataTypes == null) return; + for (int i = 0; i < dataTypes.length; i++) { + if (dataTypes[i].pValue != 0) + OS.GCHandle_Free(dataTypes[i].pValue); + } +} + +/** + * Returns the Control which is registered for this DropTarget. This is the control over which the + * user positions the cursor to drop the data. + * + * @return the Control which is registered for this DropTarget + */ +public Control getControl () { + return control; +} + +int getData(int pDataObject, int type) { + int pFormat = Transfer.getWPFFormat(type); + int result = 0; + if (OS.DataObject_GetDataPresent(pDataObject, pFormat, true)) { + result = OS.DataObject_GetData(pDataObject, pFormat, true); + } + OS.GCHandle_Free (pFormat); + return result; +} + +/** + * Returns an array of listeners who will be notified when a drag and drop + * operation is in progress, by sending it one of the messages defined in + * the <code>DropTargetListener</code> interface. + * + * @return the listeners who will be notified when a drag and drop + * operation is in progress + * + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + * + * @see DropTargetListener + * @see #addDropListener + * @see #removeDropListener + * @see DropTargetEvent + * + * @since 3.4 + */ +public DropTargetListener[] getDropListeners() { + Listener[] listeners = getListeners(DND.DragEnter); + int length = listeners.length; + DropTargetListener[] dropListeners = new DropTargetListener[length]; + int count = 0; + for (int i = 0; i < length; i++) { + Listener listener = listeners[i]; + if (listener instanceof DNDListener) { + dropListeners[count] = (DropTargetListener) ((DNDListener) listener).getEventListener(); + count++; + } + } + if (count == length) return dropListeners; + DropTargetListener[] result = new DropTargetListener[count]; + System.arraycopy(dropListeners, 0, result, 0, count); + return result; +} + +/** + * Returns the drop effect for this DropTarget. This drop effect will be + * used during a drag and drop to display the drag under effect on the + * target widget. + * + * @return the drop effect that is registered for this DropTarget + * + * @since 3.3 + */ +public DropTargetEffect getDropTargetEffect() { + return dropEffect; +} + +int getOperationFromKeyState(int keyState) { + boolean ctrl = (keyState & OS.DragDropKeyStates_ControlKey) != 0; + boolean shift = (keyState & OS.DragDropKeyStates_ShiftKey) != 0; + boolean alt = (keyState & OS.DragDropKeyStates_AltKey) != 0; + if (alt) { + if (ctrl || shift) return DND.DROP_DEFAULT; + return DND.DROP_LINK; + } + if (ctrl && shift) return DND.DROP_LINK; + if (ctrl)return DND.DROP_COPY; + if (shift)return DND.DROP_MOVE; + return DND.DROP_DEFAULT; +} + +Point getPosition(int dragEventArgs) { + int position = OS.DragEventArgs_GetPosition(dragEventArgs, control.handle); + Point pt = control.getDisplay().map(control, null, (int) OS.Point_X(position), (int) OS.Point_Y(position)); + OS.GCHandle_Free (position); + return pt; +} + +/** + * Returns a list of the data types that can be transferred to this DropTarget. + * + * @return a list of the data types that can be transferred to this DropTarget + */ +public Transfer[] getTransfer() { + return transferAgents; +} + +void hookEventHandlers() { + int handle = control.handle; + OS.UIElement_AllowDrop(handle, true); + + dragEnterEventHandler = OS.gcnew_DragEventHandler(jniRef, "DragEnter"); + OS.UIElement_DragEnter(handle, dragEnterEventHandler); + + dragLeaveEventHandler = OS.gcnew_DragEventHandler(jniRef, "DragLeave"); + OS.UIElement_DragLeave(handle, dragLeaveEventHandler); + + dragOverEventHandler = OS.gcnew_DragEventHandler(jniRef, "DragOver"); + OS.UIElement_DragOver(handle, dragOverEventHandler); + + dropEventHandler = OS.gcnew_DragEventHandler(jniRef, "Drop"); + OS.UIElement_Drop(handle, dropEventHandler); +} + +void onDispose () { + if (control == null) + return; + if (controlListener != null) + control.removeListener(SWT.Dispose, controlListener); + unhookEventHandlers(); + if (jniRef != 0) OS.DeleteGlobalRef (jniRef); + jniRef = 0; + controlListener = null; + control.setData(DND.DROP_TARGET_KEY, null); + transferAgents = null; + control = null; +} + +int osOpToOp(int osOperation){ + int operation = 0; + if ((osOperation & OS.DragDropEffects_Copy) != 0){ + operation |= DND.DROP_COPY; + } + if ((osOperation & OS.DragDropEffects_Link) != 0) { + operation |= DND.DROP_LINK; + } + if ((osOperation & OS.DragDropEffects_Move) != 0) { + operation |= DND.DROP_MOVE; + } + return operation; +} + +int opToOsOp(int operation){ + int osOperation = 0; + if ((operation & DND.DROP_COPY) != 0){ + osOperation |= OS.DragDropEffects_Copy; + } + if ((operation & DND.DROP_LINK) != 0) { + osOperation |= OS.DragDropEffects_Link; + } + if ((operation & DND.DROP_MOVE) != 0) { + osOperation |= OS.DragDropEffects_Move; + } + return osOperation; +} + +/** + * Removes the listener from the collection of listeners who will + * be notified when a drag and drop operation is in progress. + * + * @param listener the listener which should no longer be notified + * + * @exception IllegalArgumentException <ul> + * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> + * </ul> + * @exception SWTException <ul> + * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> + * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> + * </ul> + * + * @see DropTargetListener + * @see #addDropListener + * @see #getDropListeners + */ +public void removeDropListener(DropTargetListener listener) { + if (listener == null) DND.error (SWT.ERROR_NULL_ARGUMENT); + removeListener (DND.DragEnter, listener); + removeListener (DND.DragLeave, listener); + removeListener (DND.DragOver, listener); + removeListener (DND.DragOperationChanged, listener); + removeListener (DND.Drop, listener); + removeListener (DND.DropAccept, listener); +} + +boolean sameType(TransferData data1, TransferData data2) { + if (data1 == data2) return true; + if (data1 == null || data2 == null) return false; + return data1.type == data2.type; +} + +/** + * Specifies the drop effect for this DropTarget. This drop effect will be + * used during a drag and drop to display the drag under effect on the + * target widget. + * + * @param effect the drop effect that is registered for this DropTarget + * + * @since 3.3 + */ +public void setDropTargetEffect(DropTargetEffect effect) { + dropEffect = effect; +} + +boolean setEventData(DNDEvent event, int dragEventArgs) { + Point position = getPosition(dragEventArgs); + + // get allowed operations + int style = getStyle(); + int operations = osOpToOp(OS.DragEventArgs_Effects(dragEventArgs)) & style; + if (operations == DND.DROP_NONE) return false; + + // get current operation + int operation = getOperationFromKeyState(OS.DragEventArgs_KeyStates(dragEventArgs)); + keyOperation = operation; + if (operation == DND.DROP_DEFAULT) { + if ((style & DND.DROP_DEFAULT) == 0) { + operation = (operations & DND.DROP_MOVE) != 0 ? DND.DROP_MOVE : DND.DROP_NONE; + } + } else { + if ((operation & operations) == 0) operation = DND.DROP_NONE; + } + + // Get allowed transfer types + TransferData[] dataTypes = new TransferData[0]; + int pDataObject = OS.DragEventArgs_Data(dragEventArgs); + for (int i = 0; i < transferAgents.length; i++) { + Transfer transfer = transferAgents[i]; + if (transfer != null) { + int[] types = transfer.getTypeIds(); + for (int j = 0; j < types.length; j++) { + TransferData data = new TransferData(); + data.type = types[j]; + data.pValue = getData(pDataObject, data.type); + if (data.pValue != 0) { + TransferData[] newDataTypes = new TransferData[dataTypes.length + 1]; + System.arraycopy(dataTypes, 0, newDataTypes, 0, dataTypes.length); + newDataTypes[dataTypes.length] = data; + dataTypes = newDataTypes; + break; + } + } + } + } + OS.GCHandle_Free (pDataObject); + if (dataTypes.length == 0) return false; + + event.widget = this; + event.x = position.x; + event.y = position.y; + event.time = (int)System.currentTimeMillis(); + event.feedback = DND.FEEDBACK_SELECT; + event.dataTypes = dataTypes; + event.dataType = dataTypes[0]; + event.operations = operations; + event.detail = operation; + if (dropEffect != null) { + event.item = dropEffect.getItem(position.x, position.y); + } + return true; +} + +/** + * Specifies the data types that can be transferred to this DropTarget. If data is + * being dragged that does not match one of these types, the drop target will be notified of + * the drag and drop operation but the currentDataType will be null and the operation + * will be DND.NONE. + * + * @param transferAgents a list of Transfer objects which define the types of data that can be + * dropped on this target + * + * @exception IllegalArgumentException <ul> + * <li>ERROR_NULL_ARGUMENT - if transferAgents is null</li> + * </ul> + */ +public void setTransfer(Transfer[] transferAgents){ + if (transferAgents == null) DND.error(SWT.ERROR_NULL_ARGUMENT); + this.transferAgents = transferAgents; +} + +void unhookEventHandlers() { + int handle = control.handle; + OS.UIElement_AllowDrop(handle, false); + + int dragEnterEvent = OS.UIElement_DragEnterEvent(); + OS.UIElement_RemoveHandler(handle, dragEnterEvent, dragEnterEventHandler); + OS.GCHandle_Free(dragEnterEventHandler); + OS.GCHandle_Free(dragEnterEvent); + dragEnterEventHandler = 0; + + int dragLeaveEvent = OS.UIElement_DragLeaveEvent(); + OS.UIElement_RemoveHandler(handle, dragLeaveEvent, dragLeaveEventHandler); + OS.GCHandle_Free(dragLeaveEventHandler); + OS.GCHandle_Free(dragLeaveEvent); + dragLeaveEventHandler = 0; + + int dragOverEvent = OS.UIElement_DragOverEvent(); + OS.UIElement_RemoveHandler(handle, dragOverEvent, dragOverEventHandler); + OS.GCHandle_Free(dragOverEventHandler); + OS.GCHandle_Free(dragOverEvent); + dragOverEventHandler = 0; + + int dropEvent = OS.UIElement_DropEvent(); + OS.UIElement_RemoveHandler(handle, dropEvent, dropEventHandler); + OS.GCHandle_Free(dropEventHandler); + OS.GCHandle_Free(dropEvent); + dropEventHandler = 0; +} + +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/FileTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/FileTransfer.java new file mode 100644 index 0000000000..bff244fbe9 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/FileTransfer.java @@ -0,0 +1,125 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + +import org.eclipse.swt.internal.wpf.*; + +/** + * The class <code>FileTransfer</code> provides a platform specific mechanism + * for converting a list of files represented as a java <code>String[]</code> to a + * platform specific representation of the data and vice versa. + * Each <code>String</code> in the array contains the absolute path for a single + * file or directory. + * + * <p>An example of a java <code>String[]</code> containing a list of files is shown + * below:</p> + * + * <code><pre> + * File file1 = new File("C:\temp\file1"); + * File file2 = new File("C:\temp\file2"); + * String[] fileData = new String[2]; + * fileData[0] = file1.getAbsolutePath(); + * fileData[1] = file2.getAbsolutePath(); + * </code></pre> + * + * @see Transfer + */ +public class FileTransfer extends ByteArrayTransfer { + +private static FileTransfer _instance = new FileTransfer(); +private static int TYPEID = getTypeId(); + +/** + * Returns the singleton instance of the FileTransfer class. + * + * @return the singleton instance of the FileTransfer class + */ +public static FileTransfer getInstance () { + return _instance; +} + +static int getTypeId() { + int format = OS.DataFormats_FileDrop(); + String name = createJavaString(format); + OS.GCHandle_Free(format); + return registerType(name); +} + +private FileTransfer() {} + +boolean checkFile(Object object) { + if (object == null || !(object instanceof String[]) || ((String[])object).length == 0) return false; + String[] strings = (String[])object; + for (int i = 0; i < strings.length; i++) { + if (strings[i] == null || strings[i].length() == 0) return false; + } + return true; +} + +protected int[] getTypeIds(){ + return new int[]{TYPEID}; +} + +/** + * This implementation of <code>javaToNative</code> converts a list of file names + * represented by a java <code>String[]</code> to a platform specific representation. + * Each <code>String</code> in the array contains the absolute path for a single + * file or directory. + * + * @param object a java <code>String[]</code> containing the file names to be converted + * @param transferData an empty <code>TransferData</code> object that will + * be filled in on return with the platform specific format of the data + * + * @see Transfer#nativeToJava + */ +public void javaToNative(Object object, TransferData transferData) { + if (!checkFile(object) || !isSupportedType(transferData)) { + DND.error(DND.ERROR_INVALID_DATA); + } + String[] fileNames = (String[]) object; + int length = fileNames.length; + int pStringId = OS.String_typeid(); + int pStringArray = OS.Array_CreateInstance(pStringId, length); + for (int i = 0; i < length; i++) { + int pString = createDotNetString(fileNames[i]); + OS.Array_SetValue(pStringArray, pString, i); + OS.GCHandle_Free(pString); + } + transferData.pValue = pStringArray; + OS.GCHandle_Free(pStringId); +} + +/** + * This implementation of <code>nativeToJava</code> converts a platform specific + * representation of a list of file names to a java <code>String[]</code>. + * Each String in the array contains the absolute path for a single file or directory. + * + * @param transferData the platform specific representation of the data to be converted + * @return a java <code>String[]</code> containing a list of file names if the conversion + * was successful; otherwise null + * + * @see Transfer#javaToNative + */ + +public Object nativeToJava(TransferData transferData) { + if (!isSupportedType(transferData) || transferData.pValue == 0) return null; + + int pStringArray = transferData.pValue; + int length = OS.Array_GetLength(pStringArray, 0); + String[] fileNames = new String [length]; + for (int i = 0; i < length; i++) { + int pString = OS.Array_GetValue(pStringArray, i); + fileNames[i] = createJavaString(pString); + OS.GCHandle_Free(pString); + } + return fileNames; +} +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/HTMLTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/HTMLTransfer.java new file mode 100644 index 0000000000..2a9c45fd58 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/HTMLTransfer.java @@ -0,0 +1,93 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + +import org.eclipse.swt.internal.wpf.*; + +/** + * The class <code>HTMLTransfer</code> provides a platform specific mechanism + * for converting text in HTML format represented as a java <code>String</code> + * to a platform specific representation of the data and vice versa. + * + * <p>An example of a java <code>String</code> containing HTML text is shown + * below:</p> + * + * <code><pre> + * String htmlData = "<p>This is a paragraph of text.</p>"; + * </code></pre> + * + * @see Transfer + */ +public class HTMLTransfer extends ByteArrayTransfer { + +private static HTMLTransfer _instance = new HTMLTransfer(); +private static int TYPEID = getTypeId(); + +/** + * Returns the singleton instance of the HTMLTransfer class. + * + * @return the singleton instance of the HTMLTransfer class + */ +public static HTMLTransfer getInstance () { + return _instance; +} + +static int getTypeId() { + int format = OS.DataFormats_Html(); + String name = createJavaString(format); + OS.GCHandle_Free(format); + return registerType(name); +} + +private HTMLTransfer() { +} + +boolean checkHTML(Object object) { + return (object != null && object instanceof String && ((String)object).length() > 0); +} + +protected int[] getTypeIds(){ + return new int[]{TYPEID}; +} + +/** + * This implementation of <code>javaToNative</code> converts HTML-formatted text + * represented by a java <code>String</code> to a platform specific representation. + * + * @param object a java <code>String</code> containing HTML text + * @param transferData an empty <code>TransferData</code> object that will + * be filled in on return with the platform specific format of the data + * + * @see Transfer#nativeToJava + */ +public void javaToNative (Object object, TransferData transferData){ + if (!checkHTML(object) || !isSupportedType(transferData)) { + DND.error(DND.ERROR_INVALID_DATA); + } + transferData.pValue = createDotNetString((String)object); +} + +/** + * This implementation of <code>nativeToJava</code> converts a platform specific + * representation of HTML text to a java <code>String</code>. + * + * @param transferData the platform specific representation of the data to be converted + * @return a java <code>String</code> containing HTML text if the conversion was successful; + * otherwise null + * + * @see Transfer#javaToNative + */ +public Object nativeToJava(TransferData transferData){ + if (!isSupportedType(transferData) || transferData.pValue == 0) return null; + + return createJavaString(transferData.pValue); +} +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/ImageTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/ImageTransfer.java new file mode 100644 index 0000000000..fc0b6ecd75 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/ImageTransfer.java @@ -0,0 +1,108 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.graphics.*; +import org.eclipse.swt.internal.wpf.OS; + +/** + * The class <code>ImageTransfer</code> provides a platform specific mechanism + * for converting an Image represented as a java <code>ImageData</code> to a + * platform specific representation of the data and vice versa. + * + * <p>An example of a java <code>ImageData</code> is shown below:</p> + * + * <code><pre> + * Image image = new Image(display, "C:\temp\img1.gif"); + * ImageData imgData = image.getImageData(); + * </code></pre> + * + * @see Transfer + * + * @since 3.4 + */ +public class ImageTransfer extends ByteArrayTransfer { + +private static ImageTransfer _instance = new ImageTransfer(); +private static int TYPEID = getTypeId(); + +static int getTypeId() { + int format = OS.DataFormats_Bitmap(); + String name = createJavaString(format); + OS.GCHandle_Free(format); + return registerType(name); +} + +private ImageTransfer() {} + +/** + * Returns the singleton instance of the ImageTransfer class. + * + * @return the singleton instance of the ImageTransfer class + */ +public static ImageTransfer getInstance () { + return _instance; +} + +/** + * This implementation of <code>javaToNative</code> converts an ImageData object represented + * by java <code>ImageData</code> to a platform specific representation. + * + * @param object a java <code>ImageData</code> containing the ImageData to be converted + * @param transferData an empty <code>TransferData</code> object that will + * be filled in on return with the platform specific format of the data + * + * @see Transfer#nativeToJava + */ +public void javaToNative(Object object, TransferData transferData) { + if (!checkImage(object) || !isSupportedType(transferData)) { + DND.error(DND.ERROR_INVALID_DATA); + } + ImageData imgData = (ImageData)object; + if (imgData == null) SWT.error(SWT.ERROR_NULL_ARGUMENT); + + Image image = new Image(null, imgData); + transferData.pValue = image.handle; +} + +/** + * This implementation of <code>nativeToJava</code> converts a platform specific + * representation of an image to java <code>ImageData</code>. + * + * @param transferData the platform specific representation of the data to be converted + * @return a java <code>ImageData</code> of the image if the conversion was successful; + * otherwise null + * + * @see Transfer#javaToNative + */ +public Object nativeToJava(TransferData transferData) { + if (!isSupportedType(transferData) || transferData.pValue == 0) return null; + + Image image = Image.wpf_new (null, SWT.BITMAP, transferData.pValue); + ImageData imageData = image.getImageData (); + image.dispose (); + return imageData; +} + +protected int[] getTypeIds(){ + return new int[]{TYPEID}; +} + +boolean checkImage(Object object) { + if (object == null || !(object instanceof ImageData)) return false; + return true; +} + +protected boolean validate(Object object) { + return checkImage(object); +} +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/RTFTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/RTFTransfer.java new file mode 100644 index 0000000000..b5d366612a --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/RTFTransfer.java @@ -0,0 +1,94 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + +import org.eclipse.swt.internal.wpf.*; + + +/** + * The class <code>RTFTransfer</code> provides a platform specific mechanism + * for converting text in RTF format represented as a java <code>String</code> + * to a platform specific representation of the data and vice versa. + * + * <p>An example of a java <code>String</code> containing RTF text is shown + * below:</p> + * + * <code><pre> + * String rtfData = "{\\rtf1{\\colortbl;\\red255\\green0\\blue0;}\\uc1\\b\\i Hello World}"; + * </code></pre> + * + * @see Transfer + */ +public class RTFTransfer extends ByteArrayTransfer { + +private static RTFTransfer _instance = new RTFTransfer(); +private static int TYPEID = getTypeId(); + +/** + * Returns the singleton instance of the RTFTransfer class. + * + * @return the singleton instance of the RTFTransfer class + */ +public static RTFTransfer getInstance () { + return _instance; +} + +static int getTypeId() { + int format = OS.DataFormats_Rtf(); + String name = createJavaString(format); + OS.GCHandle_Free(format); + return registerType(name); +} + +private RTFTransfer() { +} + +boolean checkRTF(Object object) { + return (object != null && object instanceof String && ((String)object).length() > 0); +} + +protected int[] getTypeIds(){ + return new int[]{TYPEID}; +} + +/** + * This implementation of <code>javaToNative</code> converts RTF-formatted text + * represented by a java <code>String</code> to a platform specific representation. + * + * @param object a java <code>String</code> containing RTF text + * @param transferData an empty <code>TransferData</code> object that will + * be filled in on return with the platform specific format of the data + * + * @see Transfer#nativeToJava + */ +public void javaToNative (Object object, TransferData transferData) { + if (!checkRTF(object) || !isSupportedType(transferData)) { + DND.error(DND.ERROR_INVALID_DATA); + } + transferData.pValue = createDotNetString((String)object); +} + +/** + * This implementation of <code>nativeToJava</code> converts a platform specific + * representation of RTF text to a java <code>String</code>. + * + * @param transferData the platform specific representation of the data to be converted + * @return a java <code>String</code> containing RTF text if the conversion was successful; + * otherwise null + * + * @see Transfer#javaToNative + */ +public Object nativeToJava(TransferData transferData) { + if (!isSupportedType(transferData) || transferData.pValue == 0) return null; + + return createJavaString(transferData.pValue); +} +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TableDragSourceEffect.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TableDragSourceEffect.java new file mode 100644 index 0000000000..b7dbda53be --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TableDragSourceEffect.java @@ -0,0 +1,43 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + +import org.eclipse.swt.widgets.*; + +/** + * This class provides default implementations to display a source image + * when a drag is initiated from a <code>Table</code>. + * + * <p>Classes that wish to provide their own source image for a <code>Table</code> can + * extend the <code>TableDragSourceEffect</code> class, override the + * <code>TableDragSourceEffect.dragStart</code> method and set the field + * <code>DragSourceEvent.image</code> with their own image.</p> + * + * Subclasses that override any methods of this class must call the corresponding + * <code>super</code> method to get the default drag source effect implementation. + * + * @see DragSourceEffect + * @see DragSourceEvent + * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a> + * + * @since 3.3 + */ +public class TableDragSourceEffect extends DragSourceEffect { + /** + * Creates a new <code>TableDragSourceEffect</code> to handle drag effect + * from the specified <code>Table</code>. + * + * @param table the <code>Table</code> that the user clicks on to initiate the drag + */ + public TableDragSourceEffect(Table table) { + super(table); + } +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TableDropTargetEffect.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TableDropTargetEffect.java new file mode 100644 index 0000000000..8818ec6a4b --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TableDropTargetEffect.java @@ -0,0 +1,55 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + +import org.eclipse.swt.widgets.*; + +/** + * This class provides a default drag under effect (eg. select, insert and scroll) + * when a drag occurs over a <code>Table</code>. + * + * <p>Classes that wish to provide their own drag under effect for a <code>Table</code> + * can extend the <code>TableDropTargetEffect</code> and override any applicable methods + * in <code>TableDropTargetEffect</code> to display their own drag under effect.</p> + * + * Subclasses that override any methods of this class must call the corresponding + * <code>super</code> method to get the default drag under effect implementation. + * + * <p>The feedback value is either one of the FEEDBACK constants defined in + * class <code>DND</code> which is applicable to instances of this class, + * or it must be built by <em>bitwise OR</em>'ing together + * (that is, using the <code>int</code> "|" operator) two or more + * of those <code>DND</code> effect constants. + * </p> + * <p> + * <dl> + * <dt><b>Feedback:</b></dt> + * <dd>FEEDBACK_SELECT, FEEDBACK_SCROLL</dd> + * </dl> + * </p> + * + * @see DropTargetAdapter + * @see DropTargetEvent + * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a> + * + * @since 3.3 + */ +public class TableDropTargetEffect extends DropTargetEffect { + /** + * Creates a new <code>TableDropTargetEffect</code> to handle the drag under effect on the specified + * <code>Table</code>. + * + * @param table the <code>Table</code> over which the user positions the cursor to drop the data + */ + public TableDropTargetEffect(Table table) { + super(table); + } +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TextTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TextTransfer.java new file mode 100644 index 0000000000..3dfc44cbaa --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TextTransfer.java @@ -0,0 +1,93 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + +import org.eclipse.swt.internal.wpf.*; + + +/** + * The class <code>TextTransfer</code> provides a platform specific mechanism + * for converting plain text represented as a java <code>String</code> + * to a platform specific representation of the data and vice versa. + * + * <p>An example of a java <code>String</code> containing plain text is shown + * below:</p> + * + * <code><pre> + * String textData = "Hello World"; + * </code></pre> + * + * @see Transfer + */ +public class TextTransfer extends ByteArrayTransfer { + +private static TextTransfer _instance = new TextTransfer(); +private static int TYPEID = getTypeId(); + +/** + * Returns the singleton instance of the TextTransfer class. + * + * @return the singleton instance of the TextTransfer class + */ +public static TextTransfer getInstance () { + return _instance; +} + +static int getTypeId() { + int format = OS.DataFormats_UnicodeText(); + String name = createJavaString(format); + OS.GCHandle_Free(format); + return registerType(name); +} + +private TextTransfer() { +} + +boolean checkText(Object object) { + return object != null && object instanceof String && ((String)object).length() > 0; +} + +protected int[] getTypeIds(){ + return new int[]{TYPEID}; +} + +/** + * This implementation of <code>javaToNative</code> converts plain text + * represented by a java <code>String</code> to a platform specific representation. + * + * @param object a java <code>String</code> containing text + * @param transferData an empty <code>TransferData</code> object that will + * be filled in on return with the platform specific format of the data + * + * @see Transfer#nativeToJava + */ +public void javaToNative (Object object, TransferData transferData) { + if (!checkText(object) || !isSupportedType(transferData)) { + DND.error(DND.ERROR_INVALID_DATA); + } + transferData.pValue = createDotNetString((String)object); +} + +/** + * This implementation of <code>nativeToJava</code> converts a platform specific + * representation of plain text to a java <code>String</code>. + * + * @param transferData the platform specific representation of the data to be converted + * @return a java <code>String</code> containing text if the conversion was successful; otherwise null + * + * @see Transfer#javaToNative + */ +public Object nativeToJava(TransferData transferData) { + if (!isSupportedType(transferData) || transferData.pValue == 0) return null; + + return createJavaString(transferData.pValue); +} +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/Transfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/Transfer.java new file mode 100644 index 0000000000..1940e97a63 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/Transfer.java @@ -0,0 +1,194 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + +import org.eclipse.swt.internal.wpf.*; +import org.eclipse.swt.*; + +/** + * <code>Transfer</code> provides a mechanism for converting between a java + * representation of data and a platform specific representation of data and + * vice versa. It is used in data transfer operations such as drag and drop and + * clipboard copy/paste. + * + * <p>You should only need to become familiar with this class if you are + * implementing a Transfer subclass and you are unable to subclass the + * ByteArrayTransfer class.</p> + * + * @see ByteArrayTransfer + * @see <a href="http://www.eclipse.org/swt/snippets/#dnd">Drag and Drop snippets</a> + * @see <a href="http://www.eclipse.org/swt/examples.php">SWT Example: DNDExample</a> + * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a> + */ +public abstract class Transfer { + +private static String[] registeredTypes = new String[0]; + +static int createDotNetString (String string) { + if (string == null) return 0; + int length = string.length(); + char[] buffer = new char[length + 1]; + string.getChars(0, length, buffer, 0); + int result = OS.gcnew_String(buffer); + if (result == 0) SWT.error(SWT.ERROR_NO_HANDLES); + return result; +} + +static String createJavaString (int ptr) { + int charArray = OS.String_ToCharArray(ptr); + char[] chars = new char[OS.String_Length(ptr)]; + OS.memcpy(chars, charArray, chars.length * 2); + OS.GCHandle_Free(charArray); + return new String(chars); +} + +/** + * Returns a list of the platform specific data types that can be converted using + * this transfer agent. + * + * <p>Only the data type fields of the <code>TransferData</code> objects are filled + * in.</p> + * + * @return a list of the data types that can be converted using this transfer agent + */ +abstract public TransferData[] getSupportedTypes(); + +/** + * Returns true if the <code>TransferData</code> data type can be converted + * using this transfer agent, or false otherwise (including if transferData is + * <code>null</code>). + * + * @param transferData a platform specific description of a data type; only the data + * type fields of the <code>TransferData</code> object need to be filled in + * + * @return true if the transferData data type can be converted using this transfer + * agent + */ +abstract public boolean isSupportedType(TransferData transferData); + +/** + * Returns the platform specific names of the data types that can be converted + * using this transfer agent. + * + * @return the platform specific names of the data types that can be converted + * using this transfer agent. + */ +abstract protected String[] getTypeNames(); + +/** + * Returns the platform specific ids of the data types that can be converted using + * this transfer agent. + * + * @return the platform specific ids of the data types that can be converted using + * this transfer agent + */ +abstract protected int[] getTypeIds(); + +/** + * Converts a java representation of data to a platform specific representation of + * the data. + * + * <p>On a successful conversion, the transferData.result field will be set as follows: + * <ul> + * <li>Windows: COM.S_OK + * <li>Motif: 1 + * <li>GTK: 1 + * <li>Photon: 1 + * </ul></p> + * + * <p>If this transfer agent is unable to perform the conversion, the transferData.result + * field will be set to a failure value as follows: + * <ul> + * <li>Windows: COM.DV_E_TYMED or COM.E_FAIL + * <li>Motif: 0 + * <li>GTK: 0 + * <li>Photon: 0 + * </ul></p> + * + * @param object a java representation of the data to be converted; the type of + * Object that is passed in is dependent on the <code>Transfer</code> subclass. + * + * @param transferData an empty TransferData object; this object will be + * filled in on return with the platform specific representation of the data + * + * @exception org.eclipse.swt.SWTException <ul> + * <li>ERROR_INVALID_DATA - if object does not contain data in a valid format or is <code>null</code></li> + * </ul> + */ +abstract protected void javaToNative (Object object, TransferData transferData); + +/** + * Converts a platform specific representation of data to a java representation. + * + * @param transferData the platform specific representation of the data to be + * converted + * + * @return a java representation of the converted data if the conversion was + * successful; otherwise null. If transferData is <code>null</code> then + * <code>null</code> is returned. The type of Object that is returned is + * dependent on the <code>Transfer</code> subclass. + */ +abstract protected Object nativeToJava(TransferData transferData); + +/** + * Registers a name for a data type and returns the associated unique identifier. + * + * <p>You may register the same type more than once, the same unique identifier + * will be returned if the type has been previously registered.</p> + * + * <p>Note: On windows, do <b>not</b> call this method with pre-defined + * Clipboard Format types such as CF_TEXT or CF_BITMAP because the + * pre-defined identifier will not be returned</p> + * + * @param formatName the name of a data type + * + * @return the unique identifier associated with this data type + */ +public static int registerType(String formatName){ + int length = registeredTypes.length; + for (int i = 0; i < length; i++) { + if (registeredTypes[i].equals(formatName)) + return i + 1; + } + String[] newTypes = new String[length + 1]; + System.arraycopy(registeredTypes, 0, newTypes, 0, length); + newTypes[length] = formatName; + registeredTypes = newTypes; + return length + 1; +} + +static String getTypeName(int registeredType) { + --registeredType; + if (registeredType < 0 || registeredType >= registeredTypes.length) + DND.error(DND.ERROR_INVALID_DATA); + return registeredTypes[registeredType]; +} + +static int getWPFFormat(int registeredType) { + --registeredType; + if (registeredType < 0 || registeredType >= registeredTypes.length) + DND.error(DND.ERROR_INVALID_DATA); + return createDotNetString(registeredTypes[registeredType]); +} + +/** + * Test that the object is of the correct format for this Transfer class. + * + * @param object a java representation of the data to be converted + * + * @return true if object is of the correct form for this transfer type + * + * @since 3.1 + */ +protected boolean validate(Object object) { + return true; +} +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TransferData.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TransferData.java new file mode 100644 index 0000000000..a3ef0165a0 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TransferData.java @@ -0,0 +1,61 @@ +/******************************************************************************* + * Copyright (c) 2000, 2009 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + + +/** + * The <code>TransferData</code> class is a platform specific data structure for + * describing the type and the contents of data being converted by a transfer agent. + * + * <p>As an application writer, you do not need to know the specifics of + * TransferData. TransferData instances are passed to a subclass of Transfer + * and the Transfer object manages the platform specific issues. + * You can ask a Transfer subclass if it can handle this data by calling + * Transfer.isSupportedType(transferData).</p> + * + * <p>You should only need to become familiar with the fields in this class if you + * are implementing a Transfer subclass and you are unable to subclass the + * ByteArrayTransfer class.</p> + * + * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a> + */ +public class TransferData { + /** + * The type is a unique identifier of a system format or user defined format. + * (Warning: This field is platform dependent) + * <p> + * <b>IMPORTANT:</b> This field is <em>not</em> part of the SWT + * public API. It is marked public only so that it can be shared + * within the packages provided by SWT. It is not available on all + * platforms and should never be accessed from application code. + * </p> + */ + public int type; + + // attributes specific to set/get + int pValue; + + /** + * The result field contains the result of converting a + * java data type into a platform specific value. + * (Warning: This field is platform dependent) + * <p> + * <b>IMPORTANT:</b> This field is <em>not</em> part of the SWT + * public API. It is marked public only so that it can be shared + * within the packages provided by SWT. It is not available on all + * platforms and should never be accessed from application code. + * </p> + * <p>The value of result is 1 if the conversion was successful. + * The value of result is 0 if the conversion failed.</p> + */ + int result; + +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TreeDragSourceEffect.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TreeDragSourceEffect.java new file mode 100644 index 0000000000..7a66bebb22 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TreeDragSourceEffect.java @@ -0,0 +1,42 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + +import org.eclipse.swt.widgets.*; + +/** + * This class provides default implementations to display a source image + * when a drag is initiated from a <code>Tree</code>. + * + * <p>Classes that wish to provide their own source image for a <code>Tree</code> can + * extend <code>TreeDragSourceEffect</code> class and override the <code>TreeDragSourceEffect.dragStart</code> + * method and set the field <code>DragSourceEvent.image</code> with their own image.</p> + * + * Subclasses that override any methods of this class must call the corresponding + * <code>super</code> method to get the default drag under effect implementation. + * + * @see DragSourceEffect + * @see DragSourceEvent + * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a> + * + * @since 3.3 + */ +public class TreeDragSourceEffect extends DragSourceEffect { + /** + * Creates a new <code>TreeDragSourceEffect</code> to handle drag effect + * from the specified <code>Tree</code>. + * + * @param tree the <code>Tree</code> that the user clicks on to initiate the drag + */ + public TreeDragSourceEffect(Tree tree) { + super(tree); + } +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TreeDropTargetEffect.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TreeDropTargetEffect.java new file mode 100644 index 0000000000..348c3742cf --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/TreeDropTargetEffect.java @@ -0,0 +1,58 @@ +/******************************************************************************* + * Copyright (c) 2000, 2008 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + +import org.eclipse.swt.widgets.*; + +/** + * This class provides a default drag under effect (eg. select, insert, scroll and expand) + * when a drag occurs over a <code>Tree</code>. + * + * <p>Classes that wish to provide their own drag under effect for a <code>Tree</code> + * can extend the <code>TreeDropTargetEffect</code> class and override any applicable methods + * in <code>TreeDropTargetEffect</code> to display their own drag under effect.</p> + * + * Subclasses that override any methods of this class must call the corresponding + * <code>super</code> method to get the default drag under effect implementation. + * + * <p>The feedback value is either one of the FEEDBACK constants defined in + * class <code>DND</code> which is applicable to instances of this class, + * or it must be built by <em>bitwise OR</em>'ing together + * (that is, using the <code>int</code> "|" operator) two or more + * of those <code>DND</code> effect constants. + * </p> + * <p> + * <dl> + * <dt><b>Feedback:</b></dt> + * <dd>FEEDBACK_SELECT, FEEDBACK_INSERT_BEFORE, FEEDBACK_INSERT_AFTER, FEEDBACK_EXPAND, FEEDBACK_SCROLL</dd> + * </dl> + * </p><p> + * Note: Only one of the styles FEEDBACK_SELECT, FEEDBACK_INSERT_BEFORE or + * FEEDBACK_INSERT_AFTER may be specified. + * </p> + * + * @see DropTargetAdapter + * @see DropTargetEvent + * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a> + * + * @since 3.3 + */ +public class TreeDropTargetEffect extends DropTargetEffect { + /** + * Creates a new <code>TreeDropTargetEffect</code> to handle the drag under effect on the specified + * <code>Tree</code>. + * + * @param tree the <code>Tree</code> over which the user positions the cursor to drop the data + */ + public TreeDropTargetEffect(Tree tree) { + super(tree); + } +} diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/URLTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/URLTransfer.java new file mode 100644 index 0000000000..c509da3664 --- /dev/null +++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/wpf/org/eclipse/swt/dnd/URLTransfer.java @@ -0,0 +1,115 @@ +/******************************************************************************* + * Copyright (c) 2007, 2009 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.dnd; + +import org.eclipse.swt.internal.wpf.OS; + +/** + * The class <code>URLTransfer</code> provides a platform specific mechanism + * for converting text in URL format represented as a java <code>String</code> + * to a platform specific representation of the data and vice versa. The string + * must contain a fully specified url. + * + * <p>An example of a java <code>String</code> containing a URL is shown below:</p> + * + * <code><pre> + * String url = "http://www.eclipse.org"; + * </code></pre> + * + * @see Transfer + * @since 3.4 + */ +public class URLTransfer extends ByteArrayTransfer { + + static URLTransfer _instance = new URLTransfer(); + static final String URL = "UniformResourceLocator"; //$NON-NLS-1$ + static final int URL_ID = registerType(URL); + +private URLTransfer() {} + +/** + * Returns the singleton instance of the URLTransfer class. + * + * @return the singleton instance of the URLTransfer class + */ +public static URLTransfer getInstance () { + return _instance; +} + +/** + * This implementation of <code>javaToNative</code> converts a URL + * represented by a java <code>String</code> to a platform specific representation. + * + * @param object a java <code>String</code> containing a URL + * @param transferData an empty <code>TransferData</code> object that will + * be filled in on return with the platform specific format of the data + * + * @see Transfer#nativeToJava + */ +public void javaToNative (Object object, TransferData transferData){ + if (!checkURL(object) || !isSupportedType(transferData)) { + DND.error(DND.ERROR_INVALID_DATA); + } + String string = (String)object + '\0'; + byte[] buffer = string.getBytes(); + if (buffer.length == 0) return; + int typeid = OS.Byte_typeid(); + int pBytes = OS.Array_CreateInstance(typeid, buffer.length); + OS.GCHandle_Free(typeid); + if (pBytes == 0) return; + OS.memcpy(pBytes, buffer, buffer.length); + int pStream = OS.gcnew_MemoryStream(); + OS.MemoryStream_Write(pStream, pBytes, 0, buffer.length); + OS.GCHandle_Free(pBytes); + transferData.pValue = pStream; +} + +/** + * This implementation of <code>nativeToJava</code> converts a platform + * specific representation of a URL to a java <code>String</code>. + * + * @param transferData the platform specific representation of the data to be converted + * @return a java <code>String</code> containing a URL if the conversion was successful; + * otherwise null + * + * @see Transfer#javaToNative + */ +public Object nativeToJava(TransferData transferData){ + if (!isSupportedType(transferData) || transferData.pValue == 0) return null; + + int byteArray = OS.MemoryStream_ToArray(transferData.pValue); + int bLength = OS.Array_GetLength(byteArray, 0); + byte[] buffer = new byte[bLength]; + if (bLength == 0) return ""; + OS.memcpy(buffer, byteArray, bLength); + OS.GCHandle_Free(byteArray); + + String string = new String(buffer); + int end = string.indexOf('\0'); + return (end == -1) ? string : string.substring(0, end); +} + +protected int[] getTypeIds(){ + return new int[] {URL_ID}; +} + +protected String[] getTypeNames(){ + return new String[] {URL}; +} + +boolean checkURL(Object object) { + return object != null && (object instanceof String) && ((String)object).length() > 0; +} + +protected boolean validate(Object object) { + return checkURL(object); +} +} |