[dlgs] Add new laf-dlgs-proc exe to show the file dialog in another process (fix aseprite/aseprite#4412)

dacap · dacap · commit 4366cc92d1c1 · 2025-10-03T12:27:29.000-03:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -33,6 +33,8 @@ option(LAF_WITH_TESTS "Enable LAF tests" ON)
 option(LAF_WITH_CLIP "Enable clip module (required for future drag-and-drop feature)" ON)
 if(WIN32)
   option(LAF_WITH_IME "Enable IME for CJK input" OFF)
+  option(LAF_WITH_DLGS_PROC "Enable laf-dlgs-process.exe for Windows to open the FileDialog through an external process" OFF)
+  set(LAF_DLGS_PROC_NAME "laf-dlgs-process" CACHE STRING "Name of the process to show native dialogs")
 endif()
 set(LAF_BACKEND ${LAF_DEFAULT_BACKEND} CACHE STRING "Select laf backend")
 set_property(CACHE LAF_BACKEND PROPERTY STRINGS "none" "skia")
diff --git a/dlgs/CMakeLists.txt b/dlgs/CMakeLists.txt
@@ -1,13 +1,24 @@
 # laf-dlgs
-# Copyright (C) 2024  Igara Studio S.A.
+# Copyright (C) 2024-2025  Igara Studio S.A.
 
 add_library(laf-dlgs file_dialog.cpp)
 target_link_libraries(laf-dlgs laf-base)
 
 if(WIN32)
-  target_sources(laf-dlgs PRIVATE file_dialog_win.cpp)
+  target_sources(laf-dlgs PRIVATE win/file_dialog_win.cpp)
 elseif(APPLE)
   target_sources(laf-dlgs PRIVATE file_dialog_osx.mm)
 else()
   target_sources(laf-dlgs PRIVATE file_dialog_x11.cpp)
 endif()
+
+if(LAF_WITH_DLGS_PROC)
+  add_executable(laf-dlgs-proc win/dlgs_process.cpp)
+  target_link_libraries(laf-dlgs-proc laf-base laf-dlgs)
+  set_target_properties(laf-dlgs-proc PROPERTIES
+    OUTPUT_NAME ${LAF_DLGS_PROC_NAME})
+
+  target_compile_definitions(laf-dlgs PRIVATE
+    -DLAF_DLGS_PROC_NAME="${LAF_DLGS_PROC_NAME}")
+  target_sources(laf-dlgs PRIVATE win/file_dialog_win_safe.cpp)
+endif()
diff --git a/dlgs/file_dialog.h b/dlgs/file_dialog.h
@@ -20,6 +20,14 @@ namespace dlgs {
 class FileDialog;
 using FileDialogRef = base::Ref<FileDialog>;
 
+#if LAF_WINDOWS
+class FileDialogDelegate {
+public:
+  virtual ~FileDialogDelegate() {}
+  virtual void onFolderChange(const std::string& path) = 0;
+};
+#endif // LAF_WINDOWS
+
 class FileDialog : public base::RefCount {
 public:
   enum class Type {
@@ -36,7 +44,10 @@ class FileDialog : public base::RefCount {
   };
 
   struct Spec {
-#if LAF_MACOS
+#if LAF_WINDOWS
+    // Listen events of the FileDialog.
+    FileDialogDelegate* delegate = nullptr;
+#elif LAF_MACOS
     // Indicates which is the "Edit" menu (NSMenuItem*) with
     // Undo/Redo/Cut/Copy/Paste/etc. commands. Used by the
     // FileDialogOSX impl to completely replace the "Edit" menu with a
@@ -58,6 +69,10 @@ class FileDialog : public base::RefCount {
   static FileDialogRef make(const Spec& spec);
 #if LAF_WINDOWS
   static FileDialogRef makeWin(const Spec& spec);
+  static FileDialogRef makeWinUnsafe(const Spec& spec);
+  #ifdef LAF_DLGS_PROC_NAME
+  static FileDialogRef makeWinSafe(const Spec& spec);
+  #endif
 #elif LAF_MACOS
   static FileDialogRef makeOSX(const Spec& spec);
 #elif LAF_LINUX
diff --git a/dlgs/win/dlgs_process.cpp b/dlgs/win/dlgs_process.cpp
@@ -0,0 +1,140 @@
+// laf-dlgs
+// Copyright (C) 2024-2025  Igara Studio S.A.
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+//
+// Based in the work done in https://github.com/dacap/safedlgs/
+// prototype.
+//
+
+#ifdef HAVE_CONFIG_H
+  #include "config.h"
+#endif
+
+#ifdef LAF_DLGS_PROC_NAME
+  #error LAF_DLGS_PROC_NAME must not be defined for laf-dlgs-proc
+#endif
+
+#include "base/program_options.h"
+#include "base/split_string.h"
+#include "base/string.h"
+#include "base/win/coinit.h"
+#include "dlgs/file_dialog.h"
+
+#include <werapi.h>
+#include <windows.h>
+
+#include <cstdio>
+
+class Delegate : public dlgs::FileDialogDelegate {
+public:
+  void onFolderChange(const std::string& path) override
+  {
+    // Print folder name in stdout.
+    std::printf("%s\\\n", path.c_str());
+    std::fflush(stdout);
+  }
+};
+
+int wmain(int argc, wchar_t** wargv)
+{
+  base::ProgramOptions po;
+  auto& parent(po.add("parent").requiresValue("<parent>"));
+  auto& type(po.add("type").requiresValue("<open|openfiles|openfolder|save>"));
+  auto& title(po.add("title").requiresValue("<title>"));
+  auto& filename(po.add("filename").requiresValue("<filename>"));
+  auto& defaultExtension(po.add("defaultextension").requiresValue("<extension>"));
+  auto& addFilter(po.add("addfilter").requiresValue("<extension>;<description>"));
+
+  // Convert args to utf8 to parse them.
+  {
+    std::vector<std::string> argv_str(argc);
+    for (int i = 0; i < argc; ++i)
+      argv_str[i] = base::to_utf8(wargv[i]);
+
+    std::vector<const char*> argv(argc);
+    for (int i = 0; i < argc; ++i)
+      argv[i] = argv_str[i].data();
+
+    po.parse(argc, argv.data());
+  }
+
+  // Initialize COM library.
+  base::CoInit com;
+
+  // Avoid showing the "dlgs_process.exe has stopped working" dialog
+  // when this crashes.
+  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
+  WerSetFlags(WER_FAULT_REPORTING_NO_UI);
+
+  Delegate delegate;
+  dlgs::FileDialog::Spec spec;
+  spec.delegate = &delegate;
+
+  dlgs::FileDialogRef dlg = dlgs::FileDialog::makeWinUnsafe(spec);
+
+  // Get the parent HWND from the arguments.
+  HWND parentHandle = nullptr;
+  {
+    const std::string parentString = po.value_of(parent);
+    if (!parentString.empty())
+      parentHandle = (HWND)std::strtoull(parentString.c_str(), nullptr, 0);
+  }
+
+  bool multipleFiles = false;
+  if (po.value_of(type) == "save")
+    dlg->setType(dlgs::FileDialog::Type::SaveFile);
+  else if (po.value_of(type) == "openfiles") {
+    dlg->setType(dlgs::FileDialog::Type::OpenFiles);
+    multipleFiles = true;
+  }
+  else if (po.value_of(type) == "openfolder")
+    dlg->setType(dlgs::FileDialog::Type::OpenFolder);
+  else
+    dlg->setType(dlgs::FileDialog::Type::OpenFile);
+
+  if (po.enabled(title))
+    dlg->setTitle(po.value_of(title));
+
+  if (po.enabled(filename))
+    dlg->setFileName(po.value_of(filename));
+
+  if (po.enabled(defaultExtension))
+    dlg->setDefaultExtension(po.value_of(defaultExtension));
+
+  for (auto v : po.values()) {
+    if (v.option() == &addFilter) {
+      std::vector<std::string> result;
+      base::split_string(v.value(), result, "=");
+      if (result.size() == 2)
+        dlg->addFilter(result[0], result[1]);
+      else if (result.size() == 1)
+        dlg->addFilter(result[0], result[0]);
+    }
+  }
+
+  dlgs::FileDialog::Result result = dlg->show(parentHandle);
+
+  // Print a "OK" signal so the parent process knowns that native
+  // show() impl didn't crash.
+  std::printf("OK\n");
+
+  if (result == dlgs::FileDialog::Result::Error)
+    return 1;
+  else if (result == dlgs::FileDialog::Result::Cancel)
+    return 0;
+
+  // Print file name(s)
+  if (multipleFiles) {
+    base::paths files;
+    dlg->getMultipleFileNames(files);
+    for (auto fn : files)
+      std::printf("%s\n", fn.c_str());
+  }
+  else
+    std::printf("%s\n", dlg->fileName().c_str());
+
+  std::fflush(stdout);
+  return 0;
+}
diff --git a/dlgs/win/file_dialog_win.cpp b/dlgs/win/file_dialog_win.cpp
@@ -1,5 +1,5 @@
 // laf-dlgs
-// Copyright (C) 2020-2024  Igara Studio S.A.
+// Copyright (C) 2020-2025  Igara Studio S.A.
 // Copyright (C) 2015-2018  David Capello
 //
 // This file is released under the terms of the MIT license.
@@ -26,9 +26,94 @@ namespace dlgs {
 // 32k is the limit for Win95/98/Me/NT4/2000/XP with ANSI version
 #define FILENAME_BUFSIZE (1024 * 32)
 
+// IFileDialogEvents impl used to change the OnFolderChange() events
+// and know the latest visited folder/location. In case of crash we
+// can use this location.
+class FileDialogEvents : public IFileDialogEvents {
+public:
+  FileDialogEvents(FileDialogDelegate* delegate) : m_delegate(delegate) {}
+
+  // IUnknown impl
+  IFACEMETHOD(QueryInterface)(REFIID riid, void** ppv)
+  {
+    if (riid == __uuidof(IFileDialogEvents)) {
+      *ppv = this;
+      return S_OK;
+    }
+    return E_NOINTERFACE;
+  }
+
+  IFACEMETHOD_(ULONG, AddRef)() { return InterlockedIncrement(&m_ref); }
+
+  IFACEMETHOD_(ULONG, Release)()
+  {
+    ULONG ref = InterlockedDecrement(&m_ref);
+    if (!ref)
+      delete this;
+    return ref;
+  }
+
+  // IFileDialogEvents impl
+  IFACEMETHOD(OnFileOk)(IFileDialog* dlg) { return S_OK; }
+  IFACEMETHOD(OnFolderChanging)(IFileDialog* dlg, IShellItem* psiFolder) { return S_OK; }
+  IFACEMETHOD(OnFolderChange)(IFileDialog* dlg)
+  {
+    base::ComPtr<IShellItem> item;
+    HRESULT hr = dlg->GetFolder(&item);
+    if (FAILED(hr))
+      return hr;
+
+    LPWSTR name = nullptr;
+    hr = item->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &name);
+    if (FAILED(hr))
+      return hr;
+
+    if (m_delegate)
+      m_delegate->onFolderChange(base::to_utf8(name));
+
+    CoTaskMemFree(name);
+    return S_OK;
+  }
+  IFACEMETHOD(OnSelectionChange)(IFileDialog* dlg) { return S_OK; }
+  IFACEMETHOD(OnShareViolation)(IFileDialog* dlg,
+                                IShellItem* psi,
+                                FDE_SHAREVIOLATION_RESPONSE* pResponse)
+  {
+    return S_OK;
+  }
+  IFACEMETHOD(OnTypeChange)(IFileDialog* dlg) { return S_OK; }
+  IFACEMETHOD(OnOverwrite)(IFileDialog* dlg, IShellItem* psi, FDE_OVERWRITE_RESPONSE* pResponse)
+  {
+    return S_OK;
+  }
+
+private:
+  FileDialogDelegate* m_delegate = nullptr;
+  long m_ref = 1;
+};
+
+// A helper to call IFileDialog::Advise/Unadvise() methods.
+class ScopedAdvise {
+public:
+  ScopedAdvise(IFileDialog* dlg, IFileDialogEvents* events) : m_dlg(dlg)
+  {
+    m_dlg->Advise(events, &m_cookie);
+  }
+  ~ScopedAdvise()
+  {
+    if (m_cookie)
+      m_dlg->Unadvise(m_cookie);
+  }
+
+private:
+  base::ComPtr<IFileDialog> m_dlg;
+  DWORD m_cookie = 0;
+};
+
+// FileDialog impl for Windows
 class FileDialogWin : public FileDialog {
 public:
-  FileDialogWin(const Spec& spec) : m_filename(FILENAME_BUFSIZE), m_defFilter(0) {}
+  FileDialogWin(const Spec& spec) : m_spec(spec), m_filename(FILENAME_BUFSIZE), m_defFilter(0) {}
 
   std::string fileName() override { return base::to_utf8(&m_filename[0]); }
 
@@ -125,6 +210,9 @@ class FileDialogWin : public FileDialog {
         return hr;
     }
 
+    FileDialogEvents fde(m_spec.delegate);
+    ScopedAdvise advise(dlg.get(), &fde);
+
     hr = dlg->Show((HWND)parent);
     if (hr == HRESULT_FROM_WIN32(ERROR_CANCELLED)) {
       result = Result::Cancel;
@@ -332,13 +420,23 @@ class FileDialogWin : public FileDialog {
     return filters;
   }
 
+  Spec m_spec;
   int m_defFilter;
   std::vector<WCHAR> m_filename;
   base::paths m_filenames;
   std::wstring m_initialDir;
 };
 
 FileDialogRef FileDialog::makeWin(const Spec& spec)
+{
+#ifdef LAF_DLGS_PROC_NAME
+  return FileDialog::makeWinSafe(spec);
+#else
+  return FileDialog::makeWinUnsafe(spec);
+#endif
+}
+
+FileDialogRef FileDialog::makeWinUnsafe(const Spec& spec)
 {
   return base::make_ref<FileDialogWin>(spec);
 }
diff --git a/dlgs/win/file_dialog_win_safe.cpp b/dlgs/win/file_dialog_win_safe.cpp
