Adds initial intermediate qt6 porting state

This commit is contained in:
torsten committed 2026-08-17 17:54:56 +02:00
1 parent 99136e9460
commit d176b5e0d7
11247 files changed
+1891537

No files matched your search

+22
View File
@@ -0,0 +1,22 @@
FIND_PROGRAM(DOXYGEN_EXECUTABLE doxygen)
MACRO(ADD_DOXYGEN_TARGET target input output infile outdir)
IF(DOXYGEN_EXECUTABLE-NOTFOUND)
MESSAGE(STATUS "Doxygen executable not found - can't create doxygen documentation")
ELSE(DOXYGEN_EXECUTABLE-NOTFOUND)
CONFIGURE_FILE(${input} ${output})
ADD_CUSTOM_TARGET(doxygen_${target} doxygen ${output}
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${infile} ${outdir}
)
ENDIF(DOXYGEN_EXECUTABLE-NOTFOUND)
ENDMACRO(ADD_DOXYGEN_TARGET target)
+126
View File
@@ -0,0 +1,126 @@
IF(ARCGIS_INCLUDE_DIR AND ARCGIS_LIBRARY)
SET(ARCGIS_FOUND TRUE)
ELSE()
INCLUDE(FindLibraryWithDebug)
INCLUDE(FindPackageHandleStandardArgs)
SET(QT_MIN_VERSION 5.4.0)
FIND_PACKAGE(Qt5 COMPONENTS Core Gui Location Network Sensors REQUIRED)
SET(_arcgis_include_hint "/usr/include")
SET(_arcgis_library_hint "/usr/lib64")
SET(_arcgis_lib_dir $ENV{ARCGIS_LIB_DIR})
SET(_arcgis_inc_dir $ENV{ARCGIS_INC_DIR})
IF (NOT ${_arcgis_lib_dir} STREQUAL "")
SET(_arcgis_library_hint "${_arcgis_lib_dir}")
ENDIF()
IF (NOT ${_arcgis_inc_dir} STREQUAL "")
SET(_arcgis_include_hint "${_arcgis_inc_dir}")
ENDIF()
IF(WIN32)
GET_FILENAME_COMPONENT(_arcgis_root_path "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\ESRI\\ArcGISRuntimeQt100.0.0;InstallDir]" ABSOLUTE)
IF(_arcgis_root_path)
SET(_arcgis_include_hint "${_arcgis_root_path}/sdk/windows/include/")
SET(_arcgis_library_hint "${_arcgis_root_path}/sdk/windows/x86/lib/")
ELSE()
SET(_root "$ENV{KDEROOT}")
FILE(TO_CMAKE_PATH "${_root}" _root)
IF(NOT EXISTS "${_root}" OR NOT IS_DIRECTORY "${_root}")
SET(_root $ENV{WORKSPACE})
FILE(TO_CMAKE_PATH "${_root}" _root)
ENDIF()
IF(NOT EXISTS "${_root}" OR NOT IS_DIRECTORY "${_root}")
SET(_root ${EXTERNAL_LIBRARY_DIR})
FILE(TO_CMAKE_PATH "${_root}" _root)
ENDIF()
SET(_arcgis_include_hint "${_root}/include/")
SET(_arcgis_library_hint "${_root}/lib/")
ENDIF()
ENDIF()
FIND_PATH(ARCGIS_INCLUDE_DIR arcgis/ArcGISQt_global.h HINTS ${_arcgis_include_hint})
FIND_LIBRARY_WITH_DEBUG(ARCGIS_LIBRARY WIN32_DEBUG_POSTFIX d NAMES EsriRuntimeQt HINTS ${_arcgis_library_hint})
FIND_LIBRARY_WITH_DEBUG(ARCGIS_COMMON_LIBRARY WIN32_DEBUG_POSTFIX d NAMES EsriCommonQt HINTS ${_arcgis_library_hint})
IF (UNIX)
FIND_LIBRARY_WITH_DEBUG(ARCGIS_CPP_LIBRARY WIN32_DEBUG_POSTFIX d NAMES runtimecore HINTS ${_arcgis_library_hint})
ENDIF()
FIND_PACKAGE_HANDLE_STANDARD_ARGS(ArcGIS DEFAULT_MSG ARCGIS_LIBRARY ARCGIS_INCLUDE_DIR)
MARK_AS_ADVANCED(ARCGIS_INCLUDE_DIR ARCGIS_LIBRARY)
ENDIF()
IF(NOT TARGET ArcGIS::ArcGIS)
ADD_LIBRARY(ArcGIS::ArcGIS UNKNOWN IMPORTED)
SET_PROPERTY(TARGET ArcGIS::ArcGIS PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${ARCGIS_INCLUDE_DIR}")
SET_PROPERTY(TARGET ArcGIS::ArcGIS PROPERTY INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${ARCGIS_INCLUDE_DIR}")
IF(ARCGIS_LIBRARY_RELEASE)
SET_PROPERTY(TARGET ArcGIS::ArcGIS APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
SET_PROPERTY(TARGET ArcGIS::ArcGIS PROPERTY IMPORTED_LOCATION_RELEASE "${ARCGIS_LIBRARY_RELEASE}")
ENDIF()
IF(ARCGIS_LIBRARY_DEBUG)
SET_PROPERTY(TARGET ArcGIS::ArcGIS APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
SET_PROPERTY(TARGET ArcGIS::ArcGIS PROPERTY IMPORTED_LOCATION_DEBUG "${ARCGIS_LIBRARY_DEBUG}")
ENDIF()
IF(NOT ARCGIS_LIBRARY_RELEASE AND NOT ARCGIS_LIBRARY_DEBUG)
SET_PROPERTY(TARGET ArcGIS::ArcGIS PROPERTY IMPORTED_LOCATION "${ARCGIS_LIBRARY}")
ENDIF()
SET_PROPERTY(TARGET ArcGIS::ArcGIS PROPERTY INTERFACE_INCLUDE_DIRECTORIES
$<TARGET_PROPERTY:Qt5::Core,INTERFACE_INCLUDE_DIRECTORIES>
$<TARGET_PROPERTY:Qt5::Location,INTERFACE_INCLUDE_DIRECTORIES>
$<TARGET_PROPERTY:Qt5::Network,INTERFACE_INCLUDE_DIRECTORIES>
$<TARGET_PROPERTY:Qt5::Sensors,INTERFACE_INCLUDE_DIRECTORIES>
)
IF (UNIX)
IF(ARCGIS_COMMON_LIBRARY_RELEASE)
SET_PROPERTY(TARGET ArcGIS::ArcGIS APPEND PROPERTY INTERFACE_LINK_LIBRARIES $<$<CONFIG:Release>:"${ARCGIS_COMMON_LIBRARY_RELEASE}">)
SET_PROPERTY(TARGET ArcGIS::ArcGIS APPEND PROPERTY INTERFACE_LINK_LIBRARIES $<$<CONFIG:Release>:"${ARCGIS_CPP_LIBRARY_RELEASE}">)
ENDIF()
IF(ARCGIS_COMMON_LIBRARY_DEBUG)
SET_PROPERTY(TARGET ArcGIS::ArcGIS APPEND PROPERTY INTERFACE_LINK_LIBRARIES $<$<CONFIG:Debug>:"${ARCGIS_COMMON_LIBRARY_DEBUG}">)
SET_PROPERTY(TARGET ArcGIS::ArcGIS APPEND PROPERTY INTERFACE_LINK_LIBRARIES $<$<CONFIG:Debug>:"${ARCGIS_CPP_LIBRARY_DEBUG}">)
ENDIF()
IF(ARCGIS_COMMON_LIBRARY AND NOT ARCGIS_COMMON_LIBRARY_RELEASE AND NOT ARCGIS_COMMON_LIBRARY_DEBUG)
SET_PROPERTY(TARGET ArcGIS::ArcGIS APPEND PROPERTY INTERFACE_LINK_LIBRARIES "${ARCGIS_COMMON_LIBRARY}" "${ARCGIS_CPP_LIBRARY}")
ENDIF()
ELSE()
IF(ARCGIS_COMMON_LIBRARY_RELEASE)
SET_PROPERTY(TARGET ArcGIS::ArcGIS APPEND PROPERTY INTERFACE_LINK_LIBRARIES $<$<CONFIG:Release>:${ARCGIS_COMMON_LIBRARY_RELEASE}>)
SET_PROPERTY(TARGET ArcGIS::ArcGIS APPEND PROPERTY INTERFACE_LINK_LIBRARIES $<$<CONFIG:RelWithDebInfo>:${ARCGIS_COMMON_LIBRARY_RELEASE}>)
ENDIF()
IF(ARCGIS_COMMON_LIBRARY_DEBUG)
SET_PROPERTY(TARGET ArcGIS::ArcGIS APPEND PROPERTY INTERFACE_LINK_LIBRARIES $<$<CONFIG:Debug>:${ARCGIS_COMMON_LIBRARY_DEBUG}>)
ENDIF()
IF(ARCGIS_COMMON_LIBRARY AND NOT ARCGIS_COMMON_LIBRARY_RELEASE AND NOT ARCGIS_COMMON_LIBRARY_DEBUG)
SET_PROPERTY(TARGET ArcGIS::ArcGIS APPEND PROPERTY INTERFACE_LINK_LIBRARIES "${ARCGIS_COMMON_LIBRARY}")
ENDIF()
ENDIF()
ENDIF()
+49
View File
@@ -0,0 +1,49 @@
INCLUDE(FindPackageHandleStandardArgs)
INCLUDE(FindLibraryWithDebug)
# Allow user to supply BGVIEWER_DIR or check ./external/BgViewer by default
if(NOT DEFINED BGVIEWER_DIR)
if(DEFINED ENV{EXTERNAL_DIR})
set(_external_hint "$ENV{EXTERNAL_DIR}")
else()
set(_external_hint "${CMAKE_SOURCE_DIR}/external")
endif()
set(BGVIEWER_DIR "${_external_hint}/BgViewer" CACHE PATH "BgViewer root directory (optional)")
endif()
# Search in common system locations and in BGVIEWER_DIR
set(_hints "${BGVIEWER_DIR}/lib" "${BGVIEWER_DIR}/lib/*" "${BGVIEWER_DIR}/lib/*/*")
FIND_LIBRARY_WITH_DEBUG(BGVIEWER_DTENTITY_LIBRARY WIN32_DEBUG_POSTFIX d dtEntity HINTS ${_hints})
FIND_LIBRARY_WITH_DEBUG(BGVIEWER_DTENTITYOSG_LIBRARY WIN32_DEBUG_POSTFIX d dtEntityOSG HINTS ${_hints})
FIND_PATH(BGVIEWER_INCLUDE_DIR dtEntity/export.h HINTS "${BGVIEWER_DIR}/include" "${BGVIEWER_DIR}/include/dtEntity" ${_hints} )
FIND_PACKAGE_HANDLE_STANDARD_ARGS(BgViewer DEFAULT_MSG
BGVIEWER_DTENTITY_LIBRARY
BGVIEWER_DTENTITYOSG_LIBRARY
BGVIEWER_INCLUDE_DIR)
SET(BGVIEWER_LIBRARIES ${BGVIEWER_DTENTITYOSG_LIBRARY}
${BGVIEWER_DTENTITY_LIBRARY})
+48
View File
@@ -0,0 +1,48 @@
include(FindPkgConfig)
if(NOT BOTAN_FOUND)
pkg_check_modules(Botan botan-2)
endif()
if(NOT BOTAN_FOUND)
find_path(BOTAN_INCLUDE_DIRS NAMES botan/botan.h
PATH_SUFFIXES botan-2
DOC "The botan include directory")
find_library(BOTAN_LIBRARIES NAMES botan botan-2
DOC "The botan library")
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Botan REQUIRED_VARS BOTAN_LIBRARIES BOTAN_INCLUDE_DIRS)
if(BOTAN_FOUND)
set(BOTAN_LIBRARY ${BOTAN_LIBRARIES} CACHE INTERNAL "")
set(BOTAN_INCLUDE_DIR ${BOTAN_INCLUDE_DIRS} CACHE INTERNAL "")
set(BOTAN_FOUND ${BOTAN_FOUND} CACHE INTERNAL "")
endif()
endif()
mark_as_advanced(BOTAN_INCLUDE_DIRS BOTAN_LIBRARIES)
@@ -0,0 +1,37 @@
# Minimal Find module for Grantlee5 to allow configure to continue when not installed
# This intentionally does not attempt to build or provide Qt5-based Grantlee
# If a Qt6-compatible Grantlee is available, set Grantlee5_DIR or install the package
if (TARGET Grantlee5::Templates)
set(Grantlee5_FOUND TRUE)
return()
endif()
# Try pkg-config as a best-effort (may fail)
find_package(PkgConfig QUIET)
if (PKG_CONFIG_FOUND)
pkg_check_modules(GRANTLEE5 QUIET grantlee-templates)
if (GRANTLEE5_FOUND)
set(Grantlee5_FOUND TRUE)
# No imported targets provided by this shim
return()
endif()
endif()
# Try config-mode: look for Grantlee5Config.cmake in CMAKE_PREFIX_PATH or installed location
# Try to locate Grantlee5Config.cmake via common locations: CMAKE_PREFIX_PATH, EXTERNAL_DIR, repo/external, and typical install paths
find_file(_Grantlee5Config NAMES Grantlee5Config.cmake
PATHS ${CMAKE_PREFIX_PATH} $ENV{EXTERNAL_DIR} /repo/external /repo/external/grantlee
NO_DEFAULT_PATH
PATH_SUFFIXES Grantlee5 lib/cmake/Grantlee5)
if(_Grantlee5Config)
include(${_Grantlee5Config})
if(TARGET Grantlee5::Templates)
set(Grantlee5_FOUND TRUE)
return()
endif()
endif()
# Not found: provide helpful message and stop. Downstream CMakeLists check TARGET Grantlee5::Templates
set(Grantlee5_FOUND FALSE)
message(STATUS "Grantlee5 not found (shim cmake/FindGrantlee5.cmake); codegen_grantlee will be skipped if present.")
+40
View File
@@ -0,0 +1,40 @@
IF(KDCHART_INCLUDE_DIRS AND KDCHART_LIBRARY)
SET(KDCHART_FOUND TRUE)
ELSE()
FIND_PATH(KDCHART_INCLUDE_DIRS KDChart/kdchart_export.h)
FIND_LIBRARY(KDCHART_LIBRARY NAMES kdchart)
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(KDChart DEFAULT_MSG KDCHART_LIBRARY KDCHART_INCLUDE_DIRS)
MARK_AS_ADVANCED(KDCHART_INCLUDE_DIRS KDCHART_LIBRARY)
ENDIF()
IF(NOT TARGET KDChart::KDChart)
ADD_LIBRARY(KDChart::KDChart UNKNOWN IMPORTED)
SET_PROPERTY(TARGET KDChart::KDChart PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${KDCHART_INCLUDE_DIRS}")
SET_PROPERTY(TARGET KDChart::KDChart PROPERTY INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${KDCHART_INCLUDE_DIRS}")
SET_PROPERTY(TARGET KDChart::KDChart PROPERTY IMPORTED_LOCATION "${KDCHART_LIBRARY}")
ENDIF()
+49
View File
@@ -0,0 +1,49 @@
# Prefer Qt6 when available, fallback to Qt5
find_package(Qt6 COMPONENTS Core Gui PrintSupport Sql Svg Widgets Xml QUIET)
if(NOT Qt6_FOUND)
FIND_PACKAGE(Qt5 COMPONENTS Core Gui PrintSupport Sql Svg Widgets Xml REQUIRED)
set(_qt_prefix "Qt5")
else()
set(_qt_prefix "Qt6")
endif()
# If KDReports already provided via variables, use them
IF(KDREPORTS_INCLUDE_DIR AND KDREPORTS_KDREPORTS_INCLUDE_DIR AND KDREPORTS_LIBRARY)
SET(KDREPORTS_FOUND TRUE)
SET(KDReports_FOUND TRUE)
ELSE()
# Prefer KDReports-qt6 package config if installed under standard prefixes
if(EXISTS "${CMAKE_PREFIX_PATH}/lib/cmake/KDReports-qt6" OR EXISTS "/usr/local/lib/cmake/KDReports-qt6")
message(STATUS "Found KDReports-qt6 package config in CMAKE_PREFIX_PATH or /usr/local")
set(KDREPORTS_FOUND TRUE)
set(KDReports_FOUND TRUE)
# Best-effort defaults; specific projects will use the imported target below
set(KDREPORTS_INCLUDE_DIR "/usr/local/include")
set(KDREPORTS_KDREPORTS_INCLUDE_DIR "/usr/local/include")
set(KDREPORTS_LIBRARY "/usr/local/lib/libkdreports-qt6.so")
else()
FIND_PATH(KDREPORTS_INCLUDE_DIR KDReports/KDReports.h)
FIND_PATH(KDREPORTS_KDREPORTS_INCLUDE_DIR KDReports.h PATH_SUFFIXES KDReports)
FIND_LIBRARY(KDREPORTS_LIBRARY NAMES kdreports kdreport kdreports-qt6)
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(KDReports DEFAULT_MSG
KDREPORTS_LIBRARY
KDREPORTS_INCLUDE_DIR
KDREPORTS_KDREPORTS_INCLUDE_DIR
)
MARK_AS_ADVANCED(KDREPORTS_INCLUDE_DIR KDREPORTS_LIBRARY)
MARK_AS_ADVANCED(KDREPORTS_KDREPORTS_INCLUDE_DIR KDREPORTS_LIBRARY)
endif()
ENDIF()
IF(NOT TARGET KDReports::KDReports)
ADD_LIBRARY(KDReports::KDReports UNKNOWN IMPORTED)
SET_PROPERTY(TARGET KDReports::KDReports PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${KDREPORTS_INCLUDE_DIR}" "${KDREPORTS_KDREPORTS_INCLUDE_DIR}")
SET_PROPERTY(TARGET KDReports::KDReports PROPERTY INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${KDREPORTS_INCLUDE_DIR}" "${KDREPORTS_KDREPORTS_INCLUDE_DIR}")
SET_PROPERTY(TARGET KDReports::KDReports PROPERTY IMPORTED_LOCATION "${KDREPORTS_LIBRARY}")
SET_PROPERTY(TARGET KDReports::KDReports APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${_qt_prefix}::Core ${_qt_prefix}::Gui ${_qt_prefix}::PrintSupport ${_qt_prefix}::Widgets)
ENDIF()
@@ -0,0 +1,113 @@
MACRO(FIND_LIBRARY_WITH_DEBUG var_name win32_dbg_postfix_name dgb_postfix libname)
IF(NOT "${win32_dbg_postfix_name}" STREQUAL "WIN32_DEBUG_POSTFIX")
FIND_LIBRARY(${var_name}
${win32_dbg_postfix_name}
${dgb_postfix}
${libname}
${ARGN}
)
ELSE()
IF(NOT WIN32)
FIND_LIBRARY(${var_name} ${libname} ${ARGN})
ELSE()
SET(args ${ARGN})
SET(newargs "")
SET(libnames_release "")
SET(libnames_debug "")
IF("${libname}" STREQUAL "NAMES")
SET(append_rest 0)
LIST(LENGTH args listCount)
LIST(APPEND args " ")
FOREACH(i RANGE ${listCount})
LIST(GET args ${i} val)
IF(append_rest)
LIST(APPEND newargs ${val})
ELSE()
IF(${val} STREQUAL "PATHS" OR ${val} STREQUAL "HINTS")
LIST(APPEND newargs ${val})
SET(append_rest 1)
ELSE()
LIST(APPEND libnames_release "${val}")
LIST(APPEND libnames_debug "${val}${dgb_postfix}")
ENDIF()
ENDIF()
ENDFOREACH()
ELSE()
LIST(APPEND libnames_release "${libname}")
LIST(APPEND libnames_debug "${libname}${dgb_postfix}")
SET(newargs ${args})
ENDIF()
FIND_LIBRARY(${var_name}_RELEASE
NAMES ${libnames_release}
${newargs}
)
FIND_LIBRARY(${var_name}_DEBUG
NAMES ${libnames_debug}
${newargs}
)
IF(${var_name}_RELEASE AND ${var_name}_DEBUG)
SET(${var_name} optimized ${${var_name}_RELEASE}
debug ${${var_name}_DEBUG})
ELSE()
IF(${var_name}_RELEASE)
SET(${var_name} ${${var_name}_RELEASE})
ELSE()
SET(${var_name} ${${var_name}_DEBUG})
ENDIF()
ENDIF()
MARK_AS_ADVANCED(${var_name}_RELEASE)
MARK_AS_ADVANCED(${var_name}_DEBUG)
ENDIF()
ENDIF()
ENDMACRO()
@@ -0,0 +1,95 @@
# FindLog4Qt.cmake
# Prefer a package config (Log4QtConfig.cmake) when available, otherwise
# try to locate headers and library and create an IMPORTED target.
# First, try config mode (Log4QtConfig.cmake provided by an installed Log4Qt)
# Prefer a normal find_package(CONFIG) but also explicitly probe common
# CMAKE_PREFIX_PATH locations (/usr/local, user-provided prefixes) so a
# Log4Qt installed to /usr/local is reliably detected.
find_package(Log4Qt CONFIG QUIET)
if (Log4Qt_FOUND)
# Package config provided targets/variables; normalize names for callers.
if (TARGET Log4Qt::log4qt)
set(Log4Qt_LIBRARIES "${Log4Qt_LIBRARIES}" CACHE STRING "Log4Qt libraries (from config)" FORCE)
set(Log4Qt_INCLUDE_DIRS "${Log4Qt_INCLUDE_DIRS}" CACHE STRING "Log4Qt include dirs (from config)" FORCE)
endif()
return()
endif()
# If config-mode didn't find a package, probe common prefix paths for a
# Log4QtConfig.cmake installed by the project's Dockerfile (e.g. /usr/local).
# This handles cases where CMAKE_PREFIX_PATH isn't honored or when the
# package config file exists but wasn't discoverable via the generic search.
set(_log4qt_probed_config_file "")
# Build a list of prefixes to probe: entries in CMAKE_PREFIX_PATH plus /usr/local
set(_log4qt_prefixes "${CMAKE_PREFIX_PATH};/usr/local")
foreach(_p IN LISTS _log4qt_prefixes)
if ("${_p}" STREQUAL "")
continue()
endif()
# candidate locations under the prefix
set(_candidate1 "${_p}/lib/cmake/Log4Qt/Log4QtConfig.cmake")
set(_candidate2 "${_p}/share/cmake/Log4Qt/Log4QtConfig.cmake")
foreach(_cand IN LISTS _candidate1 _candidate2)
if (EXISTS "${_cand}")
set(_log4qt_probed_config_file "${_cand}")
break()
endif()
endforeach()
if (NOT "${_log4qt_probed_config_file}" STREQUAL "")
break()
endif()
endforeach()
if (EXISTS "${_log4qt_probed_config_file}")
# Include the config file directly; it should create targets/variables.
include("${_log4qt_probed_config_file}")
if (TARGET Log4Qt::log4qt)
# normalize cache names for callers
set(Log4Qt_FOUND TRUE CACHE INTERNAL "Log4Qt found by config probe")
# try to pick up values set by the config file, fallback to defaults
if (NOT DEFINED Log4Qt_LIBRARIES)
set(Log4Qt_LIBRARIES "" CACHE STRING "Log4Qt libraries (from probed config)" FORCE)
else()
set(Log4Qt_LIBRARIES "${Log4Qt_LIBRARIES}" CACHE STRING "Log4Qt libraries (from probed config)" FORCE)
endif()
if (NOT DEFINED Log4Qt_INCLUDE_DIRS)
set(Log4Qt_INCLUDE_DIRS "" CACHE STRING "Log4Qt include dirs (from probed config)" FORCE)
else()
set(Log4Qt_INCLUDE_DIRS "${Log4Qt_INCLUDE_DIRS}" CACHE STRING "Log4Qt include dirs (from probed config)" FORCE)
endif()
return()
endif()
endif()
# Fall back to classic Find behaviour: locate library and headers
find_path(_LOG4QT_INCLUDE_DIR
NAMES Log4Qt/Logger.h
PATHS /usr/local/include /usr/include /usr/local/include/log4qt
)
find_library(_LOG4QT_LIBRARY
NAMES log4qt Log4Qt liblog4qt libLog4Qt
PATHS /usr/local/lib /usr/lib /usr/local/lib64 /usr/lib64
)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Log4Qt DEFAULT_MSG _LOG4QT_LIBRARY _LOG4QT_INCLUDE_DIR)
if (_LOG4QT_LIBRARY AND _LOG4QT_INCLUDE_DIR)
if (NOT TARGET Log4Qt::log4qt)
add_library(Log4Qt::log4qt UNKNOWN IMPORTED)
set_target_properties(Log4Qt::log4qt PROPERTIES
IMPORTED_LOCATION "${_LOG4QT_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${_LOG4QT_INCLUDE_DIR}"
)
endif()
set(Log4Qt_FOUND TRUE CACHE INTERNAL "Log4Qt found by FindLog4Qt")
set(Log4Qt_LIBRARIES "${_LOG4QT_LIBRARY}" CACHE STRING "Log4Qt libraries")
set(Log4Qt_INCLUDE_DIRS "${_LOG4QT_INCLUDE_DIR}" CACHE STRING "Log4Qt include dirs")
else()
set(Log4Qt_FOUND FALSE CACHE INTERNAL "Log4Qt not found")
set(Log4Qt_LIBRARIES "" CACHE STRING "Log4Qt libraries (empty)")
set(Log4Qt_INCLUDE_DIRS "" CACHE STRING "Log4Qt include dirs (empty)")
endif()
+134
View File
@@ -0,0 +1,134 @@
IF(NGS_INCLUDE_DIRS AND NGS_LIBRARIES)
SET(NGS_FOUND TRUE)
ELSE()
SET(FOM_NAME "RPRFOM20d17E")
IF("$ENV{NGS_ROOT}" STREQUAL "")
SET(NGS_ROOT "/opt/NGS/NGSPublic")
MESSAGE(STATUS "NGS_ROOT env var not set - using ${NGS_ROOT}")
ELSE()
SET(NGS_ROOT "$ENV{NGS_ROOT}")
ENDIF()
FIND_PROGRAM(NGS_FOMBUILD fombuild
PATHS ${NGS_ROOT}/exe
)
FIND_PATH(NGS_INCLUDE_DIR NGSUtils/SimTime.h
PATHS ${NGS_ROOT}/include
)
FIND_PATH(NGS_SM_INCLUDE_DIR ISystem.h
PATHS ${NGS_INCLUDE_DIR}
PATH_SUFFIXES SimulationManager
)
FIND_PATH(NGS_FC_INCLUDE_DIR IRTIAmbassador.h
PATHS ${NGS_INCLUDE_DIR}
PATH_SUFFIXES RTIFacadeAPI
)
FIND_PATH(NGS_GE_INCLUDE_DIR SimulatedWorldAPI.h
PATHS ${NGS_INCLUDE_DIR}
PATH_SUFFIXES SWGeneral
)
FIND_PATH(NGS_UT_INCLUDE_DIR NGSConfig.h
PATHS ${NGS_INCLUDE_DIR}
PATH_SUFFIXES NGSUtils
)
FIND_PATH(NGS_PF_INCLUDE_DIR configureBool.h
PATHS ${NGS_INCLUDE_DIR}
PATH_SUFFIXES NGSPlatformConfigure
)
FIND_PATH(NGS_FOM_INCLUDE_DIR WorldLocationStruct.h
PATHS ${NGS_INCLUDE_DIR}
PATH_SUFFIXES sw${FOM_NAME}/rpr
PATH_SUFFIXES sw${FOM_NAME}/rpr2
)
FIND_LIBRARY(NGS_LIBRARY NGS
PATHS ${NGS_ROOT}/lib
PATHS ${NGS_ROOT}/lib64
)
FIND_LIBRARY(NGS_LIBRARY_SWGENERAL SWGENERAL
PATHS ${NGS_ROOT}/lib
PATHS ${NGS_ROOT}/lib64
)
FIND_LIBRARY(NGS_LIBRARY_UTILS NGSUtils
PATHS ${NGS_ROOT}/lib
PATHS ${NGS_ROOT}/lib64
)
FIND_LIBRARY(FOM_LIBRARY SW${FOM_NAME}
PATHS ${NGS_ROOT}/lib
PATHS ${NGS_ROOT}/lib64
)
FIND_LIBRARY(NGS_LIBRARY_CORBA CorbaNotify
PATHS ${NGS_ROOT}/lib/CorbaNotifyCdr
)
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(NGS DEFAULT_MSG NGS_LIBRARY
NGS_LIBRARY_SWGENERAL
NGS_LIBRARY_UTILS
NGS_LIBRARY_CORBA
FOM_LIBRARY
NGS_SM_INCLUDE_DIR
NGS_FC_INCLUDE_DIR
NGS_GE_INCLUDE_DIR
NGS_UT_INCLUDE_DIR
)
SET(NGS_INCLUDE_DIRS
${NGS_INCLUDE_DIR}
${NGS_SM_INCLUDE_DIR}
${NGS_FC_INCLUDE_DIR}
${NGS_GE_INCLUDE_DIR}
${NGS_UT_INCLUDE_DIR}
${NGS_PF_INCLUDE_DIR}
${NGS_FOM_INCLUDE_DIR}
CACHE STRING "All ngs include dirs" FORCE
)
SET(NGS_LIBRARIES
${NGS_LIBRARY}
${NGS_LIBRARY_SWGENERAL}
${NGS_LIBRARY_UTILS}
${NGS_LIBRARY_CORBA}
${FOM_LIBRARY}
CACHE STRING "All ngs libraries" FORCE
)
MARK_AS_ADVANCED(NGS_INCLUDE_DIR NGS_LIBRARY FOM_LIBRARY)
ENDIF()
SET(NGS_IS_GUEZ OFF)
SET(NGS_IS_AHTC OFF)
IF (NGS_FOUND)
FIND_PATH(NGS_GUEZ_INCLUDE_DIR TacticalStatusStruct.h
PATHS ${NGS_FOM_INCLUDE_DIR})
FIND_PATH(NGS_AHTC_INCLUDE_DIR LongBowApacheObjClass.h
PATHS ${NGS_FOM_INCLUDE_DIR})
IF (NGS_GUEZ_INCLUDE_DIR AND EXISTS "${NGS_GUEZ_INCLUDE_DIR}/TacticalStatusStruct.h")
SET(NGS_IS_GUEZ ON)
MESSAGE(STATUS "NGS - GUEZ version (${NGS_GUEZ_INCLUDE_DIR})")
ELSE()
SET(NGS_IS_GUEZ OFF)
ENDIF()
IF (NGS_AHTC_INCLUDE_DIR AND EXISTS "${NGS_AHTC_INCLUDE_DIR}/LongBowApacheObjClass.h")
SET(NGS_IS_AHTC ON)
MESSAGE(STATUS "NGS - AHTC version (${NGS_AHTC_INCLUDE_DIR})")
ELSE()
SET(NGS_IS_AHTC OFF)
ENDIF()
ENDIF()
IF(NOT TARGET NGS::NGS)
ADD_LIBRARY(NGS::NGS UNKNOWN IMPORTED)
SET_PROPERTY(TARGET NGS::NGS PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${NGS_INCLUDE_DIRS})
SET_PROPERTY(TARGET NGS::NGS PROPERTY INTERFACE_SYSTEM_INCLUDE_DIRECTORIES ${NGS_INCLUDE_DIRS})
SET_PROPERTY(TARGET NGS::NGS PROPERTY IMPORTED_LOCATION "${NGS_LIBRARY}")
SET_PROPERTY(TARGET NGS::NGS APPEND PROPERTY INTERFACE_LINK_LIBRARIES
"${NGS_LIBRARY_SWGENERAL}"
"${NGS_LIBRARY_UTILS}"
"${NGS_LIBRARY_CORBA}"
"${FOM_LIBRARY}"
)
ENDIF()
+116
View File
@@ -0,0 +1,116 @@
if(POPPLER_QT5_INCLUDE_DIR AND POPPLER_QT5_LIBRARY)
set(POPPLER_QT5_FOUND TRUE)
else(POPPLER_QT5_INCLUDE_DIR AND POPPLER_QT5_LIBRARY)
set(_poppler_version_bad FALSE)
if(NOT WIN32)
include(FindPkgConfig)
# Prefer poppler-qt6 if available, fall back to poppler-qt5
pkg_check_modules(_pc_poppler poppler-qt6)
if(_pc_poppler_FOUND)
set(_pc_poppler_pkgname poppler-qt6)
else()
pkg_check_modules(_pc_poppler poppler-qt5)
if(_pc_poppler_FOUND)
set(_pc_poppler_pkgname poppler-qt5)
endif()
endif()
if(_pc_poppler_FOUND)
if(NOT "${_pc_poppler_VERSION}" VERSION_GREATER 0.24.0)
set(_poppler_version_bad TRUE)
endif(NOT "${_pc_poppler_VERSION}" VERSION_GREATER 0.24.0)
endif(_pc_poppler_FOUND)
endif(NOT WIN32)
if(NOT _poppler_version_bad)
set(POPPLER_QT5_FOUND FALSE)
# try library name discovered by pkg-config (poppler-qt6 or poppler-qt5)
# Attempt to use pkg-config-provided absolute library path variable if available
if(_pc_poppler_FOUND)
# construct the variable name pkgcfg_lib__pc_poppler_<pkgname>
set(_pkg_var "pkgcfg_lib__pc_poppler_${_pc_poppler_pkgname}")
message(STATUS "FindPoppler: pkg-config found ${_pc_poppler_pkgname}, var ${_pkg_var} defined? ${${_pkg_var}}")
if(DEFINED ${_pkg_var})
set(POPPLER_QT5_LIBRARY ${${_pkg_var}})
message(STATUS "FindPoppler: using pkgcfg path ${POPPLER_QT5_LIBRARY}")
endif()
endif()
if(NOT POPPLER_QT5_LIBRARY)
find_library(POPPLER_QT5_LIBRARY ${_pc_poppler_pkgname}
HINTS ${_pc_poppler_LIBRARY_DIRS}
)
endif()
# fallback: try common library names if pkg-config hints didn't help
if(NOT POPPLER_QT5_LIBRARY)
find_library(POPPLER_QT5_LIBRARY NAMES poppler-qt6 poppler-qt5)
endif()
# extra fallback paths commonly used on Debian/Ubuntu
if(NOT POPPLER_QT5_LIBRARY)
find_library(POPPLER_QT5_LIBRARY NAMES poppler-qt6 poppler-qt5 PATHS /usr/lib/x86_64-linux-gnu /usr/lib /usr/local/lib)
endif()
# check for headers for both qt5 and qt6 layouts
find_path(POPPLER_QT5_INCLUDE_DIR poppler-qt6.h poppler-qt5.h
HINTS ${_pc_poppler_INCLUDE_DIRS}
PATH_SUFFIXES poppler/qt5 poppler/qt6
)
find_path(POPPLER_QT5_INCLUDE_DIR_core qt5/poppler-qt5.h qt6/poppler-qt6.h
HINTS ${_pc_poppler_INCLUDE_DIRS}
PATH_SUFFIXES poppler
)
if(POPPLER_QT5_LIBRARY AND POPPLER_QT5_INCLUDE_DIR AND POPPLER_QT5_INCLUDE_DIR_core)
list(APPEND POPPLER_QT5_INCLUDE_DIR "${POPPLER_QT5_INCLUDE_DIR_core}")
set(POPPLER_QT5_FOUND TRUE)
# Expose a modern imported target for consumers
if(NOT TARGET PopplerQt5::Poppler)
add_library(PopplerQt5::Poppler UNKNOWN IMPORTED)
set_target_properties(PopplerQt5::Poppler PROPERTIES
IMPORTED_LOCATION "${POPPLER_QT5_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${POPPLER_QT5_INCLUDE_DIR}"
)
endif()
# Also cache the library path so other CMakeLists can link directly
set(POPPLER_QT5_LIBRARY "${POPPLER_QT5_LIBRARY}" CACHE FILEPATH "Path to poppler-qt library")
set(POPPLER_QT5_INCLUDE_DIR "${POPPLER_QT5_INCLUDE_DIR}" CACHE PATH "Poppler include dirs")
endif(POPPLER_QT5_LIBRARY AND POPPLER_QT5_INCLUDE_DIR AND POPPLER_QT5_INCLUDE_DIR_core)
endif(NOT _poppler_version_bad)
if(POPPLER_QT5_LIBRARY AND POPPLER_QT5_INCLUDE_DIR)
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(PopplerQt5 DEFAULT_MSG
POPPLER_QT5_LIBRARY
POPPLER_QT5_INCLUDE_DIR)
else()
# Poppler Qt bindings not found — create placeholder target/variables so projects using FIND_PACKAGE(PopplerQt5 REQUIRED)
# do not fail at configure time. Real functionality will require installing poppler-qt6 or updating code.
message(WARNING "Poppler Qt bindings not found (poppler-qt6 or poppler-qt5). Creating placeholder PopplerQt5::Poppler target to allow configure.")
set(POPPLER_QT5_LIBRARY "" CACHE STRING "Placeholder poppler library" FORCE)
set(POPPLER_QT5_INCLUDE_DIR "" CACHE STRING "Placeholder poppler include dir" FORCE)
if(NOT TARGET PopplerQt5::Poppler)
add_library(PopplerQt5::Poppler UNKNOWN IMPORTED)
set_property(TARGET PopplerQt5::Poppler PROPERTY INTERFACE_INCLUDE_DIRECTORIES "")
endif()
set(POPPLER_QT5_FOUND TRUE CACHE INTERNAL "Poppler placeholder present")
endif()
endif(POPPLER_QT5_INCLUDE_DIR AND POPPLER_QT5_LIBRARY)
+223
View File
@@ -0,0 +1,223 @@
SET(_rti_gcc_arch "")
IF(NOT RTI_DIR)
SET(_arch "unknown")
IF(WIN32)
SET(_RTI_DIR $ENV{DDS_PATH})
IF(NOT _RTI_DIR)
GET_FILENAME_COMPONENT(_rti_root_path "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Real-Time Innovations\\RTI Connext DDS Pro 5.2.3;Location]" ABSOLUTE)
SET(_RTI_DIR "${_rti_root_path}")
ENDIF()
IF(MSVC_VERSION EQUAL 1900)
SET(_rti_msvc_ver "VS2015")
ELSEIF(MSVC_VERSION GREATER_EQUAL 1910)
SET(_rti_msvc_ver "VS2017")
ENDIF()
IF(CMAKE_SIZEOF_VOID_P EQUAL 8)
SET(_rti_msvc_ver "x64Win64${_rti_msvc_ver}")
ELSE()
SET(_rti_msvc_ver "i86Win32${_rti_msvc_ver}")
ENDIF()
IF(NOT ${_rti_root_path})
SET(_RTI_DIR $ENV{KDEROOT})
FILE(TO_CMAKE_PATH "${_RTI_DIR}" _RTI_DIR)
IF(NOT EXISTS "${_RTI_DIR}" OR NOT IS_DIRECTORY "${_RTI_DIR}")
SET(_RTI_DIR $ENV{WORKSPACE})
FILE(TO_CMAKE_PATH "${_RTI_DIR}" _RTI_DIR)
ENDIF()
IF(NOT EXISTS "${_RTI_DIR}" OR NOT IS_DIRECTORY "${_RTI_DIR}")
SET(_RTI_DIR ${EXTERNAL_LIBRARY_DIR})
FILE(TO_CMAKE_PATH "${_RTI_DIR}" _RTI_DIR)
ENDIF()
ENDIF()
SET(_arch "${_rti_msvc_ver}")
ELSE(WIN32)
SET(_RTI_DIR $ENV{DDS_PATH})
IF(NOT _RTI_DIR)
SET(_RTI_DIR "/opt/RTI")
ENDIF()
IF(NOT EXISTS "${_RTI_DIR}" OR NOT IS_DIRECTORY "${_RTI_DIR}")
MESSAGE(WARNING "RTI directory ${_RTI_DIR} not found; continuing without RTI. Set DDS_PATH to RTI installation to enable RTI features.")
# mark as not available
set(_RTI_DIR_NOT_FOUND TRUE)
set(_RTI_DIR "")
ENDIF()
SET(_rti_gcc_arch "x64Linux3gcc4.8.2")
IF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
IF(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 5.0.0)
# Prefer newer gcc-based RTI builds; try a sequence then fall back to any x64Linux4gcc* dir found under RTI lib
SET(_preferred_archs "x64Linux4gcc8.5.0;x64Linux4gcc7.3.0;x64Linux3gcc5.4.0")
SET(_found_arch "")
foreach(_cand IN LISTS _preferred_archs)
if(EXISTS "${_RTI_DIR}/lib/${_cand}")
SET(_found_arch "${_cand}")
break()
endif()
endforeach()
if(_found_arch STREQUAL "")
# fallback: pick any x64Linux* directory under lib
file(GLOB _rti_arch_dirs RELATIVE "${_RTI_DIR}/lib" "${_RTI_DIR}/lib/x64Linux*")
list(LENGTH _rti_arch_dirs _rti_arch_dirs_len)
if(_rti_arch_dirs_len GREATER 0)
list(GET _rti_arch_dirs 0 _found_arch)
endif()
endif()
if(NOT _found_arch STREQUAL "")
SET(_rti_gcc_arch "${_found_arch}")
else()
# final fallbacks
SET(_rti_gcc_arch "x64Linux4gcc7.3.0")
endif()
ENDIF()
ENDIF()
SET(_arch "${_rti_gcc_arch}")
ENDIF()
SET(RTI_DIR "${_RTI_DIR}" CACHE STRING "RTI base path" FORCE)
MESSAGE(STATUS "Trying to use RTI from ${RTI_DIR} with arch ${_arch}")
ENDIF()
IF(WIN32)
SET(_rti_include_hint "${RTI_DIR}/include/")
SET(_rti_library_hint "${RTI_DIR}/lib/${_rti_msvc_ver}/")
ELSE()
SET(_rti_include_hint "${RTI_DIR}/include/")
SET(_rti_library_hint "${RTI_DIR}/lib/")
ENDIF()
IF(NOT RTI_INCLUDE_DIR)
if(DEFINED _RTI_DIR_NOT_FOUND AND _RTI_DIR STREQUAL "")
# RTI directory was not found earlier; skip searching for includes and create empty placeholder
message(WARNING "Skipping RTI include search because RTI installation was not found")
set(RTI_INCLUDE_DIR "")
set(RTI_INCLUDE_DIRS "" CACHE STRING "RTI include directories" FORCE)
else()
FIND_PATH(RTI_INCLUDE_DIR ndds/ndds_cpp.h HINTS ${_rti_include_hint})
IF(RTI_INCLUDE_DIR)
SET(RTI_INCLUDE_DIRS "${RTI_INCLUDE_DIR}" "${RTI_INCLUDE_DIR}/ndds" "${RTI_INCLUDE_DIR}/ndds/hpp" CACHE STRING "RTI include directories" FORCE)
MARK_AS_ADVANCED(RTI_INCLUDE_DIRS)
ELSE()
MESSAGE(FATAL "Could not find RTI include directory at ${_rti_include_hint}")
ENDIF()
endif()
ENDIF()
IF(NOT RTI_DDSGEN_EXECUTABLE)
FIND_PROGRAM(RTI_DDSGEN_EXECUTABLE NAMES rtiddsgen rtiddsgen.bat HINTS ${RTI_DIR}/scripts ${RTI_DIR}/bin)
ENDIF()
IF(NOT RTI_VERSION_MAJOR)
EXEC_PROGRAM(${RTI_DDSGEN_EXECUTABLE} ARGS -version OUTPUT_VARIABLE _dds_version_output)
STRING(REGEX REPLACE ".* ([0-9]\\.[0-9]\\.[0-9]).*" "\\1" _dds_version_output ${_dds_version_output})
SET(_rti_version_major 5)
IF(_dds_version_output VERSION_GREATER 2.9.9)
SET(_rti_version_major 6)
ENDIF()
SET(RTI_VERSION_MAJOR ${_rti_version_major} CACHE STRING "RTI version" FORCE)
ENDIF()
INCLUDE(FindLibraryWithDebug)
INCLUDE(FindPackageHandleStandardArgs)
SET(_RTI_LIBS nddscore nddsc nddscpp2 rtiroutingservice)
SET(_libs "")
SET(_lib_vars "")
# Try recursive search for RTI libraries under RTI_DIR to handle vendor arch subdirs (e.g. x64Linux4gcc8.5.0)
foreach(_lib IN LISTS _RTI_LIBS)
file(GLOB_RECURSE _found_libs "${RTI_DIR}/lib/**/lib${_lib}.*")
list(LENGTH _found_libs _found_count)
if(_found_count GREATER 0)
list(GET _found_libs 0 _first)
set("RTI_${_lib}_LIBRARY" "${_first}" CACHE STRING "RTI library ${_lib}" FORCE)
endif()
endforeach()
FOREACH(_lib ${_RTI_LIBS})
SET(_libname "RTI_${_lib}_LIBRARY")
IF (NOT ${_libname})
# Add any arch-specific subdirectories under RTI lib to search hints
file(GLOB _rti_lib_candidates RELATIVE "${RTI_DIR}" "${RTI_DIR}/lib/*")
set(_rti_lib_full_paths "${RTI_DIR}/lib")
foreach(_p IN LISTS _rti_lib_candidates)
list(APPEND _rti_lib_full_paths "${RTI_DIR}/lib/${_p}")
endforeach()
FIND_LIBRARY_WITH_DEBUG("${_libname}"
WIN32_DEBUG_POSTFIX d
NAMES ${_lib}
HINTS ${_rti_library_hint} ${RTI_DIR}/lib ${RTI_DIR}/lib/${_rti_gcc_arch} ${_rti_lib_full_paths})
ENDIF()
SET(_tgt_name RTI::${_lib})
IF(NOT TARGET ${_tgt_name})
ADD_LIBRARY(${_tgt_name} UNKNOWN IMPORTED)
SET_PROPERTY(TARGET ${_tgt_name} PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${RTI_INCLUDE_DIRS}")
SET_PROPERTY(TARGET ${_tgt_name} PROPERTY INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${RTI_INCLUDE_DIRS}")
IF(UNIX)
SET_PROPERTY(TARGET ${_tgt_name} PROPERTY INTERFACE_COMPILE_DEFINITIONS "RTI_UNIX;RTI_LINUX;RTI_64BIT" )
ENDIF()
IF(WIN32)
IF("${_lib}" STREQUAL "rtiroutingservice")
SET_PROPERTY(TARGET ${_tgt_name} PROPERTY INTERFACE_COMPILE_DEFINITIONS "RTI_WIN32;RTI_routingservice_DLL_VARIABLE" )
ELSE()
SET_PROPERTY(TARGET ${_tgt_name} PROPERTY INTERFACE_COMPILE_DEFINITIONS "RTI_WIN32;NDDS_DLL_VARIABLE" )
ENDIF()
ENDIF()
IF(${_libname}_RELEASE)
SET_PROPERTY(TARGET ${_tgt_name} APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
SET_PROPERTY(TARGET ${_tgt_name} PROPERTY IMPORTED_LOCATION_RELEASE "${${_libname}_RELEASE}")
ENDIF()
IF(${_libname}_DEBUG)
SET_PROPERTY(TARGET ${_tgt_name} APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
SET_PROPERTY(TARGET ${_tgt_name} PROPERTY IMPORTED_LOCATION_DEBUG "${${_libname}_DEBUG}")
ENDIF()
IF(NOT ${_libname}_RELEASE AND NOT ${_libname}_DEBUG)
SET_PROPERTY(TARGET ${_tgt_name} PROPERTY IMPORTED_LOCATION "${${_libname}}")
ENDIF()
ENDIF()
LIST(APPEND _libs "${${_libname}}")
LIST(APPEND _lib_vars "${_libname}")
ENDFOREACH()
IF(TARGET RTI::nddscore AND UNIX)
SET_PROPERTY(TARGET RTI::nddscore PROPERTY INTERFACE_LINK_LIBRARIES "dl" )
ENDIF()
SET(RTI_LIBRARIES ${_libs} CACHE STRING "All rti libraries" FORCE)
MARK_AS_ADVANCED(RTI_LIBRARIES)
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(RTI DEFAULT_MSG RTI_DIR RTI_INCLUDE_DIR RTI_DDSGEN_EXECUTABLE ${_lib_vars})
+40
View File
@@ -0,0 +1,40 @@
IF(SCHUSSTAFEL_INCLUDE_DIR AND SCHUSSTAFEL_LIBRARY)
SET(SCHUSSTAFEL_FOUND TRUE)
ELSE(SCHUSSTAFEL_INCLUDE_DIR AND SCHUSSTAFEL_LIBRARY)
FIND_PATH(SCHUSSTAFEL_INCLUDE_DIR Schusstafel.h)
FIND_LIBRARY_WITH_DEBUG(SCHUSSTAFEL_LIBRARY WIN32_DEBUG_POSTFIX d NAMES Schusstafel libSchusstafel)
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(Schusstafel DEFAULT_MSG SCHUSSTAFEL_LIBRARY SCHUSSTAFEL_INCLUDE_DIR)
MARK_AS_ADVANCED(SCHUSSTAFEL_INCLUDE_DIR SCHUSSTAFEL_LIBRARY)
ENDIF(SCHUSSTAFEL_INCLUDE_DIR AND SCHUSSTAFEL_LIBRARY)
+104
View File
@@ -0,0 +1,104 @@
IF(NOT TMSIF_DIR)
SET(_arch "unknown")
SET(_TMSIF_DIR $ENV{TMSIF_PATH})
IF(NOT _TMSIF_DIR)
SET(_TMSIF_DIR "/opt/tmsif")
ENDIF()
IF(NOT EXISTS "${_TMSIF_DIR}" OR NOT IS_DIRECTORY "${_TMSIF_DIR}")
MESSAGE(FATAL_ERROR "Umgebungsvariable TMSIF_PATH nicht gesetzt!")
ENDIF()
SET(TMSIF_DIR "${_TMSIF_DIR}" CACHE STRING "TMSIF base path" FORCE)
MESSAGE(STATUS "Trying to use TMSIF_DIR from ${TMSIF_DIR}")
ENDIF()
SET(_tmsif_include_hint "${TMSIF_DIR}/include/")
SET(_tmsif_library_hint "${TMSIF_DIR}/lib/")
IF(NOT TMSIF_INCLUDE_DIR)
FIND_PATH(TMSIF_INCLUDE_DIR Common.h HINTS ${_tmsif_include_hint})
IF(TMSIF_INCLUDE_DIR)
SET(TMSIF_INCLUDE_DIRS "${TMSIF_INCLUDE_DIR}" "${TMSIF_INCLUDE_DIR}/ddscxx" CACHE STRING "TMSIF include directories" FORCE)
MARK_AS_ADVANCED(TMSIF_INCLUDE_DIRS)
ELSE()
MESSAGE(FATAL "Could not find TMSIF include directory at ${_tmsif_include_hint}")
ENDIF()
ENDIF()
SET(_TMSIF_LIBS tmsif-cyclone ddscxx ddkit-cyclone )
SET(_libs "")
SET(_lib_vars "")
FOREACH(_lib ${_TMSIF_LIBS})
SET(_libname "TMSIF_${_lib}_LIBRARY")
IF (NOT ${_libname})
FIND_LIBRARY_WITH_DEBUG("${_libname}"
WIN32_DEBUG_POSTFIX d
NAMES ${_lib}
HINTS ${_tmsif_library_hint} ${TMSIF_DIR}/lib )
ENDIF()
SET(_tgt_name TMSIF::${_lib})
IF(NOT TARGET ${_tgt_name})
ADD_LIBRARY(${_tgt_name} UNKNOWN IMPORTED)
SET_PROPERTY(TARGET ${_tgt_name} PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${TMSIF_INCLUDE_DIRS}")
SET_PROPERTY(TARGET ${_tgt_name} PROPERTY INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${TMSIF_INCLUDE_DIRS}")
IF(UNIX)
SET_PROPERTY(TARGET ${_tgt_name} PROPERTY INTERFACE_COMPILE_DEFINITIONS "TMSIF_UNIX;TMSIF_LINUX;TMSIF_64BIT" )
ENDIF()
IF(${_libname}_RELEASE)
SET_PROPERTY(TARGET ${_tgt_name} APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
SET_PROPERTY(TARGET ${_tgt_name} PROPERTY IMPORTED_LOCATION_RELEASE "${${_libname}_RELEASE}")
ENDIF()
IF(${_libname}_DEBUG)
SET_PROPERTY(TARGET ${_tgt_name} APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
SET_PROPERTY(TARGET ${_tgt_name} PROPERTY IMPORTED_LOCATION_DEBUG "${${_libname}_DEBUG}")
ENDIF()
IF(NOT ${_libname}_RELEASE AND NOT ${_libname}_DEBUG)
SET_PROPERTY(TARGET ${_tgt_name} PROPERTY IMPORTED_LOCATION "${${_libname}}")
ENDIF()
ENDIF()
LIST(APPEND _libs "${${_libname}}")
LIST(APPEND _lib_vars "${_libname}")
ENDFOREACH()
SET(TMSIF_LIBRARIES ${_libs} CACHE STRING "All TMSIF libraries" FORCE)
MARK_AS_ADVANCED(TMSIF_LIBRARIES)
INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(TMSIF DEFAULT_MSG TMSIF_DIR TMSIF_INCLUDE_DIR ${_lib_vars})
+49
View File
@@ -0,0 +1,49 @@
IF(VLC_INCLUDE_DIR AND VLC_LIBRARIES)
SET(VLC_FOUND TRUE)
ELSE()
INCLUDE(FindPackageHandleStandardArgs)
INCLUDE(FindLibraryWithDebug)
FIND_LIBRARY_WITH_DEBUG(VLC_LIBRARIES WIN32_DEBUG_POSTFIX d NAMES vlc libvlc)
FIND_PATH(VLC_INCLUDE_DIR vlc/vlc.h)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(VLC DEFAULT_MSG VLC_LIBRARIES VLC_INCLUDE_DIR)
FIND_PATH(VLC_IS_2_0_ABOVE vlc/libvlc_version.h
PATHS ${VLC_INCLUDE_DIR}
NO_DEFAULT_PATH)
IF(NOT VLC_IS_2_0_ABOVE)
MESSAGE(FATAL_ERROR "Need at least VLC 2.x")
ENDIF()
MARK_AS_ADVANCED(VLC_DEFINES)
ENDIF()
+81
View File
@@ -0,0 +1,81 @@
IF(XSD_INCLUDE_DIR AND XSD_COMPILER)
SET(XSD_FOUND TRUE)
ELSE(XSD_INCLUDE_DIR AND XSD_COMPILER)
FIND_PROGRAM(XSD_COMPILER NAMES xsdcxx xsd)
FIND_PATH(XSD_INCLUDE_DIR xsd/cxx/config.hxx)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(XSD DEFAULT_MSG
XSD_COMPILER
XSD_INCLUDE_DIR
)
MARK_AS_ADVANCED(XSD_COMPILER
XSD_INCLUDE_DIR)
ENDIF(XSD_INCLUDE_DIR AND XSD_COMPILER)
MACRO(XSD_GENERATE_TREE srcList infile)
GET_FILENAME_COMPONENT(output ${infile} NAME)
GET_FILENAME_COMPONENT(input ${infile} ABSOLUTE)
GET_FILENAME_COMPONENT(dir ${infile} DIRECTORY)
EXEC_PROGRAM(${XSD_COMPILER} ARGS version OUTPUT_VARIABLE _xsd_version_output)
STRING(REGEX REPLACE ".* ([0-9]\\.[0-9]\\.[0-9]).*" "\\1" _xsd_version_output ${_xsd_version_output})
SET(_xsd_in ${input})
SET(_cpp_out ${dir}/${output}.cxx)
SET(_hpp_out ${dir}/${output}.hxx)
STRING(REPLACE ".xsd" "" _cpp_out "${_cpp_out}")
STRING(REPLACE ".xsd" "" _hpp_out "${_hpp_out}")
SET(additional_xsd_args "")
IF(_xsd_version_output VERSION_GREATER 3.9.0)
IF(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.7.0)
SET(additional_xsd_args --std c++11)
ELSE()
IF(WIN32 OR NOT CMAKE_COMPILER_IS_GNUCC)
SET(additional_xsd_args --std c++11)
ENDIF(WIN32 OR NOT CMAKE_COMPILER_IS_GNUCC)
ENDIF()
ENDIF()
ADD_CUSTOM_COMMAND(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${dir}
COMMAND ${CMAKE_COMMAND}
ARGS -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/${dir}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
)
ADD_CUSTOM_COMMAND(OUTPUT ${_cpp_out} ${_hpp_out}
COMMAND ${XSD_COMPILER}
ARGS cxx-tree ${additional_xsd_args} --generate-serialization ${_xsd_in}
DEPENDS ${_xsd_in} ${CMAKE_CURRENT_BINARY_DIR}/${dir}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${dir}
)
LIST(APPEND ${srcList} ${_cpp_out} ${_hpp_out} ${infile})
ENDMACRO(XSD_GENERATE_TREE srcList infile)
+511
View File
@@ -0,0 +1,511 @@
INCLUDE(CMakeParseArguments)
MACRO(_ADD_SERVICE_RESTART_FLAG svcName)
STRING(TOUPPER ${svcName} _svcNameUpper)
STRING(TOLOWER ${svcName} _svcNameLower)
SET(_optionName DONTRESTARTSVC_${_svcNameUpper})
OPTION(${_optionName} "Do not automatically restart Service ${_svcNameUpper} (build dir only)" OFF)
SET(_fn "${CMAKE_BINARY_DIR}/share/Lts/xml/${_svcNameLower}.dontRestart")
IF (${_optionName})
FILE(WRITE ${_fn} "blub")
ELSE()
FILE(REMOVE ${_fn})
ENDIF()
ENDMACRO()
MACRO(_GET_SERVICENAME xmlFile_in svcNameOut)
GET_FILENAME_COMPONENT(xmlFile ${xmlFile_in} NAME_WE)
SET(_idx -1)
STRING(FIND "${xmlFile}" "_" _idx)
STRING(SUBSTRING "${xmlFile}" 0 ${_idx} ${svcNameOut})
ENDMACRO()
MACRO(_CODEGEN_ACTION action srcList xmlIn in_files out_files)
LIST(APPEND dependFiles ${ARGN} ${xmlIn} ${${in_files}})
SET(_cg codegen)
ADD_CUSTOM_COMMAND(OUTPUT ${${out_files}}
COMMAND ${_cg}
ARGS -s ${xmlIn}
-a ${action}
-o ${CMAKE_CURRENT_BINARY_DIR}
-i ${CMAKE_BINARY_DIR}/service_idl_files.txt
${${in_files}}
DEPENDS ${_cg} ${dependFiles}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
LIST(APPEND ${srcList} ${${out_files}})
GET_FILENAME_COMPONENT(_xml "${CMAKE_CURRENT_SOURCE_DIR}/${xmlIn}" ABSOLUTE)
SET_PROPERTY(GLOBAL APPEND PROPERTY CODEGEN_IDL_FILES "${_xml}")
ENDMACRO()
MACRO(CODEGEN_DATABASE_STRUCTS srcList_h xmlFile_in)
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
SET(in_files "${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_db_structs.cpp.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_db_structs.h.grantlee"
)
SET(out_files "${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_db_structs.cpp"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_db_structs.h"
)
_CODEGEN_ACTION("DATABASE" ${srcList_h} ${xmlFile_in} in_files out_files ${ARGN})
ENDMACRO()
MACRO(CODEGEN_DATABASE_SQL srcList xmlFile_in)
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
SET(in_files "${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_db.h.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_db_impl.cpp.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_db_impl.h.grantlee"
)
SET(out_files "${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_db.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_db_impl.cpp"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_db_impl.h"
)
_CODEGEN_ACTION("DATABASE" ${srcList} ${xmlFile_in} in_files out_files ${ARGN})
IF(NOT POLICY CMP0071)
QT5_WRAP_CPP(${srcList} "${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_db.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_db_impl.h")
ENDIF()
ENDMACRO()
MACRO(CODEGEN_DAO srcList xmlFile_in)
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
SET(in_files "${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_dao.cpp.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_dao.h.grantlee"
)
SET(out_files "${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_dao.cpp"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_dao.h"
)
_CODEGEN_ACTION("dao" ${srcList} ${xmlFile_in} in_files out_files ${ARGN})
IF(NOT POLICY CMP0071)
QT5_WRAP_CPP(${srcList} "${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_dao.cpp"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_dao.h")
ENDIF()
ENDMACRO()
MACRO(CODEGEN_DATABASE srcList xmlFile_in)
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
SET(in_files "${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_db_structs.cpp.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_db_structs.h.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_db_impl.cpp.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_db_impl.h.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_db.h.grantlee"
)
SET(out_files "${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_db_structs.cpp"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_db_structs.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_db_impl.cpp"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_db_impl.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_db.h"
)
_CODEGEN_ACTION("DATABASE_SERVER" ${srcList} ${xmlFile_in} in_files out_files ${ARGN})
IF(NOT POLICY CMP0071)
QT5_WRAP_CPP(${srcList} "${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_db.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_db_impl.h")
ENDIF()
ENDMACRO()
MACRO(INSTALL_SHARED_FILES srcList)
SET(options)
SET(oneValueArgs DESTINATION)
SET(multiValueArgs FILES)
CMAKE_PARSE_ARGUMENTS(_ISF "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
SET(build_out_dir ${CMAKE_BINARY_DIR}/share/Lts/${_ISF_DESTINATION})
SET(inst_out_dir share/Lts/${_ISF_DESTINATION})
FOREACH(filename ${_ISF_FILES})
GET_FILENAME_COMPONENT(fn ${filename} NAME)
SET(build_out_file ${build_out_dir}/${fn})
SET(in_file ${CMAKE_CURRENT_SOURCE_DIR}/${filename})
ADD_CUSTOM_COMMAND(OUTPUT ${build_out_file}
COMMAND ${CMAKE_COMMAND}
ARGS -E make_directory ${build_out_dir}
COMMAND ${CMAKE_COMMAND}
ARGS -E copy_if_different ${in_file} ${build_out_file}
DEPENDS ${in_file}
)
LIST(APPEND ${srcList} ${in_file} ${build_out_file})
ENDFOREACH()
NGL_INSTALL(${_ISF_UNPARSED_ARGUMENTS} FILES ${_ISF_FILES} DESTINATION ${inst_out_dir})
ENDMACRO()
MACRO(CODEGEN_SQL srcList xmlFile_in)
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
SET(out_dir_sql "${CMAKE_BINARY_DIR}/share/Lts/sql/")
SET(out_file_sql "${out_dir_sql}/${svcNameOut}.sql")
SET(action "SQL")
ADD_CUSTOM_COMMAND(OUTPUT ${out_file_sql}
COMMAND ${CMAKE_COMMAND}
ARGS -E make_directory ${out_dir_sql}
COMMAND codegen
ARGS -s ${xmlFile_in}
-a ${action}
-o ${out_dir_sql}
-i ${CMAKE_BINARY_DIR}/service_idl_files.txt
DEPENDS ${_cg} ${xmlFile_in}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
LIST(APPEND ${srcList} ${out_file_sql})
NGL_INSTALL(SV AAR FILES ${out_file_sql} DESTINATION share/Lts/sql)
ENDMACRO()
MACRO(CODEGEN_HANDLE_SVC_XML srcList xmlFile_in)
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
SET(out_dir_xml "${CMAKE_BINARY_DIR}/share/Lts/xml/")
SET(out_file_xml "${out_dir_xml}/${svcNameOut}.xml")
ADD_CUSTOM_COMMAND(OUTPUT ${out_file_xml}
COMMAND ${CMAKE_COMMAND}
ARGS -E make_directory ${out_dir_xml}
COMMAND ${CMAKE_COMMAND}
ARGS -E copy_if_different ${xmlFile_in} ${out_file_xml}
DEPENDS ${xmlFile_in}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
LIST(APPEND ${srcList} ${xmlFile_in} ${out_file_xml})
_ADD_SERVICE_RESTART_FLAG(${svcNameOut})
NGL_INSTALL(SV AAR FILES ${out_file_xml} DESTINATION share/Lts/xml)
ENDMACRO()
MACRO(CODEGEN_IDL_SVC srcList xmlFile_in)
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
SET(in_files "${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc.idl.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_enums.idl.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_json.cpp.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_json.h.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_translation.cpp.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_translation.h.grantlee"
)
SET(out_files "${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}.idl"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_enums.idl")
SET_PROPERTY(GLOBAL APPEND PROPERTY CODEGEN_IDL_FILES "${out_files}")
SET_SOURCE_FILES_PROPERTIES(${out_files} PROPERTIES HEADER_FILE_ONLY TRUE)
LIST(APPEND out_files
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_json.cpp"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_json.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_translation.cpp"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_translation.h")
_CODEGEN_ACTION("DDS_TOPICS" ${srcList} "${xmlFile_in}" in_files out_files ${ARGN})
CODEGEN_HANDLE_SVC_XML(${srcList} ${xmlFile_in})
ENDMACRO()
FIND_PACKAGE(PythonInterp 2.7 REQUIRED)
MACRO(CODEGEN_TOPIC_TYPEDEFS srcList xmlFile_in)
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
SET(inFile ${xmlFile_in})
IF(NOT IS_ABSOLUTE ${inFile})
SET(inFile ${CMAKE_CURRENT_SOURCE_DIR}/${inFile})
IF(NOT EXISTS ${inFile})
SET(inFile ${CMAKE_CURRENT_BINARY_DIR}/${inFile})
ENDIF()
ENDIF()
SET(prog ${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/codegen_simple.py)
SET(out_files "${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_dts_types.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_dtc_types.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_fts_types.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_ftc_types.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_operator_rights.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_operator_rights.cpp"
"${CMAKE_BINARY_DIR}/share/Lts/sql/${svcNameOut}_operator_rights.sql"
)
ADD_CUSTOM_COMMAND( OUTPUT ${out_files}
COMMAND ${CMAKE_COMMAND}
ARGS -E make_directory ${CMAKE_CURRENT_BINARY_DIR}
COMMAND ${CMAKE_COMMAND}
ARGS -E make_directory ${CMAKE_BINARY_DIR}/share/Lts/sql/
COMMAND ${PYTHON_EXECUTABLE}
ARGS ${prog} ALL
${inFile}
${CMAKE_CURRENT_BINARY_DIR}
COMMAND ${PYTHON_EXECUTABLE}
ARGS ${prog} SQL
${inFile}
${CMAKE_BINARY_DIR}/share/Lts/sql
DEPENDS ${inFile}
${prog}
)
LIST(APPEND ${srcList} ${out_files})
SET_PROPERTY(GLOBAL APPEND PROPERTY CODEGEN_XML_FILES "${inFile}")
ENDMACRO()
MACRO(CODEGEN_CLIENT_TOPICS_IFC srcList xmlFile_in)
SET(options)
SET(oneValueArgs)
SET(multiValueArgs PARTS)
CMAKE_PARSE_ARGUMENTS(_CST "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
IF(NOT _CST_PARTS)
SET(_CST_PARTS "DTC" "FTC")
ENDIF()
SET(in_files "")
SET(out_files "")
FOREACH(part ${_CST_PARTS})
IF(part STREQUAL "DTC")
LIST(APPEND in_files
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_dtc.h.grantlee"
)
LIST(APPEND out_files
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_dtc.h"
)
IF(NOT POLICY CMP0071)
QT5_WRAP_CPP(${srcList} "${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_dtc.h")
ENDIF()
ELSEIF(part STREQUAL "FTC")
LIST(APPEND in_files
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_ftc.h.grantlee"
)
LIST(APPEND out_files
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_ftc.h"
)
ELSE()
MESSAGE(FATAL_ERROR "Unkown part argument for CODEGEN_SERVER_TOPICS (${part})")
ENDIF()
ENDFOREACH()
_CODEGEN_ACTION("DDS_TOPICS" ${srcList} "${xmlFile_in}" in_files out_files)
ENDMACRO()
MACRO(CODEGEN_CLIENT_TOPICS_IMPL srcList xmlFile_in)
SET(options)
SET(oneValueArgs)
SET(multiValueArgs PARTS)
CMAKE_PARSE_ARGUMENTS(_CST "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
IF(NOT _CST_PARTS)
SET(_CST_PARTS "DTC" "FTC")
ENDIF()
SET(in_files "")
SET(out_files "")
FOREACH(part ${_CST_PARTS})
IF(part STREQUAL "DTC")
LIST(APPEND in_files
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_dtc_impl.h.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_dtc_impl.cpp.grantlee"
)
LIST(APPEND out_files
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_dtc_impl.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_dtc_impl.cpp"
)
IF(NOT POLICY CMP0071)
QT5_WRAP_CPP(${srcList} "${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_dtc_impl.h")
ENDIF()
ELSEIF(part STREQUAL "FTC")
LIST(APPEND in_files
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_ftc_impl.h.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_ftc_impl.cpp.grantlee"
)
LIST(APPEND out_files
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_ftc_impl.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_ftc_impl.cpp"
)
IF(NOT POLICY CMP0071)
QT5_WRAP_CPP(${srcList} "${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_ftc_impl.h")
ENDIF()
ELSE()
MESSAGE(FATAL_ERROR "Unkown part argument for CODEGEN_SERVER_TOPICS (${part})")
ENDIF()
ENDFOREACH()
_CODEGEN_ACTION("DDS_TOPICS" ${srcList} "${xmlFile_in}" in_files out_files)
ENDMACRO()
MACRO(CODEGEN_SERVER_TOPICS srcList xmlFile_in)
SET(options)
SET(oneValueArgs)
SET(multiValueArgs PARTS)
CMAKE_PARSE_ARGUMENTS(_CST "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
IF(NOT _CST_PARTS)
SET(_CST_PARTS "DTS" "FTS")
ENDIF()
SET(in_files "")
SET(out_files "")
FOREACH(part ${_CST_PARTS})
IF(part STREQUAL "DTS")
LIST(APPEND in_files
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_dts.h.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_dts_impl.h.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_dts_impl.cpp.grantlee"
)
LIST(APPEND out_files
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_dts.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_dts_impl.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_dts_impl.cpp"
)
ELSEIF(part STREQUAL "FTS")
LIST(APPEND in_files
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_fts.h.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_fts_impl.h.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_fts_impl.cpp.grantlee"
)
LIST(APPEND out_files
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_fts.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_fts_impl.h"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_fts_impl.cpp"
)
IF(NOT POLICY CMP0071)
QT5_WRAP_CPP(${srcList} ${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_fts_impl.h)
ENDIF()
ELSE()
MESSAGE(FATAL_ERROR "Unkown part argument for CODEGEN_SERVER_TOPICS (${part})")
ENDIF()
ENDFOREACH()
_CODEGEN_ACTION("DDS_TOPICS" ${srcList} "${xmlFile_in}" in_files out_files)
ENDMACRO()
MACRO(CODEGEN_TOPIC_TYPE_PLUGIN srcList xmlFile_in)
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
SET(in_files "${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_topic_type_plugin.cpp.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_topic_type_plugin.h.grantlee"
)
SET(out_files "${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_topic_type_plugin.cpp"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_topic_type_plugin.h"
)
_CODEGEN_ACTION("DDS_TOPICS" ${srcList} "${xmlFile_in}" in_files out_files)
IF(NOT POLICY CMP0071)
QT5_WRAP_CPP(${srcList} ${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_topic_type_plugin.h)
ENDIF()
ENDMACRO()
MACRO(CREATE_TOPIC_TYPE_PLUGIN xmlFile_in)
SET(_my_srcs "")
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
CODEGEN_TOPIC_TYPE_PLUGIN(_my_srcs ${xml_FILE})
STRING(SUBSTRING ${svcNameOut} 0 1 _ss1)
STRING(SUBSTRING ${svcNameOut} 1 -1 _ss2)
STRING(TOUPPER ${_ss1} _ss1)
SET(_commonLib "svc${_ss1}${_ss2}Common")
IF(svcNameOut STREQUAL "core")
SET(_commonLib ddscore)
ENDIF()
NGL_ADD_LIBRARY(WS AAR SV NO_TRANSLATION ${svcNameOut}TopicTypePlugin MODULE
${_my_srcs}
)
NGL_TARGET_LINK_LIBRARIES(${svcNameOut}TopicTypePlugin
topic_type_plugin
routing_plugin
ddscore
${_commonLib}
)
NGL_INSTALL_TARGET(${svcNameOut}TopicTypePlugin)
ENDMACRO()
MACRO(CODEGEN_RECORD_REPLAY_PLUGIN srcList xmlFile_in)
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
SET(in_files "${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_record_replay_plugin.cpp.grantlee"
"${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen/svc_record_replay_plugin.h.grantlee"
)
SET(out_files "${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_record_replay_plugin.cpp"
"${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_record_replay_plugin.h"
)
_CODEGEN_ACTION("DDS_TOPICS" ${srcList} "${xmlFile_in}" in_files out_files)
IF(NOT POLICY CMP0071)
QT5_WRAP_CPP(${srcList} ${CMAKE_CURRENT_BINARY_DIR}/${svcNameOut}_record_replay_plugin.h)
ENDIF()
ENDMACRO()
MACRO(CREATE_RECORD_REPLAY_PLUGIN_INTERN xmlFile_in svcSourceList libtype)
SET(_my_srcs "")
_GET_SERVICENAME( "${xmlFile_in}" svcNameOut )
CODEGEN_RECORD_REPLAY_PLUGIN(_my_srcs ${xml_FILE})
STRING(SUBSTRING ${svcNameOut} 0 1 _ss1)
STRING(SUBSTRING ${svcNameOut} 1 -1 _ss2)
STRING(TOUPPER ${_ss1} _ss1)
SET(_commonLib "svc${_ss1}${_ss2}Common")
IF(svcNameOut STREQUAL "core")
SET(_commonLib ddscore)
ENDIF()
LIST(APPEND ${svcSourceList} ${_my_srcs})
NGL_ADD_LIBRARY(SV AAR WS ${svcNameOut}RecordReplayPlugin ${libtype}
${_my_srcs}
)
NGL_TARGET_LINK_LIBRARIES(${svcNameOut}RecordReplayPlugin
RecordReplayPlugin
ddscore
ddsconnector
ddsdtc
ngldb
LtsUtilsCore
${_commonLib}
)
NGL_INSTALL_TARGET(${svcNameOut}RecordReplayPlugin)
NGL_TARGET_INCLUDE_DIRECTORIES(${svcNameOut}RecordReplayPlugin
PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}/../
${CMAKE_CURRENT_BINARY_DIR}/../
)
ENDMACRO()
MACRO(CREATE_RECORD_REPLAY_PLUGIN xmlFile_in svcSourceList)
CREATE_RECORD_REPLAY_PLUGIN_INTERN(${xmlFile_in} ${svcSourceList} MODULE)
ENDMACRO()
MACRO(CREATE_RECORD_REPLAY_PLUGIN_SHARED xmlFile_in)
CREATE_RECORD_REPLAY_PLUGIN_INTERN(${xmlFile_in} _unused SHARED)
ENDMACRO()
MACRO(CODEGEN_WRITE_SERVICEFILE_INFO)
GET_PROPERTY(idl_files GLOBAL PROPERTY CODEGEN_IDL_FILES)
LIST(REMOVE_DUPLICATES idl_files)
FILE(WRITE ${CMAKE_BINARY_DIR}/service_idl_files.txt "-- all available service idl files\n")
FOREACH(idl_file ${idl_files})
FILE(APPEND ${CMAKE_BINARY_DIR}/service_idl_files.txt "${idl_file}\n")
ENDFOREACH()
ENDMACRO()
@@ -0,0 +1,21 @@
MACRO (MACRO_ENSURE_OUT_OF_SOURCE_BUILD _errorMessage)
STRING(COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" insource)
IF(insource)
MESSAGE(FATAL_ERROR "${_errorMessage}")
ENDIF(insource)
ENDMACRO (MACRO_ENSURE_OUT_OF_SOURCE_BUILD)
+77
View File
@@ -0,0 +1,77 @@
MACRO(RTIDDSGEN srcList infile)
# RTI (DDS) code generation is optional during migration; if RTI is not found, skip code generation.
FIND_PACKAGE(RTI)
if (NOT RTI_FOUND)
message(STATUS "RTI not found; skipping RTI IDL code generation for ${infile}")
return()
endif()
SET(input ${infile})
IF(NOT IS_ABSOLUTE ${input})
SET(input "${CMAKE_CURRENT_BINARY_DIR}/${input}")
ENDIF()
GET_FILENAME_COMPONENT(output ${infile} NAME_WE)
GET_FILENAME_COMPONENT(input ${input} ABSOLUTE)
SET(_ddsgen_args "")
SET(output_cxx
${CMAKE_CURRENT_BINARY_DIR}/${output}.cxx
${CMAKE_CURRENT_BINARY_DIR}/${output}Plugin.cxx
)
SET(output_hpp
${CMAKE_CURRENT_BINARY_DIR}/${output}.hpp
${CMAKE_CURRENT_BINARY_DIR}/${output}Plugin.hpp
)
ADD_CUSTOM_COMMAND(OUTPUT ${output_cxx} ${output_hpp}
COMMAND ${CMAKE_COMMAND}
ARGS -E remove ${output_cxx}
COMMAND ${RTI_DDSGEN_EXECUTABLE}
ARGS -language "C++11"
ARGS -unboundedSupport
ARGS -verbosity 2
ARGS -update typefiles
ARGS -stl
ARGS -d ${CMAKE_CURRENT_BINARY_DIR}
ARGS -inputIdl ${input}
ARGS -I ${CMAKE_CURRENT_BINARY_DIR}
ARGS -I ${CMAKE_CURRENT_BINARY_DIR}/../
ARGS -I ${CMAKE_CURRENT_BINARY_DIR}/../../
ARGS -I ${CMAKE_CURRENT_SOURCE_DIR}
ARGS -I ${CMAKE_CURRENT_SOURCE_DIR}/../
ARGS -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
DEPENDS ${input} ${ARGN}
)
IF(WIN32)
SET_SOURCE_FILES_PROPERTIES(${output_cxx} PROPERTIES COMPILE_FLAGS "-DNDDS_USER_DLL_EXPORT")
ELSE()
SET_SOURCE_FILES_PROPERTIES(${output_cxx} PROPERTIES SKIP_UNITY_BUILD_INCLUSION TRUE)
ENDIF()
LIST(APPEND ${srcList} ${output_cxx} ${output_hpp})
ENDMACRO()
+634
View File
@@ -0,0 +1,634 @@
INCLUDE(GenerateExportHeader)
# Compatibility stubs for Qt5 CMake macros when Qt6 is used.
# These stubs allow configure to succeed; actual resource/ui generation should be addressed during source migration.
if(NOT COMMAND QT5_ADD_RESOURCES)
macro(QT5_ADD_RESOURCES _out)
set(${_out} "" PARENT_SCOPE)
endmacro()
endif()
if(NOT COMMAND QT5_ADD_BIG_RESOURCES)
macro(QT5_ADD_BIG_RESOURCES _out)
set(${_out} "" PARENT_SCOPE)
endmacro()
endif()
if(NOT COMMAND QT5_WRAP_UI)
macro(QT5_WRAP_UI)
# noop at configure time
endmacro()
endif()
if(NOT COMMAND QT5_WRAP_CPP)
macro(QT5_WRAP_CPP)
endmacro()
endif()
# NGL_WRAP_UI: ensure .ui files are added to source lists so CMake's AUTOUIC can process them
if(NOT COMMAND NGL_WRAP_UI)
macro(NGL_WRAP_UI _out)
# Append provided UI files to the given source list variable
set(_cur "${${_out}}")
foreach(_ui ${ARGN})
list(APPEND _cur ${_ui})
endforeach()
set(${_out} "${_cur}" PARENT_SCOPE)
endmacro()
endif()
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)
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()
MACRO (NGL_ADD_LIBRARY)
SET(_args ${ARGN})
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)
ADD_LIBRARY(${_args})
SET_TARGET_PROPERTIES(${_target_NAME} PROPERTIES ${_properties})
IF(NOT MSVC AND NOT USE_ASAN AND NOT USE_UBSAN)
SET_PROPERTY(TARGET ${_target_NAME} APPEND_STRING PROPERTY LINK_FLAGS " -Wl,--no-undefined")
ENDIF()
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()
ENDMACRO()
MACRO (NGL_ADD_LIBRARY2)
SET(_args ${ARGN})
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)
ADD_LIBRARY(${_args})
SET_TARGET_PROPERTIES(${_target_NAME} PROPERTIES ${_properties})
IF(NOT MSVC AND NOT USE_ASAN AND NOT USE_UBSAN)
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()
ENDMACRO()
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()
ENDMACRO()
MACRO(NGL_TARGET_INCLUDE_DIRECTORIES _target_NAME)
IF(TARGET ${_target_NAME})
TARGET_INCLUDE_DIRECTORIES(${_target_NAME} ${ARGN})
ENDIF()
ENDMACRO()
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()
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})
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})
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)
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()
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)
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)
set(_QT5_INTERNAL_SCOPE ON)
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()
QT5_ADD_RESOURCES(${output_qrc_objects} ${ARGN})
endif()
endmacro()
MACRO(NGL_ADD_BIG_RESOURCES)
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)
QT5_ADD_BIG_RESOURCES(${ARGN})
ELSE()
QT5_ADD_RESOURCES(${ARGN})
ENDIF()
ENDMACRO()
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()
@@ -0,0 +1,26 @@
# Placeholder internal targets to allow partial configure during migration
# Creates IMPORTED targets for internal DDS generator targets that are not
# yet available in the repository. These placeholders allow CMake checks
# like "if(TARGET ddsgen)" to behave consistently and let subdirs add
# tests during migration. They should be removed/replaced when real
# targets are added during module migration.
if(NOT TARGET ddsgen)
add_library(ddsgen UNKNOWN IMPORTED)
set_target_properties(ddsgen PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE ON)
endif()
if(NOT TARGET ddsdtc)
add_library(ddsdtc UNKNOWN IMPORTED)
set_target_properties(ddsdtc PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE ON)
endif()
if(NOT TARGET ddsfts)
add_library(ddsfts UNKNOWN IMPORTED)
set_target_properties(ddsfts PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE ON)
endif()
if(NOT TARGET ddsQoS)
add_library(ddsQoS UNKNOWN IMPORTED)
set_target_properties(ddsQoS PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE ON)
endif()
+186
View File
@@ -0,0 +1,186 @@
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
import shutil
import sys
import sgmllib
class MyParser(sgmllib.SGMLParser):
"A simple parser class."
def __init__(self, verbose=0):
"Initialise an object, passing 'verbose' to the superclass."
sgmllib.SGMLParser.__init__(self, verbose)
self.hyperlinks = []
self.descriptions = []
self.depths = []
self.inside_a_element = 0
self.inside_li_element = 0
self.current_description = ""
self.current_hyperlink = ""
self.current_ul_depth = 0
self.current_li_data = ""
def parse(self, string):
"Parse the given string 'string'."
self.feed(string)
self.close()
def start_a(self, attributes):
"Process a hyperlink and its 'attributes'."
self.current_hyperlink = ""
self.current_description = ""
self.inside_a_element = 1
for name, value in attributes:
if name == "href":
self.current_hyperlink = value
def end_a(self):
"Record the end of a hyperlink"
self.inside_a_element = 0
def start_ul(self, attributes):
"<ul>"
self.current_ul_depth += 1
def end_ul(self):
"</ul>"
self.current_ul_depth -= 1
def start_li(self, attributes):
"<li>"
self.inside_li_element = 1
self.current_description = ""
self.current_hyperlink = ""
def end_li(self):
"</li>"
self.inside_li_element = 0
if len(self.current_description) == 0:
self.descriptions.append(self.current_li_data)
self.hyperlinks.append(self.current_hyperlink)
self.depths.append(self.current_ul_depth)
def handle_data(self, data):
"Handle the textual 'data'"
if self.inside_a_element:
self.descriptions.append(data)
self.hyperlinks.append(self.current_hyperlink)
self.depths.append(self.current_ul_depth)
self.current_description = data
if self.inside_li_element:
self.current_li_data = data
def get_xml(self, spacecount, prefix):
"return the structure as xml"
ret = ""
basespaces = ' ' * spacecount
for i, val in enumerate( self.descriptions ):
depth = self.depths[i]
nextdepth = self.depths[0]
if i != len(self.descriptions) - 1:
nextdepth = self.depths[i+1]
end = '/>'
if depth < nextdepth:
end = '>'
ref = ""
if len(self.hyperlinks[i]) > 0:
ref += ' ref="%s/%s"' % ( prefix, self.hyperlinks[i] )
spaces = basespaces + ' ' * depth
ret += '%s<section title="%s"%s%s\n' % ( spaces, val, ref, end )
while depth > nextdepth:
spaces = basespaces + ' ' * (depth - 1)
ret += '%s</section>\n' % spaces
depth -= 1
return ret
def removeDir(dirname):
"remove dir 'dirname' and all it's subdirectories"
for name in os.listdir(dirname):
filename = os.path.join(dirname, name)
if not os.path.islink(filename) and os.path.isdir(filename):
removeDir(filename)
else:
os.remove(filename)
os.rmdir(dirname)
return
def main():
if len(sys.argv) < 4:
print >> sys.stderr, "To few arguments: %s <srcdir> <builddir> <lang> [<list of files to copy>]" % sys.argv[0]
sys.exit(1)
srcdir = sys.argv[1]
blddir = sys.argv[2]
lang = sys.argv[3]
files = sys.argv[4:]
files.sort()
if os.path.exists( blddir ):
removeDir( blddir )
os.makedirs( blddir )
menu_toc = ''
files_string = ''
for filename in files:
files_string += '<file>%s</file>\n' % filename
if filename.endswith( 'menu.html' ):
try:
f = open( os.path.join( srcdir, filename ), 'r' )
except IOError:
continue
parser = MyParser()
parser.parse( f.read() )
menu_toc = parser.get_xml(13, lang)
qhp_file_src = os.path.join( srcdir, lang + '.qhp' )
qhp_file_bld = os.path.join( blddir, lang + '.qhp' )
infile = open( qhp_file_src, "r" )
outfile = open( qhp_file_bld, "w" )
for line in infile:
line = line.replace( "@FILES@", files_string ).replace( "@MENU_TOC@", menu_toc )
outfile.write(line)
infile.close()
outfile.close()
qhcp_file_src = os.path.join( srcdir, lang + '.qhcp' )
qhcp_file_bld = os.path.join( blddir, lang + '.qhcp' )
shutil.copy( qhcp_file_src, qhcp_file_bld )
for filename in files:
src = os.path.join( srcdir, filename )
dst = os.path.join( blddir, filename )
if not os.path.exists( src ):
print >> sys.stderr, "Source file %s does not exist - skipping" % src
continue
if ( os.path.exists( dst ) and os.path.isfile( dst ) ) and\
( os.path.getsize( src ) == os.path.getsize( dst ) ) and\
( os.stat( src ).st_mtime <= os.stat( dst ).st_mtime ):
continue
dstdir = os.path.dirname( dst )
if not os.path.isdir( dstdir ):
if os.path.exists( dstdir ):
os.remove( dstdir )
os.makedirs( dstdir )
shutil.copy( src, dst )
if __name__ == "__main__":
main()
@@ -0,0 +1,5 @@
int main(int, char**)
{
return 0;
}