SHS/cmake
4
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

CMake refactoring

Browse Source
This commit is contained in:
Пелипенко Иван
2020-09-04 22:32:05 +03:00
parent 93caa5cc5d
commit c350c61e36
3 changed files with 519 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
DeployMacros.cmake
View File

@@ -273,19 +273,23 @@ endmacro()
macro(import_version _T _F)
if (NOT "x${_T}" STREQUAL "x${_F}")
set(_names "${__version_names};FULLSUFFIX")
foreach(_i ${_names})
set(${_T}_VERSION_${_i} "${${_F}_VERSION_${_i}}")
endforeach()
set(${_T}_VERSION "${${_F}_VERSION}")
set(${_T}_LANG "${${_F}_LANG}")
endif()
endmacro()
macro(import_deploy_properties _T _F)
if (NOT "x${_T}" STREQUAL "x${_F}")
foreach(_i ${__prop_names})
set(${_T}_${_i} "${${_F}_${_i}}")
endforeach()
endif()
endmacro()
@@ -475,21 +479,26 @@ endmacro()
macro(__gather_deps _T _search_path_var _dep_libs_var _dep_libs_cs_var _added_)
get_target_property(_LL${_T} ${_T} LINK_LIBRARIES)
foreach (_L${_T} ${_LL${_T}})
if (TARGET ${_L${_T}})
get_target_property(_II${_T} ${_L${_T}} IMPORTED)
set(_lib _L${_T})
if (TARGET ${_lib})
get_target_property(_AT ${_lib} ALIASED_TARGET)
if (NOT "x${_AT}" STREQUAL "x")
set(_lib ${_AT})
endif()
get_target_property(_II${_T} ${_lib} IMPORTED)
if (NOT _II${_T})
#message("depend on ${_L${_T}}")
get_target_property(_LT${_T} ${_L${_T}} TYPE)
#message("depend on ${_lib}")
get_target_property(_LT${_T} ${_lib} TYPE)
if (("x${_LT${_T}}" STREQUAL "xSHARED_LIBRARY") OR ("x${_LT${_T}}" STREQUAL "xSTATIC_LIBRARY"))
if (NOT _L${_T} IN_LIST ${_added_})
list(APPEND ${_added_} ${_L${_T}})
__gather_deps(${_L${_T}} ${_search_path_var} ${_dep_libs_var} ${_dep_libs_cs_var} ${_added_})
if (NOT _lib IN_LIST ${_added_})
list(APPEND ${_added_} ${_lib})
__gather_deps(${_lib} ${_search_path_var} ${_dep_libs_var} ${_dep_libs_cs_var} ${_added_})
if ("x${_LT${_T}}" STREQUAL "xSHARED_LIBRARY")
if (NOT DEFINED ANDROID_PLATFORM)
set(${_search_path_var} "${${_search_path_var}}${_dt_delim}$<TARGET_FILE_DIR:${_L${_T}}>")
set(${_search_path_var} "${${_search_path_var}}${_dt_delim}$<TARGET_FILE_DIR:${_lib}>")
endif()
set(${_dep_libs_cs_var} "${${_dep_libs_cs_var}}${_dt_delim}$<TARGET_FILE_DIR:${_L${_T}}>/$<TARGET_FILE_NAME:${_L${_T}}>")
set(${_dep_libs_var} "${${_dep_libs_var}}" "$<TARGET_FILE_DIR:${_L${_T}}>/$<TARGET_FILE_NAME:${_L${_T}}>")
set(${_dep_libs_cs_var} "${${_dep_libs_cs_var}}${_dt_delim}$<TARGET_FILE_DIR:${_lib}>/$<TARGET_FILE_NAME:${_lib}>")
set(${_dep_libs_var} "${${_dep_libs_var}}" "$<TARGET_FILE_DIR:${_lib}>/$<TARGET_FILE_NAME:${_lib}>")
endif()
endif()
endif()

388
SHSTKMacros.cmake
View File

@@ -1,72 +1,241 @@
#[[
macro(sdk_install _DIR IS_APP _TARGET _H_FILES _QM_FILES)
#message("QM=${_QM_FILES}")
if((NOT ${IS_APP}) AND (NOT "${_H_FILES}" STREQUAL ""))
if(LIB)
shstk_define_option(name desc)
shstk_begin_project(domain module)
shstk_install(dir is_app target h_files)
shstk_is_parent_exists(out)
shstk_copy_to_parent(domain)
shstk_add_directories(domain)
shstk_add_directories_with_include(is_qt domain)
shstk_set_find_dirs(domain)
shstk_find_header(module filename add_find_info)
align_list(list out)
print_list(list title prefix)
]]
find_package(MinGW REQUIRED)
include(GenerateExportHeader)
include(DeployMacros)
macro(shstk_define_option name desc)
if (NOT DEFINED ${name})
option(${name} ${desc} ${ARGN})
message("define option ${name} ${desc} ${ARGN}")
endif()
endmacro()
macro(shstk_begin_project domain module)
set(INSTALL_PREFIX)
set(_plugins_default_ 1)
if (CMAKE_CROSSCOMPILING)
if (DEFINED ANDROID_PLATFORM)
set(INSTALL_PREFIX "${CMAKE_FIND_ROOT_PATH}/")
set(_plugins_default_ 0)
else()
set(INSTALL_PREFIX "${CMAKE_STAGING_PREFIX}")
endif()
endif()
if (NOT DEFINED BUILD_NUMBER)
set(BUILD_NUMBER 9999)
endif()
if("x${BUILD_NUMBER}" STREQUAL "x")
set(BUILD_NUMBER 0)
endif()
shstk_define_option(LOCAL "Local install" OFF)
shstk_define_option(STATIC_LIB "Build static libraries" OFF)
set(_path "local \"bin\", \"lib\" and \"include\"")
if (NOT LOCAL)
if (WIN32)
install(FILES ${_H_FILES} DESTINATION ${MINGW_INCLUDE}/${_DIR})
else()
install(FILES ${_H_FILES} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/${_DIR})
if (MINGW)
set(CMAKE_INSTALL_PREFIX ${MINGW_DIR})
endif()
else()
install(FILES ${_H_FILES} DESTINATION include/${_DIR})
endif()
endif()
if (NOT "${_TARGET}" STREQUAL "")
if(LIB)
if(WIN32)
if (${IS_APP})
qt_install(TARGETS ${_TARGET} DESTINATION ${MINGW_BIN})
qt_install(TARGETS ${_TARGET} DESTINATION QtBin)
if (DEFINED ANDROID_PLATFORM)
set(CMAKE_INSTALL_PREFIX ${ANDROID_SYSTEM_LIBRARY_PATH}/usr)
else()
qt_install(TARGETS ${_TARGET} ARCHIVE DESTINATION ${MINGW_LIB})
qt_install(TARGETS ${_TARGET} RUNTIME DESTINATION ${MINGW_BIN})
qt_install(TARGETS ${_TARGET} RUNTIME DESTINATION QtBin)
if (CMAKE_CROSSCOMPILING)
set(CMAKE_INSTALL_PREFIX ${CMAKE_STAGING_PREFIX})
else()
set(CMAKE_INSTALL_PREFIX ${INSTALL_PREFIX}/usr/local)
endif()
endif()
endif()
set(_path "\"${CMAKE_INSTALL_PREFIX}\"")
endif()
if (NOT _install_msg)
set(_install_msg ON) # CACHE STRING "shstk_install_msg")
message(STATUS "Install to ${_path}")
endif()
if (CMAKE_BUILD_TYPE MATCHES Debug)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g3 -Wall")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g3 -Wall")
else()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -Wall")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3 -Wall")
endif()
if(MINGW)
list(APPEND CMAKE_LIBRARY_PATH ${MINGW_LIB})
endif()
if(APPLE)
set(CMAKE_INSTALL_RPATH "@executable_path/../Frameworks;@executable_path/lib;@loader_path/../lib")
set(CMAKE_MACOSX_RPATH TRUE)
if (CMAKE_CROSSCOMPILING)
set(CMAKE_INSTALL_NAME_DIR "@rpath")
else()
include_directories(/usr/local/include)
link_directories(/usr/local/lib)
endif()
else()
if (${IS_APP})
qt_install(TARGETS ${_TARGET} DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
set(CMAKE_INSTALL_RPATH "\$ORIGIN;\$ORIGIN/lib")
endif()
if (DEFINED ANDROID_PLATFORM)
include_directories(${ANDROID_SYSTEM_LIBRARY_PATH}/usr/include)
endif()
set(_qt_libs )
set(_qt_apps )
set(_qt_plugs)
if (NOT "x${domain}" STREQUAL "x")
set(BUILDING_${domain} ON CACHE BOOL "build ${domain}")
set(${domain}_ROOT_SRC "${CMAKE_CURRENT_SOURCE_DIR}" CACHE STRING "")
set(${domain}_ROOT_BIN "${CMAKE_CURRENT_BINARY_DIR}" CACHE STRING "")
set(SET_TARGETS_${domain} OFF CACHE BOOL "")
if(STATIC_LIB)
add_definitions(-D${module}_STATIC_DEFINE)
set(${domain}_LIB_TYPE STATIC)
set(${domain}_LIB_TYPE_MSG "Static")
else()
qt_install(TARGETS ${_TARGET} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
endif()
endif()
if(NOT "x${_QM_FILES}" STREQUAL "x")
qt_install(LANG ${_QM_FILES} DESTINATION QtLang)
set(${domain}_LIB_TYPE SHARED)
set(${domain}_LIB_TYPE_MSG "Shared")
endif()
if (CMAKE_BUILD_TYPE MATCHES Debug)
set(${domain}_BUILD_TYPE "Debug")
#add_definitions(-DPIP_DEBUG)
else()
if(${IS_APP})
qt_install(TARGETS ${_TARGET} DESTINATION bin)
set(${domain}_BUILD_TYPE "Release")
endif()
#set(${domain}_MAJOR 1)
#set(${domain}_MINOR 8)
#set(${domain}_REVISION 0)
#set(${domain}_SUFFIX )
#set(${domain}_COMPANY SHS)
#set(${domain}_DOMAIN org.SHS)
set(${domain}_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/${domain}_version.h")
set_version(${domain}
MAJOR "${${domain}_MAJOR}"
MINOR "${${domain}_MINOR}"
REVISION "${${domain}_REVISION}"
BUILD "${BUILD_NUMBER}"
SUFFIX "${${domain}_SUFFIX}"
OUTPUT "${${domain}_VERSION_FILE}")
set_deploy_property(${domain} ${${domain}_LIB_TYPE}
FULLNAME "${${domain}_DOMAIN}.*"
COMPANY "${${domain}_COMPANY}")
endif()
endmacro()
macro(shstk_install _dir is_app _target _h_files)
if((NOT ${is_app}) AND (NOT "x${_h_files}" STREQUAL "x"))
if(LOCAL)
install(FILES ${_h_files} DESTINATION include/${_dir})
else()
if(WIN32)
qt_install(TARGETS ${_TARGET} RUNTIME DESTINATION bin)
qt_install(TARGETS ${_TARGET} ARCHIVE DESTINATION lib)
install(FILES ${_h_files} DESTINATION ${MINGW_INCLUDE}/${_dir})
else()
qt_install(TARGETS ${_TARGET} DESTINATION lib)
install(FILES ${_h_files} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/${_dir})
endif()
endif()
if(NOT "x${_QM_FILES}" STREQUAL "x")
qt_install(LANG ${_QM_FILES} DESTINATION lang)
endif()
if (NOT "x${_target}" STREQUAL "x")
if(LOCAL)
if(${is_app})
install(TARGETS ${_target} DESTINATION bin)
else()
if(WIN32)
install(TARGETS ${_target} RUNTIME DESTINATION bin)
install(TARGETS ${_target} ARCHIVE DESTINATION lib)
else()
install(TARGETS ${_target} DESTINATION lib)
endif()
endif()
else()
if(WIN32)
if (${is_app})
install(TARGETS ${_target} DESTINATION ${MINGW_BIN})
install(TARGETS ${_target} DESTINATION QtBin)
else()
install(TARGETS ${_target} ARCHIVE DESTINATION ${MINGW_LIB})
install(TARGETS ${_target} RUNTIME DESTINATION ${MINGW_BIN})
install(TARGETS ${_target} RUNTIME DESTINATION QtBin)
endif()
else()
if (${is_app})
install(TARGETS ${_target} DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
else()
install(TARGETS ${_target} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
endif()
endif()
endif()
endif()
endmacro()
macro(copy_to_parent _inc_var)
macro(shstk_is_parent_exists _out)
set(${_out} FALSE)
get_property(_pd DIRECTORY PROPERTY PARENT_DIRECTORY)
if (NOT "x${_pd}" STREQUAL "x")
set(${_out} TRUE)
endif()
endmacro()
macro(shstk_copy_to_parent)
shstk_is_parent_exists(_pe)
if (_pe)
set(QT_MULTILIB_LIST ${QT_MULTILIB_LIST} PARENT_SCOPE)
set(_qt_libs ${_qt_libs} PARENT_SCOPE)
set(_qt_apps ${_qt_apps} PARENT_SCOPE)
set(_qt_plugs ${_qt_plugs} PARENT_SCOPE)
if (NOT "x${_inc_var}" STREQUAL "x")
set(${_inc_var} ${${_inc_var}} PARENT_SCOPE)
endif()
if (LIB)
set(_ALL_TARGETS ${_ALL_TARGETS} PARENT_SCOPE)
endif()
endmacro()
macro(add_directories_with_include multilib_prefix)
macro(shstk_add_directories domain)
file(GLOB _dl "[^.]*")
foreach(_d ${_dl})
if(IS_DIRECTORY ${_d})
add_subdirectory(${_d})
endif()
endforeach()
shstk_copy_to_parent("")
endmacro()
macro(shstk_add_directories_with_include is_qt domain)
set(DIRS)
file(GLOB _dl "[^.]*")
foreach(_d ${_dl})
@@ -75,33 +244,126 @@ macro(add_directories_with_include multilib_prefix)
endif()
endforeach()
set(inc_var ${multilib_prefix}includes)
set(${inc_var})
foreach(_d ${DIRS})
get_filename_component(_dname "${_d}" NAME)
list(APPEND QT_MULTILIB_LIST ${multilib_prefix}${_dname})
list(APPEND ${inc_var} "${_d}")
list(APPEND ${inc_var} "${CMAKE_CURRENT_BINARY_DIR}/${_dname}")
endforeach()
include_directories(${${inc_var}})
foreach(_d ${DIRS})
add_subdirectory(${_d})
endforeach()
copy_to_parent(${inc_var})
endmacro()
macro(add_directories multilib_prefix)
include_directories(${${multilib_prefix}includes})
file(GLOB _dl "[^.]*")
foreach(_d ${_dl})
if(IS_DIRECTORY ${_d})
add_subdirectory(${_d})
if (${is_qt})
list(APPEND QT_MULTILIB_LIST ${domain}${_dname})
#set(QT_MULTILIB_LIST "${QT_MULTILIB_LIST}" CACHE STRING "")
endif()
endforeach()
copy_to_parent(${multilib_prefix}includes)
foreach(_d ${DIRS})
add_subdirectory(${_d})
endforeach()
shstk_copy_to_parent()
endmacro()
macro(shstk_set_find_dirs domain)
#set(_PIP_INCDIR "${PIP_DIR}/include/pip")
#set(_PIP_LIBDIR "${PIP_DIR}/lib")
set(${domain}_INCDIR)
set(${domain}_LIBDIR)
set(${domain}_BINDIR)
set(${domain}_FIND_PROGRAM_ARG)
set(${domain}_BINEXT "")
#if (BUILDING_${domain})
# list(APPEND ${domain}_INCDIR "${${domain}_ROOT_SRC}")
# list(APPEND ${domain}_LIBDIR "${${domain}_ROOT_BIN}")
#endif()
if(MINGW_INCLUDE)
list(APPEND ${domain}_INCDIR "${MINGW_INCLUDE}/${domain}")
list(APPEND ${domain}_LIBDIR "${MINGW_LIB}")
list(APPEND ${domain}_BINDIR "${MINGW_BIN}")
endif()
if(CMAKE_CROSSCOMPILING)
list(APPEND ${domain}_INCDIR "${CMAKE_PREFIX_PATH}/include/${domain}")
list(APPEND ${domain}_LIBDIR "${CMAKE_PREFIX_PATH}/lib")
set(${domain}_FIND_PROGRAM_ARG "NO_DEFAULT_PATH")
list(APPEND ${domain}_BINDIR "/usr/bin" "/usr/local/bin")
include_directories(${CMAKE_PREFIX_PATH}/include)
link_directories(${CMAKE_PREFIX_PATH}/lib)
else()
list(APPEND ${domain}_BINDIR "${CMAKE_PREFIX_PATH}/bin")
if(NOT WIN32)
list(APPEND ${domain}_INCDIR "/usr/include/${domain}" "/usr/local/include/${domain}")
list(APPEND ${domain}_LIBDIR "/usr/lib" "/usr/local/lib")
endif()
if(APPLE)
include_directories(/usr/local/include)
link_directories(/usr/local/lib)
endif()
endif()
if ("x${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "xWindows")
set(${domain}_BINEXT ".exe")
if (CMAKE_CROSSCOMPILING)
set(${domain}_FIND_PROGRAM_ARG)
endif()
endif()
#list(APPEND ${domain}_BINDIR "${PIP_DIR}/bin")
endmacro()
macro(shstk_find_header module filename add_find_info)
if(NOT ${module}_VERSION)
include(CheckSymbolExists)
check_symbol_exists(${module}_VERSION_NAME "${${module}_INCLUDES}/${filename}" _version_found)
if (_version_found)
file(STRINGS "${${module}_INCLUDES}/${filename}" _version REGEX "^[ \t]*#define[ \t]+${module}_VERSION_NAME+[ \t]+.*$")
string(REGEX MATCH "\".*\"" _version ${_version})
string(LENGTH ${_version} SL)
math(EXPR SL ${SL}-2)
string(SUBSTRING ${_version} 1 ${SL} _version)
set(${module}_VERSION ${_version} CACHE STRING "${module}_VERSION")
if (NOT _FIND_${module}_MSG)
set(_FIND_${module}_MSG 1 CACHE BOOL "find_msg_${module}" FORCE)
set(_afi)
if (NOT "x${add_find_info}" STREQUAL "x")
set(_afi ": ${add_find_info}")
endif()
message(STATUS "Found ${module}${_afi} (version \"${${module}_VERSION}\")")
endif()
else()
message(FATAL_ERROR "Can`t find ${module} version file (\"${filename}\")!")
endif()
endif()
if(${module}_FIND_VERSION VERSION_GREATER ${module}_VERSION)
message(FATAL_ERROR "${module} version ${${module}_VERSION} is available, but ${${module}_FIND_VERSION} requested!")
endif()
endmacro()
macro(align_list _list _out)
set(_max_len 0)
foreach(_m ${_list})
string(LENGTH "${_m}" _clen)
if (_clen GREATER _max_len)
set(_max_len ${_clen})
endif()
endforeach()
set(${_out})
foreach(_m ${_list})
set(_am "${_m}")
while(TRUE)
string(LENGTH "${_am}" _clen)
if (_clen GREATER_EQUAL ${_max_len})
break()
endif()
string(APPEND _am " ")
endwhile()
list(APPEND ${_out} "${_am}")
endforeach()
endmacro()
macro(print_list _list _title _prefix)
if (NOT "x${_list}" STREQUAL "x")
if (NOT "x${_title}" STREQUAL "x")
message("${_title}")
endif()
foreach(_m ${_list})
message("${_prefix}${_m}")
endforeach()
endif()
endmacro()

166
SHSTKQtMacros.cmake Normal file
View File

@@ -0,0 +1,166 @@
#[[
shstk_qt_install(dir is_app target h_files qm_files)
shstk_qt_plugin(name modules libs)
shstk_qt_project(name is_app domain modules libs)
]]
set(_ok TRUE)
if (NOT BUILDING_qad)
include(SHSTKMacros)
include(QtWraps)
find_qt(Core QUIET)
find_package(QAD REQUIRED)
set(_ok ${QAD_FOUND})
endif()
if (_ok)
macro(shstk_qt_founded _out)
find_qt(Core QUIET)
set(${_out})
foreach(_v ${_QT_VERSIONS_})
#message("Qt${_v} -> ${LOCAL_FOUND${_v}}")
if (LOCAL_FOUND${_v})
list(APPEND ${_out} Qt${_v})
endif()
endforeach()
endmacro()
macro(shstk_qt_install _dir is_app _target _h_files _qm_files)
#message("QM=${_qm_files}")
if((NOT ${is_app}) AND (NOT "x${_h_files}" STREQUAL "x"))
if(LOCAL)
install(FILES ${_h_files} DESTINATION include/${_dir})
else()
if(WIN32)
install(FILES ${_h_files} DESTINATION ${MINGW_INCLUDE}/${_dir})
else()
install(FILES ${_h_files} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/${_dir})
endif()
endif()
endif()
if (NOT "x${_target}" STREQUAL "x")
if(LOCAL)
if(${is_app})
qt_install(TARGETS ${_target} DESTINATION bin)
else()
if(WIN32)
qt_install(TARGETS ${_target} RUNTIME DESTINATION bin)
qt_install(TARGETS ${_target} ARCHIVE DESTINATION lib)
else()
qt_install(TARGETS ${_target} DESTINATION lib)
endif()
endif()
if(NOT "x${_qm_files}" STREQUAL "x")
qt_install(LANG ${_qm_files} DESTINATION lang)
endif()
else()
if(WIN32)
if (${is_app})
qt_install(TARGETS ${_target} DESTINATION ${MINGW_BIN})
qt_install(TARGETS ${_target} DESTINATION QtBin)
else()
qt_install(TARGETS ${_target} ARCHIVE DESTINATION ${MINGW_LIB})
qt_install(TARGETS ${_target} RUNTIME DESTINATION ${MINGW_BIN})
qt_install(TARGETS ${_target} RUNTIME DESTINATION QtBin)
endif()
else()
if (${is_app})
qt_install(TARGETS ${_target} DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
else()
qt_install(TARGETS ${_target} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
endif()
endif()
if(NOT "x${_qm_files}" STREQUAL "x")
qt_install(LANG ${_qm_files} DESTINATION QtLang)
endif()
endif()
endif()
endmacro()
macro(shstk_qt_plugin NAME _MODULES _LIBS)
if (NOT STATIC_LIB)
if(DESIGNER_PLUGINS)
set(PROJ_NAME ${NAME}_plugin)
include_directories("..")
add_definitions(-DQT_PLUGIN)
add_definitions(-DQT_NO_DEBUG)
add_definitions(-DQT_SHARED)
add_definitions(-DQDESIGNER_EXPORT_WIDGETS)
find_qt(${QtVersions} Core Designer ${_MODULES})
qt_sources(SRC)
qt_wrap(${SRC} CPPS out_CPP QMS out_QM)
qt_add_library(${PROJ_NAME} SHARED out_CPP)
qt_target_link_libraries(${PROJ_NAME} ${_LIBS} ${_${NAME}_PLUGIN_LIBS})
if (WIN32)
qt_install(TARGETS ${PROJ_NAME} RUNTIME DESTINATION QtPlugins/designer)
else()
qt_install(TARGETS ${PROJ_NAME} DESTINATION QtPlugins/designer)
endif()
list(APPEND _qt_plugs ${NAME})
shstk_copy_to_parent()
endif()
endif()
endmacro()
macro(shstk_qt_project NAME IS_APP DOMAIN _MODULES _LIBS)
project(${NAME})
#message("find_qt ${NAME} \"${QtVersions}\" \"${_MODULES}\"")
find_qt(${QtVersions} Core ${_MODULES})
qt_sources(SRC)
import_version(${PROJECT_NAME} ${DOMAIN})
import_deploy_properties(${PROJECT_NAME} ${DOMAIN})
if (${IS_APP})
list(APPEND _qt_apps ${PROJECT_NAME})
set_deploy_property(${PROJECT_NAME}
LABEL ${PROJECT_NAME}
FULLNAME "${${DOMAIN}_DOMAIN}.${PROJECT_NAME}"
INFO "${APP_INFO}"
ICON "${APP_ICON}")
else()
list(APPEND _qt_libs ${PROJECT_NAME})
set_deploy_property(${PROJECT_NAME} SHARED
LABEL ${PROJECT_NAME}
FULLNAME "${${DOMAIN}_DOMAIN}.${PROJECT_NAME}"
INFO "${DOMAIN} ${NAME} library")
endif()
make_rc(${PROJECT_NAME} out_RC)
qt_wrap(${SRC} HDRS out_HDR CPPS out_CPP QMS out_QM ${out_RC})
if (${IS_APP})
qt_add_executable(${PROJECT_NAME} WIN32 out_CPP ${${DOMAIN}_EXPORT_HEADER} ${ARGN})
else()
set(_libtype SHARED)
if (NOT "x${${DOMAIN}_LIB_TYPE}" STREQUAL "x")
set(_libtype ${${DOMAIN}_LIB_TYPE})
endif()
qt_add_library(${PROJECT_NAME} ${_libtype} out_CPP ${${DOMAIN}_EXPORT_HEADER} ${ARGN})
#if(NOT ${DOMAIN}_STATIC_LIB)
# qt_target_compile_definitions(${PROJECT_NAME} PRIVATE ${DOMAIN}_SHARED_DEFINE)
#endif()
qt_generate_export_header(${PROJECT_NAME})
list(APPEND out_HDR "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}_export.h")
list(APPEND QT_MULTILIB_LIST ${PROJECT_NAME})
#message("${QT_MULTILIB_LIST}")
#set(QT_MULTILIB_LIST "${QT_MULTILIB_LIST}" CACHE STRING "")
endif()
qt_target_link_libraries(${PROJECT_NAME} ${_LIBS})
#message(STATUS "Building ${PROJECT_NAME}")
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/plugin")
set(_${NAME}_PLUGIN_LIBS "${_LIBS}")
add_subdirectory(plugin)
endif()
shstk_copy_to_parent()
endmacro()
endif()