[win] Mimic on Windows the macOS's Chrome drag and drop behavior of images and offer the possibility of configuring the decoding functions to be used

This is achieved by looking at the clipboard for a file that contains data in some of the supported image formats, because in Windows, the Chrome implementation puts the image's file content in the clipboard. Then after determining that the file contents corresponds to one of our supported image formats, the configured decoding function is used (which might be the default one)

Author: martincapello

clip

@@ -77,8 +77,10 @@ class DragTarget : public os::DragTarget {
       if (ev.acceptDrop()) {
         if (ev.dataProvider()->contains(os::DragDataItemType::Paths))
           windowData.paths = ev.dataProvider()->getPaths();
+#if CLIP_ENABLE_IMAGE
         if (ev.dataProvider()->contains(os::DragDataItemType::Image))
           windowData.image = ev.dataProvider()->getImage();
+#endif
         if (ev.dataProvider()->contains(os::DragDataItemType::Url))
           windowData.url = ev.dataProvider()->getUrl();
       }

examples/drag_and_drop.cpp

@@ -8,6 +8,7 @@
 set(LAF_OS_SOURCES
   common/event_queue.cpp
   common/main.cpp
+  dnd.cpp
   system.cpp
   window.cpp)
 if(WIN32)

os/CMakeLists.txt

@@ -0,0 +1,103 @@
+// LAF OS Library
+// Copyright (C) 2024  Igara Studio S.A.
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#if CLIP_ENABLE_IMAGE
+
+#ifdef HAVE_CONFIG_H
+  #include "config.h"
+#endif
+
+#include "clip/clip.h"
+#include "clip/clip_win.h"
+#include "os/dnd.h"
+#include "os/system.h"
+
+namespace os {
+
+SurfaceRef default_decode_png(const uint8_t* buf, const uint32_t len)
+{
+  clip::image img;
+  if (!clip::win::read_png(buf, len, &img, nullptr))
+    return nullptr;
+
+  return os::instance()->makeSurface(img);
+}
+
+SurfaceRef default_decode_jpg(const uint8_t* buf, const uint32_t len)
+{
+  clip::image img;
+  if (!clip::win::read_jpg(buf, len, &img, nullptr))
+    return nullptr;
+
+  return os::instance()->makeSurface(img);
+}
+
+SurfaceRef default_decode_bmp(const uint8_t* buf, const uint32_t len)
+{
+  clip::image img;
+  if (!clip::win::read_bmp(buf, len, &img, nullptr))
+    return nullptr;
+
+  return os::instance()->makeSurface(img);
+}
+
+SurfaceRef default_decode_gif(const uint8_t* buf, const uint32_t len)
+{
+  clip::image img;
+  if (!clip::win::read_gif(buf, len, &img, nullptr))
+    return nullptr;
+
+  return os::instance()->makeSurface(img);
+}
+
+static DecoderFunc g_decode_png = default_decode_png;
+static DecoderFunc g_decode_jpg = default_decode_jpg;
+static DecoderFunc g_decode_bmp = default_decode_bmp;
+static DecoderFunc g_decode_gif = default_decode_gif;
+
+void set_decode_png(DecoderFunc func)
+{
+  g_decode_png = func;
+}
+
+void set_decode_jpg(DecoderFunc func)
+{
+  g_decode_jpg = func;
+}
+
+void set_decode_bmp(DecoderFunc func)
+{
+  g_decode_bmp = func;
+}
+
+void set_decode_gif(DecoderFunc func)
+{
+  g_decode_gif = func;
+}
+
+SurfaceRef decode_png(const uint8_t* buf, const uint32_t len)
+{
+  return g_decode_png(buf, len);
+}
+
+SurfaceRef decode_jpg(const uint8_t* buf, const uint32_t len)
+{
+  return g_decode_jpg(buf, len);
+}
+
+SurfaceRef decode_bmp(const uint8_t* buf, const uint32_t len)
+{
+  return g_decode_bmp(buf, len);
+}
+
+SurfaceRef decode_gif(const uint8_t* buf, const uint32_t len)
+{
+  return g_decode_gif(buf, len);
+}
+
+} // namespace os
+
+#endif

os/dnd.cpp

@@ -13,6 +13,7 @@
 #include "gfx/point.h"
 #include "os/surface.h"
 
+#include <functional>
 #include <memory>
 
 #pragma push_macro("None")
@@ -22,6 +23,21 @@ namespace os {
 
   class Window;
 
+#if CLIP_ENABLE_IMAGE
+  using DecoderFunc = std::function<SurfaceRef(const uint8_t* buf, const uint32_t len)>;
+
+  // Methods used to configure custom decoder functions by replacing the default implementations.
+
+  void set_decode_png(DecoderFunc func);
+  void set_decode_jpg(DecoderFunc func);
+  void set_decode_bmp(DecoderFunc func);
+  void set_decode_gif(DecoderFunc func);
+
+  SurfaceRef decode_png(const uint8_t* buf, const uint32_t len);
+  SurfaceRef decode_jpg(const uint8_t* buf, const uint32_t len);
+  SurfaceRef decode_bmp(const uint8_t* buf, const uint32_t len);
+  SurfaceRef decode_gif(const uint8_t* buf, const uint32_t len);
+#endif
   // Operations that can be supported by source and target windows in a drag
   // and drop operation.
   enum class DropOperation {
@@ -44,7 +60,9 @@ namespace os {
   public:
     virtual ~DragDataProvider() {}
     virtual base::paths getPaths() = 0;
+#if CLIP_ENABLE_IMAGE
     virtual SurfaceRef getImage() = 0;
+#endif
     virtual std::string getUrl() = 0;
     virtual bool contains(DragDataItemType type) { return false; }
   };

os/dnd.h

@@ -4,6 +4,7 @@
 // This file is released under the terms of the MIT license.
 // Read LICENSE.txt for more information.
 
+#include "base/fs.h"
 #include "os/window.h"
 #include "os/win/dnd.h"
 #include "os/system.h"
@@ -68,6 +69,8 @@ class GLock {
 
   operator T() { return m_data; }
 
+  T operator ->() { return m_data; }
+
   bool operator==(std::nullptr_t) const { return m_data == nullptr; }
   bool operator!=(std::nullptr_t) const { return m_data != nullptr; }
 
@@ -108,13 +111,14 @@ class DataWrapper {
   DataWrapper(IDataObject* data) : m_data(data) {}
 
   template<typename T>
-  Medium<T> get(CLIPFORMAT cfmt) {
+  Medium<T> get(CLIPFORMAT cfmt, LONG lindex = -1)
+  {
     STGMEDIUM medium;
     FORMATETC fmt;
     fmt.cfFormat = cfmt;
     fmt.ptd = nullptr;
     fmt.dwAspect = DVASPECT_CONTENT;
-    fmt.lindex = -1;
+    fmt.lindex = lindex;
     fmt.tymed = TYMED::TYMED_HGLOBAL;
     if (m_data->GetData(&fmt, &medium) != S_OK)
       return nullptr;
@@ -151,20 +155,20 @@ base::paths DragDataProviderWin::getPaths()
   return files;
 }
 
+#if CLIP_ENABLE_IMAGE
 SurfaceRef DragDataProviderWin::getImage()
 {
   SurfaceRef surface = nullptr;
-  clip::image img;
 
   DataWrapper data(m_data);
   UINT png_format = RegisterClipboardFormatA("PNG");
   if (png_format) {
     Medium<uint8_t*> png_handle = data.get<uint8_t*>(png_format);
-    if (png_handle != nullptr &&
-        clip::win::read_png(png_handle, png_handle.size(), &img, nullptr))
-      return os::instance()->makeSurface(img);
+    if (png_handle != nullptr)
+      return os::decode_png(png_handle, png_handle.size());
   }
 
+  clip::image img;
   Medium<BITMAPV5HEADER*> b5 = data.get<BITMAPV5HEADER*>(CF_DIBV5);
   if (b5 != nullptr) {
     clip::win::BitmapInfo bi(b5);
@@ -179,9 +183,40 @@ SurfaceRef DragDataProviderWin::getImage()
       return os::instance()->makeSurface(img);
   }
 
+  // If there is a file descriptor available, then we inspect the first
+  // file of the group to see if its filename has any of the supported
+  // filename extensions for image formats.
+  UINT fileDescriptorFormat = RegisterClipboardFormat(CFSTR_FILEDESCRIPTOR);
+  UINT fileContentsFormat = RegisterClipboardFormat(CFSTR_FILECONTENTS);
+  if (fileDescriptorFormat) {
+    Medium<FILEGROUPDESCRIPTOR*> fgd = data.get<FILEGROUPDESCRIPTOR*>(fileDescriptorFormat);
+    if (fgd != nullptr &&  fgd->cItems > 0) {
+      // Get content of the first file on the group.
+      Medium<uint8_t*> content = data.get<uint8_t*>(fileContentsFormat, 0);
+      if (content != nullptr) {
+        std::string filename(base::to_utf8(fgd->fgd->cFileName));
+        std::string ext = base::get_file_extension(filename);
+        std::transform(ext.begin(), ext.end(), ext.begin(), ::toupper);
+
+        if (ext == "PNG")
+          return os::decode_png(content, content.size());
+
+        if (ext == "JPG" || ext == "JPEG" || ext == "JPE")
+          return os::decode_jpg(content, content.size());
+
+        if (ext == "GIF")
+          return os::decode_gif(content, content.size());
+
+        if (ext == "BMP")
+          return os::decode_bmp(content, content.size());
+      }
+    }
+  }
+
   // No suitable image format found.
   return nullptr;
 }
+#endif
 
 std::string DragDataProviderWin::getUrl()
 {
@@ -203,6 +238,7 @@ bool DragDataProviderWin::contains(DragDataItemType type)
 
   UINT urlFormat = RegisterClipboardFormat(CFSTR_INETURL);
   UINT pngFormat = RegisterClipboardFormat(L"PNG");
+  UINT fileDescriptorFormat = RegisterClipboardFormat(CFSTR_FILEDESCRIPTOR);
   char name[101];
   FORMATETC fmt;
   while (formats->Next(1, &fmt, nullptr) == S_OK) {
@@ -211,6 +247,7 @@ bool DragDataProviderWin::contains(DragDataItemType type)
         if (type == DragDataItemType::Paths)
           return true;
         break;
+#if CLIP_ENABLE_IMAGE
       case CF_DIBV5:
         if (type == DragDataItemType::Image)
           return true;
@@ -219,13 +256,28 @@ bool DragDataProviderWin::contains(DragDataItemType type)
         if (type == DragDataItemType::Image)
           return true;
         break;
+#endif
       default: {
         switch (type) {
+#if CLIP_ENABLE_IMAGE
           case DragDataItemType::Image:
             if (fmt.cfFormat == pngFormat)
               return true;
 
+            if (fmt.cfFormat == fileDescriptorFormat) {
+              DataWrapper data(m_data);
+              Medium<FILEGROUPDESCRIPTOR*> fgd = data.get<FILEGROUPDESCRIPTOR*>(fileDescriptorFormat);
+              if (fgd != nullptr && fgd->cItems > 0) {
+                std::string filename(base::to_utf8(fgd->fgd->cFileName));
+                std::string ext =  base::get_file_extension(filename);
+                std::transform(ext.begin(), ext.end(), ext.begin(), ::toupper);
+                if (ext == "PNG" || ext == "JPG" || ext == "JPEG" ||
+                    ext == "JPE" || ext == "GIF" || ext == "BMP")
+                  return true;
+              }
+            }
             break;
+#endif
           case DragDataItemType::Url:
             if (fmt.cfFormat == urlFormat)
               return true;

os/win/dnd.cpp

@@ -23,7 +23,9 @@ namespace os {
     IDataObject* m_data;
 
     base::paths getPaths() override;
+#if CLIP_ENABLE_IMAGE
     SurfaceRef getImage() override;
+#endif
     std::string getUrl() override;
     bool contains(DragDataItemType type) override;
   };