org.eclipse.swt.dnd
Class ByteArrayTransfer

java.lang.Object
  |
  +--org.eclipse.swt.dnd.Transfer
        |
        +--org.eclipse.swt.dnd.ByteArrayTransfer

Direct Known Subclasses:

FileTransfer, RTFTransfer, TextTransfer

public abstract class ByteArrayTransfer

extends Transfer

Untamed: The class ByteArrayTransfer provides a platform specific mechanism for converting a java byte[] to a platform specific representation of the byte array and vice versa. See Transfer for additional information.

ByteArrayTransfer is never used directly but is sub-classed by transfer agents that convert between data in a java format such as a String and a platform specific byte array.

If the data you are converting does not map to a byte[], you should sub-class Transfer directly and do your own mapping to a platform data type.

The following snippet shows a sublcass of ByteArrayTransfer that transfers data defined by the class MyType.

 public class MyType {
	public String fileName;
	public long fileLength;
	public long lastModified;
 }
 

 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};
 }
 }















Constructor Summary
ByteArrayTransfer()



          Enabled:
 



Method Summary




 TransferData[]
getSupportedTypes()



          Enabled:



 boolean
isSupportedType(TransferData transferData)



          Enabled:



protected  void
javaToNative(Object object,
             TransferData transferData)



          This implementation of javaToNative converts a java 
 byte[] to a platform specific representation.



protected  Object
nativeToJava(TransferData transferData)



          This implementation of nativeToJava converts a platform specific 
 representation of a byte array to a java byte[].


 
Methods inherited from class org.eclipse.swt.dnd.Transfer
getTypeIds, getTypeNames, registerType
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 








Constructor Detail



ByteArrayTransfer
public ByteArrayTransfer()

Enabled:






Method Detail



getSupportedTypes
public TransferData[] getSupportedTypes()

Enabled:


Specified by:
getSupportedTypes in class Transfer



Returns:
a list of the data types that can be converted using this transfer agent





isSupportedType
public boolean isSupportedType(TransferData transferData)

Enabled:


Specified by:
isSupportedType in class Transfer


Parameters:
transferData - a platform specific description of a data type; only the data
  type fields of the TransferData object need to be filled in
Returns:
true if the transferData data type can be converted using this transfer 
 agent





javaToNative
protected void javaToNative(Object object,
                            TransferData transferData)

This implementation of javaToNative converts a java 
 byte[] to a platform specific representation.  For additional
 information see Transfer#javaToNative.


Specified by:
javaToNative in class Transfer


Parameters:
object - a java byte[] containing the data to be converted
transferData - an empty TransferData object; this
  object will be filled in on return with the platform specific format of the data
See Also:
Transfer.javaToNative(java.lang.Object, org.eclipse.swt.dnd.TransferData)





nativeToJava
protected Object nativeToJava(TransferData transferData)

This implementation of nativeToJava converts a platform specific 
 representation of a byte array to a java byte[].   
 For additional information see Transfer#nativeToJava.


Specified by:
nativeToJava in class Transfer


Parameters:
transferData - the platform specific representation of the data to be 
 been converted
Returns:
a java byte[] containing the converted data if the 
 conversion was successful; otherwise null
See Also:
Transfer.nativeToJava(org.eclipse.swt.dnd.TransferData)