build(cmake): support external dependency fetching (#9887)

CMakeLists.txt

@@ -23,7 +23,7 @@ if(ESP_PLATFORM)
 elseif(MICROPY_DIR)
   include(${CMAKE_CURRENT_LIST_DIR}/env_support/cmake/micropython.cmake)
 else()
-  include(${CMAKE_CURRENT_LIST_DIR}/env_support/cmake/os_desktop.cmake)
+  include(${CMAKE_CURRENT_LIST_DIR}/env_support/cmake/main.cmake)
 endif()
 
 #[[

docs/src/integration/building/cmake.rst

@@ -171,6 +171,54 @@ To enable the demos and examples set these options:
     set(CONFIG_LV_BUILD_DEMOS ON)
     add_subdirectory(lvgl)
 
+
+.. _dependency_management_cmake:
+
+Dependency Management
+---------------------
+
+When ``LV_BUILD_SET_CONFIG_OPTS`` is enabled, LVGL can automatically resolve, and optionally fetch,
+the dependencies required by the features enabled in ``lv_conf.h``. For example, enabling
+``LV_USE_WAYLAND`` in ``lv_conf.h`` will cause LVGL to find or fetch the Wayland libraries
+automatically.
+
+Dependency resolution is attempted in this order:
+
+1. ``find_package`` — uses CMake's built-in package discovery
+2. ``pkg-config`` — uses the system's pkg-config tool (Linux/macOS)
+3. ``FetchContent`` — fetches and builds the dependency from source
+
+Each strategy can be disabled globally or per dependency. This is particularly useful for
+cross-compilation environments where system libraries should not be used.
+
+Disabling system resolution globally (e.g. for cross-compilation):
+
+.. code-block:: bash
+
+    cmake -DLV_USE_FIND_PACKAGE=OFF -DLV_USE_PKG_CONFIG=OFF ..
+
+Disabling system resolution for a specific dependency only:
+
+.. code-block:: bash
+
+    cmake -DLV_USE_FIND_PACKAGE_FREETYPE=OFF -DLV_USE_PKG_CONFIG_FREETYPE=OFF ..
+
+Disabling automatic fetching from source:
+
+.. code-block:: bash
+
+    cmake -DLV_FETCH_DEPENDENCIES=OFF ..
+
+Fetched dependency sources are cached in the ``.deps`` directory at the root of your project,
+so they are not re-downloaded between builds.
+
+.. note::
+
+    Dependency management requires ``CONFIG_LV_*`` variables to be set (e.g. ``CONFIG_LV_USE_WAYLAND``).
+    These can be set manually via ``-D`` arguments or generated automatically by enabling
+    ``LV_BUILD_SET_CONFIG_OPTS``, which parses ``lv_conf_internal.h`` to derive them.
+
+
 Below is a list of the available options/variables
 
 .. list-table::
@@ -209,6 +257,27 @@ Below is a list of the available options/variables
        ``CONFIG_LV_BUILD_*`` CMake variables based on the contents of ``lv_conf_internal.h``.
        This requires python3 with ``venv`` and ``pip`` or access to a working ``pcpp``.
        If KConfig is used, this is enabled automatically.
+   * - LV_USE_FIND_PACKAGE
+     - BOOLEAN
+     - Allow resolving dependencies via ``find_package``. Enabled by default.
+   * - LV_USE_PKG_CONFIG
+     - BOOLEAN
+     - Allow resolving dependencies via ``pkg-config``. Enabled by default. Requires pkg-config to be installed.
+   * - LV_FETCH_DEPENDENCIES
+     - BOOLEAN
+     - Fetch dependencies from source if not found on the system. Enabled by default.
+   * - LV_USE_FIND_PACKAGE_<DEP>
+     - BOOLEAN
+     - Allow resolving a specific dependency via ``find_package``. Defaults to ``LV_USE_FIND_PACKAGE``.
+       Example: ``LV_USE_FIND_PACKAGE_FREETYPE``.
+   * - LV_USE_PKG_CONFIG_<DEP>
+     - BOOLEAN
+     - Allow resolving a specific dependency via ``pkg-config``. Defaults to ``LV_USE_PKG_CONFIG``.
+       Example: ``LV_USE_PKG_CONFIG_FREETYPE``.
+   * - LV_FETCH_<DEP>
+     - BOOLEAN
+     - Fetch a specific dependency from source. Defaults to ``LV_FETCH_DEPENDENCIES``.
+       Example: ``LV_FETCH_FREETYPE``.
    * - CONFIG_LV_BUILD_DEMOS
      - BOOLEAN
      - When enabled builds the demos

env_support/cmake/dependencies.cmake

@@ -0,0 +1,105 @@
+include(FetchContent)
+
+set(FETCHCONTENT_BASE_DIR
+    "${CMAKE_SOURCE_DIR}/.deps"
+    CACHE PATH "Directory for fetched dependencies" FORCE)
+
+find_package(PkgConfig)
+
+if(UNIX AND NOT PkgConfig_FOUND)
+  message(
+    WARNING
+      "pkg-config not found - system libraries will only be resolved via find_package. "
+      "Install `pkg-config` to improve dependency detection.")
+endif()
+
+# ====== Draw Units ====== #
+if(CONFIG_LV_USE_DRAW_G2D)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/g2d.cmake)
+endif()
+
+if(CONFIG_LV_USE_DRAW_SDL)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/sdl2_image.cmake)
+endif()
+
+# ====== Drivers ====== #
+if(CONFIG_LV_USE_SDL)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/sdl2.cmake)
+endif()
+
+if(CONFIG_LV_USE_LINUX_DRM)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/drm.cmake)
+endif()
+
+if(CONFIG_LV_USE_LINUX_DRM_GBM_BUFFERS OR CONFIG_LV_LINUX_DRM_USE_EGL)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/gbm.cmake)
+endif()
+
+if(CONFIG_LV_USE_WAYLAND)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/wayland.cmake)
+endif()
+
+if(CONFIG_LV_USE_X11)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/x11.cmake)
+endif()
+
+if(CONFIG_LV_USE_GLFW)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/glfw.cmake)
+endif()
+
+# ====== Indev ====== #
+if(CONFIG_LV_USE_WAYLAND OR CONFIG_LV_USE_LIBINPUT)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/xkbcommon.cmake)
+endif()
+
+if(CONFIG_LV_USE_EVDEV)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/evdev.cmake)
+endif()
+
+if(CONFIG_LV_USE_LIBINPUT)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/libinput.cmake)
+endif()
+
+# ====== Image ====== #
+if(CONFIG_LV_USE_LIBWEBP OR CONFIG_LV_USE_GLTF)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/webp.cmake)
+endif()
+
+# ====== Video ====== #
+if(CONFIG_LV_USE_GSTREAMER)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/gstreamer.cmake)
+endif()
+
+if(CONFIG_LV_USE_FFMPEG)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/ffmpeg.cmake)
+endif()
+
+# ====== Image ====== #
+if(CONFIG_LV_USE_LIBJPEG_TURBO)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/jpeg.cmake)
+endif()
+
+if(CONFIG_LV_USE_LIBPNG)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/png.cmake)
+endif()
+
+# ====== Font ====== #
+if(CONFIG_LV_USE_FREETYPE)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/freetype.cmake)
+endif()
+
+# ====== Libraries ====== #
+if(CONFIG_LV_USE_GLTF)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/fastgltf.cmake)
+endif()
+
+# ====== External Demos  ====== #
+if(CONFIG_LV_USE_DEMO_FLEX_LAYOUT
+   OR CONFIG_LV_USE_DEMO_MULTILANG
+   OR CONFIG_LV_USE_DEMO_TRANSFORM
+   OR CONFIG_LV_USE_DEMO_SCROLL
+   OR CONFIG_LV_USE_DEMO_EBIKE
+   OR CONFIG_LV_USE_DEMO_HIGH_RES
+   OR CONFIG_LV_USE_DEMO_SMARTWATCH)
+  include(${CMAKE_CURRENT_LIST_DIR}/dependencies/lv_demos_ext.cmake)
+endif()

env_support/cmake/dependencies/drm.cmake

@@ -0,0 +1,24 @@
+option(LV_USE_FIND_PACKAGE_LIBDRM "Resolve libdrm via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_LIBDRM "Resolve libdrm via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+
+if(LV_USE_FIND_PACKAGE_LIBDRM)
+  find_package(libdrm QUIET)
+  if(libdrm_FOUND)
+    message(STATUS "lvgl: libdrm: found via find_package")
+    target_link_libraries(lvgl PRIVATE libdrm::libdrm)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_LIBDRM AND PkgConfig_FOUND)
+  pkg_check_modules(LIBDRM IMPORTED_TARGET QUIET libdrm)
+  if(LIBDRM_FOUND)
+    message(STATUS "lvgl: libdrm: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::LIBDRM)
+    return()
+  endif()
+endif()
+
+message(FATAL_ERROR "lvgl: libdrm not found. Please install libdrm.")

env_support/cmake/dependencies/evdev.cmake

@@ -0,0 +1,24 @@
+option(LV_USE_FIND_PACKAGE_EVDEV "Resolve libevdev via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_EVDEV "Resolve libevdev via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+
+if(LV_USE_FIND_PACKAGE_EVDEV)
+  find_package(evdev QUIET)
+  if(evdev_FOUND)
+    message(STATUS "lvgl: evdev: found via find_package")
+    target_link_libraries(lvgl PRIVATE evdev::evdev)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_EVDEV AND PkgConfig_FOUND)
+  pkg_check_modules(EVDEV IMPORTED_TARGET QUIET libevdev)
+  if(EVDEV_FOUND)
+    message(STATUS "lvgl: evdev: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::EVDEV)
+    return()
+  endif()
+endif()
+
+message(FATAL_ERROR "lvgl: libevdev not found. Please install libevdev.")

env_support/cmake/dependencies/fastgltf.cmake

@@ -0,0 +1,54 @@
+option(LV_USE_FIND_PACKAGE_FASTGLTF "Resolve fastgltf via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_FASTGLTF "Resolve fastgltf via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+option(LV_FETCH_FASTGLTF "Fetch fastgltf from source" ${LV_FETCH_DEPENDENCIES})
+
+if(LV_USE_FIND_PACKAGE_FASTGLTF)
+  find_package(fastgltf QUIET)
+  if(fastgltf_FOUND)
+    message(STATUS "lvgl: fastgltf: found via find_package")
+    target_link_libraries(lvgl PRIVATE fastgltf::fastgltf)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_FASTGLTF AND PkgConfig_FOUND)
+  pkg_check_modules(fastgltf IMPORTED_TARGET QUIET fastgltf)
+  if(fastgltf_FOUND)
+    message(STATUS "lvgl: fastgltf: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::fastgltf)
+    return()
+  endif()
+endif()
+
+if(NOT LV_FETCH_FASTGLTF)
+  message(
+    FATAL_ERROR
+      "lvgl: fastgltf not found. Enable LV_FETCH_FASTGLTF or install it manually."
+  )
+endif()
+
+message(STATUS "lvgl: fastgltf: fetching from source")
+
+FetchContent_Declare(
+  fastgltf
+  GIT_REPOSITORY https://github.com/spnda/fastgltf
+  GIT_TAG f04052ebd8d157c7b6e8fc3dd9f1ed83df99f3e5)
+
+set(FASTGLTF_BUILD_TESTS
+    OFF
+    CACHE BOOL "" FORCE)
+set(FASTGLTF_BUILD_EXAMPLES
+    OFF
+    CACHE BOOL "" FORCE)
+set(FASTGLTF_ENABLE_DEPRECATED_EXT
+    ON
+    CACHE BOOL "" FORCE)
+set(FASTGLTF_DIFFUSE_TRANSMISSION_SUPPORT
+    ON
+    CACHE BOOL "" FORCE)
+
+FetchContent_MakeAvailable(fastgltf)
+
+target_link_libraries(lvgl PRIVATE fastgltf::fastgltf)

env_support/cmake/dependencies/ffmpeg.cmake

@@ -0,0 +1,34 @@
+option(LV_USE_FIND_PACKAGE_FFMPEG "Resolve FFmpeg via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_FFMPEG "Resolve FFmpeg via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+
+if(LV_USE_FIND_PACKAGE_FFMPEG)
+  find_package(FFmpeg QUIET)
+  if(FFmpeg_FOUND)
+    message(STATUS "lvgl: FFmpeg: found via find_package")
+    target_link_libraries(lvgl PRIVATE FFmpeg::FFmpeg)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_FFMPEG AND PkgConfig_FOUND)
+  pkg_check_modules(AVFORMAT IMPORTED_TARGET QUIET libavformat)
+  pkg_check_modules(AVCODEC IMPORTED_TARGET QUIET libavcodec)
+  pkg_check_modules(AVUTIL IMPORTED_TARGET QUIET libavutil)
+  pkg_check_modules(SWSCALE IMPORTED_TARGET QUIET libswscale)
+  if(AVFORMAT_FOUND
+     AND AVCODEC_FOUND
+     AND AVUTIL_FOUND
+     AND SWSCALE_FOUND)
+    message(STATUS "lvgl: FFmpeg: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::AVFORMAT PkgConfig::AVCODEC
+                                       PkgConfig::AVUTIL PkgConfig::SWSCALE)
+    return()
+  endif()
+endif()
+
+message(
+  FATAL_ERROR
+    "lvgl: FFmpeg not found. Please install libavformat, libavcodec, libavutil and libswscale."
+)

env_support/cmake/dependencies/freetype.cmake

@@ -0,0 +1,59 @@
+option(LV_USE_FIND_PACKAGE_FREETYPE "Resolve Freetype via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_FREETYPE "Resolve Freetype via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+option(LV_FETCH_FREETYPE "Fetch Freetype from source" ${LV_FETCH_DEPENDENCIES})
+
+if(LV_USE_FIND_PACKAGE_FREETYPE)
+  find_package(Freetype QUIET)
+  if(Freetype_FOUND)
+    message(STATUS "lvgl: Freetype: found via find_package")
+    target_link_libraries(lvgl PRIVATE Freetype::Freetype)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_FREETYPE AND PkgConfig_FOUND)
+  pkg_check_modules(LIBFREETYPE IMPORTED_TARGET QUIET freetype2)
+  if(LIBFREETYPE_FOUND)
+    message(STATUS "lvgl: Freetype: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::LIBFREETYPE)
+    return()
+  endif()
+endif()
+
+if(NOT LV_FETCH_FREETYPE)
+  message(
+    FATAL_ERROR
+      "lvgl: Freetype not found. Enable LV_FETCH_FREETYPE or install it manually."
+  )
+endif()
+
+message(STATUS "lvgl: Freetype: fetching from source")
+FetchContent_Declare(
+  freetype
+  GIT_REPOSITORY https://gitlab.freedesktop.org/freetype/freetype.git
+  GIT_TAG VER-2-14-3)
+
+set(FT_DISABLE_ZLIB
+    OFF
+    CACHE BOOL "" FORCE)
+set(FT_DISABLE_BZIP2
+    ON
+    CACHE BOOL "" FORCE)
+set(FT_DISABLE_PNG
+    ON
+    CACHE BOOL "" FORCE)
+set(FT_DISABLE_HARFBUZZ
+    ON
+    CACHE BOOL "" FORCE)
+set(FT_DISABLE_BROTLI
+    ON
+    CACHE BOOL "" FORCE)
+set(FT_WITH_ZLIB
+    ON
+    CACHE BOOL "" FORCE)
+
+FetchContent_MakeAvailable(freetype)
+
+target_link_libraries(lvgl PRIVATE freetype)

env_support/cmake/dependencies/g2d.cmake

@@ -0,0 +1,12 @@
+find_library(G2D_LIBRARY NAMES g2d QUIET)
+find_path(G2D_INCLUDE_DIR NAMES g2d.h g2dExt.h QUIET)
+
+if(G2D_LIBRARY AND G2D_INCLUDE_DIR)
+  message(STATUS "lvgl: G2D: found at ${G2D_LIBRARY}")
+  target_link_libraries(lvgl PRIVATE ${G2D_LIBRARY})
+  target_include_directories(lvgl PRIVATE ${G2D_INCLUDE_DIR})
+  return()
+endif()
+
+message(FATAL_ERROR "lvgl: G2D not found. " "G2D_LIBRARY=${G2D_LIBRARY} "
+                    "G2D_INCLUDE_DIR=${G2D_INCLUDE_DIR}")

env_support/cmake/dependencies/gbm.cmake

@@ -0,0 +1,23 @@
+option(LV_USE_FIND_PACKAGE_GBM "Resolve gbm via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_GBM "Resolve gbm via pkg-config" ${LV_USE_PKG_CONFIG})
+
+if(LV_USE_FIND_PACKAGE_GBM)
+  find_package(gbm QUIET)
+  if(gbm_FOUND)
+    message(STATUS "lvgl: gbm: found via find_package")
+    target_link_libraries(lvgl PRIVATE gbm::gbm)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_GBM AND PkgConfig_FOUND)
+  pkg_check_modules(LIBGBM IMPORTED_TARGET QUIET gbm)
+  if(LIBGBM_FOUND)
+    message(STATUS "lvgl: gbm: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::LIBGBM)
+    return()
+  endif()
+endif()
+
+message(FATAL_ERROR "lvgl: gbm not found. Please install gbm.")

env_support/cmake/dependencies/glfw.cmake

@@ -0,0 +1,49 @@
+option(LV_USE_FIND_PACKAGE_GLFW "Resolve GLFW via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_GLFW "Resolve GLFW via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+option(LV_FETCH_GLFW "Fetch GLFW from source" ${LV_FETCH_DEPENDENCIES})
+
+if(LV_USE_FIND_PACKAGE_GLFW)
+  find_package(glfw3 QUIET)
+  if(glfw3_FOUND)
+    message(STATUS "lvgl: GLFW: found via find_package")
+    target_link_libraries(lvgl PRIVATE glfw)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_GLFW AND PkgConfig_FOUND)
+  pkg_check_modules(GLFW3 IMPORTED_TARGET QUIET glfw3)
+  if(GLFW3_FOUND)
+    message(STATUS "lvgl: GLFW: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::GLFW3)
+    return()
+  endif()
+endif()
+
+if(NOT LV_FETCH_GLFW)
+  message(
+    FATAL_ERROR
+      "lvgl: GLFW not found. Enable LV_FETCH_GLFW or install libglfw3 manually."
+  )
+endif()
+
+message(STATUS "lvgl: GLFW: fetching from source")
+FetchContent_Declare(
+  glfw
+  GIT_REPOSITORY https://github.com/glfw/glfw
+  GIT_TAG 3.4)
+
+set(GLFW_BUILD_DOCS
+    OFF
+    CACHE BOOL "" FORCE)
+set(GLFW_BUILD_TESTS
+    OFF
+    CACHE BOOL "" FORCE)
+set(GLFW_BUILD_EXAMPLES
+    OFF
+    CACHE BOOL "" FORCE)
+
+FetchContent_MakeAvailable(glfw)
+target_link_libraries(lvgl PRIVATE glfw)

env_support/cmake/dependencies/gstreamer.cmake

@@ -0,0 +1,38 @@
+option(LV_USE_FIND_PACKAGE_GSTREAMER "Resolve GStreamer via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_GSTREAMER "Resolve GStreamer via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+
+if(LV_USE_FIND_PACKAGE_GSTREAMER)
+  find_package(GStreamer QUIET COMPONENTS gstreamer gstreamer-video
+                                          gstreamer-app)
+  if(GStreamer_FOUND
+     AND GStreamer_gstreamer-video_FOUND
+     AND GStreamer_gstreamer-app_FOUND)
+    message(STATUS "lvgl: GStreamer: found via find_package")
+    target_link_libraries(
+      lvgl PRIVATE GStreamer::gstreamer GStreamer::gstreamer-video
+                   GStreamer::gstreamer-app)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_GSTREAMER AND PkgConfig_FOUND)
+  pkg_check_modules(GSTREAMER IMPORTED_TARGET QUIET gstreamer-1.0)
+  pkg_check_modules(GSTREAMER_VIDEO IMPORTED_TARGET QUIET gstreamer-video-1.0)
+  pkg_check_modules(GSTREAMER_APP IMPORTED_TARGET QUIET gstreamer-app-1.0)
+  if(GSTREAMER_FOUND
+     AND GSTREAMER_VIDEO_FOUND
+     AND GSTREAMER_APP_FOUND)
+    message(STATUS "lvgl: GStreamer: found via pkg-config")
+    target_link_libraries(
+      lvgl PRIVATE PkgConfig::GSTREAMER PkgConfig::GSTREAMER_VIDEO
+                   PkgConfig::GSTREAMER_APP)
+    return()
+  endif()
+endif()
+
+message(
+  FATAL_ERROR
+    "lvgl: GStreamer not found. Please install gstreamer-1.0, gstreamer-video-1.0 and gstreamer-app-1.0."
+)

env_support/cmake/dependencies/jpeg.cmake

@@ -0,0 +1,54 @@
+option(LV_USE_FIND_PACKAGE_JPEG "Resolve libjpeg via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_JPEG "Resolve libjpeg via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+option(LV_FETCH_JPEG "Fetch libjpeg-turbo from source" ${LV_FETCH_DEPENDENCIES})
+
+if(LV_USE_FIND_PACKAGE_JPEG)
+  find_package(JPEG QUIET)
+  if(JPEG_FOUND)
+    message(STATUS "lvgl: libjpeg: found via find_package")
+    target_link_libraries(lvgl PRIVATE JPEG::JPEG)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_JPEG AND PkgConfig_FOUND)
+  pkg_check_modules(LIBJPEG IMPORTED_TARGET QUIET libjpeg)
+  if(LIBJPEG_FOUND)
+    message(STATUS "lvgl: libjpeg: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::LIBJPEG)
+    return()
+  endif()
+endif()
+
+if(NOT LV_FETCH_JPEG)
+  message(
+    FATAL_ERROR
+      "lvgl: libjpeg not found. Enable LV_FETCH_JPEG or install it manually.")
+endif()
+
+message(STATUS "lvgl: libjpeg-turbo: fetching from source")
+FetchContent_Declare(
+  libjpeg-turbo
+  GIT_REPOSITORY https://github.com/libjpeg-turbo/libjpeg-turbo
+  GIT_TAG 3.1.0)
+
+set(ENABLE_SHARED
+    OFF
+    CACHE BOOL "" FORCE)
+set(ENABLE_STATIC
+    ON
+    CACHE BOOL "" FORCE)
+set(WITH_TURBOJPEG
+    OFF
+    CACHE BOOL "" FORCE)
+set(WITH_JAVA
+    OFF
+    CACHE BOOL "" FORCE)
+set(WITH_CRT_DLL
+    OFF
+    CACHE BOOL "" FORCE)
+
+FetchContent_MakeAvailable(libjpeg-turbo)
+target_link_libraries(lvgl PRIVATE jpeg-static)

env_support/cmake/dependencies/libinput.cmake

@@ -0,0 +1,24 @@
+option(LV_USE_FIND_PACKAGE_LIBINPUT "Resolve libinput via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_LIBINPUT "Resolve libinput via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+
+if(LV_USE_FIND_PACKAGE_LIBINPUT)
+  find_package(libinput QUIET)
+  if(libinput_FOUND)
+    message(STATUS "lvgl: libinput: found via find_package")
+    target_link_libraries(lvgl PRIVATE libinput::libinput)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_LIBINPUT AND PkgConfig_FOUND)
+  pkg_check_modules(LIBINPUT IMPORTED_TARGET QUIET libinput)
+  if(LIBINPUT_FOUND)
+    message(STATUS "lvgl: libinput: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::LIBINPUT)
+    return()
+  endif()
+endif()
+
+message(FATAL_ERROR "lvgl: libinput not found. Please install libinput.")

env_support/cmake/dependencies/lv_demos_ext.cmake

@@ -0,0 +1,15 @@
+option(LV_FETCH_LV_DEMOS "Fetch external lv_demos automatically"
+       ${LV_FETCH_DEPENDENCIES})
+
+if(NOT LV_FETCH_LV_DEMOS)
+  return()
+endif()
+
+message(STATUS "lvgl: lv_demos_ext: fetching from source")
+
+FetchContent_Declare(
+  lv_demos_ext
+  GIT_REPOSITORY https://github.com/lvgl/lv_demos
+  GIT_TAG 3d75ca15bae4d4b58b32ab11e20f8c78e61dc5f9)
+
+FetchContent_MakeAvailable(lv_demos_ext)

env_support/cmake/dependencies/png.cmake

@@ -0,0 +1,54 @@
+option(LV_USE_FIND_PACKAGE_PNG "Resolve libpng via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_PNG "Resolve libpng via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+option(LV_FETCH_PNG "Fetch libpng from source" ${LV_FETCH_DEPENDENCIES})
+
+if(LV_USE_FIND_PACKAGE_PNG)
+  find_package(PNG QUIET)
+  if(PNG_FOUND)
+    message(STATUS "lvgl: libpng: found via find_package")
+    target_link_libraries(lvgl PRIVATE PNG::PNG)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_PNG AND PkgConfig_FOUND)
+  pkg_check_modules(LIBPNG IMPORTED_TARGET QUIET libpng)
+  if(LIBPNG_FOUND)
+    message(STATUS "lvgl: libpng: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::LIBPNG)
+    return()
+  endif()
+endif()
+
+if(NOT LV_FETCH_PNG)
+  message(
+    FATAL_ERROR
+      "lvgl: libpng not found. Enable LV_FETCH_PNG or install it manually.")
+endif()
+
+message(STATUS "lvgl: libpng: fetching from source")
+message(STATUS "lvgl: libpng: zlib is required, resolving it first")
+include("${CMAKE_CURRENT_LIST_DIR}/zlib.cmake")
+
+FetchContent_Declare(
+  libpng
+  GIT_REPOSITORY https://github.com/pnggroup/libpng
+  GIT_TAG v1.6.47)
+
+set(PNG_SHARED
+    OFF
+    CACHE BOOL "" FORCE)
+set(PNG_STATIC
+    ON
+    CACHE BOOL "" FORCE)
+set(PNG_TESTS
+    OFF
+    CACHE BOOL "" FORCE)
+set(PNG_TOOLS
+    OFF
+    CACHE BOOL "" FORCE)
+
+FetchContent_MakeAvailable(libpng)
+target_link_libraries(lvgl PRIVATE png_static)

env_support/cmake/dependencies/sdl2.cmake

@@ -0,0 +1,82 @@
+option(LV_USE_FIND_PACKAGE_SDL2 "Resolve SDL2 via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_SDL2 "Resolve SDL2 via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+option(LV_FETCH_SDL2 "Fetch SDL2 from source" ${LV_FETCH_DEPENDENCIES})
+
+if(LV_USE_FIND_PACKAGE_SDL2)
+  find_package(SDL2 QUIET)
+  if(SDL2_FOUND AND TARGET SDL2::SDL2)
+    message(STATUS "lvgl: SDL2: found via find_package")
+    target_link_libraries(lvgl PRIVATE SDL2::SDL2)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_SDL2 AND PkgConfig_FOUND)
+  pkg_check_modules(SDL2 IMPORTED_TARGET QUIET sdl2)
+  if(SDL2_FOUND)
+    message(STATUS "lvgl: SDL2: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::SDL2)
+    return()
+  endif()
+endif()
+
+if(NOT LV_FETCH_SDL2)
+  message(
+    FATAL_ERROR
+      "lvgl: SDL2 not found. Enable LV_FETCH_SDL2 or install libsdl2 manually.")
+endif()
+
+message(STATUS "lvgl: SDL2: fetching from source")
+FetchContent_Declare(
+  SDL2
+  GIT_REPOSITORY https://github.com/libsdl-org/SDL
+  GIT_TAG release-2.30.11)
+
+set(SDL_OPENGLES
+    ON
+    CACHE BOOL "" FORCE)
+set(SDL_STATIC
+    ON
+    CACHE BOOL "" FORCE)
+set(SDL_X11
+    ON
+    CACHE BOOL "" FORCE)
+set(SDL_WAYLAND
+    ON
+    CACHE BOOL "" FORCE)
+set(SDL_KMSDRM
+    ON
+    CACHE BOOL "" FORCE)
+
+set(SDL_SHARED
+    OFF
+    CACHE BOOL "" FORCE)
+set(SDL_TEST
+    OFF
+    CACHE BOOL "" FORCE)
+set(SDL_ALSA
+    OFF
+    CACHE BOOL "" FORCE)
+set(SDL_PULSEAUDIO
+    OFF
+    CACHE BOOL "" FORCE)
+set(SDL_JACK
+    OFF
+    CACHE BOOL "" FORCE)
+set(SDL_OFFSCREEN
+    OFF
+    CACHE BOOL "" FORCE)
+set(SDL_OPENGL
+    OFF
+    CACHE BOOL "" FORCE)
+set(SDL_VULKAN
+    OFF
+    CACHE BOOL "" FORCE)
+set(SDL_DBUS
+    OFF
+    CACHE BOOL "" FORCE)
+
+FetchContent_MakeAvailable(SDL2)
+target_link_libraries(lvgl PRIVATE SDL2::SDL2-static)

env_support/cmake/dependencies/sdl2_image.cmake

@@ -0,0 +1,50 @@
+option(LV_USE_FIND_PACKAGE_SDL2_IMAGE "Resolve SDL2_image via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_SDL2_IMAGE "Resolve SDL2_image via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+option(LV_FETCH_SDL2_IMAGE "Fetch SDL2_image from source"
+       ${LV_FETCH_DEPENDENCIES})
+
+if(LV_USE_FIND_PACKAGE_SDL2_IMAGE)
+  find_package(SDL2_image QUIET)
+  if(SDL2_image_FOUND AND TARGET SDL2::SDL2_image)
+    message(STATUS "lvgl: SDL2_image: found via find_package")
+    target_link_libraries(lvgl PRIVATE SDL2::SDL2_image)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_SDL2_IMAGE AND PkgConfig_FOUND)
+  pkg_check_modules(SDL2_IMAGE IMPORTED_TARGET QUIET SDL2_image)
+  if(SDL2_IMAGE_FOUND)
+    message(STATUS "lvgl: SDL2_image: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::SDL2_IMAGE)
+    return()
+  endif()
+endif()
+
+if(NOT LV_FETCH_SDL2_IMAGE)
+  message(
+    FATAL_ERROR
+      "lvgl: SDL2_image not found. Enable LV_FETCH_SDL2_IMAGE or install libsdl2-image manually."
+  )
+endif()
+
+message(STATUS "lvgl: SDL2_image: fetching from source")
+FetchContent_Declare(
+  SDL2_image
+  GIT_REPOSITORY https://github.com/libsdl-org/SDL_image
+  GIT_TAG release-2.8.4)
+
+set(SDL2IMAGE_SAMPLES
+    OFF
+    CACHE BOOL "" FORCE)
+set(SDL2IMAGE_TESTS
+    OFF
+    CACHE BOOL "" FORCE)
+set(SDL2IMAGE_INSTALL
+    OFF
+    CACHE BOOL "" FORCE)
+
+FetchContent_MakeAvailable(SDL2_image)
+target_link_libraries(lvgl PRIVATE SDL2_image::SDL2_image-static)

env_support/cmake/dependencies/wayland.cmake

@@ -0,0 +1,167 @@
+option(LV_USE_FIND_PACKAGE_WAYLAND "Resolve Wayland via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_WAYLAND "Resolve Wayland via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+
+if(LV_USE_FIND_PACKAGE_WAYLAND)
+  find_package(Wayland QUIET)
+  if(Wayland_FOUND)
+    message(STATUS "lvgl: Wayland: found via find_package")
+    set(WAYLAND_CLIENT_LIBRARIES Wayland::Client)
+    set(WAYLAND_CURSOR_LIBRARIES Wayland::Cursor)
+  endif()
+endif()
+
+if(NOT Wayland_FOUND
+   AND LV_USE_PKG_CONFIG_WAYLAND
+   AND PkgConfig_FOUND)
+  pkg_check_modules(WAYLAND_CLIENT IMPORTED_TARGET QUIET wayland-client)
+  pkg_check_modules(WAYLAND_CURSOR IMPORTED_TARGET QUIET wayland-cursor)
+  pkg_check_modules(WAYLAND_PROTOCOLS QUIET wayland-protocols>=1.20)
+  if(WAYLAND_CLIENT_FOUND AND WAYLAND_CURSOR_FOUND)
+    message(STATUS "lvgl: Wayland: found via pkg-config")
+    set(WAYLAND_CLIENT_LIBRARIES PkgConfig::WAYLAND_CLIENT)
+    set(WAYLAND_CURSOR_LIBRARIES PkgConfig::WAYLAND_CURSOR)
+  else()
+    message(
+      FATAL_ERROR
+        "lvgl: Wayland not found. Please install wayland-client and wayland-cursor."
+    )
+  endif()
+endif()
+
+if(NOT Wayland_FOUND AND NOT WAYLAND_CLIENT_FOUND)
+  message(
+    FATAL_ERROR
+      "lvgl: Wayland not found. Please install wayland-client and wayland-cursor."
+  )
+endif()
+
+find_program(WAYLAND_SCANNER wayland-scanner REQUIRED)
+
+include(${CMAKE_CURRENT_LIST_DIR}/xkbcommon.cmake)
+
+# EGL
+if(CONFIG_LV_WAYLAND_USE_EGL)
+  if(LV_USE_PKG_CONFIG_WAYLAND AND PkgConfig_FOUND)
+    pkg_check_modules(WAYLAND_EGL IMPORTED_TARGET QUIET wayland-egl)
+    if(WAYLAND_EGL_FOUND)
+      message(STATUS "lvgl: Wayland EGL: found via pkg-config")
+      set(WAYLAND_EGL_LIBRARIES PkgConfig::WAYLAND_EGL)
+    else()
+      message(
+        FATAL_ERROR "lvgl: wayland-egl not found. Please install wayland-egl.")
+    endif()
+  else()
+    message(
+      FATAL_ERROR "lvgl: wayland-egl not found and PkgConfig unavailable.")
+  endif()
+endif()
+
+# Protocol root resolution
+if(DEFINED ENV{SDKTARGETSYSROOT} AND DEFINED ENV{SYSROOT})
+  message(
+    FATAL_ERROR
+      "Both SDKTARGETSYSROOT and SYSROOT are set. Please set only one.")
+endif()
+
+if(DEFINED ENV{SDKTARGETSYSROOT})
+  set(PROTOCOL_ROOT "$ENV{SDKTARGETSYSROOT}/usr/share/wayland-protocols")
+elseif(DEFINED ENV{SYSROOT})
+  set(PROTOCOL_ROOT "$ENV{SYSROOT}/usr/share/wayland-protocols")
+else()
+  set(PROTOCOL_ROOT "/usr/share/wayland-protocols")
+endif()
+
+if(NOT EXISTS ${PROTOCOL_ROOT})
+  message(FATAL_ERROR "lvgl: Wayland protocols not found at ${PROTOCOL_ROOT}")
+endif()
+
+set(PROTOCOLS_DIR "${CMAKE_CURRENT_BINARY_DIR}/wayland-protocols")
+file(MAKE_DIRECTORY ${PROTOCOLS_DIR})
+message(STATUS "lvgl: Wayland protocol directory: ${PROTOCOLS_DIR}")
+
+if(BUILD_SHARED_LIBS)
+  set(WAYLAND_SCANNER_CODE_MODE "public-code")
+else()
+  set(WAYLAND_SCANNER_CODE_MODE "private-code")
+endif()
+
+# xdg-shell (always)
+set(XDG_SHELL_XML "${PROTOCOL_ROOT}/stable/xdg-shell/xdg-shell.xml")
+set(XDG_SHELL_HEADER "${PROTOCOLS_DIR}/wayland_xdg_shell.h")
+set(XDG_SHELL_SOURCE "${PROTOCOLS_DIR}/wayland_xdg_shell.c")
+
+if(NOT EXISTS ${XDG_SHELL_HEADER} OR NOT EXISTS ${XDG_SHELL_SOURCE})
+  execute_process(
+    COMMAND wayland-scanner client-header ${XDG_SHELL_XML} ${XDG_SHELL_HEADER}
+    RESULT_VARIABLE XDG_SHELL_HEADER_RESULT
+    ERROR_VARIABLE XDG_SHELL_HEADER_ERROR)
+  if(NOT XDG_SHELL_HEADER_RESULT EQUAL 0)
+    message(
+      FATAL_ERROR
+        "lvgl: wayland-scanner failed to generate xdg-shell header: ${XDG_SHELL_HEADER_ERROR}"
+    )
+  endif()
+
+  execute_process(
+    COMMAND wayland-scanner ${WAYLAND_SCANNER_CODE_MODE} ${XDG_SHELL_XML}
+            ${XDG_SHELL_SOURCE}
+    RESULT_VARIABLE XDG_SHELL_SOURCE_RESULT
+    ERROR_VARIABLE XDG_SHELL_SOURCE_ERROR)
+  if(NOT XDG_SHELL_SOURCE_RESULT EQUAL 0)
+    message(
+      FATAL_ERROR
+        "lvgl: wayland-scanner failed to generate xdg-shell source: ${XDG_SHELL_SOURCE_ERROR}"
+    )
+  endif()
+endif()
+
+set(WAYLAND_PROTOCOL_SOURCES ${XDG_SHELL_SOURCE})
+
+# dmabuf (optional)
+if(CONFIG_LV_WAYLAND_USE_G2D)
+  set(DMABUF_XML "${PROTOCOL_ROOT}/stable/linux-dmabuf/linux-dmabuf-v1.xml")
+  set(DMABUF_HEADER "${PROTOCOLS_DIR}/wayland_linux_dmabuf.h")
+  set(DMABUF_SOURCE "${PROTOCOLS_DIR}/wayland_linux_dmabuf.c")
+
+  if(NOT EXISTS ${DMABUF_HEADER} OR NOT EXISTS ${DMABUF_SOURCE})
+    execute_process(
+      COMMAND wayland-scanner client-header ${DMABUF_XML} ${DMABUF_HEADER}
+      RESULT_VARIABLE DMABUF_HEADER_RESULT
+      ERROR_VARIABLE DMABUF_HEADER_ERROR)
+    if(NOT DMABUF_HEADER_RESULT EQUAL 0)
+      message(
+        FATAL_ERROR
+          "lvgl: wayland-scanner failed to generate dmabuf header: ${DMABUF_HEADER_ERROR}"
+      )
+    endif()
+
+    execute_process(
+      COMMAND wayland-scanner ${WAYLAND_SCANNER_CODE_MODE} ${DMABUF_XML}
+              ${DMABUF_SOURCE}
+      RESULT_VARIABLE DMABUF_SOURCE_RESULT
+      ERROR_VARIABLE DMABUF_SOURCE_ERROR)
+    if(NOT DMABUF_SOURCE_RESULT EQUAL 0)
+      message(
+        FATAL_ERROR
+          "lvgl: wayland-scanner failed to generate dmabuf source: ${DMABUF_SOURCE_ERROR}"
+      )
+    endif()
+  endif()
+
+  list(APPEND WAYLAND_PROTOCOL_SOURCES ${DMABUF_SOURCE})
+endif()
+
+# Protocol library
+add_library(lv_wayland_protocols ${WAYLAND_PROTOCOL_SOURCES})
+target_include_directories(lv_wayland_protocols PUBLIC ${PROTOCOLS_DIR})
+
+# Link lvgl
+target_link_libraries(
+  lvgl PRIVATE lv_wayland_protocols ${WAYLAND_CLIENT_LIBRARIES}
+               ${WAYLAND_CURSOR_LIBRARIES})
+
+if(CONFIG_LV_WAYLAND_USE_EGL)
+  target_link_libraries(lvgl PRIVATE ${WAYLAND_EGL_LIBRARIES})
+endif()

env_support/cmake/dependencies/webp.cmake

@@ -0,0 +1,66 @@
+option(LV_USE_FIND_PACKAGE_WEBP "Resolve libwebp via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_WEBP "Resolve libwebp via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+option(LV_FETCH_WEBP "Fetch libwebp from source" ${LV_FETCH_DEPENDENCIES})
+
+if(LV_USE_FIND_PACKAGE_WEBP)
+  find_package(WebP QUIET)
+  if(WebP_FOUND)
+    message(STATUS "lvgl: libwebp: found via find_package")
+    target_link_libraries(lvgl PRIVATE WebP::webp)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_WEBP AND PkgConfig_FOUND)
+  pkg_check_modules(WebP IMPORTED_TARGET QUIET libwebp)
+  if(WebP_FOUND)
+    message(STATUS "lvgl: libwebp: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::WebP)
+    return()
+  endif()
+endif()
+
+if(NOT LV_FETCH_WEBP)
+  message(
+    FATAL_ERROR
+      "lvgl: libwebp not found. Enable LV_FETCH_WEBP or install it manually.")
+endif()
+
+message(STATUS "lvgl: libwebp: fetching from source")
+set(WEBP_BUILD_ANIM_UTILS
+    OFF
+    CACHE BOOL "" FORCE)
+set(WEBP_BUILD_CWEBP
+    OFF
+    CACHE BOOL "" FORCE)
+set(WEBP_BUILD_DWEBP
+    OFF
+    CACHE BOOL "" FORCE)
+set(WEBP_BUILD_GIF2WEBP
+    OFF
+    CACHE BOOL "" FORCE)
+set(WEBP_BUILD_IMG2WEBP
+    OFF
+    CACHE BOOL "" FORCE)
+set(WEBP_BUILD_VWEBP
+    OFF
+    CACHE BOOL "" FORCE)
+set(WEBP_BUILD_WEBPINFO
+    OFF
+    CACHE BOOL "" FORCE)
+set(WEBP_BUILD_WEBPMUX
+    OFF
+    CACHE BOOL "" FORCE)
+set(WEBP_BUILD_EXTRAS
+    OFF
+    CACHE BOOL "" FORCE)
+
+FetchContent_Declare(
+  webp
+  GIT_REPOSITORY https://github.com/webmproject/libwebp
+  GIT_TAG 4fa21912338357f89e4fd51cf2368325b59e9bd9)
+
+FetchContent_MakeAvailable(webp)
+target_link_libraries(lvgl PRIVATE webp)

env_support/cmake/dependencies/x11.cmake

@@ -0,0 +1,29 @@
+option(LV_USE_FIND_PACKAGE_X11 "Resolve X11 via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_X11 "Resolve X11 via pkg-config" ${LV_USE_PKG_CONFIG})
+
+if(LV_USE_FIND_PACKAGE_X11)
+  find_package(X11 QUIET)
+  if(X11_FOUND)
+    message(STATUS "lvgl: X11: found via find_package")
+    # X11::X11 imported target requires CMake 3.14+
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.14")
+      target_link_libraries(lvgl PRIVATE X11::X11)
+    else()
+      target_link_libraries(lvgl PRIVATE ${X11_LIBRARIES})
+      target_include_directories(lvgl PRIVATE ${X11_INCLUDE_DIR})
+    endif()
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_X11 AND PkgConfig_FOUND)
+  pkg_check_modules(X11 IMPORTED_TARGET QUIET x11)
+  if(X11_FOUND)
+    message(STATUS "lvgl: X11: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::X11)
+    return()
+  endif()
+endif()
+
+message(FATAL_ERROR "lvgl: X11 not found. Please install libx11.")

env_support/cmake/dependencies/xkbcommon.cmake

@@ -0,0 +1,24 @@
+option(LV_USE_FIND_PACKAGE_XKBCOMMON "Resolve xkbcommon via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_XKBCOMMON "Resolve xkbcommon via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+
+if(LV_USE_FIND_PACKAGE_XKBCOMMON)
+  find_package(Xkbcommon QUIET)
+  if(Xkbcommon_FOUND)
+    message(STATUS "lvgl: xkbcommon: found via find_package")
+    target_link_libraries(lvgl PRIVATE Xkbcommon::Xkbcommon)
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_XKBCOMMON AND PkgConfig_FOUND)
+  pkg_check_modules(XKBCOMMON IMPORTED_TARGET QUIET xkbcommon)
+  if(XKBCOMMON_FOUND)
+    message(STATUS "lvgl: xkbcommon: found via pkg-config")
+    target_link_libraries(lvgl PRIVATE PkgConfig::XKBCOMMON)
+    return()
+  endif()
+endif()
+
+message(FATAL_ERROR "lvgl: xkbcommon not found. Please install xkbcommon.")

env_support/cmake/dependencies/zlib.cmake

@@ -0,0 +1,35 @@
+option(LV_USE_FIND_PACKAGE_ZLIB "Resolve zlib via find_package"
+       ${LV_USE_FIND_PACKAGE})
+option(LV_USE_PKG_CONFIG_ZLIB "Resolve zlib via pkg-config"
+       ${LV_USE_PKG_CONFIG})
+option(LV_FETCH_ZLIB "Fetch zlib from source" ${LV_FETCH_DEPENDENCIES})
+
+if(LV_USE_FIND_PACKAGE_ZLIB)
+  find_package(ZLIB QUIET)
+  if(ZLIB_FOUND)
+    message(STATUS "lvgl: zlib: found via find_package")
+    return()
+  endif()
+endif()
+
+if(LV_USE_PKG_CONFIG_ZLIB AND PkgConfig_FOUND)
+  pkg_check_modules(ZLIB IMPORTED_TARGET QUIET zlib)
+  if(ZLIB_FOUND)
+    message(STATUS "lvgl: zlib: found via pkg-config")
+    return()
+  endif()
+endif()
+
+if(NOT LV_FETCH_ZLIB)
+  message(
+    FATAL_ERROR
+      "lvgl: zlib not found. Enable LV_FETCH_ZLIB or install it manually.")
+endif()
+
+message(STATUS "lvgl: zlib: fetching from source")
+FetchContent_Declare(
+  zlib
+  GIT_REPOSITORY https://github.com/madler/zlib
+  GIT_TAG v1.3.1)
+
+FetchContent_MakeAvailable(zlib)

env_support/cmake/main.cmake

@@ -23,12 +23,17 @@ option(LV_BUILD_LVGL_H_SYSTEM_INCLUDE
 
 option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
 
-### LVGL configuration options always use the prefix CONFIG_
-### They can be set using the -D argument or cmake-gui(1) and are kept in cache
-### The option names are the same as the defines in lv_conf.h - so check it for a description
+# These control how LVGL resolves its optional dependencies.
+# All three strategies are tried in order: find_package -> pkg-config -> FetchContent.
+# Individual dependencies can be further controlled with LV_USE_FIND_PACKAGE_<DEP>,
+# LV_USE_PKG_CONFIG_<DEP>, and LV_FETCH_<DEP> options.
 
-### INFO: When LV_BUILD_SET_CONFIG_OPTS is enabled - these options are set automatically
-### based on lv_conf.h or Kconfig
+# Dependency management require CONFIG_LV_* variables to be set (e.g. CONFIG_LV_USE_WAYLAND).
+# CONFIG_LV_* variables can be set manually using the -D argument or cmake-gui and are kept in cache  
+# or generated automatically by enabling LV_BUILD_SET_CONFIG_OPTS, which parses lv_conf_internal.h to derive them.
+option(LV_USE_FIND_PACKAGE "Resolve dependencies via find_package" ON)
+option(LV_USE_PKG_CONFIG "Resolve dependencies via pkg-config (requires pkg-config to be installed)" ON)
+option(LV_FETCH_DEPENDENCIES "Fetch dependencies from source if not found on the system" ON)
 
 option(CONFIG_LV_BUILD_DEMOS "Build demos" ON)
 option(CONFIG_LV_BUILD_EXAMPLES "Build examples" ON)
@@ -209,6 +214,8 @@ if (LV_BUILD_SET_CONFIG_OPTS)
     include(${CMAKE_CURRENT_BINARY_DIR}/lv_conf.cmake)
 endif()
 
+include(${CMAKE_CURRENT_LIST_DIR}/dependencies.cmake)
+
 # Set the configuration inc dir for all targets created in this CMakeLists.txt
 # CMAKE_CURRENT_SOURCE_DIR is necessary because the assets include lvgl/lvgl.h ...
 include_directories(${CONF_INC_DIR} ${LVGL_ROOT_DIR})

tests/CMakeLists.txt

@@ -268,7 +268,7 @@ endif()
 get_filename_component(LVGL_DIR ${LVGL_TEST_DIR} DIRECTORY)
 
 # Include lvgl project file.
-# Set LV_BUILD_CONF_PATH so os_desktop.cmake knows about it before compiling lvgl
+# Set LV_BUILD_CONF_PATH so main.cmake knows about it before compiling lvgl
 # Used to preprocess lv_conf_internal.h with the test config
 set(LV_BUILD_CONF_PATH "${LVGL_TEST_DIR}/src/lv_test_conf.h" CACHE STRING "set test configuration")
 
@@ -296,7 +296,7 @@ if (TARGET lvgl_demos)
 endif()
 
 
-# LVGL_CONF_DIR and LVGL_CONF_PATH are normalized and set by os_desktop.cmake
+# LVGL_CONF_DIR and LVGL_CONF_PATH are normalized and set by main.cmake
 
 set(TEST_INCLUDE_DIRS
     $<BUILD_INTERFACE:${LVGL_TEST_DIR}/src>