1 files changed, 198 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 &lt; 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;
+}
+}