#
# some macros for NGL
#
# $Id$
# $HeadURL$
# $Author$
#
#
# <FOO>_INSTALL_PATH: prefix for installation path for component <FOO>
#
# NGL_ADD_LIBRARY: like ADD_LIBRARY but expects at least one of the
#                  buildcomponent keywords which triggers building
#                  and installation dependening on BUILD_<FOO> options
#                  The default visibility is set to 'hidden' (CMAKE_CXX_VISIBILITY_PRESET)
# NGL_ADD_LIBRARY2: Same as NGL_ADD_LIBRARY, but the export header (foo_export.h)
#                   is automatically created and the target is also automatically installed
#
# NGL_ADD_EXECUTABLE: like ADD_EXECUTABLE but expects at least on of the
#                  buildcomponent keywords which triggers building
#                  and installation dependening on BUILD_<FOO> optionsB
#
# NGL_TARGET_LINK_LIBRARIES: like TARGET_LINK_LIBRARIES but does not
#                  executes TARGET_LINK_LIBRARIES when the target is
#                  not been build because of BUILD_<FOO> options
#
# NGL_INSTALL_TARGET: Installs the target dependening on BUILD_WS and
#                  BUILD_SV options. When no arguments are given,
#                  INSTALL_DEFAULT_ARGS is used. The paths are modifed to
#                  make sure <FOO>_INSTALL_PATH is added
#
# NGL_ADD_BIG_RESOURCES - is using QT5_ADD_BIG_RESOURCES if available, otherwise QT5_ADD_RESOURCES
# NGL_WRAP_UI - deprecated, use QT5_WRAP_UI

INCLUDE(GenerateExportHeader) # for NGL_ADD_LIBRARY2
SET(_default_build OFF)
IF(BUILD_ALL)
  SET(_default_build ON)
ENDIF()

OPTION(BUILD_SV  "Build and install Server software parts" ${_default_build})
OPTION(BUILD_AAR  "Build and install AAR software parts" ${_default_build})
OPTION(BUILD_LTSCC  "Build and install LTS CC Conf" OFF)
OPTION(BUILD_HLA  "Build and install HLA Server software parts" OFF)
OPTION(BUILD_WS  "Build and install Workstation software parts" ${_default_build})
OPTION(BUILD_TOOLSWS "Build and install TOOLS for WS" OFF)
OPTION(BUILD_TOOLSSV "Build and install TOOLS for SV" OFF)

OPTION(BUILD_DEP_TEST_EXECUTABLES "Build executables for created libs to check library dependencies" OFF)
OPTION(BUILD_TS_FILES "Regenerate ts-files for translations" OFF)
OPTION(BUILD_STATIC_LIBRARIES "Build all libraries as static libraries" OFF)

IF(BUILD_STATIC_LIBRARIES)
  ADD_DEFINITIONS(-DBUILD_STATIC_LIBRARIES)
ENDIF()


SET(AAR_INSTALL_PATH "AAR")
SET(SV_INSTALL_PATH "SV")
SET(HLA_INSTALL_PATH "SV")
SET(DDS_INSTALL_PATH "SV")
SET(WS_INSTALL_PATH "WS")
SET(TOOLSWS_INSTALL_PATH "WS")
SET(TOOLSSV_INSTALL_PATH "SV")
IF(WIN32)
  SET(INSTALL_DEFAULT_ARGS  RUNTIME DESTINATION bin
                            LIBRARY DESTINATION bin
                            ARCHIVE DESTINATION lib COMPONENT Devel)
ELSE()
  SET(INSTALL_DEFAULT_ARGS  RUNTIME DESTINATION bin
                            LIBRARY DESTINATION lib
                            ARCHIVE DESTINATION lib COMPONENT Devel)
ENDIF()
SET(INSTALL_DEFAULT_ARGS_DEVEL RUNTIME DESTINATION bin COMPONENT Devel
                               LIBRARY DESTINATION lib COMPONENT Devel
                               ARCHIVE DESTINATION lib COMPONENT Devel)
SET(_components SV WS AAR TOOLSWS TOOLSSV HLA)

#
# Extrahierung der Buildoptionen aus den Kommandos
#
MACRO (NGL_GET_BUILDPARTS _args _buildopts)

  SET(${_buildopts} "")
  SET(_at_least_one_keyword_found OFF)

  LIST(FIND ${_args} "ALL" _all)
  IF (_all GREATER -1)
    LIST(REMOVE_AT ${_args} ${_all})
    SET(_at_least_one_keyword_found ON)
    FOREACH(_component ${_components})
      IF(BUILD_${_component})
        LIST(APPEND ${_buildopts} ${_component})
      ENDIF()
    ENDFOREACH()
  ELSE()
    FOREACH(_component ${_components})
      LIST(FIND ${_args} "${_component}" _idx)
      IF(_idx GREATER -1)
        LIST(REMOVE_AT ${_args} ${_idx})
        SET(_at_least_one_keyword_found ON)
        IF(BUILD_${_component})
          LIST(APPEND ${_buildopts} ${_component})
        ENDIF()
      ENDIF()
    ENDFOREACH()
  ENDIF()

  IF(NOT _at_least_one_keyword_found)
    MESSAGE(FATAL_ERROR "No software component keyword (ALL/SV/WS) given!")
  ENDIF()
ENDMACRO()

MACRO (NGL_PARSE_BUILDCOMPONENT_INTERNAL _args _properties _build_target)

  NGL_GET_BUILDPARTS(${_args} _buildopts)
  SET(${_build_target} OFF)

  FOREACH(_component ${_components})
    LIST(FIND _buildopts ${_component} _idx)
    IF(_idx GREATER -1)
      LIST(APPEND ${_properties} NGL_INSTALL_${_component} ON)
      SET(${_build_target} ON)
    ENDIF()
  ENDFOREACH()
  LIST(FIND ${_args} "NO_TRANSLATION" _no_i18n)
  IF (_no_i18n GREATER -1)
    LIST(REMOVE_AT ${_args} ${_no_i18n})
    LIST(APPEND ${_properties} NO_TRANSLATION ON)
  ENDIF ()

ENDMACRO()

MACRO(NGL_ADD_TRANSLATION output_location _qm_file_name _ts_file _qm_files)
  GET_FILENAME_COMPONENT(_abs_FILE ${_ts_file} ABSOLUTE)
  FILE(MAKE_DIRECTORY "${output_location}")
  SET(qm "${output_location}/${_qm_file_name}.qm")

  ADD_CUSTOM_COMMAND(OUTPUT ${qm}
      COMMAND Qt5::lrelease
      ARGS ${_abs_FILE} -qm ${qm}
      DEPENDS ${_abs_FILE}
  )
  SET(${_qm_files} ${${_qm_files}} ${qm})
ENDMACRO()

#
# NGL_ADD_LIBRARY / NGL_ADD_LIBRARY2
#
MACRO (NGL_ADD_LIBRARY)

  SET(_args ${ARGN})

  # nur statische Libs unter Windows
  IF(BUILD_STATIC_LIBRARIES)
    LIST(FIND _args "SHARED" _is_shared)
    IF(_is_shared GREATER -1)
      LIST(REMOVE_AT _args ${_is_shared})
    ENDIF()
  ENDIF()

  SET(_properties "")
  SET(_build_target OFF)
  NGL_PARSE_BUILDCOMPONENT_INTERNAL(_args _properties _build_target)
  LIST(GET _args 0 _target_NAME)

  IF(_build_target)
    # create library
    ADD_LIBRARY(${_args})
    SET_TARGET_PROPERTIES(${_target_NAME} PROPERTIES ${_properties})

    IF(NOT MSVC AND NOT USE_ASAN AND NOT USE_UBSAN)
      # APPEND_STRING - make sure to add whitespace before string to append
      SET_PROPERTY(TARGET ${_target_NAME} APPEND_STRING PROPERTY LINK_FLAGS " -Wl,--no-undefined")
    ENDIF()

    # add MAKE_FOO_LIB
    STRING(TOUPPER ${_target_NAME} _symbol)
    STRING(REGEX REPLACE "[^_A-Za-z0-9]" "_" _symbol ${_symbol})
    IF(BUILD_STATIC_LIBRARIES)
      SET(_symbol "${_symbol}_EXPORT=")
      TARGET_COMPILE_DEFINITIONS(${_target_NAME} PUBLIC ${_symbol})
    ELSE()
      GET_TARGET_PROPERTY(target_type ${_target_NAME} TYPE)
      IF(target_type STREQUAL "SHARED_LIBRARY" OR
         target_type STREQUAL "MODULE_LIBRARY")
        SET(_symbol "MAKE_${_symbol}_LIB")
        TARGET_COMPILE_DEFINITIONS(${_target_NAME} PRIVATE ${_symbol})
      ENDIF()
    ENDIF()

    IF(BUILD_DEP_TEST_EXECUTABLES)
      LIST(FIND _args "SHARED" _is_shared)
      IF(_is_shared GREATER -1)
        LIST(REMOVE_AT _args ${_is_shared})
        LIST(REMOVE_ITEM _args "${_target_NAME}")
        ADD_EXECUTABLE(${_target_NAME}_dep_test ${NGL_MODULE_DIR}/ngl_dep_test_main.cpp ${_args})
      ENDIF()
    ENDIF()
    SET_PROPERTY(GLOBAL APPEND PROPERTY NGL_TS_TARGETS ${_target_NAME})
  ENDIF()

  #MESSAGE(STATUS "Build: ${_target_NAME} ${_build_ws} ${_build_sv}")

ENDMACRO()

MACRO (NGL_ADD_LIBRARY2)

  SET(_args ${ARGN})

  # nur statische Libs unter Windows
  IF(BUILD_STATIC_LIBRARIES)
    LIST(FIND _args "SHARED" _is_shared)
    IF(_is_shared GREATER -1)
      LIST(REMOVE_AT _args ${_is_shared})
    ENDIF()
  ENDIF()

  SET(_properties "")
  SET(_build_target OFF)
  NGL_PARSE_BUILDCOMPONENT_INTERNAL(_args _properties _build_target)
  LIST(GET _args 0 _target_NAME)

  IF(_build_target)
    # create library
    ADD_LIBRARY(${_args})
    SET_TARGET_PROPERTIES(${_target_NAME} PROPERTIES ${_properties})

    IF(NOT MSVC AND NOT USE_ASAN AND NOT USE_UBSAN)
      # APPEND_STRING - make sure to add whitespace before string to append
      SET_PROPERTY(TARGET ${_target_NAME} APPEND_STRING PROPERTY LINK_FLAGS " -Wl,--no-undefined")
    ENDIF()
    TARGET_INCLUDE_DIRECTORIES(${_target_NAME}
      PUBLIC
        ${CMAKE_CURRENT_BINARY_DIR}/../
    )
    GET_PROPERTY(type TARGET ${_target_NAME} PROPERTY TYPE)
    IF(NOT ${type} STREQUAL "STATIC_LIBRARY")
      NGL_INSTALL_TARGET(${_target_NAME})
    ENDIF()
    IF(${type} STREQUAL "SHARED_LIBRARY" OR ${type} STREQUAL "MODULE_LIBRARY")
      GENERATE_EXPORT_HEADER(${_target_NAME})
    ENDIF()
    IF(BUILD_DEP_TEST_EXECUTABLES)
      IF(${type} STREQUAL "SHARED_LIBRARY")
        LIST(REMOVE_ITEM _args "SHARED")
        LIST(REMOVE_ITEM _args "${_target_NAME}")
        ADD_EXECUTABLE(${_target_NAME}_dep_test ${NGL_MODULE_DIR}/ngl_dep_test_main.cpp ${_args})
      ENDIF()
    ENDIF()

    SET_PROPERTY(GLOBAL APPEND PROPERTY NGL_TS_TARGETS ${_target_NAME})
  ENDIF()

  #MESSAGE(STATUS "Build: ${_target_NAME} ${_build_ws} ${_build_sv}")

ENDMACRO()

#
# NGL_ADD_EXECUTABLE
#
MACRO (NGL_ADD_EXECUTABLE)

  SET(_args ${ARGN})
  SET(_properties "")
  SET(_build_target OFF)
  NGL_PARSE_BUILDCOMPONENT_INTERNAL(_args _properties _build_target)
  LIST(GET _args 0 _target_NAME)

  IF(_build_target)
    ADD_EXECUTABLE(${_args})
    SET_TARGET_PROPERTIES(${_target_NAME} PROPERTIES ${_properties})
    SET_PROPERTY(GLOBAL APPEND PROPERTY NGL_TS_TARGETS ${_target_NAME})
  ENDIF()

  #MESSAGE(STATUS "Build: ${_target_NAME} '${_build_WS}' '${_build_SV}' '${_build_IF}'")

ENDMACRO()

#
# NGL_TARGET_INCLUDE_DIRECTORIES
#
MACRO(NGL_TARGET_INCLUDE_DIRECTORIES _target_NAME)

  IF(TARGET ${_target_NAME})
    TARGET_INCLUDE_DIRECTORIES(${_target_NAME} ${ARGN})
  ENDIF()

ENDMACRO()

#
# NGL_TARGET_LINK_LIBRARIES
#
MACRO(NGL_TARGET_LINK_LIBRARIES _target_NAME)

  IF(TARGET ${_target_NAME})
    TARGET_LINK_LIBRARIES(${_target_NAME} ${ARGN})
    IF(BUILD_DEP_TEST_EXECUTABLES)
      GET_TARGET_PROPERTY(_type ${_target_NAME} TYPE)
      IF("${_type}" STREQUAL "SHARED_LIBRARY")
        TARGET_LINK_LIBRARIES(${_target_NAME}_dep_test ${ARGN} ${_target_NAME})
      ENDIF()
    ENDIF()
  ENDIF()

ENDMACRO()
MACRO(NGL_ADD_INSTALL_PREFIX_INTERNAL _args prefix)
  LIST(LENGTH ${_args} len)

  SET(_ret_args "")
  SET(_replace_next OFF)
  FOREACH( _arg ${${_args}})
    IF(${_arg} STREQUAL "DESTINATION")
      SET(_replace_next ON)
      LIST(APPEND _ret_args ${_arg})
    ELSE()
      IF(_replace_next)
        LIST(APPEND _ret_args "${prefix}/${_arg}")
        SET(_replace_next OFF)
      ELSE()
        LIST(APPEND _ret_args ${_arg})
      ENDIF()
    ENDIF()
  ENDFOREACH()

  SET(${_args} ${_ret_args})
ENDMACRO()

#
# NGL_INSTALL_TARGET
# only works for a single target atm
#
MACRO(_NGL_INSTALL_TARGET_internal _target_NAME)

  SET(_args ${ARGN})
  IF(TARGET ${_target_NAME})
    FOREACH(_component ${_components})
      GET_TARGET_PROPERTY(_install_component ${_target_NAME} NGL_INSTALL_${_component})
      IF(_install_component)
        SET(_my_args ${_args})
        NGL_ADD_INSTALL_PREFIX_INTERNAL(_my_args ${${_component}_INSTALL_PATH})
        INSTALL(TARGETS ${_target_NAME} ${_my_args})
      ENDIF()
    ENDFOREACH()
  ENDIF()
ENDMACRO()

MACRO(NGL_INSTALL_TARGET _target_NAME)
  SET(_args ${ARGN})
  LIST(LENGTH _args len)
  IF(${len} EQUAL 0)
    SET(_args ${INSTALL_DEFAULT_ARGS})
  ENDIF()
  _NGL_INSTALL_TARGET_internal(${_target_NAME} ${_args})
ENDMACRO()

MACRO(NGL_INSTALL_TARGET_DEVEL _target_NAME)
  IF (NOT BUILD_RPM)
    SET(_args ${ARGN})
    LIST(LENGTH _args len)
    IF(${len} EQUAL 0)
      SET(_args ${INSTALL_DEFAULT_ARGS_DEVEL})
    ENDIF()
    _NGL_INSTALL_TARGET_internal(${_target_NAME} ${_args})
  ENDIF()
ENDMACRO()

MACRO(NGL_INSTALL)
  SET(_args ${ARGN})

  NGL_GET_BUILDPARTS(_args _buildopts)

  FOREACH(_component ${_components})
    LIST(FIND _buildopts ${_component} _idx)
    IF(_idx GREATER -1)
      SET(_my_args ${_args})
      NGL_ADD_INSTALL_PREFIX_INTERNAL(_my_args ${${_component}_INSTALL_PATH})
      INSTALL(${_my_args})
    ENDIF()
  ENDFOREACH()

ENDMACRO()

MACRO(NGL_SET_TARGET_PROPERTIES _target_NAME)
  IF(TARGET ${_target_NAME})
    SET_TARGET_PROPERTIES(${_target_NAME} ${ARGN})
  ENDIF()
ENDMACRO()

MACRO(NGL_TARGET_COMPILE_DEFINITIONS _target_NAME)
  IF(TARGET ${_target_NAME})
    TARGET_COMPILE_DEFINITIONS(${_target_NAME} ${ARGN})
  ENDIF()
ENDMACRO()

MACRO(NGL_ADD_COMPILE_FLAGS _target_NAME _property_value)
  IF(TARGET ${_target_NAME})
     # APPEND_STRING - make sure to add whitespace before string to append
    SET_PROPERTY(TARGET ${_target_NAME} APPEND_STRING PROPERTY COMPILE_FLAGS " ${_property_value}")
  ENDIF()
ENDMACRO()

MACRO(NGL_ADD_TEST)
  IF(TARGET ${_target_NAME})
    ADD_TEST(${_target_NAME} ${ARGN})
  ENDIF()
ENDMACRO()

MACRO(NGL_CREATE_ASSISTANT_HELP type target_name language)

  SET(_QHP_FILE_SRC  "${CMAKE_CURRENT_SOURCE_DIR}/${language}.qhp")
  SET(_QHP_FILE_BLD  "${CMAKE_CURRENT_BINARY_DIR}/${language}/${language}.qhp")
  SET(_QCH_FILE      "${CMAKE_CURRENT_BINARY_DIR}/${language}/${language}.qch")
  SET(_QHCP_FILE_SRC "${CMAKE_CURRENT_SOURCE_DIR}/${language}.qhcp")
  SET(_QHCP_FILE_BLD "${CMAKE_CURRENT_BINARY_DIR}/${language}/${language}.qhcp")
  SET(_QHC_FILE      "${CMAKE_CURRENT_BINARY_DIR}/${language}/${language}.qhc")

  SET(_file_list ${ARGN})
  # TODO: per FIND_PROGRAM suchen
  SET(_command_qhg qhelpgenerator-qt5)
  SET(_command_qcg qcollectiongenerator-qt5)

  ADD_CUSTOM_COMMAND(DEPENDS ${_file_list} ${_QHP_FILE_SRC} ${_QHCP_FILE_SRC}
                     COMMAND ${NGL_MODULE_DIR}/make_qt_help.py
                        ARGS ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/${language} ${language} ${_file_list}
                     COMMAND ${_command_qhg}
                        ARGS ${_QHP_FILE_BLD} -o ${_QCH_FILE}
                     COMMAND ${_command_qcg}
                        ARGS "${_QHCP_FILE_BLD}" -o "${_QHC_FILE}"
                     COMMAND ${CMAKE_COMMAND}
                        ARGS -E touch ${CMAKE_CURRENT_BINARY_DIR}/${language}_qch_dummy.c
                     OUTPUT "${_QHC_FILE}"
                            "${_QHCP_FILE_BLD}"
                            "${_QHP_FILE_BLD}"
                            "${_QCH_FILE}"
                            "${CMAKE_CURRENT_BINARY_DIR}/${language}_qch_dummy.c"
                     WORKING_DIRECTORY ${CMAKE_CURRENT_BUILD_DIR}
                     COMMENT "Generating Qt assistant help for language ${language}"
                    )

  NGL_ADD_LIBRARY(${type} "${type}_${target_name}_${language}_qch_dummy" "${language}_qch_dummy")
  NGL_INSTALL(${type} FILES "${_QCH_FILE}" "${_QHC_FILE}" DESTINATION help/${target_name}/)

ENDMACRO()

MACRO(NGL_ADD_TARGET_LINK targetName targetAbbr)

IF(TARGET ${targetName})
  IF(NOT WIN32) #bis Lösung für Windows gefunden
    SET(cmake_operation create_symlink)
    IF(WIN32)
      SET(cmake_operation copy)
    ENDIF(WIN32)
    ADD_CUSTOM_COMMAND(TARGET ${targetName} POST_BUILD
      COMMAND ${CMAKE_COMMAND} -E remove -f ${targetAbbr}
      COMMAND ${CMAKE_COMMAND} -E ${cmake_operation} ${targetName} ${targetAbbr}
      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/bin
    )
  ENDIF() #not win32
ENDIF()
ENDMACRO()


MACRO(ADD_INTERFACE_LIBRARY name_ header_ inc_path_)
  SET(link_libs_ ${ARGN})
  ADD_LIBRARY(${name_} INTERFACE)
  TARGET_INCLUDE_DIRECTORIES(${name_}
    INTERFACE
      ${inc_path_}
  )
  FOREACH(link_lib_ ${link_libs_})
    TARGET_LINK_LIBRARIES(${name_}
      INTERFACE
        ${link_lib_}
     )
  ENDFOREACH()
  TARGET_SOURCES(${name_} INTERFACE ${header_})
ENDMACRO()


macro(NGL_COMPILE_RESOURCES output_qrc_objects) # qrc_files ...
  # VERSION_GREATER_EQUAL only available in cmake 3.7 and up
  # rcc does not work correctly on windows with Qt5.12.3 - permission denied error... :(
  get_property(ipo_active VARIABLE PROPERTY CMAKE_INTERPROCEDURAL_OPTIMIZATION)
  if(CMAKE_VERSION VERSION_GREATER 3.8.99 AND Qt5Core_VERSION VERSION_GREATER 5.12.99 AND NOT WIN32 AND NOT ipo_active) # bug in Qt 5.12.2 - 5.13 seems to have a fix
    set(_QT5_INTERNAL_SCOPE ON) # prevent dev warnings for calling internal API functions

    set(options)
    set(oneValueArgs)
    set(multiValueArgs OPTIONS)
    cmake_parse_arguments(_NGL_COMPILE_RESOURCES "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})

    set(qrc_files ${_NGL_COMPILE_RESOURCES_UNPARSED_ARGUMENTS})
    set(rcc_options ${_NGL_COMPILE_RESOURCES_OPTIONS})

    foreach(qrc_file ${qrc_files})
      get_filename_component(qrc_object_file ${qrc_file} NAME_WE)
      get_filename_component(qrc_filename ${qrc_file} ABSOLUTE)
      set(qrc_header_file ${CMAKE_CURRENT_BINARY_DIR}/qrc_${qrc_object_file}_header.cpp)
      set(qrc_object ${CMAKE_CURRENT_BINARY_DIR}/qrc_${qrc_object_file}.o)

      _qt5_parse_qrc_file(${qrc_filename} _out_depends _rc_depends)
      set_source_files_properties(${qrc_filename} PROPERTIES SKIP_AUTORCC ON)
      add_custom_command(OUTPUT ${qrc_header_file}
                         COMMAND echo ">>> 1: Regenerating ${qrc_header_file}"
                         COMMAND ${Qt5Core_RCC_EXECUTABLE} ${rcc_options} --name ${qrc_object_file} --pass 1 --output ${qrc_header_file} ${qrc_filename}
                         DEPENDS ${qrc_filename} ${_rc_depends} "${_out_depends}"
                         VERBATIM)

      add_custom_target(resources_${qrc_object_file} ALL DEPENDS ${qrc_header_file})
      add_library(qrc_object_${qrc_object_file} OBJECT ${qrc_header_file})
      add_dependencies(qrc_object_${qrc_object_file} resources_${qrc_object_file})

      set_target_properties(qrc_object_${qrc_object_file} PROPERTIES AUTOMOC OFF)
      set_target_properties(qrc_object_${qrc_object_file} PROPERTIES AUTOUIC OFF)

      add_custom_command(OUTPUT ${qrc_object}
                         COMMAND echo ">>> 2: Regenerating ${qrc_object} with $<TARGET_OBJECTS:qrc_object_${qrc_object_file}>"
                         COMMAND ${Qt5Core_RCC_EXECUTABLE}
                         ARGS ${rcc_options} --name ${qrc_object_file} --pass 2 --temp $<TARGET_OBJECTS:qrc_object_${qrc_object_file}> --output ${qrc_object} ${qrc_filename}
                         DEPENDS qrc_object_${qrc_object_file} ${qrc_filename} ${qrc_header_file}
                         VERBATIM)

     list(APPEND ${output_qrc_objects} ${qrc_object})
    endforeach()
  else()
    # fallback for openSUSE 42.3 - resources not rebuilt automatically
    QT5_ADD_RESOURCES(${output_qrc_objects} ${ARGN})
  endif()
endmacro()


MACRO(NGL_ADD_BIG_RESOURCES)
  # VERSION_GREATER_EQUAL only available in cmake 3.7 and up
  # rcc does not work correctly on windows with Qt5.12.3 - permission denied error... :(
  GET_PROPERTY(ipo_active VARIABLE PROPERTY CMAKE_INTERPROCEDURAL_OPTIMIZATION)
  IF(CMAKE_VERSION VERSION_GREATER 3.8.99 AND Qt5Core_VERSION VERSION_GREATER 5.12.99 AND NOT WIN32 AND NOT ipo_active) # bug in Qt 5.12.2, 5.13 seems to have a fix
    QT5_ADD_BIG_RESOURCES(${ARGN})
  ELSE()
    QT5_ADD_RESOURCES(${ARGN})
  ENDIF()
ENDMACRO()


# NGL_WRAP_UI(outfiles inputfile ... )
# no longer needed
MACRO(NGL_WRAP_UI)
  QT5_WRAP_UI(${ARGN})
ENDMACRO()

MACRO(NGL_ADD_APP_ICON_INTERNAL _srcs icon)
  IF(WIN32)
    SET(_rc_file ${CMAKE_CURRENT_BINARY_DIR}/${target}_icon.rc)
    FILE(WRITE ${_rc_file} "IDI_ICON1 ICON DISCARDABLE \"${icon}\"\n")
    LIST(APPEND ${target} ${_rc_file})
    SET_SOURCE_FILES_PROPERTIES(${_rc_file} PROPERTIES OBJECT_DEPENDS ${icon})
    LIST(APPEND ${_srcs} ${_rc_file})
  ENDIF()
ENDMACRO()

MACRO(NGL_ADD_APP_ICON target)
  NGL_ADD_APP_ICON_INTERNAL(${target} "${CMAKE_SOURCE_DIR}/Lts/Common/LtsWidgets/resources/rde_icon_256.ico")
ENDMACRO()

MACRO(NGL_ADD_SVC_ICON target)
  NGL_ADD_APP_ICON_INTERNAL(${target} "${CMAKE_SOURCE_DIR}/Lts/Common/LtsWidgets/resources/rde_icon_256.ico")
ENDMACRO()

MACRO(NGL_ADD_TOOL_ICON target)
  SET(_args ${ARGN})
  LIST(LENGTH _args len)
  SET(_ico "rde_logo.ico")
  IF (len EQUAL 1)
    LIST(GET _args 0 _tool)
    SET(_ico "rde_internal_${_tool}_logo_256x256.ico")
  ENDIF()
  NGL_ADD_APP_ICON_INTERNAL(${target} "${CMAKE_SOURCE_DIR}/Lts/Common/LtsWidgets/resources/${_ico}")
ENDMACRO()


macro(NGL_TEST_APPS_JSON target)
  if(NOT BUILD_RPM AND TARGET ${target})
    add_custom_command(
      TARGET ${target}
      PRE_BUILD
      COMMAND $<TARGET_FILE:LtsAppDescriptorChecker>
      ARGS ${CMAKE_CURRENT_SOURCE_DIR} resources/apps.json
      VERBATIM)

    if(jsonschema)
      add_custom_command(
        TARGET ${target}
        POST_BUILD
        COMMAND jsonschema
        ARGS -i ${CMAKE_CURRENT_SOURCE_DIR}/resources/apps.json ${CMAKE_CURRENT_SOURCE_DIR}/../apps.schema.json
        VERBATIM)
    endif()
  endif()
endmacro()