myvtm/CMakeLists.txt

#
# This is a CMake makefile.  CMake is a tool that helps you build C++ programs.
# You can download CMake from http://www.cmake.org.  This CMakeLists.txt file
# you are reading builds dlib's example programs. 
#
# To compile this program all you need to do is ask cmake.  You would type
# these commands from within the directory containing this CMakeLists.txt
# file:
#   mkdir build
#   cd build
#   cmake ..
#   cmake --build . --config {Release|Debug}
#
# The cmake .. command looks in the parent folder for a file named
# CMakeLists.txt, reads it, and sets up everything needed to build program.
#
# CMake can generate a lot of different types of IDE projects.  Run the cmake -h 
# command to see a list of arguments to -G to see what kinds of projects cmake can generate for you. 
# It probably includes your favorite IDE in the list.

cmake_minimum_required (VERSION 3.8)

project(RvcFramework)

set(CMAKE_CXX_STANDARD 11)



#  Include extend cmake scripts
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/addin/cmake/ )
include(CheckStructHasMember)
include(CheckIncludeFiles)
include(CheckSymbolExists)
include(ConfigOptions)
include(GetGitRevisionDescription)

# include path enviroment for RVC
include(BuildMakeSettings)
include(ModMakeSettings)
include(ThirdPartySettings)

# Turn on solution folders (2.8.4+) for Visual Studio.
set_property(GLOBAL PROPERTY USE_FOLDERS ON)

set(BUILD_NUMBER 0)
if ($ENV{BUILD_NUMBER})
	set(BUILD_NUMBER $ENV{BUILD_NUMBER})
endif()

set(RVC_COMPANY "China Merchants Bank" CACHE STRING "China Merchants Bank Corporation")
set(RVC_PRODUCT "VTM")
set(RVC_AUTHOR "CCDG")
set(RVC_COPYRIGHT "Copyright (C) 2020")
set(RVC_DESCRIPTION "2020.01")

#Set the project version
set(RAW_VERSION_STRING "1.0.1-dev1")

string(STRIP ${RAW_VERSION_STRING} RAW_VERSION_STRING)

set(VERSION_REGEX "^.?([0-9]+)\\.([0-9]+)\\.([0-9]+)-?(.*)")
string(REGEX REPLACE "${VERSION_REGEX}" "\\1" RVC_VERSION_MAJOR "${RAW_VERSION_STRING}")
string(REGEX REPLACE "${VERSION_REGEX}" "\\2" RVC_VERSION_MINOR "${RAW_VERSION_STRING}")
string(REGEX REPLACE "${VERSION_REGEX}" "\\3" RVC_VERSION_REVISION "${RAW_VERSION_STRING}")
string(REGEX REPLACE "${VERSION_REGEX}" "\\4" RVC_VERSION_SUFFIX "${RAW_VERSION_STRING}")

set(RVC_VERSION_BUILD "${BUILD_NUMBER}")
set(RVC_API_VERSION "${RVC_VERSION_MAJOR}")
set(RVC_VERSION "${RVC_VERSION_MAJOR}.${RVC_VERSION_MINOR}.${RVC_VERSION_REVISION}.${RVC_VERSION_BUILD}")
set(RVC_FRAMEWORK_VERSION "${RVC_VERSION_MAJOR}.${RVC_VERSION_MINOR}.${RVC_VERSION_REVISION}")
if (RVC_VERSION_SUFFIX)
	set(RVC_VERSION_FULL "${RVC_VERSION}-${RVC_VERSION_SUFFIX}")
else()
	set(RVC_VERSION_FULL "${RVC_VERSION}")
endif()
message("RVC_VERSION=${RVC_VERSION_FULL}")

git_get_exact_tag(_GIT_TAG --tags --always)
if (NOT ${_GIT_TAG} STREQUAL "n/a")
	message(STATUS "GIT tag: ${_GIT_TAG}")
endif()

message("CMAKE_SYSTEM_NAME: ${CMAKE_SYSTEM_NAME}, CMAKE_GENERATOR: ${CMAKE_GENERATOR}")

configure_file("${PROJECT_SOURCE_DIR}/version.h.in" "${PROJECT_BINARY_DIR}/spbase/version.h")

set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set(CMAKE_PDB_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)

if(NOT DEFINED BUILD_SHARED_LIBS)
	set(BUILD_SHARED_LIBS ON)
endif()

if(MSVC)
	set(LIB_PREFIX "")
	set(LIB_SUFFIX ".dll")
	set(ROOT_INI_NAME "root.ini.win32")
else()
	set(LIB_PREFIX "lib")
	set(LIB_SUFFIX ".so")
	set(ROOT_INI_NAME "root.ini.unix")
endif(MSVC)

if(SIMULATE_DEV_AND_TEST_TEMP)
# simulate the real executive path environment, for debug easily.
	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/run/version/1.2.3.4/bin")
	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
	file(MAKE_DIRECTORY  ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
	file(MAKE_DIRECTORY  "${CMAKE_BINARY_DIR}/run/hardwarecfg")
	file(MAKE_DIRECTORY  "${CMAKE_BINARY_DIR}/run/version/1.2.3.4/cfg")
	file(MAKE_DIRECTORY  "${CMAKE_BINARY_DIR}/run/version/1.2.3.4/mod")
	file(COPY "${CMAKE_SOURCE_DIR}/addin/hardwarecfg/${ROOT_INI_NAME}" DESTINATION "${CMAKE_BINARY_DIR}/run/hardwarecfg")
	file(RENAME "${CMAKE_BINARY_DIR}/run/hardwarecfg/${ROOT_INI_NAME}" "${CMAKE_BINARY_DIR}/run/hardwarecfg/root.ini")
	file(GLOB SIMU_CONFIG_FILE "${CMAKE_SOURCE_DIR}/addin/cfg/*.ini")
	file(COPY ${SIMU_CONFIG_FILE} DESTINATION "${CMAKE_BINARY_DIR}/run/version/1.2.3.4/cfg")
	configure_file("${CMAKE_CURRENT_SOURCE_DIR}/addin/cfg/shell.ini.in" "${CMAKE_BINARY_DIR}/run/version/1.2.3.4/cfg/shell.ini" @ONLY)
endif(SIMULATE_DEV_AND_TEST_TEMP)#end simulate

if(BUILD_TESTING)
	include(CTest)
	message(STATUS "build the tests.")
	enable_testing()
	set(GTEST_ROOT "${CMAKE_SOURCE_DIR}/third_party/gtest/googletest/include")
	set(GMOCK_ROOT "${CMAKE_SOURCE_DIR}/third_party/gtest/googlemock/include")
	if(MSVC)
		set(TESTING_OUTPUT_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
	else()
		set(TESTING_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/Testing")
	endif()
endif()

if(BUILD_SHARED_LIBS)
	message(STATUS "Build shared libraries")
endif(BUILD_SHARED_LIBS)

# Some buildsystems generated by CMake have a predetermined build-configuration set in the 
# CMAKE_BUILD_TYPE variable. The buildsystem for the IDEs such as Visual Studio and Xcode are 
# generated independent of the build-configuration, and the actual build configuration is not known 
# until build-time. 
# string(TOLOWER ${CMAKE_BUILD_TYPE} _type)
#if (_type STREQUAL debug)
#  target_compile_definitions(exe1 PRIVATE DEBUG_BUILD)
# endif()
#may appear to work for Makefile Generators and Ninja generators, but is not portable to IDE generators. 
#Additionally, the IMPORTED configuration-mappings are not accounted for with code like this, so it should be avoided.

if(${CMAKE_GENERATOR} MATCHES "Visual Studio*")
	if(CMAKE_CONFIGURATION_TYPES STREQUAL Debug)
		message(STATUS "debug type")
		set(BUILD_TYPE_NAME "Debug")
	else()
		set(BUILD_TYPE_NAME "Release")
	endif()
	if(NOT CMAKE_GENERATOR_PLATFORM)
		message(STATUS "set win32 platform default")
		set(CMAKE_GENERATOR_PLATFORM "${CMAKE_SYSTEM_PROCESSOR}")
	else()
		message(STATUS ${CMAKE_GENERATOR_PLATFORM})
	endif()

elseif(${CMAKE_GENERATOR} MATCHES "Unix*")
	if(NOT CMAKE_BUILD_TYPE)
		set(CMAKE_BUILD_TYPE "Debug")
	endif()
	set(BUILD_TYPE_NAME ${CMAKE_BUILD_TYPE})
	if(NOT CMAKE_GENERATOR_PLATFORM)
		message(STATUS "set unix platform default: ${CMAKE_SYSTEM_PROCESSOR}")
		# set(CMAKE_GENERATOR_PLATFORM "${CMAKE_SYSTEM_PROCESSOR}")
	else()
		message(STATUS ${CMAKE_GENERATOR_PLATFORM})
	endif()
endif()
string(TOLOWER ${BUILD_TYPE_NAME} BUILD_TYPE_NAME_lower)
# 注释掉之后，目测在Linux之下是跑 x64 位，否则会出现 pthread 找不到的情况，应该是没安装对应的版本
#if(${CMAKE_GENERATOR} MATCHES "Unix*")
#	message(STATUS "set 32bits and debug")
#	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32 -g")
#	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32 -g")
#endif()



# Configure MSVC Runtime
if(MSVC)
	include(MSVCRuntime)
	if(NOT DEFINED MSVC_RUNTIME)
		set(MSVC_RUNTIME "dynamic")
		message(STATUS "dynamic format")
	endif()
	set(MSVC_DYNAMIC_RUNTIME ${MSVC_RUNTIME})
	configure_msvc_runtime()
	set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
endif(MSVC)

# Enable 64bit file support on linux and FreeBSD.
if("${CMAKE_SYSTEM_NAME}" MATCHES "Linux" OR FREEBSD)
	add_definitions("-D_FILE_OFFSET_BITS=64")
endif()

if(CMAKE_COMPILER_IS_GNUCC)
	if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64" OR CMAKE_SYSTEM_PROCESSOR MATCHES "i686")
		CHECK_SYMBOL_EXISTS(__x86_64__ "" IS_X86_64)
		if(IS_X86_64)
			set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
			message(STATUS "set -fPIC")
		else()
			set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=i686")
			message(STATUS "set -march=i686")
		endif()
	else()
		if(CMAKE_POSITION_INDEPENDENT_CODE)
			if(${CMAKE_VERSION} VERSION_LESS 2.8.9)
				message(STATUS "set -fPIC 2")
				set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
			endif()
		endif()
	endif()
	# active warning or gun c compiler would not burn warning if not necessary.
	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
endif()

if(MSVC)
	# Window occurs '/' error
	STRING(REGEX REPLACE "^([A-Z]*.)([/\\].*)" "\\1" CURRENT_DISK "${CMAKE_CURRENT_SOURCE_DIR}")
	set(OUTPUT_CUR_DISK_PATH "${CURRENT_DISK}\\")
else(MSVC)
		set(OUTPUT_CUR_DISK_PATH "/opt/")
endif(MSVC)
set(OUTPUT_VERSION_DIR_PATH "${OUTPUT_CUR_DISK_PATH}run\\version")
set(OUTPUT_CUR_VERSION_PATH "${OUTPUT_VERSION_DIR_PATH}\\${RVC_VERSION}")

if(NOT MSVC)
	string(REPLACE "\\" "/" OUTPUT_VERSION_DIR_PATH ${OUTPUT_VERSION_DIR_PATH})
	string(REPLACE "\\" "/" OUTPUT_CUR_VERSION_PATH ${OUTPUT_CUR_VERSION_PATH})
endif(NOT MSVC)


#Config install information
set(PACK_INSTALL_RUN_DIR "run")
set(PACK_INSTALL_PREFIX_VERSION "${PACK_INSTALL_RUN_DIR}/version")
set(PACK_INSTALL_PREFIX_CUR_VER "${PACK_INSTALL_PREFIX_VERSION}/${RVC_VERSION}")

set(RVC_INCLUDE_PATH  "${PACK_INSTALL_PREFIX_CUR_VER}/include")
set(RVC_LIBRARY_PATH   "${PACK_INSTALL_PREFIX_CUR_VER}/lib")
set(RVC_RUNTIME_PATH "${PACK_INSTALL_PREFIX_CUR_VER}/bin")
set(RVC_MODULE_PATH  "${PACK_INSTALL_PREFIX_CUR_VER}/mod")
set(RVC_CONFIG_PATH    "${PACK_INSTALL_PREFIX_CUR_VER}/cfg")
set(RVC_VENDOR_PATH  "${PACK_INSTALL_PREFIX_CUR_VER}/dep")
set(RVC_SHARED_PATH   "${PACK_INSTALL_PREFIX_CUR_VER}/share")

set(CMAKE_INSTALL_INCLUDEDIR ${RVC_INCLUDE_PATH})
set(CMAKE_INSTALL_LIBDIR           ${RVC_LIBRARY_PATH})
set(CMAKE_INSTALL_BINDIR          ${RVC_RUNTIME_PATH})

# This macro maybe not be used now!!
# macro(copy_output_on_build module_name output_subdir)
#	set(target_name ${module_name})
#	set(output_dir ${OUTPUT_CUR_DISK_PATH}\\${output_subdir})
#	if(NOT EXISTS ${output_dir} OR NOT IS_DIRECTORY ${output_dir})
		# nothing to do.
#	endif()
#	add_custom_command(TARGET ${target_name} PRE_BUILD
#		COMMAND ${CMAKE_COMMAND}
#		ARGS -E make_directory ${output_dir})
#	add_custom_command(TARGET ${target_name} POST_BUILD
#		COMMAND ${CMAKE_COMMAND} -E copy
#		$<TARGET_FILE:${target_name}>
#		${OUTPUT_CUR_DISK_PATH}/${output_subdir}
#	)
#endmacro(copy_output_on_build)

set(CPACK_SYSTEM_NAME "${CMAKE_SYSTEM_NAME}-${CMAKE_GENERATOR_PLATFORM}-${BUILD_TYPE_NAME}")
set(CPACK_TOPLEVEL_TAG "${CMAKE_SYSTEM_NAME}-${CMAKE_GENERATOR_PLATFORM}-${BUILD_TYPE_NAME}")

if(WIN32)
   # dll rc version
	string(TIMESTAMP RC_VERSION_YEAR "%Y")
	set(RC_VERSION_AUTHOR    ${RVC_AUTHOR})
	set(RC_VERSION_COMPANY ${RVC_COMPANY})
	set(RC_VERSION_PRODUCT  ${RVC_PRODUCT})
	set(RC_VERSION_PATCH       ${BUILD_NUMBER})
	set(RC_VERSION_DESCRIPTION "${RVC_VERSION_FULL} ${CPACK_SYSTEM_NAME}")

	#set previous definitions
	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
	add_definitions(-DWIN32_LEAN_AND_MEAN)
	add_definitions(-D_WINSOCK_DEPRECATED_NO_WARNINGS)

	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc")
endif(WIN32)

# Include files
check_include_files(fcntl.h HAVE_FCNTL_H)
check_include_files(unistd.h HAVE_UNISTD_H)
check_include_files(execinfo.h HAVE_EXECINFO_H)
check_include_files(inttypes.h HAVE_INTTYPES_H)
check_include_files(sys/modem.h HAVE_SYS_MODEM_H)
check_include_files(sys/filio.h HAVE_SYS_FILIO_H)
check_include_files(sys/sockio.h HAVE_SYS_SOCKIO_H)
check_include_files(sys/strtio.h HAVE_SYS_STRTIO_H)
check_include_files(sys/select.h HAVE_SYS_SELECT_H)
check_include_files(syslog.h HAVE_SYSLOG_H)

check_struct_has_member("struct tm" tm_gmtoff time.h HAVE_TM_GMTOFF)
set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
find_package(Threads REQUIRED)

if(NOT WIN32)
	CHECK_SYMBOL_EXISTS(pthread_mutex_timedlock pthread.h HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL)
	if (NOT HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL)
		CHECK_LIBRARY_EXISTS(pthread pthread_mutex_timedlock "" HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB)
	endif (NOT HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL)
	if (NOT HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB)
		CHECK_LIBRARY_EXISTS(pthreads pthread_mutex_timedlock "" HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIBS)
	endif (NOT HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB)

	if (HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL OR HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB OR HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIBS)
		set(HAVE_PTHREAD_MUTEX_TIMEDLOCK ON)
	endif (HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL OR HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB OR HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIBS)
endif()

if(UNIX)
	check_include_files(aio.h HAVE_AIO_H)
	check_include_files(sys/eventfd.h HAVE_SYS_EVENTFD_H)
	if (HAVE_SYS_EVENTFD_H)
		check_symbol_exists(eventfd_read sys/eventfd.h WITH_EVENTFD_READ_WRITE)
	endif()
	check_include_files(sys/timerfd.h HAVE_SYS_TIMERFD_H)
	check_include_files(poll.h HAVE_POLL_H)
endif(UNIX)

add_definitions("-DWITH_OPENSSL")

# Include directories
include_directories(${CMAKE_CURRENT_BINARY_DIR})

# Configure files
add_definitions("-DHAVE_CONFIG_H")
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h)
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/addin/cfg/shell.ini.in" ${CMAKE_BINARY_DIR}/shell.ini @ONLY)
# WinPR
include_directories("${CMAKE_SOURCE_DIR}/winpr/include")
include_directories("${CMAKE_BINARY_DIR}/winpr/include")

include_directories(Common)
add_subdirectory(third_party)
if(WITH_THIRD_PARTY)
	
	if (NOT "${THIRD_PARTY_INCLUDES}" STREQUAL "")
		include_directories(${THIRD_PARTY_INCLUDES})
	endif()
endif(WITH_THIRD_PARTY)

add_subdirectory(winpr)
add_subdirectory(libtoolkit)
add_subdirectory(RVCComm)
add_subdirectory(spbase)
add_subdirectory(spshell)
add_subdirectory(sphost)
add_subdirectory(Other)
add_subdirectory(Module)

add_subdirectory(DevAdapter)

# build module for test
# if(BUILD_TESTING)
	add_subdirectory(test)
# endif()

#Just copy and edit a little for output buildflags.h header file, deal it at future.
set(RVC_BUILD_CONFIG_LIST "")
GET_CMAKE_PROPERTY(res VARIABLES)
FOREACH(var ${res})
	IF (var MATCHES "^WITH_*|^BUILD_TESTING|^BUILTIN_CHANNELS|^HAVE_*")
		LIST(APPEND RVC_BUILD_CONFIG_LIST "${var}=${${var}}")
	ENDIF()
ENDFOREACH()
string(REPLACE ";" " " RVC_BUILD_CONFIG "${RVC_BUILD_CONFIG_LIST}")
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/buildflags.h.in ${CMAKE_CURRENT_BINARY_DIR}/buildflags.h)

# 
if(MSVC)
	string(REPLACE "\\" "/" OUTPUT_VERSION_DIR_PATH ${OUTPUT_VERSION_DIR_PATH})
	string(REPLACE "\\" "/" OUTPUT_CUR_DISK_PATH ${OUTPUT_CUR_DISK_PATH})
endif(MSVC)
set(CMAKE_INSTALL_PREFIX "${OUTPUT_CUR_DISK_PATH}")
set(CMAKE_INSTALL_LOCAL_ONLY ON)

# Config package information.
set(CPACK_SOURCE_IGNORE_FILES "/\\\\.git/;/\\\\.gitignore;/CMakeCache.txt;/\\\\build;/\\\\out")
string(TOLOWER ${CMAKE_PROJECT_NAME} CMAKE_PROJECT_NAME_lower)
set(CPACK_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME_lower}-${RVC_VERSION_FULL}-${CPACK_SYSTEM_NAME}")
set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME_lower}-${RVC_VERSION_FULL}-${CPACK_SYSTEM_NAME}")
# 
set(CPACK_PACKAGE_NAME "RvcFramework")
set(CPACK_PACKAGE_VENDOR "RVC-CCDG")
# 
set(CPACK_PACKAGE_VERSION              ${RVC_VERSION_FULL})
set(CPACK_PACKAGE_VERSION_MAJOR ${RVC_VERSION_MAJOR})
set(CPACK_PACKAGE_VERSION_MINOR ${RVC_VERSION_MINOR})
set(CPACK_PACKAGE_VERSION_PATCH ${RVC_VERSION_REVISION})

# Configure package type
if(MSVC)
	if( NOT CPACK_GENERATOR)
		set(CPACK_GENERATOR "ZIP")
		message(STATUS "set zip package file type")
	endif()
	if(CPACK_GENERATOR MATCHES "NSIS")
		set(CPACK_PACKAGE_INSTALL_DIRECTORY "C:\\\\Run")
	endif()
else(MSVC)
	if( NOT CPACK_GENERATOR)
		set(CPACK_GENERATOR "TGZ")
	message(STATUS "set tgz package file type")
	endif()
endif(MSVC)

if(MSVC)
	if(MSVC_RUNTIME STREQUAL "dynamic")
	# the INSTALL command is not called. The user can use the variable 
	# CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS to use a custom install command and install them however they want.
		set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP TRUE)
		include(InstallRequiredSystemLibraries)
		install(PROGRAMS ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS}
			DESTINATION ${RVC_RUNTIME_PATH}
			COMPONENT libraries)
	else()
		include(InstallRequiredSystemLibraries)
	endif()
endif()

#
if(INSTALL_DEVELOP_FILES)
	install(DIRECTORY Common DESTINATION ${RVC_INCLUDE_PATH} COMPONENT headers FILES_MATCHING PATTERN "*.h")
	install(FILES "${PROJECT_BINARY_DIR}/spbase/version.h" DESTINATION "${RVC_INCLUDE_PATH}/Common" COMPONENT headers)
endif(INSTALL_DEVELOP_FILES)

if(MSVC)
	file(GLOB BIN_FILES "${CMAKE_SOURCE_DIR}/addin/din/win/*")
else()
	file(GLOB BIN_FILES "${CMAKE_SOURCE_DIR}/addin/din/unix/*")
endif(MSVC)
install(PROGRAMS ${BIN_FILES} DESTINATION "${RVC_RUNTIME_PATH}" COMPONENT libraries)

install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/cfg" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" 
	COMPONENT scripts FILES_MATCHING PATTERN "*.ini")
install(FILES ${CMAKE_BINARY_DIR}/shell.ini DESTINATION ${RVC_CONFIG_PATH} COMPONENT scripts)
set(active_txt_file "${CMAKE_BINARY_DIR}/active.txt")
file(WRITE ${active_txt_file} "${RVC_VERSION}")
install(FILES ${active_txt_file} DESTINATION ${PACK_INSTALL_PREFIX_VERSION} COMPONENT scripts)
# Actually, this directory only has root.ini for now.
install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/hardwarecfg" DESTINATION "${PACK_INSTALL_RUN_DIR}" 
	COMPONENT scripts FILES_MATCHING PATTERN "*.ini")
if(MSVC)
	file(GLOB BAT_SCRIPTS "${CMAKE_SOURCE_DIR}/addin/startup_scripts/*.vbs")
	install(FILES "${CMAKE_SOURCE_DIR}/test/rvc_test.bat" DESTINATION ${OUTPUT_CUR_DISK_PATH}  COMPONENT scripts)
else(MSVC)
	file(GLOB BAT_SCRIPTS "${CMAKE_SOURCE_DIR}/addin/startup_scripts/*.sh")
endif(MSVC)
install(FILES "${CMAKE_SOURCE_DIR}/addin/hardwarecfg/${ROOT_INI_NAME}" 
	DESTINATION "${PACK_INSTALL_RUN_DIR}/hardwarecfg" 
	RENAME "root.ini"
	COMPONENT scripts)
install(PROGRAMS ${BAT_SCRIPTS} DESTINATION "${PACK_INSTALL_PREFIX_VERSION}" COMPONENT scripts)

#appoint the component to install , except header file here.
 #set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
set(CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE TRUE)

GET_CMAKE_PROPERTY(PACK_COMPONENTS_ALL  COMPONENTS)
FOREACH(item ${PACK_COMPONENTS_ALL})
message(STATUS "component: ${item}")
ENDFOREACH()
list(REMOVE_ITEM PACK_COMPONENTS_ALL "headers" "tools" "symbols")
set(CPACK_COMPONENTS_ALL ${PACK_COMPONENTS_ALL})

set_property(GLOBAL PROPERTY COMPONENTS ${PACK_COMPONENTS_ALL})
GET_CMAKE_PROPERTY(PACK_COMPONENTS_ALL  COMPONENTS)
FOREACH(item ${PACK_COMPONENTS_ALL})
message(STATUS "after component: ${item}")
ENDFOREACH()

set(CPACK_COMPONENT_headers_DISABLED TRUE)

include(CPack)

#install(CODE "EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E make_directory ${OUTPUT_VERSION_DIR_PATH})")
#install(CODE "EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E copy_if_different ${active_txt_file} ${OUTPUT_VERSION_DIR_PATH}/active.txt   )")

# if necessary
# install(DIRECTORY ${CMAKE_SOURCE_DIR}/addin/mod DESTINATION ${RVC_MODULE_PATH} COMPONENT modules)
# install(DIRECTORY ${CMAKE_SOURCE_DIR}/addin/dep DESTINATION ${RVC_VENDOR_PATH} COMPONENT vendors)
# install(PROGRAMS "")
# install(CODE "EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E remove_directory \"${CMAKE_INSTALL_PREFIX}/${RVC_INCLUDE_PATH}\")")