ByteArrayTransfer (Eclipse Rich Ajax Platform API Reference)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Eclipse Rich Ajax Platform

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.eclipse.swt.dnd
Class ByteArrayTransfer

java.lang.Object
  org.eclipse.swt.dnd.Transfer
      org.eclipse.swt.dnd.ByteArrayTransfer

Direct Known Subclasses:: FileTransfer, HTMLTransfer, ImageTransfer, RTFTransfer, TextTransfer, URLTransfer

public abstract class ByteArrayTransfer
extends Transfer
extends Transfer

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.

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

Since:: 1.3
See Also:: Transfer

Constructor Summary
`ByteArrayTransfer()`

Method Summary
`TransferData[]`	`getSupportedTypes()` Returns a list of the platform specific data types that can be converted using this transfer agent.
`boolean`	`isSupportedType(TransferData transferData)` Returns true if the `TransferData` data type can be converted using this transfer agent, or false otherwise (including if transferData is `null`).
`void`	`javaToNative(java.lang.Object object, TransferData transferData)` This implementation of `javaToNative` converts a java `byte[]` to a platform specific representation.
`java.lang.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, validate`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail