Can I drag items from Outlook into my SWT application?

Question

Background

Our Eclipse RCP 3.6-based application lets people drag files in for storage/processing. This works fine when the files are dragged from a filesystem, but not when people drag items (messages or attachments) directly from Outlook.

This appears to be because Outlook wants to feed our application the files via a FileGroupDescriptorW and FileContents, but SWT only includes a FileTransfer type. (In a FileTransfer, only the file paths are passed, with the assumption that the receiver can locate and read them. The FileGroupDescriptorW/FileContents approach can supply files directly application-to-application without writing temporary files out to disk.)

We have tried to produce a ByteArrayTransfer subclass that could accept FileGroupDescriptorW and FileContents. Based on some examples on the Web, we were able to receive and parse the FileGroupDescriptorW, which (as the name implies) describes the files available for transfer. (See code sketch below.) But we have been unable to accept the FileContents.

This seems to be because Outlook offers the FileContents data only as TYMED_ISTREAM or TYMED_ISTORAGE, but SWT only understands how to exchange data as TYMED_HGLOBAL. Of those, it appears that TYMED_ISTORAGE would be preferable, since it's not clear how TYMED_ISTREAM could provide access to multiple files' contents.

(We also have some concerns about SWT's desire to pick and convert only a single TransferData type, given that we need to process two, but we think we could probably hack around that in Java somehow: it seems that all the TransferDatas are available at other points of the process.)

Questions

Are we on the right track here? Has anyone managed to accept FileContents in SWT yet? Is there any chance that we could process the TYMED_ISTORAGE data without leaving Java (even if by creating a fragment-based patch to, or a derived version of, SWT), or would we have to build some new native support code too?

Relevant code snippets

Sketch code that extracts file names:

    // THIS IS NOT PRODUCTION-QUALITY CODE - FOR ILLUSTRATION ONLY
    final Transfer transfer = new ByteArrayTransfer() {
        private final String[] typeNames = new String[] { "FileGroupDescriptorW", "FileContents" };
        private final int[] typeIds = new int[] { registerType(typeNames[0]), registerType(typeNames[1]) };

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

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

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

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

            try {
                final DataInputStream in = new DataInputStream(new ByteArrayInputStream(buffer));

                long count = 0;
                for (int i = 0; i < 4; i++) {
                    count += in.readUnsignedByte() << i;
                }

                for (int i = 0; i < count; i++) {
                    final byte[] filenameBytes = new byte[260 * 2];
                    in.skipBytes(72); // probable architecture assumption(s) - may be wrong outside standard 32-bit Win XP
                    in.read(filenameBytes);
                    final String fileNameIncludingTrailingNulls = new String(filenameBytes, "UTF-16LE");
                    int stringLength = fileNameIncludingTrailingNulls.indexOf('\0');
                    if (stringLength == -1)
                        stringLength = 260;
                    final String fileName = fileNameIncludingTrailingNulls.substring(0, stringLength);
                    System.out.println("File " + i + ": " + fileName);
                }

                in.close();

                return buffer;
            }
            catch (final Exception e) {
                return null;
            }
        }
    };

In the debugger, we see that ByteArrayTransfer's isSupportedType() ultimately returns false for the FileContents because the following test is not passed (since its tymed is TYMED_ISTREAM | TYMED_ISTORAGE):

    if (format.cfFormat == types[i] &&
        (format.dwAspect & COM.DVASPECT_CONTENT) == COM.DVASPECT_CONTENT && 
        (format.tymed & COM.TYMED_HGLOBAL) == COM.TYMED_HGLOBAL  )
        return true;

This excerpt from org.eclipse.swt.internal.ole.win32.COM leaves us feeling less hope for an easy solution:

public static final int TYMED_HGLOBAL = 1;
//public static final int TYMED_ISTORAGE = 8;
//public static final int TYMED_ISTREAM = 4;

Thanks.

Answer 1

even if

//public static final int TYMED_ISTREAM = 4;

Try below code.. it should work

package com.nagarro.jsag.poc.swtdrag;

imports ... 

public class MyTransfer extends ByteArrayTransfer {
private static int BYTES_COUNT = 592;
private static int SKIP_BYTES = 72;

private final String[] typeNames = new String[] { "FileGroupDescriptorW", "FileContents" };
private final int[] typeIds = new int[] { registerType(typeNames[0]), registerType(typeNames[1]) };

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

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

@Override
protected Object nativeToJava(TransferData transferData) {
    String[] result = null;

    if (!isSupportedType(transferData) || transferData.pIDataObject == 0)
        return null;

    IDataObject data = new IDataObject(transferData.pIDataObject);
    data.AddRef();
    // Check for descriptor format type
    try {
        FORMATETC formatetcFD = transferData.formatetc;
        STGMEDIUM stgmediumFD = new STGMEDIUM();
        stgmediumFD.tymed = COM.TYMED_HGLOBAL;
        transferData.result = data.GetData(formatetcFD, stgmediumFD);

        if (transferData.result == COM.S_OK) {
            // Check for contents format type
            long hMem = stgmediumFD.unionField;
            long fileDiscriptorPtr = OS.GlobalLock(hMem);
            int[] fileCount = new int[1];
            try {
                OS.MoveMemory(fileCount, fileDiscriptorPtr, 4);
                fileDiscriptorPtr += 4;
                result = new String[fileCount[0]];
                for (int i = 0; i < fileCount[0]; i++) {
                    String fileName = handleFile(fileDiscriptorPtr, data);
                    System.out.println("FileName : = " + fileName);
                    result[i] = fileName;
                    fileDiscriptorPtr += BYTES_COUNT;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                OS.GlobalFree(hMem);
            }
        }
    } finally {
        data.Release();
    }
    return result;
}

private String handleFile(long fileDiscriptorPtr, IDataObject data) throws Exception {

    // GetFileName
    char[] fileNameChars = new char[OS.MAX_PATH];
    byte[] fileNameBytes = new byte[OS.MAX_PATH];
    COM.MoveMemory(fileNameBytes, fileDiscriptorPtr, BYTES_COUNT);
    // Skip some bytes.
    fileNameBytes = Arrays.copyOfRange(fileNameBytes, SKIP_BYTES, fileNameBytes.length);
    String fileNameIncludingTrailingNulls = new String(fileNameBytes, "UTF-16LE");
    fileNameChars = fileNameIncludingTrailingNulls.toCharArray();
    StringBuilder builder = new StringBuilder(OS.MAX_PATH);
    for (int i = 0; fileNameChars[i] != 0 && i < fileNameChars.length; i++) {
        builder.append(fileNameChars[i]);
    }
    String name = builder.toString();

    try {
        File file = saveFileContent(name, data);
        if (file != null) {
            System.out.println("File Saved @ " + file.getAbsolutePath());
            ;
        }
    } catch (IOException e) {
        System.out.println("Count not save file content");
        ;
    }

    return name;
}

private File saveFileContent(String fileName, IDataObject data) throws IOException {
    File file = null;
    FORMATETC formatetc = new FORMATETC();
    formatetc.cfFormat = typeIds[1];
    formatetc.dwAspect = COM.DVASPECT_CONTENT;
    formatetc.lindex = 0;
    formatetc.tymed = 4; // content.

    STGMEDIUM stgmedium = new STGMEDIUM();
    stgmedium.tymed = 4;

    if (data.GetData(formatetc, stgmedium) == COM.S_OK) {
        file = new File(fileName);
        IStream iStream = new IStream(stgmedium.unionField);
        iStream.AddRef();

        try (FileOutputStream outputStream = new FileOutputStream(file)) {

            int increment = 1024 * 4;
            long pv = COM.CoTaskMemAlloc(increment);
            int[] pcbWritten = new int[1];
            while (iStream.Read(pv, increment, pcbWritten) == COM.S_OK && pcbWritten[0] > 0) {
                byte[] buffer = new byte[pcbWritten[0]];
                OS.MoveMemory(buffer, pv, pcbWritten[0]);
                outputStream.write(buffer);
            }
            COM.CoTaskMemFree(pv);

        } finally {
            iStream.Release();
        }
        return file;
    } else {
        return null;
    }
}
}

Answer 2

Have you looked at https://bugs.eclipse.org/bugs/show_bug.cgi?id=132514 ?

Attached to this bugzilla entry is an patch (against an rather old version of SWT) that might be of interest.

Answer 3

I had the same problem and created a small library providing a Drag'n Drop Transfer Class for JAVA SWT. It can be found here:

https://github.com/HendrikHoetker/OutlookItemTransfer

Currently it supports dropping Mail Items from Outlook to your Java SWT application and will provide a list of OutlookItems with the Filename and a byte array of the file contents.

All is pure Java and in-memory (no temp files).

Usage in your SWT java application:

  if (OutlookItemTransfer.getInstance().isSupportedType(event.currentDataType)) {
      Object o = OutlookItemTransfer.getInstance().nativeToJava(event.currentDataType);
      if (o != null && o instanceof OutlookMessage[]) {
          OutlookMessage[] outlookMessages = (OutlookMessage[])o;
          for (OutlookMessage msg: outlookMessages) {
              //...
          }
      }
  }

The OutlookItem will then provide two elements: filename as String and file contents as array of byte.

From here on, one could write it to a file or further process the byte array.

To your question above: - What you find in the file descriptor is the filename of the outlook item and a pointer to an IDataObject - the IDataObject can be parsed and will provide an IStorage object - The IStorageObject will be then a root container providing further sub-IStorageObjects or IStreams similar to a filesystem (directory = IStorage, file = IStream

You find those elements in the following lines of code:

• Get File Contents, see OutlookItemTransfer.java, method nativeToJava:

  FORMATETC format = new FORMATETC();
  format.cfFormat = getTypeIds()[1];
  format.dwAspect = COM.DVASPECT_CONTENT;
  format.lindex = <fileIndex>;
  format.ptd = 0;
  format.tymed = TYMED_ISTORAGE | TYMED_ISTREAM | COM.TYMED_HGLOBAL;
  
  STGMEDIUM medium = new STGMEDIUM();
  
  if (data.GetData(format, medium) == COM.S_OK) {
      // medium.tymed will now contain TYMED_ISTORAGE
      // in medium.unionfield you will find the root IStorage
  }
  

• Read the root IStorage, see CompoundStorage, method readOutlookStorage:

      // open IStorage object
  IStorage storage = new IStorage(pIStorage);
  storage.AddRef();
  
  
  // walk through the content of the IStorage object
  long[] pEnumStorage = new long[1];
  if (storage.EnumElements(0, 0, 0, pEnumStorage) == COM.S_OK) {
  
      // get storage iterator
      IEnumSTATSTG enumStorage = new IEnumSTATSTG(pEnumStorage[0]);
      enumStorage.AddRef();
      enumStorage.Reset();
  
      // prepare statstg structure which tells about the object found by the iterator
      long pSTATSTG = OS.GlobalAlloc(OS.GMEM_FIXED | OS.GMEM_ZEROINIT, STATSTG.sizeof);
      int[] fetched = new int[1];
  
      while (enumStorage.Next(1, pSTATSTG, fetched) == COM.S_OK && fetched[0] == 1) {
          // get the description of the the object found
          STATSTG statstg = new STATSTG();
          COM.MoveMemory(statstg, pSTATSTG, STATSTG.sizeof);
  
          // get the name of the object found
          String name = readPWCSName(statstg);
  
          // depending on type of object
          switch (statstg.type) {
              case COM.STGTY_STREAM: {    // load an IStream (=File)
                  long[] pIStream = new long[1];
  
                  // get the pointer to the IStream
                  if (storage.OpenStream(name, 0, COM.STGM_DIRECT | COM.STGM_READ | COM.STGM_SHARE_EXCLUSIVE, 0, pIStream) == COM.S_OK) {
                      // load the IStream
                  }
              }
  
              case COM.STGTY_STORAGE: {   // load an IStorage (=SubDirectory) - requires recursion to traverse the sub dies
  
                  }
  
              }
          }
      }
  
      // close the iterator
      enumStorage.Release();
  }
  
  // close the IStorage object
  storage.Release();