Package org.eclipse.swt.dnd

Class ByteArrayTransfer

java.lang.Object
org.eclipse.swt.dnd.Transfer
org.eclipse.swt.dnd.ByteArrayTransfer
Direct Known Subclasses:
EditorInputTransfer, FileTransfer, HTMLTransfer, ImageTransfer, LocalSelectionTransfer, MarkerTransfer, PluginTransfer, ResourceTransfer, RTFTransfer, TextTransfer, URLTransfer
public abstract class ByteArrayTransfer 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;
 }

 @Override
 public void javaToNative(Object object, TransferData transferData) {
        if (!checkMyType(object) || !isSupportedType(transferData)) {
                DND.error(DND.ERROR_INVALID_DATA);
        }

        MyType myType = (MyType) object;
        // write data to a byte array and then ask super to convert to native
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        try (DataOutputStream writeOut = new DataOutputStream(out)) {
                byte[] fileNameBytes = myType.fileName.getBytes(StandardCharsets.UTF_8);
                writeOut.writeInt(fileNameBytes.length);
                writeOut.write(fileNameBytes);
                writeOut.writeLong(myType.fileLength);
                writeOut.writeLong(myType.lastModified);
                super.javaToNative(out.toByteArray(), transferData);
        } catch (IOException e) {
        }
 }

 @Override
 public Object nativeToJava(TransferData transferData) {
        if (!isSupportedType(transferData)) {
                return null;
        }

        byte[] buffer = (byte[]) super.nativeToJava(transferData);
        if (buffer == null) {
                return null;
        }

        ByteArrayInputStream in = new ByteArrayInputStream(buffer);
        try (DataInputStream readIn = new DataInputStream(in)) {
                MyType myType = new MyType();
                int size = readIn.readInt();
                byte[] name = new byte[size];
                readIn.read(name);
                myType.fileName = new String(name);
                myType.fileLength = readIn.readLong();
                myType.lastModified = readIn.readLong();
                return myType;
        } catch (IOException ex) {
        }
        return null;
 }

 @Override
 protected String[] getTypeNames() {
        return new String[] { MYTYPENAME };
 }

 @Override
 protected int[] getTypeIds() {
        return new int[] { MYTYPEID };
 }

 private boolean checkMyType(Object object) {
        return (object instanceof MyType);
 }

 @Override
 protected boolean validate(Object object) {
        return checkMyType(object);
 }
 }
See Also:

  • Constructor Details

    • ByteArrayTransfer

      public ByteArrayTransfer()

  • Method Details

    • getSupportedTypes

      public TransferData[] getSupportedTypes()
      Description copied from class: Transfer
      Returns a list of the platform specific data types that can be converted using this transfer agent.

      Only the data type fields of the TransferData objects are filled in.

      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)
      Description copied from class: Transfer
      Returns true if the TransferData data type can be converted using this transfer agent, or false otherwise (including if transferData is null).
      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.
      Specified by:
      javaToNative in class Transfer
      Parameters:
      object - a java byte[] containing the data to be converted
      transferData - an empty TransferData object that will be filled in on return with the platform specific format of the data
      See Also:

    • nativeToJava

      protected Object nativeToJava(TransferData transferData)
      This implementation of nativeToJava converts a platform specific representation of a byte array to a java byte[].
      Specified by:
      nativeToJava in class Transfer
      Parameters:
      transferData - the platform specific representation of the data to be converted
      Returns:
      a java byte[] containing the converted data if the conversion was successful; otherwise null
      See Also: