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)
 
 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.
 
@@ -322,11 +322,20 @@ 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 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 is a no-op 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.
+
 #### Others
 
 If you are using another platform abstraction framework, or not using any such framework, you can do the following:
@@ -344,7 +353,7 @@ 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.
+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).  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.
 
 ### Initialization order
 

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,

src/include/nfd_sdl2.h

@@ -34,8 +34,8 @@ endif()
 if(${NFD_BUILD_SDL2_TESTS})
   find_package(PkgConfig REQUIRED)
   pkg_check_modules(SDL2 REQUIRED sdl2 SDL2_ttf)
-  if(WIN32)
-    add_executable(test_sdl2 WIN32 test_sdl.c test_sdl.manifest)
+  if(nfd_PLATFORM STREQUAL PLATFORM_WIN32)
+    add_executable(test_sdl2 WIN32 test_sdl.c test.manifest)
   else()
     add_executable(test_sdl2 test_sdl.c)
   endif()
@@ -44,3 +44,70 @@ if(${NFD_BUILD_SDL2_TESTS})
   target_link_libraries(test_sdl2 PRIVATE ${SDL2_LINK_LIBRARIES})
   target_compile_options(test_sdl2 PUBLIC ${SDL2_CFLAGS_OTHER})
 endif()
+
+if(${NFD_BUILD_GLFW3_TESTS})
+  find_package(PkgConfig REQUIRED)
+  pkg_check_modules(GLFW3 REQUIRED glfw3)
+  if(nfd_PLATFORM STREQUAL PLATFORM_WIN32)
+    add_executable(test_glfw3 WIN32 test_glfw.c test.manifest)
+  else()
+    add_executable(test_glfw3 test_glfw.c)
+  endif()
+  target_link_libraries(test_glfw3 PRIVATE nfd)
+  target_include_directories(test_glfw3 PRIVATE ${GLFW3_INCLUDE_DIRS})
+  target_link_libraries(test_glfw3 PRIVATE ${GLFW3_LINK_LIBRARIES})
+  target_compile_options(test_glfw3 PUBLIC ${GLFW3_CFLAGS_OTHER})
+  if(nfd_PLATFORM STREQUAL PLATFORM_WIN32)
+    target_link_libraries(test_glfw3 PRIVATE opengl32)
+    target_compile_definitions(test_glfw3 PRIVATE GLFW_EXPOSE_NATIVE_WIN32)
+  elseif(nfd_PLATFORM STREQUAL PLATFORM_MACOS)
+    find_package(OpenGL REQUIRED)
+    target_include_directories(test_glfw3 PRIVATE ${OPENGL_INCLUDE_DIRS})
+    target_link_libraries(test_glfw3 PRIVATE ${OPENGL_LIBRARIES})
+    target_compile_definitions(test_glfw3 PRIVATE GLFW_EXPOSE_NATIVE_COCOA)
+    target_compile_definitions(test_glfw3 PRIVATE GL_SILENCE_DEPRECATION) # OpenGL is deprecated on macOS
+  elseif(nfd_PLATFORM STREQUAL PLATFORM_LINUX)
+    pkg_check_modules(OPENGL REQUIRED gl)
+    target_include_directories(test_glfw3 PRIVATE ${OPENGL_INCLUDE_DIRS})
+    target_link_libraries(test_glfw3 PRIVATE ${OPENGL_LINK_LIBRARIES})
+    target_compile_options(test_glfw3 PUBLIC ${OPENGL_CFLAGS_OTHER})
+    if(${NFD_X11})
+      include(CheckCXXSourceCompiles)
+      set(CMAKE_REQUIRED_INCLUDES ${GLFW3_INCLUDE_DIRS})
+      set(CMAKE_REQUIRED_LIBRARIES ${GLFW3_LINK_LIBRARIES})
+      check_cxx_source_compiles(
+        "
+        #define GLFW_EXPOSE_NATIVE_X11
+        #include <GLFW/glfw3.h>
+        #include <GLFW/glfw3native.h>
+        int main() { glfwGetX11Window(nullptr); return 0; }
+        "
+        NFD_GLFW_HAS_X11
+      )
+      unset(CMAKE_REQUIRED_LIBRARIES)
+      unset(CMAKE_REQUIRED_INCLUDES)
+      if(NFD_GLFW_HAS_X11)
+        target_compile_definitions(test_glfw3 PRIVATE GLFW_EXPOSE_NATIVE_X11)
+      endif()
+    endif()
+    if(${NFD_WAYLAND})
+      include(CheckCXXSourceCompiles)
+      set(CMAKE_REQUIRED_INCLUDES ${GLFW3_INCLUDE_DIRS})
+      set(CMAKE_REQUIRED_LIBRARIES ${GLFW3_LINK_LIBRARIES})
+      check_cxx_source_compiles(
+        "
+        #define GLFW_EXPOSE_NATIVE_WAYLAND
+        #include <GLFW/glfw3.h>
+        #include <GLFW/glfw3native.h>
+        int main() { glfwGetWaylandWindow(nullptr); return 0; }
+        "
+        NFD_GLFW_HAS_WAYLAND
+      )
+      unset(CMAKE_REQUIRED_LIBRARIES)
+      unset(CMAKE_REQUIRED_INCLUDES)
+      if(NFD_GLFW_HAS_WAYLAND)
+        target_compile_definitions(test_glfw3 PRIVATE GLFW_EXPOSE_NATIVE_WAYLAND)
+      endif()
+    endif()
+  endif()
+endif()