Add GLFW3 test

Author: btzy

.github/workflows/cmake.yml

@@ -251,6 +251,35 @@ jobs:
           build/src/*
           build/test/*
 
+  build-ubuntu-glfw3:
+
+    name: Ubuntu latest - GCC, ${{ matrix.portal.name }}, ${{ matrix.wayland.name }}, Static, GLFW3
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        portal: [ {flag: OFF, dep: libgtk-3-dev, name: GTK}, {flag: ON, dep: libdbus-1-dev, name: Portal} ] # The NFD_PORTAL setting defaults to OFF (i.e. uses GTK)
+        wayland: [ {flag: OFF, dep: , name: NoWayland}, {flag: ON, dep: libwayland-dev libwayland-bin, name: Wayland} ]
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+      with:
+        submodules: true
+    - name: Install Dependencies
+      run: sudo apt-get update && sudo apt-get install ${{ matrix.portal.dep }} ${{ matrix.wayland.dep }} libglfw3-dev
+    - name: Configure
+      run: mkdir build && mkdir install && cd build && cmake -DCMAKE_INSTALL_PREFIX="../install" -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_FLAGS="-Wall -Wextra -Wshadow -Werror -pedantic" -DCMAKE_CXX_FLAGS="-Wall -Wextra -Wshadow -Werror -pedantic" -DNFD_PORTAL=${{ matrix.portal.flag }} -DNFD_WAYLAND=${{ matrix.wayland.flag }} -DNFD_APPEND_EXTENSION=OFF -DNFD_BUILD_TESTS=OFF -DNFD_BUILD_GLFW3_TESTS=ON ..
+    - name: Build
+      run: cmake --build build --target install
+    - name: Upload test binaries
+      uses: actions/upload-artifact@v4
+      with:
+        name: Ubuntu latest - GCC, ${{ matrix.portal.name }}, ${{ matrix.wayland.name }}, Static, GLFW3
+        path: |
+          build/src/*
+          build/test/*
+
   build-macos-sdl2:
 
     name: MacOS latest - Clang, Static, SDL2
@@ -273,6 +302,28 @@ jobs:
           build/src/*
           build/test/*
 
+  build-macos-glfw3:
+
+    name: MacOS latest - Clang, Static, GLFW3
+    runs-on: macos-latest
+    
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+    - name: Install Dependencies
+      run: brew install glfw
+    - name: Configure
+      run: mkdir build && mkdir install && cd build && cmake -DCMAKE_INSTALL_PREFIX="../install" -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_FLAGS="-Wall -Wextra -Wshadow -Werror -pedantic" -DCMAKE_CXX_FLAGS="-Wall -Wextra -Wshadow -Werror -pedantic" -DNFD_BUILD_TESTS=OFF -DNFD_BUILD_GLFW3_TESTS=ON ..
+    - name: Build
+      run: cmake --build build --target install
+    - name: Upload test binaries
+      uses: actions/upload-artifact@v4
+      with:
+        name: MacOS latest - Clang, Static, GLFW3
+        path: |
+          build/src/*
+          build/test/*
+
   build-windows-sdl2:
 
     name: Windows latest - MSVC, Static, SDL2
@@ -296,3 +347,27 @@ jobs:
         path: |
           build/src/Release/*
           build/test/Release/*
+
+  build-windows-glfw3:
+
+    name: Windows latest - MSVC, Static, GLFW3
+    runs-on: windows-latest
+    
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+    - name: Install pkgconfiglite
+      run: choco install pkgconfiglite
+    - name: Install Dependencies
+      run: vcpkg integrate install && vcpkg install glfw3 --triplet=x64-windows-release
+    - name: Configure
+      run: mkdir build && mkdir install && cd build && cmake -DCMAKE_INSTALL_PREFIX="../install" -DCMAKE_TOOLCHAIN_FILE="C:/vcpkg/scripts/buildsystems/vcpkg.cmake" -DVCPKG_TARGET_TRIPLET="x64-windows-release" -DNFD_BUILD_TESTS=OFF -DNFD_BUILD_GLFW3_TESTS=ON ..
+    - name: Build
+      run: cmake --build build --target install --config Release
+    - name: Upload test binaries
+      uses: actions/upload-artifact@v4
+      with:
+        name: Windows latest - MSVC, Static, GLFW3
+        path: |
+          build/src/Release/*
+          build/test/Release/*

3ps/wayland-protocols

@@ -9,6 +9,7 @@ endif ()
 option(BUILD_SHARED_LIBS "Build a shared library instead of static" OFF)
 option(NFD_BUILD_TESTS "Build tests for nfd" ${nfd_ROOT_PROJECT})
 option(NFD_BUILD_SDL2_TESTS "Build SDL2 tests for nfd" OFF)
+option(NFD_BUILD_GLFW3_TESTS "Build GLFW3 tests for nfd" OFF)
 option(NFD_INSTALL "Generate install target for nfd" ${nfd_ROOT_PROJECT})
 
 set(nfd_PLATFORM Undefined)
@@ -47,6 +48,6 @@ endif()
 
 add_subdirectory(src)
 
-if(${NFD_BUILD_TESTS} OR ${NFD_BUILD_SDL2_TESTS})
+if(${NFD_BUILD_TESTS} OR ${NFD_BUILD_SDL2_TESTS} OR ${NFD_BUILD_GLFW3_TESTS})
   add_subdirectory(test)
 endif()

CMakeLists.txt

@@ -1,7 +1,7 @@
 
 # Native File Dialog Extended
 
-![GitHub Actions](https://github.com/btzy/nativefiledialog-extended/workflows/build/badge.svg)
+![GitHub Actions](https://github.com/btzy/nativefiledialog-extended/workflows/build/badge.svg?branch=master&event=push)
 
 A small C library that portably invokes native file open, folder select and file save dialogs.  Write dialog code once and have it pop up native dialogs on all supported platforms.  Avoid linking large dependencies like wxWidgets and Qt.
 
@@ -298,6 +298,32 @@ Macros that might be defined by `nfd.h`:
 
 NFDe is known to work with SDL2 and GLFW, and should also work with other platform abstraction framworks.  This section explains how to use NFDe properly with such frameworks.
 
+### Initialization order
+
+You should initialize NFDe _after_ initializing the framework, and probably should deinitialize NFDe _before_ deinitializing the framework.  This is because some frameworks expect to be initialized on a "clean slate", and they may configure the system in a different way from NFDe.  `NFD_Init` is generally very careful not to disrupt the existing configuration unless necessary, and `NFD_Quit` restores the configuration back exactly to what it was before initialization.
+
+An example with SDL2:
+
+```
+// Initialize SDL2 first
+if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO) != 0) {
+    // display some error here
+}
+
+// Then initialize NFDe
+if (NFD_Init() != NFD_OKAY) {
+    // display some error here
+}
+
+/*
+Your main program goes here
+*/
+
+NFD_Quit(); // deinitialize NFDe first
+
+SDL_Quit(); // Then deinitialize SDL2
+```
+
 ### Parent window handle
 
 The `parentWindow` argument allows the user to give the dialog a parent.
@@ -308,7 +334,7 @@ Win32 (Windows), Cocoa (macOS), X11 (Linux), and Wayland (Linux) windows are sup
 
 If using SDL2, include `<nfd_sdl2.h>` and do the following:
 
-Call the following function once, after you create your first SDL2 window (usually with `SDL_CreateWindow()`) but before opening any file dialogs, to tell NFDe the `wl_display` your application is using (this is a no-op if your application isn't using Wayland):
+Call the following function once, after you create your first SDL2 window (usually with `SDL_CreateWindow()`) but before opening any file dialogs, to tell NFDe the `wl_display` your application is using (this function does nothing if your application isn't using Wayland):
 ```C
 NFD_SetDisplayPropertiesFromSDLWindow(sdlWindow /* SDL_Window* */);
 ```
@@ -322,16 +348,27 @@ See `test_sdl.c` for an example.
 
 #### GLFW3
 
-If using GLFW3, define the appropriate `GLFW_EXPOSE_NATIVE_*` macros described on the [GLFW native access page](https://www.glfw.org/docs/latest/group__native.html), and then include `<nfd_glfw3.h>` and call the following function to set the parent window handle:
+If using GLFW3, define the appropriate `GLFW_EXPOSE_NATIVE_*` macros as described on the [GLFW native access page](https://www.glfw.org/docs/latest/group__native.html), and then include `<nfd_glfw3.h>` and do the following:
+
+Call the following function once, after `glfwInit()` and `NFD_Init()` but before opening any file dialogs, to tell NFDe the `wl_display` your application is using (this function does nothing if your application isn't using Wayland):
+```C
+NFD_SetDisplayPropertiesFromGLFW();
+```
+
+Each time you want to show a dialog, call the following function to retrieve the parent window handle and set the corresponding argument:
 ```C
 NFD_GetNativeWindowFromGLFWWindow(glfwWindow /* GLFWwindow* */, &args.parentWindow);
 ```
 
+See `test_glfw.c` for an example.
+
+*Note:  GLFW version < 3.4 does not support dynamically selecting a display server at runtime, meaning that it will support either X11 or Wayland, but not both.  Make sure the `GLFW_EXPOSE_NATIVE_*` macros you define are indeed available on your GLFW library.*
+
 #### Others
 
-If you are using another platform abstraction framework, or not using any such framework, you can do the following:
+If using another platform abstraction framework or not using any such framework, do the following:
 
-If you are using Wayland, call the following function once, after connecting to the Wayland compositor (thereby obtaining a `wl_display*`) but before opening any file dialogs:
+Figure out if you are using Wayland in your application code, and if so, call the following function to tell NFDe the `wl_display` you are using:
 ```C
 NFD_SetWaylandDisplay(display /* wl_display* */);
 ```
@@ -344,41 +381,15 @@ To make a window (in this case the file dialog) stay above another window, we ne
 
 #### Why is Wayland special?
 
-Linux has two differences when compared with Windows and macOS: Linux applications open a connection with a display server (X11 or Wayland) to show their windows, and windows are owned by this connection.  It is possible to open multiple connections at the same time (including multiple connections to the same display server), and windows are not shared between those connections.  GTK needs to use a connection opened by itself, and so it opens a new connection if it hasn't previously opened a connection (which will be the case if your application doesn't create its own GTK windows).  Using portals essentially causes the file dialog to be shown by a separate helper process, which also opens its own connection.  In either case, the window handle needs to be passed to a different connection.  On X11, window handles are global identifiers that can be used as-is by another connection, but on Wayland, the handles need to be _exported_ to a string and then _imported_ by the receiving connection, and performing the export operation requires the owner's Wayland display handle.
-
-### Initialization order
-
-You should initialize NFDe _after_ initializing the framework, and probably should deinitialize NFDe _before_ deinitializing the framework.  This is because some frameworks expect to be initialized on a "clean slate", and they may configure the system in a different way from NFDe.  `NFD_Init` is generally very careful not to disrupt the existing configuration unless necessary, and `NFD_Quit` restores the configuration back exactly to what it was before initialization.
-
-An example with SDL2:
-
-```
-// Initialize SDL2 first
-if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO) != 0) {
-    // display some error here
-}
-
-// Then initialize NFDe
-if (NFD_Init() != NFD_OKAY) {
-    // display some error here
-}
-
-/*
-Your main program goes here
-*/
-
-NFD_Quit(); // deinitialize NFDe first
-
-SDL_Quit(); // Then deinitialize SDL2
-```
+Linux has two differences when compared with Windows and macOS: (1) Linux applications open a connection with a display server (X11 or Wayland) to show their windows, and (2) windows are owned by this connection.  It is possible to open multiple connections at the same time (including multiple connections to the same display server), and windows are not shared between those connections.  GTK needs to use a connection opened by itself, and so it opens a new connection if it hasn't previously opened a connection (which will be the case if your application doesn't use GTK on its own).  Portals work by opening the file dialog in a separate helper process, which also opens its own connection.  In either case, the window handle needs to be passed to a different connection.  On X11, window handles are global identifiers that can be used as-is by another connection, but on Wayland, the handles need to be _exported_ to a string and then _imported_ by the receiving connection, and performing the export operation requires the owner's Wayland display handle.
 
 ## Using xdg-desktop-portal on Linux
 
 On Linux, you can use the portal implementation instead of GTK, which will open the "native" file chooser selected by the OS or customized by the user.  The user must have `xdg-desktop-portal` and a suitable backend installed (this comes pre-installed with most common desktop distros), otherwise `NFD_ERROR` will be returned.
 
 To use the portal implementation, add `-DNFD_PORTAL=ON` to the build command.
 
-*Note:  The folder picker is only supported on org.freedesktop.portal.FileChooser interface version >= 3, which corresponds to xdg-desktop-portal version >= 1.7.1.  `NFD_PickFolder()` will query the interface version at runtime, and return `NFD_ERROR` if the version is too low.
+*Note:  The folder picker is only supported on org.freedesktop.portal.FileChooser interface version >= 3, which corresponds to xdg-desktop-portal version >= 1.7.1.  `NFD_PickFolder()` will query the interface version at runtime, and return `NFD_ERROR` if the version is too low.*
 
 ### What is a portal?
 

README.md

@@ -24,16 +24,90 @@ extern "C" {
 #endif  // __cplusplus
 
 /**
- *  Converts a GLFW window handle to a native window handle that can be passed to NFDe.
- *  @param sdlWindow The GLFW window handle.
- *  @param[out] nativeWindow The output native window handle, populated if and only if this function
- *  returns true.
- *  @return Either true to indicate success, or false to indicate failure.  It is intended that
+ * Sets the wayland display if the process is running under Wayland, otherwise does nothing.
+ * @return Either true to indicate success, or false to indicate failure.  If false is returned,
+ * you can call SDL_GetError() for more information.
+ */
+NFD_INLINE bool NFD_SetDisplayPropertiesFromGLFW(void) {
+#if defined(GLFW_EXPOSE_NATIVE_WAYLAND)
+#if defined(GLFW_VERSION_MAJOR) && defined(GLFW_VERSION_MINOR) && \
+    (GLFW_VERSION_MAJOR > 3 || (GLFW_VERSION_MAJOR == 3 && GLFW_VERSION_MINOR >= 4))
+    // GLFW 3.4+ has glfwGetPlatform()
+    const int platform = glfwGetPlatform();
+    if (!platform) {
+        return false;
+    }
+    if (platform != GLFW_PLATFORM_WAYLAND) {
+        return true;
+    }
+    struct wl_display* wayland_display = glfwGetWaylandDisplay();
+    if (!wayland_display) {
+        return false;
+    }
+    return NFD_SetWaylandDisplay(wayland_display) == NFD_OKAY;
+#else
+    const GLFWerrorfun oldCallback = glfwSetErrorCallback(NULL);
+    bool success = true;
+    struct wl_display* wayland_display = glfwGetWaylandDisplay();
+    if (wayland_display) {
+        success = NFD_SetWaylandDisplay(wayland_display) == NFD_OKAY;
+    }
+    glfwSetErrorCallback(oldCallback);
+    return success;
+#endif
+#else
+    return true;
+#endif
+}
+
+/**
+ * Converts a GLFW window handle to a native window handle that can be passed to NFDe.
+ * @param sdlWindow The GLFW window handle.
+ * @param[out] nativeWindow The output native window handle, populated if and only if this function
+ * returns true.
+ * @return Either true to indicate success, or false to indicate failure.  It is intended that
  * users ignore the error and simply pass a value-initialized nfdwindowhandle_t to NFDe if this
  * function fails. */
 NFD_INLINE bool NFD_GetNativeWindowFromGLFWWindow(GLFWwindow* glfwWindow,
                                                   nfdwindowhandle_t* nativeWindow) {
-    GLFWerrorfun oldCallback = glfwSetErrorCallback(NULL);
+#if defined(GLFW_VERSION_MAJOR) && defined(GLFW_VERSION_MINOR) && \
+    (GLFW_VERSION_MAJOR > 3 || (GLFW_VERSION_MAJOR == 3 && GLFW_VERSION_MINOR >= 4))
+    // GLFW 3.4+ has glfwGetPlatform()
+    const int platform = glfwGetPlatform();
+    switch (platform) {
+        case 0:
+            return false;
+#if defined(GLFW_EXPOSE_NATIVE_WIN32)
+        case GLFW_PLATFORM_WIN32:
+            nativeWindow->type = NFD_WINDOW_HANDLE_TYPE_WINDOWS;
+            nativeWindow->handle = (void*)glfwGetWin32Window(glfwWindow);
+            return true;
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_COCOA)
+        case GLFW_PLATFORM_COCOA:
+            nativeWindow->type = NFD_WINDOW_HANDLE_TYPE_COCOA;
+            nativeWindow->handle = (void*)glfwGetCocoaWindow(glfwWindow);
+            return true;
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_X11)
+        case GLFW_PLATFORM_X11:
+            nativeWindow->type = NFD_WINDOW_HANDLE_TYPE_X11;
+            nativeWindow->handle = (void*)glfwGetX11Window(glfwWindow);
+            return true;
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_WAYLAND)
+        case GLFW_PLATFORM_WAYLAND:
+            nativeWindow->type = NFD_WINDOW_HANDLE_TYPE_WAYLAND;
+            nativeWindow->handle = (void*)glfwGetWaylandWindow(glfwWindow);
+            return true;
+#endif
+        default:
+            (void)glfwWindow;
+            (void)nativeWindow;
+            return true;
+    }
+#else
+    const GLFWerrorfun oldCallback = glfwSetErrorCallback(NULL);
     bool success = false;
 #if defined(GLFW_EXPOSE_NATIVE_WIN32)
     if (!success) {
@@ -66,15 +140,18 @@ NFD_INLINE bool NFD_GetNativeWindowFromGLFWWindow(GLFWwindow* glfwWindow,
     }
 #endif
 #if defined(GLFW_EXPOSE_NATIVE_WAYLAND)
-    // For now we don't support Wayland, but we intend to support it eventually.
-    // Silence the warnings.
-    {
-        (void)glfwWindow;
-        (void)nativeWindow;
+    if (!success) {
+        const struct wl_surface* wayland_window = glfwGetWaylandWindow(glfwWindow);
+        if (wayland_window) {
+            nativeWindow->type = NFD_WINDOW_HANDLE_TYPE_WAYLAND;
+            nativeWindow->handle = (void*)wayland_window;
+            success = true;
+        }
     }
 #endif
     glfwSetErrorCallback(oldCallback);
     return success;
+#endif
 }
 
 #undef NFD_INLINE

src/include/nfd_glfw3.h

@@ -26,13 +26,22 @@ extern "C" {
 #define NFD_INLINE static inline
 #endif  // __cplusplus
 
+/**
+ * Sets the wayland display if the process is running under Wayland, otherwise does nothing.
+ * @param sdlWindow The SDL window handle.
+ * @return Either true to indicate success, or false to indicate failure.  If false is returned,
+ * you can call SDL_GetError() for more information.
+ */
 NFD_INLINE bool NFD_SetDisplayPropertiesFromSDLWindow(SDL_Window* sdlWindow) {
 #if defined(SDL_VIDEO_DRIVER_WAYLAND)
     SDL_SysWMinfo info;
     SDL_VERSION(&info.version);
-    if (!SDL_GetWindowWMInfo(sdlWindow, &info) || info.subsystem != SDL_SYSWM_WAYLAND) {
+    if (!SDL_GetWindowWMInfo(sdlWindow, &info)) {
         return false;
     }
+    if (info.subsystem != SDL_SYSWM_WAYLAND) {
+        return true;
+    }
     return NFD_SetWaylandDisplay(info.info.wl.display) == NFD_OKAY;
 #else
     (void)sdlWindow;
@@ -41,11 +50,11 @@ NFD_INLINE bool NFD_SetDisplayPropertiesFromSDLWindow(SDL_Window* sdlWindow) {
 }
 
 /**
- *  Converts an SDL window handle to a native window handle that can be passed to NFDe.
- *  @param sdlWindow The SDL window handle.
- *  @param[out] nativeWindow The output native window handle, populated if and only if this function
- *  returns true.
- *  @return Either true to indicate success, or false to indicate failure.  If false is returned,
+ * Converts an SDL window handle to a native window handle that can be passed to NFDe.
+ * @param sdlWindow The SDL window handle.
+ * @param[out] nativeWindow The output native window handle, populated if and only if this function
+ * returns true.
+ * @return Either true to indicate success, or false to indicate failure.  If false is returned,
  * you can call SDL_GetError() for more information.  However, it is intended that users ignore the
  * error and simply pass a value-initialized nfdwindowhandle_t to NFDe if this function fails. */
 NFD_INLINE bool NFD_GetNativeWindowFromSDLWindow(SDL_Window* sdlWindow,