cmake_minimum_required(VERSION 3.5...4.0 FATAL_ERROR)

list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
include(GetVersionFromGit)
get_version_from_git(GR_VERSION GR_VERSION_FULL)

project(
  GR
  VERSION ${GR_VERSION}
  LANGUAGES C CXX
)

include(GNUInstallDirs)
include(CheckCXXCompilerFlag)

check_cxx_compiler_flag("-Werror=implicit" ERROR_IMPLICIT_SUPPORTED)
if(ERROR_IMPLICIT_SUPPORTED)
  set(COMPILER_OPTION_ERROR_IMPLICIT
      "-Werror=implicit"
      CACHE INTERNAL "Compiler flag for generating errors on implicit declarations"
  )
else()
  set(COMPILER_OPTION_ERROR_IMPLICIT
      ""
      CACHE INTERNAL "Compiler flag for generating errors on implicit declarations"
  )
endif()

if(UNIX)
  if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
    set(CMAKE_INSTALL_PREFIX
        "/usr/local/gr"
        CACHE PATH "GR install prefix" FORCE
    )
  endif()
endif()
set(GR_DIRECTORY
    "${CMAKE_INSTALL_PREFIX}"
    CACHE STRING "Default value for GRDIR"
)
option(GR_BUILD_DEMOS "Build demos for GR" OFF)
option(GR_BUILD_GKSM "Build GKS metafile reader for GR" OFF)
option(GR_INSTALL "Create installation target for GR" ON)
option(GR_USE_BUNDLED_LIBRARIES "Use thirdparty libraries bundled with GR" OFF)
option(GR_MANUAL_MOC_AND_RCC "Manually run moc and rcc instead of relying on AUTOMOC and AUTORCC" OFF)
option(GR_FIND_QT5_BY_VARIABLES "Find Qt5 based on the variables Qt5_INCLUDE_DIR and Qt5_LIBRARY_DIR" OFF)
option(GR_PREFER_XCODEBUILD "Prefer xcodebuild to build macOS applications if available" ON)

if(GR_USE_BUNDLED_LIBRARIES)
  list(APPEND CMAKE_FIND_ROOT_PATH "${CMAKE_CURRENT_LIST_DIR}/3rdparty/build/")
  set(GR_THIRDPARTY_LIBRARY_PREFIX ${CMAKE_STATIC_LIBRARY_PREFIX})
  set(GR_THIRDPARTY_LIBRARY_SUFFIX ${CMAKE_STATIC_LIBRARY_SUFFIX})
else()
  set(GR_THIRDPARTY_LIBRARY_PREFIX ${CMAKE_SHARED_LIBRARY_PREFIX})
  set(GR_THIRDPARTY_LIBRARY_SUFFIX ${CMAKE_SHARED_LIBRARY_SUFFIX})
endif()

if(GR_FIND_QT5_BY_VARIABLES)
  list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake/optional/qt5")
endif()

if(WIN32)
  set(GR_PLUGIN_SUFFIX ".dll")
else()
  set(GR_PLUGIN_SUFFIX ".so")
endif()

if(APPLE)
  set(DEFAULT_SHARED_LIBRARY_SUFFIX ".dylib")
else()
  set(DEFAULT_SHARED_LIBRARY_SUFFIX "${GR_PLUGIN_SUFFIX}")
endif()

set(GR_SHARED_LIBRARY_SUFFIX
    "${DEFAULT_SHARED_LIBRARY_SUFFIX}"
    CACHE STRING "File suffix for shared libraries"
)

set(CMAKE_FIND_PACKAGE_PREFER_CONFIG
    TRUE
    CACHE BOOL ""
)

# Find the following packages always in system locations even if `GR_USE_BUNDLED_LIBRARIES` is set, because they are not
# located in 3rdparty
find_package(X11)
find_package(Fontconfig)
find_package(OpenGL OPTIONAL_COMPONENTS OpenGL)
if(${CMAKE_VERSION} VERSION_GREATER "3.16.0")
  find_package(
    Qt6
    OPTIONAL_COMPONENTS
      Widgets
      Core
      Network
      Gui
      PrintSupport
  )
endif()
find_package(
  Qt5
  OPTIONAL_COMPONENTS
    Widgets
    Core
    Network
    Gui
    PrintSupport
)
find_package(Qt4)

# Find the following packages only in 3rdparty, if `GR_USE_BUNDLED_LIBRARIES` is set
if(GR_USE_BUNDLED_LIBRARIES)
  set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
  set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
  set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
  set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
endif()
find_package(Freetype)
if(TARGET freetype AND NOT TARGET Freetype::Freetype)
  add_library(Freetype::Freetype ALIAS freetype)
endif()
find_package(Jpeg REQUIRED)
find_package(Libpng REQUIRED)
find_package(ZLIB REQUIRED)
find_package(Qhull REQUIRED)
if(TARGET Qhull::qhullstatic_r AND NOT TARGET Qhull::qhull_r)
  add_library(Qhull::qhull_r ALIAS Qhull::qhullstatic_r)
endif()
find_package(Tiff)
find_package(Ffmpeg 57.48.100)
find_package(glfw3)
if(TARGET glfw AND NOT TARGET Glfw::Glfw)
  add_library(Glfw::Glfw ALIAS glfw)
endif()
find_package(ZeroMQ)
if(NOT TARGET ZeroMQ::ZeroMQ)
  if(TARGET libzmq)
    add_library(ZeroMQ::ZeroMQ ALIAS libzmq)
  elseif(TARGET libzmq-static)
    add_library(ZeroMQ::ZeroMQ ALIAS libzmq-static)
    get_target_property(ZeroMQ_LIBRARY libzmq-static LOCATION)
  endif()
endif()
find_package(Cairo)
find_package(Agg)
find_package(Gs)
find_package(XercesC)

if(APPLE)
  set(INSTALL_RPATH "${GR_DIRECTORY}/lib/;@loader_path/.")
else()
  set(INSTALL_RPATH "${GR_DIRECTORY}/lib/;$ORIGIN/.")
endif()

if(Qt4_FOUND
   OR (Qt5Widgets_FOUND
       AND Qt5Core_FOUND
       AND Qt5Network_FOUND
      )
   OR (Qt6Widgets_FOUND
       AND Qt6Core_FOUND
       AND Qt6Network_FOUND
      )
)
  if(GR_MANUAL_MOC_AND_RCC)
    if(NOT QT_MOC_EXECUTABLE)
      find_program(QT_MOC_EXECUTABLE moc CMAKE_FIND_ROOT_PATH_BOTH)
    endif()
    if(NOT QT_MOC_EXECUTABLE)
      message(FATAL_ERROR "Could not find moc but GR_MANUAL_MOC_AND_RCC is set.")
    endif()
    if(NOT QT_RCC_EXECUTABLE)
      find_program(QT_RCC_EXECUTABLE rcc CMAKE_FIND_ROOT_PATH_BOTH)
    endif()
    if(NOT QT_RCC_EXECUTABLE)
      message(FATAL_ERROR "Could not find rcc but GR_MANUAL_MOC_AND_RCC is set.")
    endif()
  endif()
endif()
if(Qt4_FOUND)
  set(QT4_MOC_INCLUDE_FLAGS "")
  foreach(DIR IN LISTS QT_INCLUDE_DIR)
    set(QT4_MOC_INCLUDE_FLAGS ${QT4_MOC_INCLUDE_FLAGS} -I${DIR})
  endforeach()
  if(NOT DEFINED Qt4_LIBRARY_DIR)
    get_filename_component(Qt4_LIBRARY_DIR "${QT_LIBRARY_DIR}/../.." ABSOLUTE)
  endif()
endif()
if(Qt5Widgets_FOUND
   AND Qt5Core_FOUND
   AND Qt5Network_FOUND
)
  set(QT5_MOC_INCLUDE_FLAGS "")
  foreach(DIR IN LISTS Qt5Core_INCLUDE_DIRS Qt5Gui_INCLUDE_DIRS Qt5Widgets_INCLUDE_DIRS)
    set(QT5_MOC_INCLUDE_FLAGS ${QT5_MOC_INCLUDE_FLAGS} -I${DIR})
  endforeach()
  if(NOT DEFINED Qt5_LIBRARY_DIR)
    get_filename_component(Qt5_LIBRARY_DIR "${Qt5_DIR}/../.." ABSOLUTE)
  endif()
endif()
if(Qt6Widgets_FOUND
   AND Qt6Core_FOUND
   AND Qt6Network_FOUND
)
  set(QT6_MOC_INCLUDE_FLAGS "")
  foreach(DIR IN LISTS Qt6Core_INCLUDE_DIRS Qt6Gui_INCLUDE_DIRS Qt6Widgets_INCLUDE_DIRS)
    set(QT6_MOC_INCLUDE_FLAGS ${QT6_MOC_INCLUDE_FLAGS} -I${DIR})
  endforeach()
  if(NOT DEFINED Qt6_LIBRARY_DIR)
    get_filename_component(Qt6_LIBRARY_DIR "${Qt6_DIR}/../.." ABSOLUTE)
  endif()
endif()

if(X11_FOUND)
  # older versions of FindX11.cmake set variables but do not create targets
  if(NOT TARGET X11::X11
     AND X11_INCLUDE_DIR
     AND X11_X11_LIB
     AND X11_Xft_LIB
  )
    add_library(X11::X11 UNKNOWN IMPORTED)
    set_target_properties(
      X11::X11
      PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${X11_INCLUDE_DIR}/"
                 IMPORTED_LINK_INTERFACE_LANGUAGES "C"
                 IMPORTED_LOCATION "${X11_X11_LIB}"
                 INTERFACE_LINK_LIBRARIES "${X11_Xft_LIB}"
    )
  endif()
  if(NOT TARGET X11::Xt
     AND X11_INCLUDE_DIR
     AND X11_Xt_LIB
     AND TARGET X11::X11
  )
    add_library(X11::Xt UNKNOWN IMPORTED)
    set_target_properties(
      X11::Xt
      PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${X11_INCLUDE_DIR}/"
                 IMPORTED_LINK_INTERFACE_LANGUAGES "C"
                 IMPORTED_LOCATION "${X11_Xt_LIB}"
                 INTERFACE_LINK_LIBRARIES "X11::X11"
    )
  endif()
endif()

set(GKS_SOURCES
    lib/gks/afm.c
    lib/gks/font.c
    lib/gks/socket.c
    lib/gks/ft.c
    lib/gks/malloc.c
    lib/gks/util.c
    lib/gks/compress.c
    lib/gks/gks.c
    lib/gks/mf.c
    lib/gks/win.c
    lib/gks/gksforbnd.c
    lib/gks/pdf.c
    lib/gks/wiss.c
    lib/gks/dl.c
    lib/gks/plugin.c
    lib/gks/error.c
    lib/gks/io.c
    lib/gks/ps.c
    lib/gks/resample.c
)

add_library(gks_static STATIC ${GKS_SOURCES})
add_library(gks_shared SHARED ${GKS_SOURCES})

foreach(LIBRARY gks_static gks_shared)
  if(LIBRARY MATCHES "static")
    set(GKS_LINK_MODE PUBLIC)
  else()
    set(GKS_LINK_MODE PRIVATE)
  endif()
  if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
    target_compile_definitions(${LIBRARY} PRIVATE _CRT_SECURE_NO_WARNINGS)
  endif()
  if(NOT ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC"))
    target_link_libraries(${LIBRARY} ${GKS_LINK_MODE} pthread)
    target_link_libraries(${LIBRARY} ${GKS_LINK_MODE} m)
  endif()
  if(Freetype_FOUND)
    target_link_libraries(${LIBRARY} ${GKS_LINK_MODE} Freetype::Freetype)
  else()
    target_compile_definitions(
      ${LIBRARY}
      ${GKS_LINK_MODE}
      NO_FT
    )
  endif()
  target_link_libraries(${LIBRARY} ${GKS_LINK_MODE} ZLIB::ZLIB)
  target_compile_definitions(
    ${LIBRARY}
    ${GKS_LINK_MODE}
    HAVE_ZLIB
  )
  if(UNIX)
    target_link_libraries(${LIBRARY} ${GKS_LINK_MODE} dl)
  elseif(WIN32)
    target_link_libraries(${LIBRARY} ${GKS_LINK_MODE} ws2_32)
    target_link_libraries(${LIBRARY} ${GKS_LINK_MODE} msimg32)
    target_link_libraries(${LIBRARY} ${GKS_LINK_MODE} gdi32)
  endif()
  if(NOT ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC"))
    target_compile_options(${LIBRARY} ${GKS_LINK_MODE} -pthread)
  endif()
  target_compile_options(${LIBRARY} PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  target_include_directories(
    ${LIBRARY} PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/lib/gks/>
                      $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
  )
  target_compile_definitions(${LIBRARY} PRIVATE GRDIR="${GR_DIRECTORY}")
  target_compile_definitions(${LIBRARY} PRIVATE GRLIB="${CMAKE_INSTALL_LIBDIR}")
  set_target_properties(
    ${LIBRARY}
    PROPERTIES C_STANDARD 90
               C_EXTENSIONS OFF
               C_STANDARD_REQUIRED ON
               POSITION_INDEPENDENT_CODE ON
               PREFIX "lib"
               IMPORT_PREFIX "lib"
               OUTPUT_NAME GKS
               INSTALL_RPATH "${INSTALL_RPATH}"
  )
endforeach()
unset(GKS_LINK_MODE)
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
  set_target_properties(gks_static PROPERTIES OUTPUT_NAME GKSstatic)
endif()
set_target_properties(gks_shared PROPERTIES SUFFIX "${GR_SHARED_LIBRARY_SUFFIX}" EXPORT_NAME GKS)
set_target_properties(gks_shared PROPERTIES SOVERSION 0)
add_library(GR::GKS ALIAS gks_static)
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/gr_version.h
     "#ifndef GR_VERSION\n#define GR_VERSION \"${GR_VERSION_FULL}\"\n#endif\n"
)
set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/gr_version.h PROPERTIES GENERATED TRUE)

set(GR_SOURCES
    lib/gr/boundary.c
    lib/gr/contour.c
    lib/gr/contourf.c
    lib/gr/delaunay.c
    lib/gr/gr.c
    lib/gr/grforbnd.c
    lib/gr/gridit.c
    lib/gr/image.c
    lib/gr/import.c
    lib/gr/interp2.c
    lib/gr/stream.c
    lib/gr/md5.c
    lib/gr/shade.c
    lib/gr/spline.c
    lib/gr/strlib.c
    lib/gr/text.c
    lib/gr/mathtex2.c
    lib/gr/mathtex2_kerning.c
    lib/gr/mathtex2.tab.c
    lib/gr/threadpool.c
    ${CMAKE_CURRENT_BINARY_DIR}/gr_version.h
)

add_library(gr_static STATIC ${GR_SOURCES})
add_library(gr_shared SHARED ${GR_SOURCES})

foreach(LIBRARY gr_static gr_shared)
  if(LIBRARY MATCHES "static")
    set(GR_LINK_MODE PUBLIC)
  else()
    set(GR_LINK_MODE PRIVATE)
  endif()
  target_link_libraries(${LIBRARY} ${GR_LINK_MODE} gks_static)
  if(NOT ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC"))
    target_link_libraries(${LIBRARY} ${GR_LINK_MODE} m)
  endif()
  target_link_libraries(${LIBRARY} ${GR_LINK_MODE} Qhull::qhull_r)
  target_link_libraries(${LIBRARY} ${GR_LINK_MODE} Jpeg::Jpeg)
  target_link_libraries(${LIBRARY} ${GR_LINK_MODE} Libpng::Libpng)
  if(WIN32)
    target_link_libraries(${LIBRARY} ${GR_LINK_MODE} ws2_32)
  endif()
  target_include_directories(
    ${LIBRARY} PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/lib/gr/>
                      $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
  )
  target_include_directories(${LIBRARY} PRIVATE $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
  if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
    target_compile_definitions(${LIBRARY} PRIVATE _CRT_SECURE_NO_WARNINGS)
  endif()
  target_compile_definitions(${LIBRARY} PRIVATE GRDIR="${GR_DIRECTORY}")
  target_compile_options(${LIBRARY} PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  set_target_properties(
    ${LIBRARY}
    PROPERTIES C_STANDARD 90
               C_EXTENSIONS OFF
               C_STANDARD_REQUIRED ON
               POSITION_INDEPENDENT_CODE ON
               INSTALL_RPATH "${INSTALL_RPATH}"
               PREFIX "lib"
               IMPORT_PREFIX "lib"
               OUTPUT_NAME GR
  )
endforeach()
unset(GR_LINK_MODE)
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
  set_target_properties(gr_static PROPERTIES OUTPUT_NAME GRstatic)
endif()
set_target_properties(gr_shared PROPERTIES SUFFIX "${GR_SHARED_LIBRARY_SUFFIX}" EXPORT_NAME GR)
set_target_properties(gr_shared PROPERTIES SOVERSION 0)
add_library(GR::GR ALIAS gr_shared)

set(GR3_SOURCES
    lib/gr3/gr3.c
    lib/gr3/gr3_convenience.c
    lib/gr3/gr3_gr.c
    lib/gr3/gr3_html.c
    lib/gr3/gr3_jpeg.c
    lib/gr3/gr3_mc.c
    lib/gr3/gr3_png.c
    lib/gr3/gr3_povray.c
    lib/gr3/gr3_slices.c
    lib/gr3/gr3_sr.c
)

add_library(gr3_static STATIC ${GR3_SOURCES})
add_library(gr3_shared SHARED ${GR3_SOURCES})
foreach(LIBRARY gr3_static gr3_shared)
  if(LIBRARY MATCHES "static")
    set(GR3_LINK_MODE PUBLIC)
  else()
    set(GR3_LINK_MODE PRIVATE)
  endif()
  if(APPLE)
    target_sources(${LIBRARY} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/lib/gr3/gr3_cgl.c)
  elseif(UNIX AND NOT APPLE)
    target_sources(${LIBRARY} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/lib/gr3/gr3_glx.c)
  elseif(WIN32)
    target_sources(${LIBRARY} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/lib/gr3/gr3_win.c)
  endif()
  target_link_libraries(${LIBRARY} ${GR3_LINK_MODE} GR::GR)
  target_link_libraries(${LIBRARY} ${GR3_LINK_MODE} GR::GKS)
  target_link_libraries(${LIBRARY} ${GR3_LINK_MODE} Jpeg::Jpeg)
  target_link_libraries(${LIBRARY} ${GR3_LINK_MODE} Libpng::Libpng)
  if(NOT ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC"))
    target_link_libraries(${LIBRARY} ${GR3_LINK_MODE} pthread)
    target_link_libraries(${LIBRARY} ${GR3_LINK_MODE} m)
  endif()
  if((APPLE OR WIN32) AND OpenGL_FOUND)
    target_link_libraries(${LIBRARY} ${GR3_LINK_MODE} OpenGL::GL)
  endif()
  if(APPLE)
    # Apple has deprecated OpenGL in macOS 10.14
    target_compile_definitions(${LIBRARY} PRIVATE GL_SILENCE_DEPRECATION)
  endif()
  if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
    target_compile_definitions(${LIBRARY} PRIVATE _CRT_SECURE_NO_WARNINGS)
  endif()
  target_compile_definitions(${LIBRARY} PRIVATE GRDIR="${GR_DIRECTORY}")
  target_compile_definitions(${LIBRARY} PRIVATE GRLIB="${CMAKE_INSTALL_LIBDIR}")
  if(NOT ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC"))
    target_compile_options(${LIBRARY} ${GR3_LINK_MODE} -pthread)
  endif()
  target_compile_options(${LIBRARY} PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  target_include_directories(
    ${LIBRARY} PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/lib/gr3/>
                      $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
  )
  set_target_properties(
    ${LIBRARY}
    PROPERTIES C_STANDARD 90
               C_EXTENSIONS OFF
               C_STANDARD_REQUIRED ON
               POSITION_INDEPENDENT_CODE ON
               INSTALL_RPATH "${INSTALL_RPATH}"
               PREFIX "lib"
               IMPORT_PREFIX "lib"
               OUTPUT_NAME GR3
  )
endforeach()
unset(GR3_LINK_MODE)
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
  set_target_properties(gr3_static PROPERTIES OUTPUT_NAME GR3static)
endif()
set_target_properties(gr3_shared PROPERTIES SUFFIX "${GR_SHARED_LIBRARY_SUFFIX}" EXPORT_NAME GR3)
set_target_properties(gr3_shared PROPERTIES SOVERSION 0)
add_library(GR::GR3 ALIAS gr3_shared)

if(UNIX AND NOT APPLE)
  if(TARGET X11::X11
     AND TARGET OpenGL::GLX
     AND TARGET OpenGL::GL
  )
    add_library(gr3platform SHARED lib/gr3/gr3_platform_glx.c)
    target_link_libraries(gr3platform PUBLIC GR::GR)
    target_link_libraries(gr3platform PUBLIC X11::X11)
    target_link_libraries(gr3platform PUBLIC OpenGL::GLX)
    target_link_libraries(gr3platform PUBLIC OpenGL::GL)
    target_compile_options(gr3platform PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
    set_target_properties(
      gr3platform
      PROPERTIES C_STANDARD 90
                 C_EXTENSIONS OFF
                 C_STANDARD_REQUIRED ON
                 POSITION_INDEPENDENT_CODE ON
                 INSTALL_RPATH "${INSTALL_RPATH}"
                 OUTPUT_NAME GR3platform
                 SOVERSION 0
    )
  else()
    target_compile_definitions(gr3_static PUBLIC -DNO_GL)
    target_compile_definitions(gr3_shared PUBLIC -DNO_GL)
    message(WARNING "libGR3platform.so requires X11 and will not be built.")
  endif()
elseif(NOT OpenGL_FOUND)
  target_compile_definitions(gr3_static PUBLIC -DNO_GL)
  target_compile_definitions(gr3_shared PUBLIC -DNO_GL)
endif()

set(GRM_SOURCES
    lib/grm/src/grm/args.c
    lib/grm/src/grm/backtrace.c
    lib/grm/src/grm/base64.c
    lib/grm/src/grm/bson.c
    lib/grm/src/grm/dump.c
    lib/grm/src/grm/dynamic_args_array.c
    lib/grm/src/grm/error.c
    lib/grm/src/grm/event.c
    lib/grm/src/grm/interaction.cxx
    lib/grm/src/grm/json.c
    lib/grm/src/grm/layout_c.cxx
    lib/grm/src/grm/layout.cxx
    lib/grm/src/grm/layout_error.cxx
    lib/grm/src/grm/logging.c
    lib/grm/src/grm/memwriter.c
    lib/grm/src/grm/net.c
    lib/grm/src/grm/plot.cxx
    lib/grm/src/grm/util.c
    lib/grm/src/grm/import.cxx
    lib/grm/src/grm/utilcpp.cxx
    lib/grm/src/grm/datatype/double_map.c
    lib/grm/src/grm/datatype/size_t_list.c
    lib/grm/src/grm/datatype/string_array_map.c
    lib/grm/src/grm/datatype/string_list.c
    lib/grm/src/grm/datatype/string_map.c
    lib/grm/src/grm/datatype/uint_map.c
    lib/grm/src/grm/dom_render/context.cxx
    lib/grm/src/grm/dom_render/render.cxx
    lib/grm/src/grm/dom_render/Drawable.cxx
    lib/grm/src/grm/dom_render/graphics_tree/Comment.cxx
    lib/grm/src/grm/dom_render/graphics_tree/Document.cxx
    lib/grm/src/grm/dom_render/graphics_tree/Element.cxx
    lib/grm/src/grm/dom_render/graphics_tree/Node.cxx
    lib/grm/src/grm/dom_render/graphics_tree/Value.cxx
    lib/grm/src/grm/dom_render/graphics_tree/util.cxx
    lib/grm/src/grm/dom_render/ManageCustomColorIndex.cxx
    lib/grm/src/grm/dom_render/ManageGRContextIds.cxx
    lib/grm/src/grm/dom_render/ManageZIndex.cxx
)

add_library(grm_static STATIC ${GRM_SOURCES})
add_library(grm_shared SHARED ${GRM_SOURCES})
add_library(grm_shared_internal SHARED ${GRM_SOURCES})

foreach(LIBRARY grm_static grm_shared grm_shared_internal)
  if(LIBRARY MATCHES "static")
    set(GRM_LINK_MODE PUBLIC)
  else()
    set(GRM_LINK_MODE PRIVATE)
  endif()
  if(NOT LIBRARY MATCHES "internal")
    set_target_properties(${LIBRARY} PROPERTIES C_VISIBILITY_PRESET hidden CXX_VISIBILITY_PRESET hidden)
  endif()
  target_link_libraries(${LIBRARY} ${GRM_LINK_MODE} GR::GKS)
  target_link_libraries(${LIBRARY} ${GRM_LINK_MODE} GR::GR)
  target_link_libraries(${LIBRARY} ${GRM_LINK_MODE} GR::GR3)
  if(TARGET XercesC::XercesC)
    target_link_libraries(${LIBRARY} ${GRM_LINK_MODE} XercesC::XercesC)
  else()
    target_compile_definitions(${LIBRARY} PRIVATE NO_XERCES_C)
  endif()
  if(NOT ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC"))
    target_link_libraries(${LIBRARY} ${GRM_LINK_MODE} m)
  endif()
  if(WIN32)
    target_link_libraries(${LIBRARY} ${GRM_LINK_MODE} ws2_32)
  endif()
  target_include_directories(
    ${LIBRARY}
    PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/include/>
           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/src/> $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
  )
  target_compile_definitions(${LIBRARY} PRIVATE BUILDING_GR)
  target_compile_definitions(${LIBRARY} PRIVATE GRDIR="${GR_DIRECTORY}")
  target_compile_options(${LIBRARY} PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
    target_compile_options(${LIBRARY} PRIVATE /permissive-)
  endif()
  set_target_properties(
    ${LIBRARY}
    PROPERTIES C_STANDARD 90
               C_EXTENSIONS OFF
               C_STANDARD_REQUIRED ON
               CXX_STANDARD 17
               CXX_EXTENSIONS OFF
               CXX_STANDARD_REQUIRED ON
               POSITION_INDEPENDENT_CODE ON
               INSTALL_RPATH "${INSTALL_RPATH}"
               PREFIX "lib"
               IMPORT_PREFIX "lib"
               OUTPUT_NAME GRM
  )
endforeach()
unset(GRM_LINK_MODE)
set_target_properties(grm_shared_internal PROPERTIES C_VISIBILITY_PRESET default)
set_target_properties(grm_shared_internal PROPERTIES OUTPUT_NAME GRM_int)
target_include_directories(grm_shared_internal PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/lib/gks/>)
if(WIN32)
  target_compile_definitions(grm_static PRIVATE GR_STATIC_LIB)
  target_compile_definitions(grm_shared PRIVATE BUILDING_DLL)
  target_compile_definitions(grm_shared_internal PRIVATE BUILDING_DLL)
endif()
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
  set_target_properties(grm_static PROPERTIES OUTPUT_NAME GRMstatic)
endif()
set_target_properties(grm_shared PROPERTIES SUFFIX "${GR_SHARED_LIBRARY_SUFFIX}" EXPORT_NAME GRM)
set_target_properties(grm_shared_internal PROPERTIES SUFFIX "${GR_SHARED_LIBRARY_SUFFIX}")
set_target_properties(grm_shared PROPERTIES SOVERSION 0)
add_library(GR::GRM ALIAS grm_shared)

set(GR_REPORT "GKS plugins:\n")

add_library(cairoplugin SHARED lib/gks/plugin/cairoplugin.c)
target_link_libraries(cairoplugin PUBLIC gks_static)
if(Cairo_FOUND)
  target_link_libraries(cairoplugin PRIVATE Cairo::Cairo)
  target_link_libraries(cairoplugin PRIVATE Jpeg::Jpeg)
  string(APPEND GR_REPORT "- cairoplugin:\n")
  string(APPEND GR_REPORT "\tPNG output: Yes\n")
  string(APPEND GR_REPORT "\tBMP output: Yes\n")
  string(APPEND GR_REPORT "\tJPEG output: Yes\n")

  if(Tiff_FOUND)
    target_link_libraries(cairoplugin PRIVATE Tiff::Tiff)
    string(APPEND GR_REPORT "\tTiff output: Yes\n")
  else()
    string(APPEND GR_REPORT "\tTiff output: No (libtiff not found)\n")
    target_compile_definitions(cairoplugin PRIVATE NO_TIFF)
  endif()
  target_compile_options(cairoplugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  string(APPEND GR_REPORT "\tSixel output: Yes\n")
  string(APPEND GR_REPORT "\tMemory output: Yes\n")
  string(APPEND GR_REPORT "\tX11 output: No (not available in CMake build)\n")
else()
  target_compile_definitions(cairoplugin PRIVATE NO_CAIRO)
  string(APPEND GR_REPORT "- cairoplugin: No (Cairo not found)\n")
endif()
# Cairo X11 support is disabled to allow users to generate images using Cairo on systems without X11 installed
target_compile_definitions(cairoplugin PRIVATE NO_X11)
set_target_properties(
  cairoplugin
  PROPERTIES C_STANDARD 90
             C_EXTENSIONS OFF
             C_STANDARD_REQUIRED ON
             PREFIX ""
             SUFFIX "${GR_PLUGIN_SUFFIX}"
)

add_library(aggplugin SHARED lib/gks/plugin/aggplugin.cxx)
target_link_libraries(aggplugin PUBLIC gks_static)
if(Agg_FOUND)
  target_link_libraries(aggplugin PRIVATE Agg::Agg)
  target_link_libraries(aggplugin PRIVATE Jpeg::Jpeg)
  target_link_libraries(aggplugin PRIVATE Libpng::Libpng)
  string(APPEND GR_REPORT "- aggplugin: Yes\n")
  target_compile_options(aggplugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
    # Do not define `min` and `max` as macros because this can have unintended side effects (like error messages when
    # using `std::min`)
    target_compile_definitions(aggplugin PRIVATE NOMINMAX)
  endif()
else()
  target_compile_definitions(aggplugin PRIVATE NO_AGG)
  string(APPEND GR_REPORT "- aggplugin: No (Agg not found)\n")
endif()
set_target_properties(
  aggplugin
  PROPERTIES CXX_STANDARD 11
             CXX_EXTENSIONS OFF
             CXX_STANDARD_REQUIRED ON
             PREFIX ""
             SUFFIX "${GR_PLUGIN_SUFFIX}"
)

add_library(videoplugin SHARED lib/gks/plugin/gif.c lib/gks/plugin/vc.c lib/gks/plugin/videoplugin.c)
target_link_libraries(videoplugin PUBLIC gks_static)
if(NOT Cairo_FOUND)
  target_compile_definitions(videoplugin PRIVATE NO_CAIRO)
  target_compile_definitions(videoplugin PRIVATE NO_AV)
  string(APPEND GR_REPORT "- videoplugin: No (Cairo not found)\n")
elseif(NOT Ffmpeg_FOUND)
  target_compile_definitions(videoplugin PRIVATE NO_CAIRO)
  target_compile_definitions(videoplugin PRIVATE NO_AV)
  string(APPEND GR_REPORT "- videoplugin: No (ffmpeg / ogg / theora / vpx / openh264 not found)\n")
else()
  string(APPEND GR_REPORT "- videoplugin:\n")
  string(APPEND GR_REPORT "\tMP4 output: Yes\n")
  string(APPEND GR_REPORT "\tMOV output: Yes\n")
  string(APPEND GR_REPORT "\tWEBM output: Yes\n")
  string(APPEND GR_REPORT "\tOGG output: Yes\n")
  string(APPEND GR_REPORT "\tGIF output: Yes\n")
  string(APPEND GR_REPORT "\tAPNG output: Yes\n")
  target_link_libraries(videoplugin PUBLIC Ffmpeg::Ffmpeg)
endif()
target_compile_options(videoplugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
set_target_properties(
  videoplugin
  PROPERTIES C_STANDARD 99
             C_EXTENSIONS OFF
             C_STANDARD_REQUIRED ON
             LINKER_LANGUAGE CXX
             PREFIX ""
             SUFFIX "${GR_PLUGIN_SUFFIX}"
)

add_library(pgfplugin SHARED lib/gks/plugin/pgfplugin.c)
target_link_libraries(pgfplugin PUBLIC gks_static)
target_link_libraries(pgfplugin PUBLIC Libpng::Libpng)
target_compile_options(pgfplugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
set_target_properties(
  pgfplugin
  PROPERTIES C_STANDARD 90
             C_EXTENSIONS OFF
             C_STANDARD_REQUIRED ON
             PREFIX ""
             SUFFIX "${GR_PLUGIN_SUFFIX}"
)
string(APPEND GR_REPORT "- pgfplugin:\n")
string(APPEND GR_REPORT "\tTeX output: Yes\n")

add_library(wmfplugin SHARED lib/gks/plugin/wmfplugin.c)
target_link_libraries(wmfplugin PUBLIC gks_static)
target_compile_options(wmfplugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
set_target_properties(
  wmfplugin
  PROPERTIES C_STANDARD 90
             C_EXTENSIONS OFF
             C_STANDARD_REQUIRED ON
             PREFIX ""
             SUFFIX "${GR_PLUGIN_SUFFIX}"
)
string(APPEND GR_REPORT "- wmfplugin:\n")
string(APPEND GR_REPORT "\tWMF output: Yes\n")

add_library(gsplugin SHARED lib/gks/plugin/gsplugin.c)
target_link_libraries(gsplugin PUBLIC gks_static)
if(NOT TARGET X11::Xt)
  string(APPEND GR_REPORT "- gsplugin: No (X11 / Xt not found)\n")
  target_compile_definitions(gsplugin PRIVATE NO_GS)
elseif(NOT Gs_FOUND)
  string(APPEND GR_REPORT "- gsplugin: No (ghostscript not found)\n")
  target_compile_definitions(gsplugin PRIVATE NO_GS)
else()
  target_link_libraries(gsplugin PUBLIC X11::Xt)
  target_link_libraries(gsplugin PUBLIC Gs::Gs)
  string(APPEND GR_REPORT "- gsplugin:\n")
  string(APPEND GR_REPORT "\tPNG outout: Yes\n")
  string(APPEND GR_REPORT "\tBMP outout: Yes\n")
  string(APPEND GR_REPORT "\tJPEG outout: Yes\n")
  string(APPEND GR_REPORT "\tTiff outout: Yes\n")
endif()
target_compile_options(gsplugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
set_target_properties(
  gsplugin
  PROPERTIES C_STANDARD 90
             C_EXTENSIONS OFF
             C_STANDARD_REQUIRED ON
             PREFIX ""
             SUFFIX "${GR_PLUGIN_SUFFIX}"
)

add_library(svgplugin SHARED lib/gks/plugin/svgplugin.c)
target_link_libraries(svgplugin PUBLIC gks_static)
target_link_libraries(svgplugin PUBLIC Libpng::Libpng)
target_compile_options(svgplugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
set_target_properties(
  svgplugin
  PROPERTIES C_STANDARD 90
             C_EXTENSIONS OFF
             C_STANDARD_REQUIRED ON
             PREFIX ""
             SUFFIX "${GR_PLUGIN_SUFFIX}"
)
string(APPEND GR_REPORT "- svgplugin:\n")
string(APPEND GR_REPORT "\tSVG output: Yes\n")

add_library(glplugin SHARED lib/gks/plugin/glplugin.c)
target_link_libraries(glplugin PUBLIC gks_static)
if(TARGET Glfw::Glfw AND OpenGL_FOUND)
  string(APPEND GR_REPORT "- glplugin: Yes\n")
  target_link_libraries(glplugin PUBLIC Glfw::Glfw)
  target_link_libraries(glplugin PUBLIC OpenGL::GL)
else()
  string(APPEND GR_REPORT "- glplugin: No (GLFW / OpenGL not found)\n")
  target_compile_definitions(glplugin PRIVATE NO_GLFW)
endif()
if(NOT Freetype_FOUND)
  target_compile_definitions(glplugin PRIVATE NO_FT)
endif()
if(APPLE)
  # Apple has deprecated OpenGL in macOS 10.14
  target_compile_definitions(glplugin PRIVATE GL_SILENCE_DEPRECATION)
endif()
target_compile_options(glplugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
set_target_properties(
  glplugin
  PROPERTIES C_STANDARD 90
             C_EXTENSIONS OFF
             C_STANDARD_REQUIRED ON
             PREFIX ""
             SUFFIX "${GR_PLUGIN_SUFFIX}"
)

add_library(zmqplugin SHARED lib/gks/plugin/zmqplugin.c)
target_link_libraries(zmqplugin PUBLIC gks_static)
if(ZeroMQ_FOUND)
  string(APPEND GR_REPORT "- zmqplugin: Yes\n")
  target_link_libraries(zmqplugin PUBLIC ZeroMQ::ZeroMQ)
else()
  string(APPEND GR_REPORT "- zmqplugin: No (ZeroMQ not found)\n")
  target_compile_definitions(zmqplugin PRIVATE NO_ZMQ)
endif()
target_compile_options(zmqplugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
set_target_properties(
  zmqplugin
  PROPERTIES C_STANDARD 90
             C_EXTENSIONS OFF
             C_STANDARD_REQUIRED ON
             PREFIX ""
             SUFFIX "${GR_PLUGIN_SUFFIX}"
)

add_library(x11plugin SHARED lib/gks/plugin/x11plugin.c)
target_link_libraries(x11plugin PUBLIC gks_static)
if(NOT Freetype_FOUND)
  target_compile_definitions(x11plugin PRIVATE NO_FT)
endif()
if(TARGET X11::Xt)
  if(Xft_FOUND AND Fontconfig_FOUND)
    target_link_libraries(x11plugin PUBLIC Fontconfig::Fontconfig)
  else()
    target_compile_definitions(x11plugin PRIVATE NO_XFT)
  endif()
  target_link_libraries(x11plugin PUBLIC X11::Xt)
  string(APPEND GR_REPORT "- x11plugin: Yes\n")
else()
  target_compile_definitions(x11plugin PRIVATE NO_X11)
  target_compile_definitions(x11plugin PRIVATE NO_XFT)
  string(APPEND GR_REPORT "- x11plugin: No (X11 / Xft / Xt not found)\n")
endif()
target_compile_options(x11plugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
set_target_properties(
  x11plugin
  PROPERTIES C_STANDARD 90
             C_EXTENSIONS OFF
             C_STANDARD_REQUIRED ON
             CXX_STANDARD 11
             CXX_EXTENSIONS OFF
             CXX_STANDARD_REQUIRED ON
             PREFIX ""
             SUFFIX "${GR_PLUGIN_SUFFIX}"
)

add_library(qt5plugin SHARED lib/gks/plugin/qt5plugin.cxx)
target_link_libraries(qt5plugin PUBLIC gks_static)
if(Qt5Widgets_FOUND)
  string(APPEND GR_REPORT "- qt5plugin: Yes\n")
  target_link_libraries(qt5plugin PUBLIC Qt5::Widgets)
else()
  string(APPEND GR_REPORT "- qt5plugin: No (Qt5 not found)\n")
  target_compile_definitions(qt5plugin PRIVATE NO_QT5)
endif()
target_compile_options(qt5plugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
set_target_properties(
  qt5plugin
  PROPERTIES CXX_STANDARD 11
             CXX_EXTENSIONS OFF
             CXX_STANDARD_REQUIRED ON
             PREFIX ""
             SUFFIX "${GR_PLUGIN_SUFFIX}"
)

add_library(qt6plugin SHARED lib/gks/plugin/qt6plugin.cxx)
target_link_libraries(qt6plugin PUBLIC gks_static)
if(Qt6Widgets_FOUND AND ${CMAKE_VERSION} VERSION_GREATER "3.16.0")
  string(APPEND GR_REPORT "- qt6plugin: Yes\n")
  target_link_libraries(qt6plugin PUBLIC Qt6::Widgets)
  set_target_properties(
    qt6plugin
    PROPERTIES CXX_STANDARD 17
               CXX_EXTENSIONS OFF
               CXX_STANDARD_REQUIRED ON
               PREFIX ""
               SUFFIX "${GR_PLUGIN_SUFFIX}"
  )
else()
  if(${CMAKE_VERSION} VERSION_LESS "3.16.0")
    string(APPEND GR_REPORT "- qt6plugin: No (CMake version < 3.16.0)\n")
  else()
    string(APPEND GR_REPORT "- qt6plugin: No (Qt6 not found)\n")
  endif()
  set_target_properties(
    qt6plugin
    PROPERTIES CXX_STANDARD 11
               CXX_EXTENSIONS OFF
               CXX_STANDARD_REQUIRED ON
               PREFIX ""
               SUFFIX "${GR_PLUGIN_SUFFIX}"
  )
  target_compile_definitions(qt6plugin PRIVATE NO_QT6)
endif()
target_compile_options(qt6plugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})

add_library(qtplugin SHARED lib/gks/plugin/qtplugin.cxx)
target_link_libraries(qtplugin PUBLIC gks_static)
if(Qt4_FOUND)
  string(APPEND GR_REPORT "- qtplugin: Yes\n")
  target_link_libraries(qtplugin PUBLIC Qt4::QtGui)
else()
  string(APPEND GR_REPORT "- qtplugin: No (Qt4 not found)\n")
  target_compile_definitions(qtplugin PRIVATE NO_QT)
endif()
target_compile_options(qtplugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
set_target_properties(
  qtplugin
  PROPERTIES CXX_STANDARD 11
             CXX_EXTENSIONS OFF
             CXX_STANDARD_REQUIRED ON
             PREFIX ""
             SUFFIX "${GR_PLUGIN_SUFFIX}"
)

add_library(gtkplugin SHARED lib/gks/plugin/gtkplugin.c)
target_link_libraries(gtkplugin PUBLIC gks_static)
set_target_properties(
  gtkplugin
  PROPERTIES C_STANDARD 90
             C_EXTENSIONS OFF
             C_STANDARD_REQUIRED ON
             PREFIX ""
             SUFFIX "${GR_PLUGIN_SUFFIX}"
)
target_compile_options(gtkplugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
string(APPEND GR_REPORT "- gtkplugin: No (not implemented yet)\n")

if(APPLE)
  add_library(quartzplugin SHARED lib/gks/plugin/quartzplugin.m)
  target_link_libraries(quartzplugin PUBLIC gks_static)
  if(ZeroMQ_FOUND)
    target_link_libraries(quartzplugin PUBLIC ZeroMQ::ZeroMQ)
    target_link_libraries(quartzplugin PUBLIC "-framework Foundation -framework ApplicationServices -framework AppKit")
    target_compile_definitions(quartzplugin PRIVATE GRDIR="${GR_DIRECTORY}")
  else()
    target_compile_definitions(quartzplugin PRIVATE NO_GKSTERM)
  endif()
  target_compile_options(quartzplugin PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  set_target_properties(
    quartzplugin
    PROPERTIES C_STANDARD 90
               C_EXTENSIONS OFF
               C_STANDARD_REQUIRED ON
               PREFIX ""
               SUFFIX "${GR_PLUGIN_SUFFIX}"
  )
endif()

if(Qt4_FOUND)
  add_library(qt4gr SHARED lib/gr/qtgr/grwidget.cxx)
  target_link_libraries(qt4gr PUBLIC GR::GR)
  target_link_libraries(qt4gr PUBLIC Qt4::QtCore Qt4::QtGui)
  if(MINGW AND CMAKE_SYSTEM_PROCESSOR STREQUAL "i686")
    target_compile_options(qt4gr PRIVATE -fno-exceptions)
  endif()
  target_compile_options(qt4gr PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  set_target_properties(qt4gr PROPERTIES SUFFIX "${GR_SHARED_LIBRARY_SUFFIX}" INSTALL_RPATH "${INSTALL_RPATH}")
  if(GR_MANUAL_MOC_AND_RCC)
    set_target_properties(qt4gr PROPERTIES AUTOMOC OFF AUTORCC OFF)
    add_custom_command(
      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_qt4_grwidget.cxx
      COMMAND ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${QT4_MOC_INCLUDE_FLAGS}
              ${CMAKE_CURRENT_SOURCE_DIR}/lib/gr/qtgr/grwidget.h -o ${CMAKE_CURRENT_BINARY_DIR}/moc_qt4_grwidget.cxx
      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/gr/qtgr/grwidget.cxx
    )
    target_sources(qt4gr PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/moc_qt4_grwidget.cxx)
  else()
    set_target_properties(qt4gr PROPERTIES AUTOMOC ON AUTORCC ON)
    target_sources(qt4gr PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/lib/gr/qtgr/grwidget.h)
  endif()
  add_library(GR::qt4gr ALIAS qt4gr)
endif()

if(Qt5Widgets_FOUND AND Qt5Core_FOUND)
  add_library(qt5gr SHARED lib/gr/qtgr/grwidget.cxx)
  target_link_libraries(qt5gr PUBLIC GR::GR)
  target_link_libraries(qt5gr PUBLIC Qt5::Core Qt5::Widgets)
  if(MINGW AND CMAKE_SYSTEM_PROCESSOR STREQUAL "i686")
    target_compile_options(qt5gr PRIVATE -fno-exceptions)
  endif()
  target_compile_options(qt5gr PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  set_target_properties(qt5gr PROPERTIES SUFFIX "${GR_SHARED_LIBRARY_SUFFIX}" INSTALL_RPATH "${INSTALL_RPATH}")
  if(GR_MANUAL_MOC_AND_RCC)
    set_target_properties(qt5gr PROPERTIES AUTOMOC OFF AUTORCC OFF)
    add_custom_command(
      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_qt5_grwidget.cxx
      COMMAND ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${QT5_MOC_INCLUDE_FLAGS}
              ${CMAKE_CURRENT_SOURCE_DIR}/lib/gr/qtgr/grwidget.h -o ${CMAKE_CURRENT_BINARY_DIR}/moc_qt5_grwidget.cxx
      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/gr/qtgr/grwidget.cxx
    )
    target_sources(qt5gr PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/moc_qt5_grwidget.cxx)
  else()
    set_target_properties(qt5gr PROPERTIES AUTOMOC ON AUTORCC ON)
    target_sources(qt5gr PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/lib/gr/qtgr/grwidget.h)
  endif()
  set_target_properties(qt5gr PROPERTIES SOVERSION 0)
  add_library(GR::qt5gr ALIAS qt5gr)
endif()

if(Qt6Widgets_FOUND AND Qt6Core_FOUND)
  add_library(qt6gr SHARED lib/gr/qtgr/grwidget.cxx)
  target_link_libraries(qt6gr PUBLIC GR::GR)
  target_link_libraries(qt6gr PUBLIC Qt6::Core Qt6::Widgets)
  if(MINGW AND CMAKE_SYSTEM_PROCESSOR STREQUAL "i686")
    target_compile_options(qt6gr PRIVATE -fno-exceptions)
  endif()
  target_compile_options(qt6gr PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  set_target_properties(qt6gr PROPERTIES SUFFIX "${GR_SHARED_LIBRARY_SUFFIX}" INSTALL_RPATH "${INSTALL_RPATH}")
  if(GR_MANUAL_MOC_AND_RCC)
    set_target_properties(qt6gr PROPERTIES AUTOMOC OFF AUTORCC OFF)
    add_custom_command(
      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_qt6_grwidget.cxx
      COMMAND ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${QT6_MOC_INCLUDE_FLAGS}
              ${CMAKE_CURRENT_SOURCE_DIR}/lib/gr/qtgr/grwidget.h -o ${CMAKE_CURRENT_BINARY_DIR}/moc_qt6_grwidget.cxx
      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/gr/qtgr/grwidget.cxx
    )
    target_sources(qt6gr PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/moc_qt6_grwidget.cxx)
  else()
    set_target_properties(qt6gr PROPERTIES AUTOMOC ON AUTORCC ON)
    target_sources(qt6gr PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/lib/gr/qtgr/grwidget.h)
  endif()
  set_target_properties(qt6gr PROPERTIES SOVERSION 0)
  add_library(GR::qt6gr ALIAS qt6gr)
endif()

if(Qt6Widgets_FOUND
   AND Qt6Core_FOUND
   AND (NOT MINGW OR NOT CMAKE_SYSTEM_PROCESSOR STREQUAL "i686")
)
  add_library(
    grplotWidget SHARED
    lib/grm/grplot/gredit/AddElementWidget.cpp
    lib/grm/grplot/gredit/BoundingLogic.cpp
    lib/grm/grplot/gredit/BoundingObject.cpp
    lib/grm/grplot/gredit/CustomTreeWidgetItem.cpp
    lib/grm/grplot/gredit/EditElementWidget.cpp
    lib/grm/grplot/gredit/TableWidget.cpp
    lib/grm/grplot/gredit/TreeWidget.cpp
    lib/grm/grplot/grplotWidget.cxx
    lib/grm/grplot/qtterm/ArgsWrapper.cpp
    lib/grm/grplot/qtterm/Receiver.cpp
    lib/grm/grplot/util.cxx
  )
  target_link_libraries(grplotWidget PUBLIC GR::GRM)
  target_link_libraries(grplotWidget PUBLIC GR::GR)
  target_link_libraries(grplotWidget PUBLIC Qt6::Core Qt6::Widgets)
  target_include_directories(grplotWidget INTERFACE $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/grplotWidget>)
  target_compile_definitions(grplotWidget PRIVATE GRDIR="${GR_DIRECTORY}")
  if(NOT TARGET XercesC::XercesC)
    target_compile_definitions(grplotWidget PRIVATE NO_XERCES_C)
  endif()
  target_compile_options(grplotWidget PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  set_target_properties(grplotWidget PROPERTIES SUFFIX "${GR_SHARED_LIBRARY_SUFFIX}" INSTALL_RPATH "${INSTALL_RPATH}")
  set_target_properties(grplotWidget PROPERTIES SOVERSION 0)
  if(GR_MANUAL_MOC_AND_RCC)
    set_target_properties(grplotWidget PROPERTIES AUTOMOC OFF AUTORCC OFF)
    add_custom_command(
      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_grplotWidget.cxx
      COMMAND
        ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${QT6_MOC_INCLUDE_FLAGS}
        ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/grplotWidget.hxx -o ${CMAKE_CURRENT_BINARY_DIR}/moc_grplotWidget.cxx
      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/grplotWidget.cxx
    )
    target_sources(grplotWidget PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/moc_grplotWidget.cxx)
  else()
    set_target_properties(grplotWidget PROPERTIES AUTOMOC ON AUTORCC ON)
    target_sources(grplotWidget PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/grplotWidget.hxx)
  endif()
  add_library(GR::grplotWidget ALIAS grplotWidget)
endif()

string(APPEND GR_REPORT "\nGKS applications:\n")

if(APPLE)
  if(ZeroMQ_FOUND)
    if(GR_PREFER_XCODEBUILD)
      find_program(XCODE_BUILD xcodebuild CMAKE_FIND_ROOT_PATH_BOTH)
      if(XCODE_BUILD)
        execute_process(COMMAND ${XCODE_BUILD} -version RESULT_VARIABLE XCODE_BUILD_CHECK_RESULT)
        if(NOT XCODE_BUILD_CHECK_RESULT EQUAL 0)
          set(XCODE_BUILD "XCODE_BUILD-NOTFOUND")
        endif()
      endif()
    endif()
    if(GR_PREFER_XCODEBUILD AND XCODE_BUILD)
      set(GKSTERM_SOURCES
          lib/gks/quartz/GKSTerm.h
          lib/gks/quartz/GKSTerm.icns
          lib/gks/quartz/GKSTerm.m
          lib/gks/quartz/GKSTerm_Prefix.pch
          lib/gks/quartz/GKSView.h
          lib/gks/quartz/GKSView.m
          lib/gks/quartz/Info.plist
          lib/gks/quartz/MacOSXBundleInfo.plist.in
          lib/gks/quartz/main.m
          lib/gks/quartz/English.lproj/InfoPlist.strings
          lib/gks/quartz/English.lproj/ExtendSavePanel.nib/designable.nib
          lib/gks/quartz/English.lproj/ExtendSavePanel.nib/keyedobjects.nib
          lib/gks/quartz/English.lproj/MainMenu.nib/designable.nib
          lib/gks/quartz/English.lproj/MainMenu.nib/keyedobjects.nib
          lib/gks/quartz/GKSTerm.xcodeproj/project.pbxproj
          lib/gks/quartz/GKSTerm.xcodeproj/project.xcworkspace
          lib/gks/quartz/GKSTerm.xcodeproj/project.xcworkspace/contents.xcworkspacedata
      )
      add_custom_target(
        GKSTerm ALL
        COMMAND ${XCODE_BUILD} -arch ${CMAKE_SYSTEM_PROCESSOR} -project GKSTerm.xcodeproj
                CONFIGURATION_BUILD_DIR=${CMAKE_CURRENT_BINARY_DIR}/GKSTerm
        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/GKSTerm-build/quartz
        DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/GKSTerm-build/quartz/GKSTerm.xcodeproj ZeroMQ::ZeroMQ gks_static
      )
      # Disable autoformat to not break the `sed` command
      # cmake-format: off
      add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/GKSTerm-build/quartz/GKSTerm.xcodeproj
        COMMAND ${CMAKE_COMMAND} -E copy_directory lib/gks ${CMAKE_CURRENT_BINARY_DIR}/GKSTerm-build
        COMMAND sed -e s%../../../3rdparty/build/lib/libzmq.a%${ZeroMQ_LIBRARY}% -e s%../../../3rdparty/build/include/zmq.h%${ZeroMQ_INCLUDE_DIR}/zmq.h% ${CMAKE_SOURCE_DIR}/lib/gks/quartz/GKSTerm.xcodeproj/project.pbxproj >${CMAKE_CURRENT_BINARY_DIR}/GKSTerm-build/quartz/GKSTerm.xcodeproj/project.pbxproj
        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
        DEPENDS ${GKS_SOURCES} ${GKSTERM_SOURCES}
      )
      # cmake-format: on
      string(APPEND GR_REPORT "- GKSTerm: Yes (Xcode build)\n")
    else()
      add_executable(GKSTerm MACOSX_BUNDLE lib/gks/quartz/GKSTerm.m lib/gks/quartz/GKSView.m lib/gks/quartz/main.m)
      target_link_libraries(GKSTerm PUBLIC ZeroMQ::ZeroMQ)
      target_link_libraries(
        GKSTerm PUBLIC gks_static
                       "-framework CoreGraphics -framework CoreFoundation -framework CoreVideo -framework Cocoa"
      )

      add_custom_command(
        TARGET GKSTerm
        POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/lib/gks/quartz/English.lproj
                ${CMAKE_CURRENT_BINARY_DIR}/GKSTerm.app/Contents/Resources/English.lproj
        BYPRODUCTS ${CMAKE_CURRENT_BINARY_DIR}/GKSTerm.app/Contents/Resources/English.lproj
      )
      target_sources(GKSTerm PRIVATE lib/gks/quartz/GKSTerm.icns)
      set_source_files_properties(lib/gks/quartz/GKSTerm.icns PROPERTIES MACOSX_PACKAGE_LOCATION Resources/)
      target_compile_options(GKSTerm PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
      set_target_properties(
        GKSTerm
        PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "GKSTerm"
                   MACOSX_BUNDLE_GUI_IDENTIFIER "de.fz-juelich.GKSTerm"
                   MACOSX_BUNDLE_ICON_FILE "GKSTerm"
                   MACOSX_BUNDLE_BUNDLE_VERSION "${GR_VERSION}"
                   MACOSX_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_SOURCE_DIR}/lib/gks/quartz/MacOSXBundleInfo.plist.in"
      )
      set(GKSTerm_MACOSX_BUNDLE_SIGNATURE "GKST")
      set(GKSTerm_MACOSX_MAIN_NIB_FILE "MainMenu")
      string(APPEND GR_REPORT "- GKSTerm: Yes (Build without Xcode)\n")
    endif()
  else()
    string(APPEND GR_REPORT "- GKSTerm: No (ZeroMQ not found)\n")
  endif()
endif()

if(Qt4_FOUND
   OR (Qt5Widgets_FOUND
       AND Qt5Core_FOUND
       AND Qt5Network_FOUND
      )
   OR (Qt6Widgets_FOUND
       AND Qt6Core_FOUND
       AND Qt6Network_FOUND
      )
)
  add_executable(gksqt WIN32 MACOSX_BUNDLE lib/gks/qt/gksqt.cxx lib/gks/qt/gksserver.cxx lib/gks/qt/gkswidget.cxx)
  target_link_libraries(gksqt PUBLIC gks_static)
  if(Qt6Widgets_FOUND
     AND Qt6Core_FOUND
     AND Qt6Network_FOUND
  )
    target_link_libraries(gksqt PUBLIC Qt6::Widgets Qt6::Core Qt6::Network)
    set(gksqt_INSTALL_RPATH "${INSTALL_RPATH};${Qt6_LIBRARY_DIR}")
  elseif(
    Qt5Widgets_FOUND
    AND Qt5Core_FOUND
    AND Qt5Network_FOUND
  )
    target_link_libraries(gksqt PUBLIC Qt5::Widgets Qt5::Core Qt5::Network)
    set(gksqt_INSTALL_RPATH "${INSTALL_RPATH};${Qt5_LIBRARY_DIR}")
  elseif(Qt4_FOUND)
    target_link_libraries(gksqt PUBLIC Qt4::QtCore Qt4::QtGui Qt4::QtNetwork)
    set(gksqt_INSTALL_RPATH "${INSTALL_RPATH};${Qt4_LIBRARY_DIR}")
  endif()
  set_target_properties(
    gksqt PROPERTIES CXX_STANDARD 11 CXX_EXTENSIONS OFF CXX_STANDARD_REQUIRED ON INSTALL_RPATH "${gksqt_INSTALL_RPATH}"
  )
  if(MINGW AND CMAKE_SYSTEM_PROCESSOR STREQUAL "i686")
    target_compile_options(gksqt PRIVATE -fno-exceptions)
  endif()
  target_compile_options(gksqt PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  if(GR_MANUAL_MOC_AND_RCC)
    set_target_properties(gksqt PROPERTIES AUTOMOC OFF AUTORCC OFF)
    if(Qt6Widgets_FOUND
       AND Qt6Core_FOUND
       AND Qt6Network_FOUND
    )
      set(MOC_INCLUDE_FLAGS ${QT6_MOC_INCLUDE_FLAGS})
    elseif(
      Qt5Widgets_FOUND
      AND Qt5Core_FOUND
      AND Qt5Network_FOUND
    )
      set(MOC_INCLUDE_FLAGS ${QT5_MOC_INCLUDE_FLAGS})
    else()
      set(MOC_INCLUDE_FLAGS ${QT4_MOC_INCLUDE_FLAGS})
    endif()
    add_custom_command(
      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_gkswidget.cxx
      COMMAND ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${MOC_INCLUDE_FLAGS}
              ${CMAKE_CURRENT_SOURCE_DIR}/lib/gks/qt/gkswidget.h -o ${CMAKE_CURRENT_BINARY_DIR}/moc_gkswidget.cxx
      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/gks/qt/gkswidget.h
    )
    add_custom_command(
      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_gksserver.cxx
      COMMAND ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${MOC_INCLUDE_FLAGS}
              ${CMAKE_CURRENT_SOURCE_DIR}/lib/gks/qt/gksserver.h -o ${CMAKE_CURRENT_BINARY_DIR}/moc_gksserver.cxx
      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/gks/qt/gksserver.h
    )
    add_custom_command(
      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/qrc_gksqt.cxx
      COMMAND ${QT_RCC_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/lib/gks/qt/gksqt.qrc -o
              ${CMAKE_CURRENT_BINARY_DIR}/qrc_gksqt.cxx
      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/gks/qt/gksqt.qrc
    )
    target_sources(
      gksqt PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/moc_gksserver.cxx ${CMAKE_CURRENT_BINARY_DIR}/moc_gkswidget.cxx
                    ${CMAKE_CURRENT_BINARY_DIR}/qrc_gksqt.cxx
    )
  else()
    set_target_properties(gksqt PROPERTIES AUTOMOC ON AUTORCC ON)
    target_sources(
      gksqt PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/lib/gks/qt/gksserver.h
                    ${CMAKE_CURRENT_SOURCE_DIR}/lib/gks/qt/gkswidget.h ${CMAKE_CURRENT_SOURCE_DIR}/lib/gks/qt/gksqt.qrc
    )
  endif()
  if(APPLE)
    target_sources(gksqt PRIVATE lib/gks/qt/gksqt.icns)
    set_source_files_properties(lib/gks/qt/gksqt.icns PROPERTIES MACOSX_PACKAGE_LOCATION Resources/)
    set_target_properties(
      gksqt
      PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "gksqt"
                 MACOSX_BUNDLE_GUI_IDENTIFIER "de.fz-juelich.gksqt"
                 MACOSX_BUNDLE_ICON_FILE "gksqt"
                 MACOSX_BUNDLE_BUNDLE_VERSION "${GR_VERSION}"
    )
    set(gksqt_MACOSX_BUNDLE_SIGNATURE "gksqt")
    set(gksqt_MACOSX_MAIN_NIB_FILE "")
  endif()
  string(APPEND GR_REPORT "- gksqt: Yes\n")
else()
  string(APPEND GR_REPORT "- gksqt: No (Qt4 / Qt5 / Qt6 not found)\n")
endif()

if((Qt6Widgets_FOUND
    AND Qt6Core_FOUND
    AND Qt6Gui_FOUND
   )
   OR (Qt5Widgets_FOUND
       AND Qt5Core_FOUND
       AND Qt5Gui_FOUND
      )
)

  if(NOT MINGW OR NOT CMAKE_SYSTEM_PROCESSOR STREQUAL "i686")
    add_executable(
      grplot WIN32 MACOSX_BUNDLE
      lib/grm/grplot/gredit/AddElementWidget.cpp
      lib/grm/grplot/gredit/BoundingLogic.cpp
      lib/grm/grplot/gredit/BoundingObject.cpp
      lib/grm/grplot/gredit/CustomTreeWidgetItem.cpp
      lib/grm/grplot/gredit/EditElementWidget.cpp
      lib/grm/grplot/gredit/TableWidget.cpp
      lib/grm/grplot/gredit/TreeWidget.cpp
      lib/grm/grplot/grplot.cxx
      lib/grm/grplot/grplotMainwindow.cxx
      lib/grm/grplot/grplotWidget.cxx
      lib/grm/grplot/qtterm/ArgsWrapper.cpp
      lib/grm/grplot/qtterm/Receiver.cpp
      lib/grm/grplot/util.cxx
    )
    if(Qt6Widgets_FOUND AND Qt6Core_FOUND)
      target_link_libraries(grplot PRIVATE Qt6::Widgets Qt6::Core Qt6::Gui grm_static)
      set(grplot_INSTALL_RPATH "${INSTALL_RPATH};${Qt6_LIBRARY_DIR}")
    else()
      target_link_libraries(grplot PRIVATE Qt5::Widgets Qt5::Core Qt5::Gui grm_static)
      set(grplot_INSTALL_RPATH "${INSTALL_RPATH};${Qt5_LIBRARY_DIR}")
    endif()
    target_compile_definitions(grplot PRIVATE GRDIR="${GR_DIRECTORY}")
    if(NOT TARGET XercesC::XercesC)
      target_compile_definitions(grplot PRIVATE NO_XERCES_C)
    endif()
    set_target_properties(
      grplot PROPERTIES CXX_STANDARD 17 CXX_EXTENSIONS OFF CXX_STANDARD_REQUIRED ON INSTALL_RPATH
                                                                                    "${grplot_INSTALL_RPATH}"
    )
    if(WIN32)
      if(MINGW)
        target_link_options(grplot PRIVATE -mconsole)
      else()
        target_link_options(grplot PRIVATE /SUBSYSTEM:CONSOLE)
      endif()
    endif()
    if(GR_MANUAL_MOC_AND_RCC)
      set_target_properties(grplot PROPERTIES AUTOMOC OFF AUTORCC OFF)
      if(Qt6Widgets_FOUND AND Qt6Core_FOUND)
        set(MOC_INCLUDE_FLAGS ${QT6_MOC_INCLUDE_FLAGS})
      else()
        set(MOC_INCLUDE_FLAGS ${QT5_MOC_INCLUDE_FLAGS})
      endif()
      add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_grplotWidget.cxx
        COMMAND
          ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${MOC_INCLUDE_FLAGS}
          ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/grplotWidget.hxx -o
          ${CMAKE_CURRENT_BINARY_DIR}/moc_grplotWidget.cxx
        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/grplotWidget.hxx
      )
      add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_grplotMainwindow.cxx
        COMMAND
          ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${MOC_INCLUDE_FLAGS}
          ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/grplotMainwindow.hxx -o
          ${CMAKE_CURRENT_BINARY_DIR}/moc_grplotMainwindow.cxx
        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/grplotMainwindow.hxx
      )
      add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_ArgsWrapper.cpp
        COMMAND
          ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${MOC_INCLUDE_FLAGS}
          ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/qtterm/ArgsWrapper.hxx -o
          ${CMAKE_CURRENT_BINARY_DIR}/moc_ArgsWrapper.cpp
        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/qtterm/ArgsWrapper.hxx
      )
      add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_Receiver.cpp
        COMMAND
          ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${MOC_INCLUDE_FLAGS}
          ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/qtterm/Receiver.hxx -o ${CMAKE_CURRENT_BINARY_DIR}/moc_Receiver.cpp
        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/qtterm/Receiver.hxx
      )

      add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_BoundingLogic.cpp
        COMMAND
          ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${MOC_INCLUDE_FLAGS}
          ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/BoundingLogic.hxx -o
          ${CMAKE_CURRENT_BINARY_DIR}/moc_BoundingLogic.cpp
        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/BoundingLogic.hxx
      )
      add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_BoundingObject.cpp
        COMMAND
          ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${MOC_INCLUDE_FLAGS}
          ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/BoundingObject.hxx -o
          ${CMAKE_CURRENT_BINARY_DIR}/moc_BoundingObject.cpp
        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/BoundingObject.hxx
      )
      add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_CustomTreeWidgetItem.cpp
        COMMAND
          ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${MOC_INCLUDE_FLAGS}
          ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/CustomTreeWidgetItem.hxx -o
          ${CMAKE_CURRENT_BINARY_DIR}/moc_CustomTreeWidgetItem.cpp
        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/CustomTreeWidgetItem.hxx
      )
      add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_TreeWidget.cpp
        COMMAND
          ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${MOC_INCLUDE_FLAGS}
          ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/TreeWidget.hxx -o
          ${CMAKE_CURRENT_BINARY_DIR}/moc_TreeWidget.cpp
        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/TreeWidget.hxx
      )
      add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_AddElementWidget.cpp
        COMMAND
          ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${MOC_INCLUDE_FLAGS}
          ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/AddElementWidget.hxx -o
          ${CMAKE_CURRENT_BINARY_DIR}/moc_AddElementWidget.cpp
        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/AddElementWidget.hxx
      )
      add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_EditElementWidget.cpp
        COMMAND
          ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${MOC_INCLUDE_FLAGS}
          ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/EditElementWidget.hxx -o
          ${CMAKE_CURRENT_BINARY_DIR}/moc_EditElementWidget.cpp
        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/EditElementWidget.hxx
      )
      add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/moc_TableWidget.cpp
        COMMAND
          ${QT_MOC_EXECUTABLE} -DGRDIR=\"$(GR_DIRECTORY)\" ${MOC_INCLUDE_FLAGS}
          ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/TableWidget.hxx -o
          ${CMAKE_CURRENT_BINARY_DIR}/moc_TableWidget.cpp
        DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/TableWidget.hxx
      )
      target_sources(
        grplot
        PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/moc_grplotMainwindow.cxx
                ${CMAKE_CURRENT_BINARY_DIR}/moc_grplotWidget.cxx
                ${CMAKE_CURRENT_BINARY_DIR}/moc_AddElementWidget.cpp
                ${CMAKE_CURRENT_BINARY_DIR}/moc_BoundingLogic.cpp
                ${CMAKE_CURRENT_BINARY_DIR}/moc_BoundingObject.cpp
                ${CMAKE_CURRENT_BINARY_DIR}/moc_CustomTreeWidgetItem.cpp
                ${CMAKE_CURRENT_BINARY_DIR}/moc_EditElementWidget.cpp
                ${CMAKE_CURRENT_BINARY_DIR}/moc_TableWidget.cpp
                ${CMAKE_CURRENT_BINARY_DIR}/moc_TreeWidget.cpp
                ${CMAKE_CURRENT_BINARY_DIR}/moc_ArgsWrapper.cpp
                ${CMAKE_CURRENT_BINARY_DIR}/moc_Receiver.cpp
      )
    else()
      set_target_properties(grplot PROPERTIES AUTOMOC ON AUTORCC ON)
      target_sources(
        grplot
        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/grplotMainwindow.hxx
                ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/grplotWidget.hxx
                ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/AddElementWidget.hxx
                ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/BoundingLogic.hxx
                ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/BoundingObject.hxx
                ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/CustomTreeWidgetItem.hxx
                ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/EditElementWidget.hxx
                ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/TableWidget.hxx
                ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/gredit/TreeWidget.hxx
                ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/qtterm/ArgsWrapper.hxx
                ${CMAKE_CURRENT_SOURCE_DIR}/lib/grm/grplot/qtterm/Receiver.hxx
      )
    endif()
    if(APPLE)
      set_target_properties(grplot PROPERTIES MACOSX_BUNDLE_GUI_IDENTIFIER "de.fz-juelich.grplot")
    endif()
    if(WIN32)
      target_compile_definitions(grplot PRIVATE GR_STATIC_LIB)
    endif()
    target_compile_options(grplot PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  else()
    add_executable(grplot lib/grm/grplot/grplot.cxx)
  endif()
  string(APPEND GR_REPORT "- grplot: Yes\n")
else()
  string(APPEND GR_REPORT "- grplot: No (Qt6 and Qt5 not found)\n")
endif()

add_executable(gksm lib/gks/gksm.c)
target_link_libraries(gksm PUBLIC gks_shared Freetype::Freetype ZLIB::ZLIB)
string(APPEND GR_REPORT "- gksm: Yes\n")

string(APPEND GR_REPORT "\nGRM integrations:\n")
if(TARGET XercesC::XercesC)
  string(APPEND GR_REPORT "- Xerces-C++: Yes\n")
else()
  string(APPEND GR_REPORT "- Xerces-C++: No\n")
endif()

if(GR_BUILD_DEMOS)
  add_executable(gksdemo lib/gks/demo.c)
  target_link_libraries(gksdemo PUBLIC gks_static)
  target_compile_options(gksdemo PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  set_target_properties(gksdemo PROPERTIES C_STANDARD 90 C_EXTENSIONS OFF C_STANDARD_REQUIRED ON)

  add_executable(grdemo lib/gr/demo.c)
  target_link_libraries(grdemo PUBLIC GR::GR)
  target_link_libraries(grdemo PUBLIC GR::GKS)
  target_compile_options(grdemo PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  set_target_properties(grdemo PROPERTIES C_STANDARD 90 C_EXTENSIONS OFF C_STANDARD_REQUIRED ON)

  add_subdirectory(lib/grm/test/public_api/grm grm_test_public_api)
  add_subdirectory(lib/grm/test/internal_api/grm grm_test_internal_api)
endif()

if(GR_BUILD_GKSM)
  add_executable(gksm lib/gks/gksm.c)
  target_link_libraries(gksm PUBLIC gks_static)
  target_compile_options(gksm PRIVATE ${COMPILER_OPTION_ERROR_IMPLICIT})
  set_target_properties(gksm PROPERTIES C_STANDARD 90 C_EXTENSIONS OFF C_STANDARD_REQUIRED ON)
endif()

if(GR_INSTALL)
  install(FILES LICENSE.md DESTINATION ${CMAKE_INSTALL_DATADIR}/licenses/GR)
  install(
    FILES lib/grm/src/grm/dom_render/graphics_tree/schema.xsd
    DESTINATION ${CMAKE_INSTALL_DATADIR}/xml/GRM
    RENAME grm_graphics_tree_schema.xsd
  )
  install(
    FILES lib/grm/src/grm/dom_render/graphics_tree/private_schema.xsd
    DESTINATION ${CMAKE_INSTALL_DATADIR}/xml/GRM
    RENAME grm_graphics_tree_private_schema.xsd
  )
  include(CMakePackageConfigHelpers)
  configure_package_config_file(
    "cmake/Config.cmake.in" "GRConfig.cmake" INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/GR"
  )
  write_basic_package_version_file(
    ${CMAKE_CURRENT_BINARY_DIR}/GRConfigVersion.cmake
    VERSION ${GR_VERSION}
    COMPATIBILITY SameMajorVersion
  )
  install(FILES "${CMAKE_CURRENT_BINARY_DIR}/GRConfig.cmake" "${CMAKE_CURRENT_BINARY_DIR}/GRConfigVersion.cmake"
          DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/GR"
  )
  install(
    TARGETS gks_shared gr_shared gr3_shared grm_shared
    EXPORT GRTargets
    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
  )
  if(TARGET qt4gr)
    install(
      TARGETS qt4gr
      EXPORT GRTargets
      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
      LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    )
  endif()
  if(TARGET qt5gr)
    install(
      TARGETS qt5gr
      EXPORT GRTargets
      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
      LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    )
  endif()
  if(TARGET qt6gr)
    install(
      TARGETS qt6gr
      EXPORT GRTargets
      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
      LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    )
  endif()
  if(TARGET grplotWidget)
    install(
      TARGETS grplotWidget
      EXPORT GRTargets
      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
      LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    )
  endif()
  install(
    EXPORT GRTargets
    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/GR"
    NAMESPACE GR::
  )
  foreach(PACKAGE gr gr3 gks grm)
    configure_file("${PACKAGE}.pc.in" "${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}.pc" @ONLY)
    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}.pc" DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig/")
  endforeach()
  install(
    TARGETS gks_static
            gr_static
            gr3_static
            grm_static
            aggplugin
            cairoplugin
            glplugin
            gsplugin
            gtkplugin
            pgfplugin
            svgplugin
            videoplugin
            wmfplugin
            x11plugin
            zmqplugin
            qtplugin
            qt5plugin
            qt6plugin
    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
  )
  if(TARGET gr3platform)
    install(
      TARGETS gr3platform
      LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    )
  endif()
  if(TARGET qt4gr)
    install(
      TARGETS qt4gr
      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
      LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    )
  endif()
  if(TARGET qt5gr)
    install(
      TARGETS qt5gr
      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
      LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    )
  endif()
  if(TARGET qt6gr)
    install(
      TARGETS qt6gr
      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
      LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    )
  endif()
  if(TARGET quartzplugin)
    install(
      TARGETS quartzplugin
      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
      LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    )
  endif()
  if(TARGET GKSTerm)
    if(XCODE_BUILD)
      install(
        DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/GKSTerm/GKSTerm.app
        DESTINATION Applications
        USE_SOURCE_PERMISSIONS
      )
    else()
      install(TARGETS GKSTerm BUNDLE DESTINATION Applications)
    endif()
  endif()
  if(TARGET gksqt)
    install(
      TARGETS gksqt
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
      BUNDLE DESTINATION Applications
    )
  endif()
  if(TARGET grplotWidget)
    install(
      TARGETS grplotWidget
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
      BUNDLE DESTINATION Applications
    )
  endif()
  if(TARGET grplot)
    install(
      TARGETS grplot
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
      BUNDLE DESTINATION Applications
    )
    install(
      FILES lib/grm/grplot/README.md
      DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/doc/grplot
      RENAME grplot.man.md
    )
  endif()
  if(TARGET gksm)
    install(
      TARGETS gksm
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
      BUNDLE DESTINATION Applications
    )
  endif()
  install(FILES lib/gr/gr.h lib/gks/gks.h lib/gr3/gr3.h lib/grm/include/grm.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/)
  install(DIRECTORY lib/grm/include/grm DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/)
  if(TARGET qt4gr
     OR TARGET qt5gr
     OR TARGET qt6gr
  )
    install(FILES lib/gr/qtgr/grwidget.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/)
  endif()
  if(TARGET grplotWidget)
    install(FILES lib/grm/grplot/grplotWidget.hxx lib/grm/grplot/util.hxx
            DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/grplotWidget
    )
    file(GLOB GREDIT_HEADERS "lib/grm/grplot/gredit/*.h")
    install(FILES ${GREDIT_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/grplotWidget/gredit)
    file(GLOB QTTERM_HEADERS "lib/grm/grplot/qtterm/*.h")
    install(FILES ${QTTERM_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/grplotWidget/qtterm)
  endif()
  install(
    DIRECTORY lib/gks/fonts
    DESTINATION ${CMAKE_INSTALL_PREFIX}/
    USE_SOURCE_PERMISSIONS
  )
endif()

message(${GR_REPORT})