diutil: Add notify when disk has been formatted with EPM partition.

Signed-off-by: Amlal El Mahrouss <amlal.elmahrouss@icloud.com>

2 files changed, 1894 insertions, 2 deletions

diff --git a/public/tools/diutil/CommandLine.cc b/public/tools/diutil/CommandLine.cc
index a539e5ae..ff56eb73 100644
--- a/public/tools/diutil/CommandLine.cc
+++ b/public/tools/diutil/CommandLine.cc
@@ -15,6 +15,8 @@
 #include <FSKit/NeFS.h>
 #include <uuid/uuid.h>
 
+#include "vendor/Dialogs.h"
+
 static std::string kDiskName	 = "Disk";
 static int		   kDiskSectorSz = 512;
 static const int   kDiskBlockCnt = 1;
@@ -58,7 +60,7 @@ int main(int argc, char** argv)
 		}
 	}
 
-	std::cout << "diutil: EPM Disk Tool.\n";
+	std::cout << "diutil: EPM partition tool.\n";
 
 	struct ::EPM_PART_BLOCK block
 	{
@@ -116,7 +118,10 @@ int main(int argc, char** argv)
 	output_epm.seekp(p_prev);
 	output_epm.close();
 
-	std::cout << "diutil: EPM Disk has been written to: " << kOutDisk << "\n";
+	std::cout << "diutil: EPM disk has been written to: " << kOutDisk << "\n";
+
+	pfd::notify("Disk Utility", kOutDisk + " has been formatted successfully.",
+            pfd::icon::info);
 
 	return 0;
 }
\ No newline at end of file
diff --git a/public/tools/diutil/vendor/Dialogs.h b/public/tools/diutil/vendor/Dialogs.h
new file mode 100644
index 00000000..ec71cec4
--- /dev/null
+++ b/public/tools/diutil/vendor/Dialogs.h
@@ -0,0 +1,1887 @@
+//
+//  Portable File Dialogs
+//
+//  Copyright © 2018–2022 Sam Hocevar <sam@hocevar.net>
+//
+//  This library is free software. It comes without any warranty, to
+//  the extent permitted by applicable law. You can redistribute it
+//  and/or modify it under the terms of the Do What the Fuck You Want
+//  to Public License, Version 2, as published by the WTFPL Task Force.
+//  See http://www.wtfpl.net/ for more details.
+//
+
+#pragma once
+
+#if _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#   define WIN32_LEAN_AND_MEAN 1
+#endif
+#include <windows.h>
+#include <commdlg.h>
+#include <shlobj.h>
+#include <shobjidl.h> // IFileDialog
+#include <shellapi.h>
+#include <strsafe.h>
+#include <future>     // std::async
+#include <userenv.h>  // GetUserProfileDirectory()
+
+#elif __EMSCRIPTEN__
+#include <emscripten.h>
+
+#else
+#ifndef _POSIX_C_SOURCE
+#   define _POSIX_C_SOURCE 2 // for popen()
+#endif
+#ifdef __APPLE__
+#   ifndef _DARWIN_C_SOURCE
+#       define _DARWIN_C_SOURCE
+#   endif
+#endif
+#include <cstdio>     // popen()
+#include <cstdlib>    // std::getenv()
+#include <fcntl.h>    // fcntl()
+#include <unistd.h>   // read(), pipe(), dup2(), getuid()
+#include <csignal>    // ::kill, std::signal
+#include <sys/stat.h> // stat()
+#include <sys/wait.h> // waitpid()
+#include <pwd.h>      // getpwnam()
+#endif
+
+#include <string>   // std::string
+#include <memory>   // std::shared_ptr
+#include <iostream> // std::ostream
+#include <map>      // std::map
+#include <set>      // std::set
+#include <regex>    // std::regex
+#include <thread>   // std::mutex, std::this_thread
+#include <chrono>   // std::chrono
+
+// Versions of mingw64 g++ up to 9.3.0 do not have a complete IFileDialog
+#ifndef PFD_HAS_IFILEDIALOG
+#   define PFD_HAS_IFILEDIALOG 1
+#   if (defined __MINGW64__ || defined __MINGW32__) && defined __GXX_ABI_VERSION
+#       if __GXX_ABI_VERSION <= 1013
+#           undef PFD_HAS_IFILEDIALOG
+#           define PFD_HAS_IFILEDIALOG 0
+#       endif
+#   endif
+#endif
+
+namespace pfd
+{
+
+enum class button
+{
+    cancel = -1,
+    ok,
+    yes,
+    no,
+    abort,
+    retry,
+    ignore,
+};
+
+enum class choice
+{
+    ok = 0,
+    ok_cancel,
+    yes_no,
+    yes_no_cancel,
+    retry_cancel,
+    abort_retry_ignore,
+};
+
+enum class icon
+{
+    info = 0,
+    warning,
+    error,
+    question,
+};
+
+// Additional option flags for various dialog constructors
+enum class opt : uint8_t
+{
+    none = 0,
+    // For file open, allow multiselect.
+    multiselect     = 0x1,
+    // For file save, force overwrite and disable the confirmation dialog.
+    force_overwrite = 0x2,
+    // For folder select, force path to be the provided argument instead
+    // of the last opened directory, which is the Microsoft-recommended,
+    // user-friendly behaviour.
+    force_path      = 0x4,
+};
+
+inline opt operator |(opt a, opt b) { return opt(uint8_t(a) | uint8_t(b)); }
+inline bool operator &(opt a, opt b) { return bool(uint8_t(a) & uint8_t(b)); }
+
+// The settings class, only exposing to the user a way to set verbose mode
+// and to force a rescan of installed desktop helpers (zenity, kdialog…).
+class settings
+{
+public:
+    static bool available();
+
+    static void verbose(bool value);
+    static void rescan();
+
+protected:
+    explicit settings(bool resync = false);
+
+    bool check_program(std::string const &program);
+
+    inline bool is_osascript() const;
+    inline bool is_zenity() const;
+    inline bool is_kdialog() const;
+
+    enum class flag
+    {
+        is_scanned = 0,
+        is_verbose,
+
+        has_zenity,
+        has_matedialog,
+        has_qarma,
+        has_kdialog,
+        is_vista,
+
+        max_flag,
+    };
+
+    // Static array of flags for internal state
+    bool const &flags(flag in_flag) const;
+
+    // Non-const getter for the static array of flags
+    bool &flags(flag in_flag);
+};
+
+// Internal classes, not to be used by client applications
+namespace internal
+{
+
+// Process wait timeout, in milliseconds
+static int const default_wait_timeout = 20;
+
+class executor
+{
+    friend class dialog;
+
+public:
+    // High level function to get the result of a command
+    std::string result(int *exit_code = nullptr);
+
+    // High level function to abort
+    bool kill();
+
+#if _WIN32
+    void start_func(std::function<std::string(int *)> const &fun);
+    static BOOL CALLBACK enum_windows_callback(HWND hwnd, LPARAM lParam);
+#elif __EMSCRIPTEN__
+    void start(int exit_code);
+#else
+    void start_process(std::vector<std::string> const &command);
+#endif
+
+    ~executor();
+
+protected:
+    bool ready(int timeout = default_wait_timeout);
+    void stop();
+
+private:
+    bool m_running = false;
+    std::string m_stdout;
+    int m_exit_code = -1;
+#if _WIN32
+    std::future<std::string> m_future;
+    std::set<HWND> m_windows;
+    std::condition_variable m_cond;
+    std::mutex m_mutex;
+    DWORD m_tid;
+#elif __EMSCRIPTEN__ || __NX__
+    // FIXME: do something
+#else
+    pid_t m_pid = 0;
+    int m_fd = -1;
+#endif
+};
+
+class platform
+{
+protected:
+#if _WIN32
+    // Helper class around LoadLibraryA() and GetProcAddress() with some safety
+    class dll
+    {
+    public:
+        dll(std::string const &name);
+        ~dll();
+
+        template<typename T> class proc
+        {
+        public:
+            proc(dll const &lib, std::string const &sym)
+              : m_proc(reinterpret_cast<T *>((void *)::GetProcAddress(lib.handle, sym.c_str())))
+            {}
+
+            operator bool() const { return m_proc != nullptr; }
+            operator T *() const { return m_proc; }
+
+        private:
+            T *m_proc;
+        };
+
+    private:
+        HMODULE handle;
+    };
+
+    // Helper class around CoInitialize() and CoUnInitialize()
+    class ole32_dll : public dll
+    {
+    public:
+        ole32_dll();
+        ~ole32_dll();
+        bool is_initialized();
+
+    private:
+        HRESULT m_state;
+    };
+
+    // Helper class around CreateActCtx() and ActivateActCtx()
+    class new_style_context
+    {
+    public:
+        new_style_context();
+        ~new_style_context();
+
+    private:
+        HANDLE create();
+        ULONG_PTR m_cookie = 0;
+    };
+#endif
+};
+
+class dialog : protected settings, protected platform
+{
+public:
+    bool ready(int timeout = default_wait_timeout) const;
+    bool kill() const;
+
+protected:
+    explicit dialog();
+
+    std::vector<std::string> desktop_helper() const;
+    static std::string buttons_to_name(choice _choice);
+    static std::string get_icon_name(icon _icon);
+
+    std::string powershell_quote(std::string const &str) const;
+    std::string osascript_quote(std::string const &str) const;
+    std::string shell_quote(std::string const &str) const;
+
+    // Keep handle to executing command
+    std::shared_ptr<executor> m_async;
+};
+
+class file_dialog : public dialog
+{
+protected:
+    enum type
+    {
+        open,
+        save,
+        folder,
+    };
+
+    file_dialog(type in_type,
+                std::string const &title,
+                std::string const &default_path = "",
+                std::vector<std::string> const &filters = {},
+                opt options = opt::none);
+
+protected:
+    std::string string_result();
+    std::vector<std::string> vector_result();
+
+#if _WIN32
+    static int CALLBACK bffcallback(HWND hwnd, UINT uMsg, LPARAM, LPARAM pData);
+#if PFD_HAS_IFILEDIALOG
+    std::string select_folder_vista(IFileDialog *ifd, bool force_path);
+#endif
+
+    std::wstring m_wtitle;
+    std::wstring m_wdefault_path;
+
+    std::vector<std::string> m_vector_result;
+#endif
+};
+
+} // namespace internal
+
+//
+// The path class provides some platform-specific path constants
+//
+
+class path : protected internal::platform
+{
+public:
+    static std::string home();
+    static std::string separator();
+};
+
+//
+// The notify widget
+//
+
+class notify : public internal::dialog
+{
+public:
+    notify(std::string const &title,
+           std::string const &message,
+           icon _icon = icon::info);
+};
+
+//
+// The message widget
+//
+
+class message : public internal::dialog
+{
+public:
+    message(std::string const &title,
+            std::string const &text,
+            choice _choice = choice::ok_cancel,
+            icon _icon = icon::info);
+
+    button result();
+
+private:
+    // Some extra logic to map the exit code to button number
+    std::map<int, button> m_mappings;
+};
+
+//
+// The open_file, save_file, and open_folder widgets
+//
+
+class open_file : public internal::file_dialog
+{
+public:
+    open_file(std::string const &title,
+              std::string const &default_path = "",
+              std::vector<std::string> const &filters = { "All Files", "*" },
+              opt options = opt::none);
+
+#if defined(__has_cpp_attribute)
+#if __has_cpp_attribute(deprecated)
+    // Backwards compatibility
+    [[deprecated("Use pfd::opt::multiselect instead of allow_multiselect")]]
+#endif
+#endif
+    open_file(std::string const &title,
+              std::string const &default_path,
+              std::vector<std::string> const &filters,
+              bool allow_multiselect);
+
+    std::vector<std::string> result();
+};
+
+class save_file : public internal::file_dialog
+{
+public:
+    save_file(std::string const &title,
+              std::string const &default_path = "",
+              std::vector<std::string> const &filters = { "All Files", "*" },
+              opt options = opt::none);
+
+#if defined(__has_cpp_attribute)
+#if __has_cpp_attribute(deprecated)
+    // Backwards compatibility
+    [[deprecated("Use pfd::opt::force_overwrite instead of confirm_overwrite")]]
+#endif
+#endif
+    save_file(std::string const &title,
+              std::string const &default_path,
+              std::vector<std::string> const &filters,
+              bool confirm_overwrite);
+
+    std::string result();
+};
+
+class select_folder : public internal::file_dialog
+{
+public:
+    select_folder(std::string const &title,
+                  std::string const &default_path = "",
+                  opt options = opt::none);
+
+    std::string result();
+};
+
+//
+// Below this are all the method implementations. You may choose to define the
+// macro PFD_SKIP_IMPLEMENTATION everywhere before including this header except
+// in one place. This may reduce compilation times.
+//
+
+#if !defined PFD_SKIP_IMPLEMENTATION
+
+// internal free functions implementations
+
+namespace internal
+{
+
+#if _WIN32
+static inline std::wstring str2wstr(std::string const &str)
+{
+    int len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.size(), nullptr, 0);
+    std::wstring ret(len, '\0');
+    MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.size(), (LPWSTR)ret.data(), (int)ret.size());
+    return ret;
+}
+
+static inline std::string wstr2str(std::wstring const &str)
+{
+    int len = WideCharToMultiByte(CP_UTF8, 0, str.c_str(), (int)str.size(), nullptr, 0, nullptr, nullptr);
+    std::string ret(len, '\0');
+    WideCharToMultiByte(CP_UTF8, 0, str.c_str(), (int)str.size(), (LPSTR)ret.data(), (int)ret.size(), nullptr, nullptr);
+    return ret;
+}
+
+static inline bool is_vista()
+{
+    OSVERSIONINFOEXW osvi;
+    memset(&osvi, 0, sizeof(osvi));
+    DWORDLONG const mask = VerSetConditionMask(
+            VerSetConditionMask(
+                    VerSetConditionMask(
+                            0, VER_MAJORVERSION, VER_GREATER_EQUAL),
+                    VER_MINORVERSION, VER_GREATER_EQUAL),
+            VER_SERVICEPACKMAJOR, VER_GREATER_EQUAL);
+    osvi.dwOSVersionInfoSize = sizeof(osvi);
+    osvi.dwMajorVersion = HIBYTE(_WIN32_WINNT_VISTA);
+    osvi.dwMinorVersion = LOBYTE(_WIN32_WINNT_VISTA);
+    osvi.wServicePackMajor = 0;
+
+    return VerifyVersionInfoW(&osvi, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR, mask) != FALSE;
+}
+#endif
+
+// This is necessary until C++20 which will have std::string::ends_with() etc.
+
+static inline bool ends_with(std::string const &str, std::string const &suffix)
+{
+    return suffix.size() <= str.size() &&
+        str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
+}
+
+static inline bool starts_with(std::string const &str, std::string const &prefix)
+{
+    return prefix.size() <= str.size() &&
+        str.compare(0, prefix.size(), prefix) == 0;
+}
+
+// This is necessary until C++17 which will have std::filesystem::is_directory
+
+static inline bool is_directory(std::string const &path)
+{
+#if _WIN32
+    auto attr = GetFileAttributesA(path.c_str());
+    return attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY);
+#elif __EMSCRIPTEN__
+    // TODO
+    return false;
+#else
+    struct stat s;
+    return stat(path.c_str(), &s) == 0 && S_ISDIR(s.st_mode);
+#endif
+}
+
+// This is necessary because getenv is not thread-safe
+
+static inline std::string getenv(std::string const &str)
+{
+#if _MSC_VER
+    char *buf = nullptr;
+    size_t size = 0;
+    if (_dupenv_s(&buf, &size, str.c_str()) == 0 && buf)
+    {
+        std::string ret(buf);
+        free(buf);
+        return ret;
+    }
+    return "";
+#else
+    auto buf = std::getenv(str.c_str());
+    return buf ? buf : "";
+#endif
+}
+
+} // namespace internal
+
+// settings implementation
+
+inline settings::settings(bool resync)
+{
+    flags(flag::is_scanned) &= !resync;
+
+    if (flags(flag::is_scanned))
+        return;
+
+    auto pfd_verbose = internal::getenv("PFD_VERBOSE");
+    auto match_no = std::regex("(|0|no|false)", std::regex_constants::icase);
+    if (!std::regex_match(pfd_verbose, match_no))
+        flags(flag::is_verbose) = true;
+
+#if _WIN32
+    flags(flag::is_vista) = internal::is_vista();
+#elif !__APPLE__
+    flags(flag::has_zenity) = check_program("zenity");
+    flags(flag::has_matedialog) = check_program("matedialog");
+    flags(flag::has_qarma) = check_program("qarma");
+    flags(flag::has_kdialog) = check_program("kdialog");
+
+    // If multiple helpers are available, try to default to the best one
+    if (flags(flag::has_zenity) && flags(flag::has_kdialog))
+    {
+        auto desktop_name = internal::getenv("XDG_SESSION_DESKTOP");
+        if (desktop_name == std::string("gnome"))
+            flags(flag::has_kdialog) = false;
+        else if (desktop_name == std::string("KDE"))
+            flags(flag::has_zenity) = false;
+    }
+#endif
+
+    flags(flag::is_scanned) = true;
+}
+
+inline bool settings::available()
+{
+#if _WIN32
+    return true;
+#elif __APPLE__
+    return true;
+#elif __EMSCRIPTEN__
+    // FIXME: Return true after implementation is complete.
+    return false;
+#else
+    settings tmp;
+    return tmp.flags(flag::has_zenity) ||
+           tmp.flags(flag::has_matedialog) ||
+           tmp.flags(flag::has_qarma) ||
+           tmp.flags(flag::has_kdialog);
+#endif
+}
+
+inline void settings::verbose(bool value)
+{
+    settings().flags(flag::is_verbose) = value;
+}
+
+inline void settings::rescan()
+{
+    settings(/* resync = */ true);
+}
+
+// Check whether a program is present using “which”.
+inline bool settings::check_program(std::string const &program)
+{
+#if _WIN32
+    (void)program;
+    return false;
+#elif __EMSCRIPTEN__
+    (void)program;
+    return false;
+#else
+    int exit_code = -1;
+    internal::executor async;
+    async.start_process({"/bin/sh", "-c", "which " + program});
+    async.result(&exit_code);
+    return exit_code == 0;
+#endif
+}
+
+inline bool settings::is_osascript() const
+{
+#if __APPLE__
+    return true;
+#else
+    return false;
+#endif
+}
+
+inline bool settings::is_zenity() const
+{
+    return flags(flag::has_zenity) ||
+           flags(flag::has_matedialog) ||
+           flags(flag::has_qarma);
+}
+
+inline bool settings::is_kdialog() const
+{
+    return flags(flag::has_kdialog);
+}
+
+inline bool const &settings::flags(flag in_flag) const
+{
+    static bool flags[size_t(flag::max_flag)];
+    return flags[size_t(in_flag)];
+}
+
+inline bool &settings::flags(flag in_flag)
+{
+    return const_cast<bool &>(static_cast<settings const *>(this)->flags(in_flag));
+}
+
+// path implementation
+inline std::string path::home()
+{
+#if _WIN32
+    // First try the USERPROFILE environment variable
+    auto user_profile = internal::getenv("USERPROFILE");
+    if (user_profile.size() > 0)
+        return user_profile;
+    // Otherwise, try GetUserProfileDirectory()
+    HANDLE token = nullptr;
+    DWORD len = MAX_PATH;
+    char buf[MAX_PATH] = { '\0' };
+    if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token))
+    {
+        dll userenv("userenv.dll");
+        dll::proc<BOOL WINAPI (HANDLE, LPSTR, LPDWORD)> get_user_profile_directory(userenv, "GetUserProfileDirectoryA");
+        get_user_profile_directory(token, buf, &len);
+        CloseHandle(token);
+        if (*buf)
+            return buf;
+    }
+#elif __EMSCRIPTEN__
+    return "/";
+#else
+    // First try the HOME environment variable
+    auto home = internal::getenv("HOME");
+    if (home.size() > 0)
+        return home;
+    // Otherwise, try getpwuid_r()
+    size_t len = 4096;
+#if defined(_SC_GETPW_R_SIZE_MAX)
+    auto size_max = sysconf(_SC_GETPW_R_SIZE_MAX);
+    if (size_max != -1)
+        len = size_t(size_max);
+#endif
+    std::vector<char> buf(len);
+    struct passwd pwd, *result;
+    if (getpwuid_r(getuid(), &pwd, buf.data(), buf.size(), &result) == 0)
+        return result->pw_dir;
+#endif
+    return "/";
+}
+
+inline std::string path::separator()
+{
+#if _WIN32
+    return "\\";
+#else
+    return "/";
+#endif
+}
+
+// executor implementation
+
+inline std::string internal::executor::result(int *exit_code /* = nullptr */)
+{
+    stop();
+    if (exit_code)
+        *exit_code = m_exit_code;
+    return m_stdout;
+}
+
+inline bool internal::executor::kill()
+{
+#if _WIN32
+    if (m_future.valid())
+    {
+        // Close all windows that weren’t open when we started the future
+        auto previous_windows = m_windows;
+        EnumWindows(&enum_windows_callback, (LPARAM)this);
+        for (auto hwnd : m_windows)
+            if (previous_windows.find(hwnd) == previous_windows.end())
+            {
+                SendMessage(hwnd, WM_CLOSE, 0, 0);
+                // Also send IDNO in case of a Yes/No or Abort/Retry/Ignore messagebox
+                SendMessage(hwnd, WM_COMMAND, IDNO, 0);
+            }
+    }
+#elif __EMSCRIPTEN__ || __NX__
+    // FIXME: do something
+    return false; // cannot kill
+#else
+    ::kill(m_pid, SIGKILL);
+#endif
+    stop();
+    return true;
+}
+
+#if _WIN32
+inline BOOL CALLBACK internal::executor::enum_windows_callback(HWND hwnd, LPARAM lParam)
+{
+    auto that = (executor *)lParam;
+
+    DWORD pid;
+    auto tid = GetWindowThreadProcessId(hwnd, &pid);
+    if (tid == that->m_tid)
+        that->m_windows.insert(hwnd);
+    return TRUE;
+}
+#endif
+
+#if _WIN32
+inline void internal::executor::start_func(std::function<std::string(int *)> const &fun)
+{
+    stop();
+
+    auto trampoline = [fun, this]()
+    {
+        // Save our thread id so that the caller can cancel us
+        m_tid = GetCurrentThreadId();
+        EnumWindows(&enum_windows_callback, (LPARAM)this);
+        m_cond.notify_all();
+        return fun(&m_exit_code);
+    };
+
+    std::unique_lock<std::mutex> lock(m_mutex);
+    m_future = std::async(std::launch::async, trampoline);
+    m_cond.wait(lock);
+    m_running = true;
+}
+
+#elif __EMSCRIPTEN__
+inline void internal::executor::start(int exit_code)
+{
+    m_exit_code = exit_code;
+}
+
+#else
+inline void internal::executor::start_process(std::vector<std::string> const &command)
+{
+    stop();
+    m_stdout.clear();
+    m_exit_code = -1;
+
+    int in[2], out[2];
+    if (pipe(in) != 0 || pipe(out) != 0)
+        return;
+
+    m_pid = fork();
+    if (m_pid < 0)
+        return;
+
+    close(in[m_pid ? 0 : 1]);
+    close(out[m_pid ? 1 : 0]);
+
+    if (m_pid == 0)
+    {
+        dup2(in[0], STDIN_FILENO);
+        dup2(out[1], STDOUT_FILENO);
+
+        // Ignore stderr so that it doesn’t pollute the console (e.g. GTK+ errors from zenity)
+        int fd = open("/dev/null", O_WRONLY);
+        dup2(fd, STDERR_FILENO);
+        close(fd);
+
+        std::vector<char *> args;
+        std::transform(command.cbegin(), command.cend(), std::back_inserter(args),
+                       [](std::string const &s) { return const_cast<char *>(s.c_str()); });
+        args.push_back(nullptr); // null-terminate argv[]
+
+        execvp(args[0], args.data());
+        exit(1);
+    }
+
+    close(in[1]);
+    m_fd = out[0];
+    auto flags = fcntl(m_fd, F_GETFL);
+    fcntl(m_fd, F_SETFL, flags | O_NONBLOCK);
+
+    m_running = true;
+}
+#endif
+
+inline internal::executor::~executor()
+{
+    stop();
+}
+
+inline bool internal::executor::ready(int timeout /* = default_wait_timeout */)
+{
+    if (!m_running)
+        return true;
+
+#if _WIN32
+    if (m_future.valid())
+    {
+        auto status = m_future.wait_for(std::chrono::milliseconds(timeout));
+        if (status != std::future_status::ready)
+        {
+            // On Windows, we need to run the message pump. If the async
+            // thread uses a Windows API dialog, it may be attached to the
+            // main thread and waiting for messages that only we can dispatch.
+            MSG msg;
+            while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
+            {
+                TranslateMessage(&msg);
+                DispatchMessage(&msg);
+            }
+            return false;
+        }
+
+        m_stdout = m_future.get();
+    }
+#elif __EMSCRIPTEN__ || __NX__
+    // FIXME: do something
+    (void)timeout;
+#else
+    char buf[BUFSIZ];
+    ssize_t received = read(m_fd, buf, BUFSIZ); // Flawfinder: ignore
+    if (received > 0)
+    {
+        m_stdout += std::string(buf, received);
+        return false;
+    }
+
+    // Reap child process if it is dead. It is possible that the system has already reaped it
+    // (this happens when the calling application handles or ignores SIG_CHLD) and results in
+    // waitpid() failing with ECHILD. Otherwise we assume the child is running and we sleep for
+    // a little while.
+    int status;
+    pid_t child = waitpid(m_pid, &status, WNOHANG);
+    if (child != m_pid && (child >= 0 || errno != ECHILD))
+    {
+        // FIXME: this happens almost always at first iteration
+        std::this_thread::sleep_for(std::chrono::milliseconds(timeout));
+        return false;
+    }
+
+    close(m_fd);
+    m_exit_code = WEXITSTATUS(status);
+#endif
+
+    m_running = false;
+    return true;
+}
+
+inline void internal::executor::stop()
+{
+    // Loop until the user closes the dialog
+    while (!ready())
+        ;
+}
+
+// dll implementation
+
+#if _WIN32
+inline internal::platform::dll::dll(std::string const &name)
+  : handle(::LoadLibraryA(name.c_str()))
+{}
+
+inline internal::platform::dll::~dll()
+{
+    if (handle)
+        ::FreeLibrary(handle);
+}
+#endif // _WIN32
+
+// ole32_dll implementation
+
+#if _WIN32
+inline internal::platform::ole32_dll::ole32_dll()
+    : dll("ole32.dll")
+{
+    // Use COINIT_MULTITHREADED because COINIT_APARTMENTTHREADED causes crashes.
+    // See https://github.com/samhocevar/portable-file-dialogs/issues/51
+    auto coinit = proc<HRESULT WINAPI (LPVOID, DWORD)>(*this, "CoInitializeEx");
+    m_state = coinit(nullptr, COINIT_MULTITHREADED);
+}
+
+inline internal::platform::ole32_dll::~ole32_dll()
+{
+    if (is_initialized())
+        proc<void WINAPI ()>(*this, "CoUninitialize")();
+}
+
+inline bool internal::platform::ole32_dll::is_initialized()
+{
+    return m_state == S_OK || m_state == S_FALSE;
+}
+#endif
+
+// new_style_context implementation
+
+#if _WIN32
+inline internal::platform::new_style_context::new_style_context()
+{
+    // Only create one activation context for the whole app lifetime.
+    static HANDLE hctx = create();
+
+    if (hctx != INVALID_HANDLE_VALUE)
+        ActivateActCtx(hctx, &m_cookie);
+}
+
+inline internal::platform::new_style_context::~new_style_context()
+{
+    DeactivateActCtx(0, m_cookie);
+}
+
+inline HANDLE internal::platform::new_style_context::create()
+{
+    // This “hack” seems to be necessary for this code to work on windows XP.
+    // Without it, dialogs do not show and close immediately. GetError()
+    // returns 0 so I don’t know what causes this. I was not able to reproduce
+    // this behavior on Windows 7 and 10 but just in case, let it be here for
+    // those versions too.
+    // This hack is not required if other dialogs are used (they load comdlg32
+    // automatically), only if message boxes are used.
+    dll comdlg32("comdlg32.dll");
+
+    // Using approach as shown here: https://stackoverflow.com/a/10444161
+    UINT len = ::GetSystemDirectoryA(nullptr, 0);
+    std::string sys_dir(len, '\0');
+    ::GetSystemDirectoryA(&sys_dir[0], len);
+
+    ACTCTXA act_ctx =
+    {
+        // Do not set flag ACTCTX_FLAG_SET_PROCESS_DEFAULT, since it causes a
+        // crash with error “default context is already set”.
+        sizeof(act_ctx),
+        ACTCTX_FLAG_RESOURCE_NAME_VALID | ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID,
+        "shell32.dll", 0, 0, sys_dir.c_str(), (LPCSTR)124, nullptr, 0,
+    };
+
+    return ::CreateActCtxA(&act_ctx);
+}
+#endif // _WIN32
+
+// dialog implementation
+
+inline bool internal::dialog::ready(int timeout /* = default_wait_timeout */) const
+{
+    return m_async->ready(timeout);
+}
+
+inline bool internal::dialog::kill() const
+{
+    return m_async->kill();
+}
+
+inline internal::dialog::dialog()
+  : m_async(std::make_shared<executor>())
+{
+}
+
+inline std::vector<std::string> internal::dialog::desktop_helper() const
+{
+#if __APPLE__
+    return { "osascript" };
+#else
+    return { flags(flag::has_zenity) ? "zenity"
+           : flags(flag::has_matedialog) ? "matedialog"
+           : flags(flag::has_qarma) ? "qarma"
+           : flags(flag::has_kdialog) ? "kdialog"
+           : "echo" };
+#endif
+}
+
+inline std::string internal::dialog::buttons_to_name(choice _choice)
+{
+    switch (_choice)
+    {
+        case choice::ok_cancel: return "okcancel";
+        case choice::yes_no: return "yesno";
+        case choice::yes_no_cancel: return "yesnocancel";
+        case choice::retry_cancel: return "retrycancel";
+        case choice::abort_retry_ignore: return "abortretryignore";
+        /* case choice::ok: */ default: return "ok";
+    }
+}
+
+inline std::string internal::dialog::get_icon_name(icon _icon)
+{
+    switch (_icon)
+    {
+        case icon::warning: return "warning";
+        case icon::error: return "error";
+        case icon::question: return "question";
+        // Zenity wants "information" but WinForms wants "info"
+        /* case icon::info: */ default:
+#if _WIN32
+            return "info";
+#else
+            return "information";
+#endif
+    }
+}
+
+// This is only used for debugging purposes
+inline std::ostream& operator <<(std::ostream &s, std::vector<std::string> const &v)
+{
+    int not_first = 0;
+    for (auto &e : v)
+        s << (not_first++ ? " " : "") << e;
+    return s;
+}
+
+// Properly quote a string for Powershell: replace ' or " with '' or ""
+// FIXME: we should probably get rid of newlines!
+// FIXME: the \" sequence seems unsafe, too!
+// XXX: this is no longer used but I would like to keep it around just in case
+inline std::string internal::dialog::powershell_quote(std::string const &str) const
+{
+    return "'" + std::regex_replace(str, std::regex("['\"]"), "$&$&") + "'";
+}
+
+// Properly quote a string for osascript: replace \ or " with \\ or \"
+// XXX: this also used to replace ' with \' when popen was used, but it would be
+// smarter to do shell_quote(osascript_quote(...)) if this is needed again.
+inline std::string internal::dialog::osascript_quote(std::string const &str) const
+{
+    return "\"" + std::regex_replace(str, std::regex("[\\\\\"]"), "\\$&") + "\"";
+}
+
+// Properly quote a string for the shell: just replace ' with '\''
+// XXX: this is no longer used but I would like to keep it around just in case
+inline std::string internal::dialog::shell_quote(std::string const &str) const
+{
+    return "'" + std::regex_replace(str, std::regex("'"), "'\\''") + "'";
+}
+
+// file_dialog implementation
+
+inline internal::file_dialog::file_dialog(type in_type,
+            std::string const &title,
+            std::string const &default_path /* = "" */,
+            std::vector<std::string> const &filters /* = {} */,
+            opt options /* = opt::none */)
+{
+#if _WIN32
+    std::string filter_list;
+    std::regex whitespace("  *");
+    for (size_t i = 0; i + 1 < filters.size(); i += 2)
+    {
+        filter_list += filters[i] + '\0';
+        filter_list += std::regex_replace(filters[i + 1], whitespace, ";") + '\0';
+    }
+    filter_list += '\0';
+
+    m_async->start_func([this, in_type, title, default_path, filter_list,
+                         options](int *exit_code) -> std::string
+    {
+        (void)exit_code;
+        m_wtitle = internal::str2wstr(title);
+        m_wdefault_path = internal::str2wstr(default_path);
+        auto wfilter_list = internal::str2wstr(filter_list);
+
+        // Initialise COM. This is required for the new folder selection window,
+        // (see https://github.com/samhocevar/portable-file-dialogs/pull/21)
+        // and to avoid random crashes with GetOpenFileNameW() (see
+        // https://github.com/samhocevar/portable-file-dialogs/issues/51)
+        ole32_dll ole32;
+
+        // Folder selection uses a different method
+        if (in_type == type::folder)
+        {
+#if PFD_HAS_IFILEDIALOG
+            if (flags(flag::is_vista))
+            {
+                // On Vista and higher we should be able to use IFileDialog for folder selection
+                IFileDialog *ifd;
+                HRESULT hr = dll::proc<HRESULT WINAPI (REFCLSID, LPUNKNOWN, DWORD, REFIID, LPVOID *)>(ole32, "CoCreateInstance")
+                                 (CLSID_FileOpenDialog, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&ifd));
+
+                // In case CoCreateInstance fails (which it should not), try legacy approach
+                if (SUCCEEDED(hr))
+                    return select_folder_vista(ifd, options & opt::force_path);
+            }
+#endif
+
+            BROWSEINFOW bi;
+            memset(&bi, 0, sizeof(bi));
+
+            bi.lpfn = &bffcallback;
+            bi.lParam = (LPARAM)this;
+
+            if (flags(flag::is_vista))
+            {
+                if (ole32.is_initialized())
+                    bi.ulFlags |= BIF_NEWDIALOGSTYLE;
+                bi.ulFlags |= BIF_EDITBOX;
+                bi.ulFlags |= BIF_STATUSTEXT;
+            }
+
+            auto *list = SHBrowseForFolderW(&bi);
+            std::string ret;
+            if (list)
+            {
+                auto buffer = new wchar_t[MAX_PATH];
+                SHGetPathFromIDListW(list, buffer);
+                dll::proc<void WINAPI (LPVOID)>(ole32, "CoTaskMemFree")(list);
+                ret = internal::wstr2str(buffer);
+                delete[] buffer;
+            }
+            return ret;
+        }
+
+        OPENFILENAMEW ofn;
+        memset(&ofn, 0, sizeof(ofn));
+        ofn.lStructSize = sizeof(OPENFILENAMEW);
+        ofn.hwndOwner = GetActiveWindow();
+
+        ofn.lpstrFilter = wfilter_list.c_str();
+
+        auto woutput = std::wstring(MAX_PATH * 256, L'\0');
+        ofn.lpstrFile = (LPWSTR)woutput.data();
+        ofn.nMaxFile = (DWORD)woutput.size();
+        if (!m_wdefault_path.empty())
+        {
+            // If a directory was provided, use it as the initial directory. If
+            // a valid path was provided, use it as the initial file. Otherwise,
+            // let the Windows API decide.
+            auto path_attr = GetFileAttributesW(m_wdefault_path.c_str());
+            if (path_attr != INVALID_FILE_ATTRIBUTES && (path_attr & FILE_ATTRIBUTE_DIRECTORY))
+                ofn.lpstrInitialDir = m_wdefault_path.c_str();
+            else if (m_wdefault_path.size() <= woutput.size())
+                //second argument is size of buffer, not length of string
+                StringCchCopyW(ofn.lpstrFile, MAX_PATH*256+1, m_wdefault_path.c_str());
+            else
+            {
+                ofn.lpstrFileTitle = (LPWSTR)m_wdefault_path.data();
+                ofn.nMaxFileTitle = (DWORD)m_wdefault_path.size();
+            }
+        }
+        ofn.lpstrTitle = m_wtitle.c_str();
+        ofn.Flags = OFN_NOCHANGEDIR | OFN_EXPLORER;
+
+        dll comdlg32("comdlg32.dll");
+
+        // Apply new visual style (required for windows XP)
+        new_style_context ctx;
+
+        if (in_type == type::save)
+        {
+            if (!(options & opt::force_overwrite))
+                ofn.Flags |= OFN_OVERWRITEPROMPT;
+
+            dll::proc<BOOL WINAPI (LPOPENFILENAMEW)> get_save_file_name(comdlg32, "GetSaveFileNameW");
+            if (get_save_file_name(&ofn) == 0)
+                return "";
+            return internal::wstr2str(woutput.c_str());
+        }
+        else
+        {
+            if (options & opt::multiselect)
+                ofn.Flags |= OFN_ALLOWMULTISELECT;
+            ofn.Flags |= OFN_PATHMUSTEXIST;
+
+            dll::proc<BOOL WINAPI (LPOPENFILENAMEW)> get_open_file_name(comdlg32, "GetOpenFileNameW");
+            if (get_open_file_name(&ofn) == 0)
+                return "";
+        }
+
+        std::string prefix;
+        for (wchar_t const *p = woutput.c_str(); *p; )
+        {
+            auto filename = internal::wstr2str(p);
+            p += wcslen(p);
+            // In multiselect mode, we advance p one wchar further and
+            // check for another filename. If there is one and the
+            // prefix is empty, it means we just read the prefix.
+            if ((options & opt::multiselect) && *++p && prefix.empty())
+            {
+                prefix = filename + "/";
+                continue;
+            }
+
+            m_vector_result.push_back(prefix + filename);
+        }
+
+        return "";
+    });
+#elif __EMSCRIPTEN__
+    // FIXME: do something
+    (void)in_type;
+    (void)title;
+    (void)default_path;
+    (void)filters;
+    (void)options;
+#else
+    auto command = desktop_helper();
+
+    if (is_osascript())
+    {
+        std::string script = "set ret to choose";
+        switch (in_type)
+        {
+            case type::save:
+                script += " file name";
+                break;
+            case type::open: default:
+                script += " file";
+                if (options & opt::multiselect)
+                    script += " with multiple selections allowed";
+                break;
+            case type::folder:
+                script += " folder";
+                break;
+        }
+
+        if (default_path.size())
+        {
+            if (in_type == type::folder || is_directory(default_path))
+                script += " default location ";
+            else
+                script += " default name ";
+            script += osascript_quote(default_path);
+        }
+
+        script += " with prompt " + osascript_quote(title);
+
+        if (in_type == type::open)
+        {
+            // Concatenate all user-provided filter patterns
+            std::string patterns;
+            for (size_t i = 0; i < filters.size() / 2; ++i)
+                patterns += " " + filters[2 * i + 1];
+
+            // Split the pattern list to check whether "*" is in there; if it
+            // is, we have to disable filters because there is no mechanism in
+            // OS X for the user to override the filter.
+            std::regex sep("\\s+");
+            std::string filter_list;
+            bool has_filter = true;
+            std::sregex_token_iterator iter(patterns.begin(), patterns.end(), sep, -1);
+            std::sregex_token_iterator end;
+            for ( ; iter != end; ++iter)
+            {
+                auto pat = iter->str();
+                if (pat == "*" || pat == "*.*")
+                    has_filter = false;
+                else if (internal::starts_with(pat, "*."))
+                    filter_list += "," + osascript_quote(pat.substr(2, pat.size() - 2));
+            }
+
+            if (has_filter && filter_list.size() > 0)
+            {
+                // There is a weird AppleScript bug where file extensions of length != 3 are
+                // ignored, e.g. type{"txt"} works, but type{"json"} does not. Fortunately if
+                // the whole list starts with a 3-character extension, everything works again.
+                // We use "///" for such an extension because we are sure it cannot appear in
+                // an actual filename.
+                script += " of type {\"///\"" + filter_list + "}";
+            }
+        }
+
+        if (in_type == type::open && (options & opt::multiselect))
+        {
+            script += "\nset s to \"\"";
+            script += "\nrepeat with i in ret";
+            script += "\n  set s to s & (POSIX path of i) & \"\\n\"";
+            script += "\nend repeat";
+            script += "\ncopy s to stdout";
+        }
+        else
+        {
+            script += "\nPOSIX path of ret";
+        }
+
+        command.push_back("-e");
+        command.push_back(script);
+    }
+    else if (is_zenity())
+    {
+        command.push_back("--file-selection");
+
+        // If the default path is a directory, make sure it ends with "/" otherwise zenity will
+        // open the file dialog in the parent directory.
+        auto filename_arg = "--filename=" + default_path;
+        if (in_type != type::folder && !ends_with(default_path, "/") && internal::is_directory(default_path))
+            filename_arg += "/";
+        command.push_back(filename_arg);
+
+        command.push_back("--title");
+        command.push_back(title);
+        command.push_back("--separator=\n");
+
+        for (size_t i = 0; i < filters.size() / 2; ++i)
+        {
+            command.push_back("--file-filter");
+            command.push_back(filters[2 * i] + "|" + filters[2 * i + 1]);
+        }
+
+        if (in_type == type::save)
+            command.push_back("--save");
+        if (in_type == type::folder)
+            command.push_back("--directory");
+        if (!(options & opt::force_overwrite))
+            command.push_back("--confirm-overwrite");
+        if (options & opt::multiselect)
+            command.push_back("--multiple");
+    }
+    else if (is_kdialog())
+    {
+        switch (in_type)
+        {
+            case type::save: command.push_back("--getsavefilename"); break;
+            case type::open: command.push_back("--getopenfilename"); break;
+            case type::folder: command.push_back("--getexistingdirectory"); break;
+        }
+        if (options & opt::multiselect)
+        {
+            command.push_back("--multiple");
+            command.push_back("--separate-output");
+        }
+
+        command.push_back(default_path);
+
+        std::string filter;
+        for (size_t i = 0; i < filters.size() / 2; ++i)
+            filter += (i == 0 ? "" : " | ") + filters[2 * i] + "(" + filters[2 * i + 1] + ")";
+        command.push_back(filter);
+
+        command.push_back("--title");
+        command.push_back(title);
+    }
+
+    if (flags(flag::is_verbose))
+        std::cerr << "pfd: " << command << std::endl;
+
+    m_async->start_process(command);
+#endif
+}
+
+inline std::string internal::file_dialog::string_result()
+{
+#if _WIN32
+    return m_async->result();
+#else
+    auto ret = m_async->result();
+    // Strip potential trailing newline (zenity). Also strip trailing slash
+    // added by osascript for consistency with other backends.
+    while (!ret.empty() && (ret.back() == '\n' || ret.back() == '/'))
+        ret.pop_back();
+    return ret;
+#endif
+}
+
+inline std::vector<std::string> internal::file_dialog::vector_result()
+{
+#if _WIN32
+    m_async->result();
+    return m_vector_result;
+#else
+    std::vector<std::string> ret;
+    auto result = m_async->result();
+    for (;;)
+    {
+        // Split result along newline characters
+        auto i = result.find('\n');
+        if (i == 0 || i == std::string::npos)
+            break;
+        ret.push_back(result.substr(0, i));
+        result = result.substr(i + 1, result.size());
+    }
+    return ret;
+#endif
+}
+
+#if _WIN32
+// Use a static function to pass as BFFCALLBACK for legacy folder select
+inline int CALLBACK internal::file_dialog::bffcallback(HWND hwnd, UINT uMsg,
+                                                       LPARAM, LPARAM pData)
+{
+    auto inst = (file_dialog *)pData;
+    switch (uMsg)
+    {
+        case BFFM_INITIALIZED:
+            SendMessage(hwnd, BFFM_SETSELECTIONW, TRUE, (LPARAM)inst->m_wdefault_path.c_str());
+            break;
+    }
+    return 0;
+}
+
+#if PFD_HAS_IFILEDIALOG
+inline std::string internal::file_dialog::select_folder_vista(IFileDialog *ifd, bool force_path)
+{
+    std::string result;
+
+    IShellItem *folder;
+
+    // Load library at runtime so app doesn't link it at load time (which will fail on windows XP)
+    dll shell32("shell32.dll");
+    dll::proc<HRESULT WINAPI (PCWSTR, IBindCtx*, REFIID, void**)>
+        create_item(shell32, "SHCreateItemFromParsingName");
+
+    if (!create_item)
+        return "";
+
+    auto hr = create_item(m_wdefault_path.c_str(),
+                          nullptr,
+                          IID_PPV_ARGS(&folder));
+
+    // Set default folder if found. This only sets the default folder. If
+    // Windows has any info about the most recently selected folder, it
+    // will display it instead. Generally, calling SetFolder() to set the
+    // current directory “is not a good or expected user experience and
+    // should therefore be avoided”:
+    // https://docs.microsoft.com/windows/win32/api/shobjidl_core/nf-shobjidl_core-ifiledialog-setfolder
+    if (SUCCEEDED(hr))
+    {
+        if (force_path)
+            ifd->SetFolder(folder);
+        else
+            ifd->SetDefaultFolder(folder);
+        folder->Release();
+    }
+
+    // Set the dialog title and option to select folders
+    ifd->SetOptions(FOS_PICKFOLDERS | FOS_FORCEFILESYSTEM);
+    ifd->SetTitle(m_wtitle.c_str());
+
+    hr = ifd->Show(GetActiveWindow());
+    if (SUCCEEDED(hr))
+    {
+        IShellItem* item;
+        hr = ifd->GetResult(&item);
+        if (SUCCEEDED(hr))
+        {
+            wchar_t* wname = nullptr;
+            // This is unlikely to fail because we use FOS_FORCEFILESYSTEM, but try
+            // to output a debug message just in case.
+            if (SUCCEEDED(item->GetDisplayName(SIGDN_FILESYSPATH, &wname)))
+            {
+                result = internal::wstr2str(std::wstring(wname));
+                dll::proc<void WINAPI (LPVOID)>(ole32_dll(), "CoTaskMemFree")(wname);
+            }
+            else
+            {
+                if (SUCCEEDED(item->GetDisplayName(SIGDN_NORMALDISPLAY, &wname)))
+                {
+                    auto name = internal::wstr2str(std::wstring(wname));
+                    dll::proc<void WINAPI (LPVOID)>(ole32_dll(), "CoTaskMemFree")(wname);
+                    std::cerr << "pfd: failed to get path for " << name << std::endl;
+                }
+                else
+                    std::cerr << "pfd: item of unknown type selected" << std::endl;
+            }
+
+            item->Release();
+        }
+    }
+
+    ifd->Release();
+
+    return result;
+}
+#endif
+#endif
+
+// notify implementation
+
+inline notify::notify(std::string const &title,
+                      std::string const &message,
+                      icon _icon /* = icon::info */)
+{
+    if (_icon == icon::question) // Not supported by notifications
+        _icon = icon::info;
+
+#if _WIN32
+    // Use a static shared pointer for notify_icon so that we can delete
+    // it whenever we need to display a new one, and we can also wait
+    // until the program has finished running.
+    struct notify_icon_data : public NOTIFYICONDATAW
+    {
+        ~notify_icon_data() { Shell_NotifyIconW(NIM_DELETE, this); }
+    };
+
+    static std::shared_ptr<notify_icon_data> nid;
+
+    // Release the previous notification icon, if any, and allocate a new
+    // one. Note that std::make_shared() does value initialization, so there
+    // is no need to memset the structure.
+    nid = nullptr;
+    nid = std::make_shared<notify_icon_data>();
+
+    // For XP support
+    nid->cbSize = NOTIFYICONDATAW_V2_SIZE;
+    nid->hWnd = nullptr;
+    nid->uID = 0;
+
+    // Flag Description:
+    // - NIF_ICON    The hIcon member is valid.
+    // - NIF_MESSAGE The uCallbackMessage member is valid.
+    // - NIF_TIP     The szTip member is valid.
+    // - NIF_STATE   The dwState and dwStateMask members are valid.
+    // - NIF_INFO    Use a balloon ToolTip instead of a standard ToolTip. The szInfo, uTimeout, szInfoTitle, and dwInfoFlags members are valid.
+    // - NIF_GUID    Reserved.
+    nid->uFlags = NIF_MESSAGE | NIF_ICON | NIF_INFO;
+
+    // Flag Description
+    // - NIIF_ERROR     An error icon.
+    // - NIIF_INFO      An information icon.
+    // - NIIF_NONE      No icon.
+    // - NIIF_WARNING   A warning icon.
+    // - NIIF_ICON_MASK Version 6.0. Reserved.
+    // - NIIF_NOSOUND   Version 6.0. Do not play the associated sound. Applies only to balloon ToolTips
+    switch (_icon)
+    {
+        case icon::warning: nid->dwInfoFlags = NIIF_WARNING; break;
+        case icon::error: nid->dwInfoFlags = NIIF_ERROR; break;
+        /* case icon::info: */ default: nid->dwInfoFlags = NIIF_INFO; break;
+    }
+
+    ENUMRESNAMEPROC icon_enum_callback = [](HMODULE, LPCTSTR, LPTSTR lpName, LONG_PTR lParam) -> BOOL
+    {
+        ((NOTIFYICONDATAW *)lParam)->hIcon = ::LoadIcon(GetModuleHandle(nullptr), lpName);
+        return false;
+    };
+
+    nid->hIcon = ::LoadIcon(nullptr, IDI_APPLICATION);
+    ::EnumResourceNames(nullptr, RT_GROUP_ICON, icon_enum_callback, (LONG_PTR)nid.get());
+
+    nid->uTimeout = 5000;
+
+    StringCchCopyW(nid->szInfoTitle, ARRAYSIZE(nid->szInfoTitle), internal::str2wstr(title).c_str());
+    StringCchCopyW(nid->szInfo, ARRAYSIZE(nid->szInfo), internal::str2wstr(message).c_str());
+
+    // Display the new icon
+    Shell_NotifyIconW(NIM_ADD, nid.get());
+#elif __EMSCRIPTEN__
+    // FIXME: do something
+    (void)title;
+    (void)message;
+#else
+    auto command = desktop_helper();
+
+    if (is_osascript())
+    {
+        command.push_back("-e");
+        command.push_back("display notification " + osascript_quote(message) +
+                          " with title " + osascript_quote(title));
+    }
+    else if (is_zenity())
+    {
+        command.push_back("--notification");
+        command.push_back("--window-icon");
+        command.push_back(get_icon_name(_icon));
+        command.push_back("--text");
+        command.push_back(title + "\n" + message);
+    }
+    else if (is_kdialog())
+    {
+        command.push_back("--icon");
+        command.push_back(get_icon_name(_icon));
+        command.push_back("--title");
+        command.push_back(title);
+        command.push_back("--passivepopup");
+        command.push_back(message);
+        command.push_back("5");
+    }
+
+    if (flags(flag::is_verbose))
+        std::cerr << "pfd: " << command << std::endl;
+
+    m_async->start_process(command);
+#endif
+}
+
+// message implementation
+
+inline message::message(std::string const &title,
+                        std::string const &text,
+                        choice _choice /* = choice::ok_cancel */,
+                        icon _icon /* = icon::info */)
+{
+#if _WIN32
+    // Use MB_SYSTEMMODAL rather than MB_TOPMOST to ensure the message window is brought
+    // to front. See https://github.com/samhocevar/portable-file-dialogs/issues/52
+    UINT style = MB_SYSTEMMODAL;
+    switch (_icon)
+    {
+        case icon::warning: style |= MB_ICONWARNING; break;
+        case icon::error: style |= MB_ICONERROR; break;
+        case icon::question: style |= MB_ICONQUESTION; break;
+        /* case icon::info: */ default: style |= MB_ICONINFORMATION; break;
+    }
+
+    switch (_choice)
+    {
+        case choice::ok_cancel: style |= MB_OKCANCEL; break;
+        case choice::yes_no: style |= MB_YESNO; break;
+        case choice::yes_no_cancel: style |= MB_YESNOCANCEL; break;
+        case choice::retry_cancel: style |= MB_RETRYCANCEL; break;
+        case choice::abort_retry_ignore: style |= MB_ABORTRETRYIGNORE; break;
+        /* case choice::ok: */ default: style |= MB_OK; break;
+    }
+
+    m_mappings[IDCANCEL] = button::cancel;
+    m_mappings[IDOK] = button::ok;
+    m_mappings[IDYES] = button::yes;
+    m_mappings[IDNO] = button::no;
+    m_mappings[IDABORT] = button::abort;
+    m_mappings[IDRETRY] = button::retry;
+    m_mappings[IDIGNORE] = button::ignore;
+
+    m_async->start_func([text, title, style](int* exit_code) -> std::string
+    {
+        auto wtext = internal::str2wstr(text);
+        auto wtitle = internal::str2wstr(title);
+        // Apply new visual style (required for all Windows versions)
+        new_style_context ctx;
+        *exit_code = MessageBoxW(GetActiveWindow(), wtext.c_str(), wtitle.c_str(), style);
+        return "";
+    });
+
+#elif __EMSCRIPTEN__
+    std::string full_message;
+    switch (_icon)
+    {
+        case icon::warning: full_message = "⚠️"; break;
+        case icon::error: full_message = "⛔"; break;
+        case icon::question: full_message = "❓"; break;
+        /* case icon::info: */ default: full_message = "ℹ"; break;
+    }
+
+    full_message += ' ' + title + "\n\n" + text;
+
+    // This does not really start an async task; it just passes the
+    // EM_ASM_INT return value to a fake start() function.
+    m_async->start(EM_ASM_INT(
+    {
+        if ($1)
+            return window.confirm(UTF8ToString($0)) ? 0 : -1;
+        alert(UTF8ToString($0));
+        return 0;
+    }, full_message.c_str(), _choice == choice::ok_cancel));
+#else
+    auto command = desktop_helper();
+
+    if (is_osascript())
+    {
+        std::string script = "display dialog " + osascript_quote(text) +
+                             " with title " + osascript_quote(title);
+        auto if_cancel = button::cancel;
+        switch (_choice)
+        {
+            case choice::ok_cancel:
+                script += "buttons {\"OK\", \"Cancel\"}"
+                          " default button \"OK\""
+                          " cancel button \"Cancel\"";
+                break;
+            case choice::yes_no:
+                script += "buttons {\"Yes\", \"No\"}"
+                          " default button \"Yes\""
+                          " cancel button \"No\"";
+                if_cancel = button::no;
+                break;
+            case choice::yes_no_cancel:
+                script += "buttons {\"Yes\", \"No\", \"Cancel\"}"
+                          " default button \"Yes\""
+                          " cancel button \"Cancel\"";
+                break;
+            case choice::retry_cancel:
+                script += "buttons {\"Retry\", \"Cancel\"}"
+                          " default button \"Retry\""
+                          " cancel button \"Cancel\"";
+                break;
+            case choice::abort_retry_ignore:
+                script += "buttons {\"Abort\", \"Retry\", \"Ignore\"}"
+                          " default button \"Abort\""
+                          " cancel button \"Retry\"";
+                if_cancel = button::retry;
+                break;
+            case choice::ok: default:
+                script += "buttons {\"OK\"}"
+                          " default button \"OK\""
+                          " cancel button \"OK\"";
+                if_cancel = button::ok;
+                break;
+        }
+        m_mappings[1] = if_cancel;
+        m_mappings[256] = if_cancel; // XXX: I think this was never correct
+        script += " with icon ";
+        switch (_icon)
+        {
+            #define PFD_OSX_ICON(n) "alias ((path to library folder from system domain) as text " \
+                "& \"CoreServices:CoreTypes.bundle:Contents:Resources:" n ".icns\")"
+            case icon::info: default: script += PFD_OSX_ICON("ToolBarInfo"); break;
+            case icon::warning: script += "caution"; break;
+            case icon::error: script += "stop"; break;
+            case icon::question: script += PFD_OSX_ICON("GenericQuestionMarkIcon"); break;
+            #undef PFD_OSX_ICON
+        }
+
+        command.push_back("-e");
+        command.push_back(script);
+    }
+    else if (is_zenity())
+    {
+        switch (_choice)
+        {
+            case choice::ok_cancel:
+                command.insert(command.end(), { "--question", "--cancel-label=Cancel", "--ok-label=OK" }); break;
+            case choice::yes_no:
+                // Do not use standard --question because it causes “No” to return -1,
+                // which is inconsistent with the “Yes/No/Cancel” mode below.
+                command.insert(command.end(), { "--question", "--switch", "--extra-button=No", "--extra-button=Yes" }); break;
+            case choice::yes_no_cancel:
+                command.insert(command.end(), { "--question", "--switch", "--extra-button=Cancel", "--extra-button=No", "--extra-button=Yes" }); break;
+            case choice::retry_cancel:
+                command.insert(command.end(), { "--question", "--switch", "--extra-button=Cancel", "--extra-button=Retry" }); break;
+            case choice::abort_retry_ignore:
+                command.insert(command.end(), { "--question", "--switch", "--extra-button=Ignore", "--extra-button=Abort", "--extra-button=Retry" }); break;
+            case choice::ok:
+            default:
+                switch (_icon)
+                {
+                    case icon::error: command.push_back("--error"); break;
+                    case icon::warning: command.push_back("--warning"); break;
+                    default: command.push_back("--info"); break;
+                }
+        }
+
+        command.insert(command.end(), { "--title", title,
+                                        "--width=300", "--height=0", // sensible defaults
+                                        "--no-markup", // do not interpret text as Pango markup
+                                        "--text", text,
+                                        "--icon-name=dialog-" + get_icon_name(_icon) });
+    }
+    else if (is_kdialog())
+    {
+        if (_choice == choice::ok)
+        {
+            switch (_icon)
+            {
+                case icon::error: command.push_back("--error"); break;
+                case icon::warning: command.push_back("--sorry"); break;
+                default: command.push_back("--msgbox"); break;
+            }
+        }
+        else
+        {
+            std::string flag = "--";
+            if (_icon == icon::warning || _icon == icon::error)
+                flag += "warning";
+            flag += "yesno";
+            if (_choice == choice::yes_no_cancel)
+                flag += "cancel";
+            command.push_back(flag);
+            if (_choice == choice::yes_no || _choice == choice::yes_no_cancel)
+            {
+                m_mappings[0] = button::yes;
+                m_mappings[256] = button::no;
+            }
+        }
+
+        command.push_back(text);
+        command.push_back("--title");
+        command.push_back(title);
+
+        // Must be after the above part
+        if (_choice == choice::ok_cancel)
+            command.insert(command.end(), { "--yes-label", "OK", "--no-label", "Cancel" });
+    }
+
+    if (flags(flag::is_verbose))
+        std::cerr << "pfd: " << command << std::endl;
+
+    m_async->start_process(command);
+#endif
+}
+
+inline button message::result()
+{
+    int exit_code;
+    auto ret = m_async->result(&exit_code);
+    // osascript will say "button returned:Cancel\n"
+    // and others will just say "Cancel\n"
+    if (internal::ends_with(ret, "Cancel\n"))
+        return button::cancel;
+    if (internal::ends_with(ret, "OK\n"))
+        return button::ok;
+    if (internal::ends_with(ret, "Yes\n"))
+        return button::yes;
+    if (internal::ends_with(ret, "No\n"))
+        return button::no;
+    if (internal::ends_with(ret, "Abort\n"))
+        return button::abort;
+    if (internal::ends_with(ret, "Retry\n"))
+        return button::retry;
+    if (internal::ends_with(ret, "Ignore\n"))
+        return button::ignore;
+    if (m_mappings.count(exit_code) != 0)
+        return m_mappings[exit_code];
+    return exit_code == 0 ? button::ok : button::cancel;
+}
+
+// open_file implementation
+
+inline open_file::open_file(std::string const &title,
+                            std::string const &default_path /* = "" */,
+                            std::vector<std::string> const &filters /* = { "All Files", "*" } */,
+                            opt options /* = opt::none */)
+  : file_dialog(type::open, title, default_path, filters, options)
+{
+}
+
+inline open_file::open_file(std::string const &title,
+                            std::string const &default_path,
+                            std::vector<std::string> const &filters,
+                            bool allow_multiselect)
+  : open_file(title, default_path, filters,
+              (allow_multiselect ? opt::multiselect : opt::none))
+{
+}
+
+inline std::vector<std::string> open_file::result()
+{
+    return vector_result();
+}
+
+// save_file implementation
+
+inline save_file::save_file(std::string const &title,
+                            std::string const &default_path /* = "" */,
+                            std::vector<std::string> const &filters /* = { "All Files", "*" } */,
+                            opt options /* = opt::none */)
+  : file_dialog(type::save, title, default_path, filters, options)
+{
+}
+
+inline save_file::save_file(std::string const &title,
+                            std::string const &default_path,
+                            std::vector<std::string> const &filters,
+                            bool confirm_overwrite)
+  : save_file(title, default_path, filters,
+              (confirm_overwrite ? opt::none : opt::force_overwrite))
+{
+}
+
+inline std::string save_file::result()
+{
+    return string_result();
+}
+
+// select_folder implementation
+
+inline select_folder::select_folder(std::string const &title,
+                                    std::string const &default_path /* = "" */,
+                                    opt options /* = opt::none */)
+  : file_dialog(type::folder, title, default_path, {}, options)
+{
+}
+
+inline std::string select_folder::result()
+{
+    return string_result();
+}
+
+#endif // PFD_SKIP_IMPLEMENTATION
+
+} // namespace pfd
\ No newline at end of file