Fix image drag-drop onto Explorer (fixes #5701)

Explorer requires EnumFormatEtc, CFSTR_FILECONTENTS as TYMED_HGLOBAL, and Preferred DropEffect for virtual file drops. Browsers accepted the minimal IDataObject but Explorer did not.

Author: kjk

src/Canvas.cpp

@@ -104,6 +104,69 @@ class TextDropSource : public IDropSource {
     STDMETHODIMP GiveFeedback(__unused DWORD) override { return DRAGDROP_S_USEDEFAULTCURSORS; }
 };
 
+class SimpleEnumFormatEtc : public IEnumFORMATETC {
+    LONG refCount = 1;
+    const FORMATETC* formats = nullptr;
+    ULONG count = 0;
+    ULONG index = 0;
+
+  public:
+    SimpleEnumFormatEtc(const FORMATETC* fmts, ULONG n) : formats(fmts), count(n) {}
+
+    STDMETHODIMP QueryInterface(REFIID riid, void** ppv) override {
+        if (riid == IID_IUnknown || riid == IID_IEnumFORMATETC) {
+            *ppv = this;
+            AddRef();
+            return S_OK;
+        }
+        *ppv = nullptr;
+        return E_NOINTERFACE;
+    }
+    ULONG STDMETHODCALLTYPE AddRef() override { return InterlockedIncrement(&refCount); }
+    ULONG STDMETHODCALLTYPE Release() override {
+        LONG r = InterlockedDecrement(&refCount);
+        if (r == 0) {
+            delete this;
+        }
+        return r;
+    }
+
+    STDMETHODIMP Next(ULONG celt, FORMATETC* rgelt, ULONG* pceltFetched) override {
+        if (!rgelt) {
+            return E_POINTER;
+        }
+        ULONG fetched = 0;
+        while (fetched < celt && index < count) {
+            rgelt[fetched++] = formats[index++];
+        }
+        if (pceltFetched) {
+            *pceltFetched = fetched;
+        }
+        return fetched == celt ? S_OK : S_FALSE;
+    }
+    STDMETHODIMP Skip(ULONG celt) override {
+        if (index + celt < count) {
+            index += celt;
+            return S_OK;
+        }
+        index = count;
+        return S_FALSE;
+    }
+    STDMETHODIMP Reset() override {
+        index = 0;
+        return S_OK;
+    }
+    STDMETHODIMP Clone(IEnumFORMATETC** ppEnum) override {
+        if (!ppEnum) {
+            return E_POINTER;
+        }
+        auto* e = new SimpleEnumFormatEtc(formats, count);
+        e->index = index;
+        *ppEnum = e;
+        return S_OK;
+    }
+};
+
 class TextDataObject : public IDataObject {
     LONG refCount = 1;
     HGLOBAL hText = nullptr;
@@ -243,21 +306,45 @@ static HGLOBAL EncodeBitmapToPngGlobal(HBITMAP hbmp) {
 }
 
 // IDataObject that provides an image as a virtual file (CFSTR_FILEDESCRIPTOR + CFSTR_FILECONTENTS)
-// and CF_DIB, without creating any temporary files on disk.
-// Browsers and web apps accept virtual file drops just like real file drops.
+// without creating any temporary files on disk.
 class ImageDataObject : public IDataObject {
     LONG refCount = 1;
     HGLOBAL hPngData = nullptr; // PNG-encoded image data
     size_t pngSize = 0;
     UINT cfFileDescriptor = 0;
     UINT cfFileContents = 0;
+    UINT cfPreferredDropEffect = 0;
+    FORMATETC fmts[3]{};
+    ULONG fmtCount = 0;
+
+    bool QueryFormatSupported(FORMATETC* pFE) const {
+        for (ULONG i = 0; i < fmtCount; i++) {
+            const FORMATETC& fmt = fmts[i];
+            if (pFE->cfFormat != fmt.cfFormat) {
+                continue;
+            }
+            if (fmt.lindex >= 0 && pFE->lindex != fmt.lindex) {
+                continue;
+            }
+            if (pFE->tymed & fmt.tymed) {
+                return true;
+            }
+        }
+        return false;
+    }
 
   public:
     explicit ImageDataObject(HGLOBAL hPng) {
         hPngData = hPng;
         pngSize = GlobalSize(hPng);
         cfFileDescriptor = RegisterClipboardFormatW(CFSTR_FILEDESCRIPTORW);
         cfFileContents = RegisterClipboardFormatW(CFSTR_FILECONTENTS);
+        cfPreferredDropEffect = RegisterClipboardFormatW(L"Preferred DropEffect");
+
+        fmts[0] = {(CLIPFORMAT)cfFileDescriptor, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
+        fmts[1] = {(CLIPFORMAT)cfFileContents, nullptr, DVASPECT_CONTENT, 0, TYMED_ISTREAM | TYMED_HGLOBAL};
+        fmts[2] = {(CLIPFORMAT)cfPreferredDropEffect, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
+        fmtCount = 3;
     }
     ~ImageDataObject() {
         if (hPngData) {
@@ -290,14 +377,15 @@ class ImageDataObject : public IDataObject {
 
         // CFSTR_FILEDESCRIPTORW: describe one virtual file "image.png"
         if (pFE->cfFormat == cfFileDescriptor && (pFE->tymed & TYMED_HGLOBAL)) {
-            size_t cb = sizeof(FILEGROUPDESCRIPTORW);
+            size_t cb = offsetof(FILEGROUPDESCRIPTORW, fgd) + sizeof(FILEDESCRIPTORW);
             HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, cb);
             if (!h) {
                 return E_OUTOFMEMORY;
             }
             auto* fgd = (FILEGROUPDESCRIPTORW*)GlobalLock(h);
             fgd->cItems = 1;
-            fgd->fgd[0].dwFlags = FD_FILESIZE;
+            fgd->fgd[0].dwFlags = FD_FILESIZE | FD_ATTRIBUTES;
+            fgd->fgd[0].dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
             fgd->fgd[0].nFileSizeLow = (DWORD)pngSize;
             fgd->fgd[0].nFileSizeHigh = 0;
             wcscpy_s(fgd->fgd[0].cFileName, MAX_PATH, L"image.png");
@@ -308,44 +396,75 @@ class ImageDataObject : public IDataObject {
             return S_OK;
         }
 
-        // CFSTR_FILECONTENTS: provide the PNG data as an IStream
-        if (pFE->cfFormat == cfFileContents && (pFE->tymed & TYMED_ISTREAM) && pFE->lindex == 0) {
-            IStream* stream = nullptr;
-            HRESULT hr = CreateStreamOnHGlobal(nullptr, TRUE, &stream);
-            if (FAILED(hr) || !stream) {
+        // CFSTR_FILECONTENTS: provide the PNG data as an IStream or HGLOBAL
+        if (pFE->cfFormat == cfFileContents && pFE->lindex == 0) {
+            if (pFE->tymed & TYMED_HGLOBAL) {
+                HGLOBAL hCopy = GlobalAlloc(GMEM_MOVEABLE, pngSize);
+                if (!hCopy) {
+                    return E_OUTOFMEMORY;
+                }
+                void* src = GlobalLock(hPngData);
+                void* dst = GlobalLock(hCopy);
+                memcpy(dst, src, pngSize);
+                GlobalUnlock(hCopy);
+                GlobalUnlock(hPngData);
+                pMedium->tymed = TYMED_HGLOBAL;
+                pMedium->hGlobal = hCopy;
+                pMedium->pUnkForRelease = nullptr;
+                return S_OK;
+            }
+            if (pFE->tymed & TYMED_ISTREAM) {
+                IStream* stream = nullptr;
+                HRESULT hr = CreateStreamOnHGlobal(nullptr, TRUE, &stream);
+                if (FAILED(hr) || !stream) {
+                    return E_OUTOFMEMORY;
+                }
+                void* src = GlobalLock(hPngData);
+                ULONG written = 0;
+                stream->Write(src, (ULONG)pngSize, &written);
+                GlobalUnlock(hPngData);
+                LARGE_INTEGER zero{};
+                stream->Seek(zero, STREAM_SEEK_SET, nullptr);
+                pMedium->tymed = TYMED_ISTREAM;
+                pMedium->pstm = stream;
+                pMedium->pUnkForRelease = nullptr;
+                return S_OK;
+            }
+        }
+
+        if (pFE->cfFormat == cfPreferredDropEffect && (pFE->tymed & TYMED_HGLOBAL)) {
+            HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE, sizeof(DWORD));
+            if (!h) {
                 return E_OUTOFMEMORY;
             }
-            void* src = GlobalLock(hPngData);
-            ULONG written = 0;
-            stream->Write(src, (ULONG)pngSize, &written);
-            GlobalUnlock(hPngData);
-            // reset stream position to beginning
-            LARGE_INTEGER zero{};
-            stream->Seek(zero, STREAM_SEEK_SET, nullptr);
-            pMedium->tymed = TYMED_ISTREAM;
-            pMedium->pstm = stream;
+            auto* effect = (DWORD*)GlobalLock(h);
+            *effect = DROPEFFECT_COPY;
+            GlobalUnlock(h);
+            pMedium->tymed = TYMED_HGLOBAL;
+            pMedium->hGlobal = h;
             pMedium->pUnkForRelease = nullptr;
             return S_OK;
         }
 
         return DV_E_FORMATETC;
     }
     STDMETHODIMP GetDataHere(__unused FORMATETC*, __unused STGMEDIUM*) override { return E_NOTIMPL; }
-    STDMETHODIMP QueryGetData(FORMATETC* pFE) override {
-        if (pFE->cfFormat == cfFileDescriptor && (pFE->tymed & TYMED_HGLOBAL)) {
-            return S_OK;
-        }
-        if (pFE->cfFormat == cfFileContents && (pFE->tymed & TYMED_ISTREAM) && pFE->lindex == 0) {
-            return S_OK;
-        }
-        return DV_E_FORMATETC;
-    }
+    STDMETHODIMP QueryGetData(FORMATETC* pFE) override { return QueryFormatSupported(pFE) ? S_OK : DV_E_FORMATETC; }
     STDMETHODIMP GetCanonicalFormatEtc(__unused FORMATETC*, FORMATETC* pOut) override {
         pOut->ptd = nullptr;
         return E_NOTIMPL;
     }
     STDMETHODIMP SetData(__unused FORMATETC*, __unused STGMEDIUM*, __unused BOOL) override { return E_NOTIMPL; }
-    STDMETHODIMP EnumFormatEtc(__unused DWORD, __unused IEnumFORMATETC**) override { return E_NOTIMPL; }
+    STDMETHODIMP EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC** ppEnum) override {
+        if (!ppEnum) {
+            return E_POINTER;
+        }
+        if (dwDirection != DATADIR_GET) {
+            return E_NOTIMPL;
+        }
+        *ppEnum = new SimpleEnumFormatEtc(fmts, fmtCount);
+        return S_OK;
+    }
     STDMETHODIMP DAdvise(__unused FORMATETC*, __unused DWORD, __unused IAdviseSink*, __unused DWORD*) override {
         return E_NOTIMPL;
     }