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)

# program url: http://mayun.itc.cmbchina.cn/QD_RemoteBankArea/LR04.02_RVCTerminalPlus.git
project(RvcTerminalApp)

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(ComplexLibrary)
include(TodayTimeStamp)
include(PrecompiledHeader)
include(WindowsDLLVersion)
include(BuildMakeSettings)
# Turn on solution folders (2.8.4+) for Visual Studio.
set_property(GLOBAL PROPERTY USE_FOLDERS ON)

# THIS_MONTH(BUILD_NUMBER)
get_today(BUILD_YEAR BUILD_MONTH BUILD_DAY)
set(BUILD_DATE_STRING "${BUILD_YEAR}.${BUILD_MONTH}.${BUILD_DAY}")

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

set(DEVOPS_ON FALSE)
set(FORMAT_WITH_SUFFIX TRUE)
set(DEVOPS_ON_CMAKE_ST FALSE)
set(DEVOPS_ON_CMAKE_UAT FALSE)
set(DEVOPS_ON_CMAKE_DEV FALSE)
set(DEVOPS_ON_CMAKE_PRD FALSE)

if(MSVC)
	set(TARGET_PLATFORM Windows)
else()
	set(TARGET_PLATFORM UOS)
endif(MSVC)

if($ENV{PIPELINE_BUILD_ID})
	message(STATUS "DevOps pipeline environment: $ENV{DEVOPS_ENV}")
	message(STATUS "PIPELINE_BUILD_ID: $ENV{PIPELINE_BUILD_ID}")
	message(STATUS "PIPELINE_NAME: $ENV{PIPELINE_NAME}")
	message(STATUS "DEVOPS_GROUPID: $ENV{DEVOPS_GROUPID}")
	message(STATUS "DEVOPS_ARTIFACTID: $ENV{DEVOPS_ARTIFACTID}")
	message(STATUS "PIPELINE_NUMBER: $ENV{PIPELINE_NUMBER}")
	message(STATUS "PIPELINE_BRANCH: $ENV{PIPELINE_BRANCH}")
	set(DEVOPS_ON TRUE)
else()
	set(GIT_HASH "unknown")
	get_git_hash(GIT_HASH)
	message(STATUS "Git hash is ${GIT_HASH}")

	set(GIT_BRANCH "unknown")
	get_git_branch(GIT_BRANCH)
	message(STATUS "Git branch is ${GIT_BRANCH}")
endif($ENV{PIPELINE_BUILD_ID})

# alpha: 内测版本，BUG多，不稳定
# beta1,beta2: 公测版本，不稳定（比alpha稍微稳定），BUG相对较多
# rc1,rc2: 候选版本
# stable 稳定版本

#Set the project(terminal) version
set(RAW_VERSION_STRING "1.5.1-rc1")
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(VERSION_DEV_REGEX "^.?([0-9]+)\\.([0-9]+)\\.([0-9]+)-?([A-Za-z]*)(.*)")
string(REGEX REPLACE "${VERSION_DEV_REGEX}" "\\5" RVC_DEV_NUM "${RAW_VERSION_STRING}")

if(DEVOPS_ON)
	set(DEVOPS_ENV_STR $ENV{DEVOPS_ENV})
	string(TOLOWER $ENV{DEVOPS_ENV} DEVOPS_ENV_STR)
	
	string(COMPARE EQUAL ${DEVOPS_ENV_STR} "st" DEVOPS_ON_CMAKE_ST)
	string(COMPARE EQUAL ${DEVOPS_ENV_STR} "dev" DEVOPS_ON_CMAKE_DEV)
	string(COMPARE EQUAL ${DEVOPS_ENV_STR} "uat" DEVOPS_ON_CMAKE_UAT)
	if(DEVOPS_ON_CMAKE_UAT)
		message(STATUS "UAT devops environment, judge PRD or not.")
		if(DEFINED ENV{FOR_PRD})
			message(STATUS "FOR_PRD: $ENV{FOR_PRD}")
			if($ENV{FOR_PRD})
				set(DEVOPS_ON_CMAKE_PRD TRUE)
				set(DEVOPS_ON_CMAKE_UAT FALSE)
			endif($ENV{FOR_PRD})
		endif(DEFINED ENV{FOR_PRD})
	endif(DEVOPS_ON_CMAKE_UAT)

	#set vesion number: ENV_VER_Major.ENV_VER_Minor.ENV_VER_Revision.ENV_VER_Build
	if(DEFINED ENV{ENV_VER_Major})
		set(ENV_VER_Major_STR $ENV{ENV_VER_Major})
		string(LENGTH ${ENV_VER_Major_STR} ENV_VER_Major_STR_var)
		if(${ENV_VER_Major_STR_var})
			set(RVC_VERSION_MAJOR "${ENV_VER_Major_STR}")
			message(STATUS "reset RVC_VERSION_MAJOR: ${RVC_VERSION_MAJOR}")
		endif(${ENV_VER_Major_STR_var})
	endif(DEFINED ENV{ENV_VER_Major})
	if(DEFINED ENV{ENV_VER_Minor})
		set(ENV_VER_Minor_STR $ENV{ENV_VER_Minor})
		string(LENGTH ${ENV_VER_Minor_STR} ENV_VER_Minor_STR_var)
		if(${ENV_VER_Minor_STR_var})
			set(RVC_VERSION_MINOR "${ENV_VER_Minor_STR}")
			message(STATUS "reset RVC_VERSION_MINOR: ${RVC_VERSION_MINOR}")
		endif(${ENV_VER_Minor_STR_var})
	endif(DEFINED ENV{ENV_VER_Minor})
	if(DEFINED ENV{ENV_VER_Revision})
		set(ENV_VER_Revision_STR $ENV{ENV_VER_Revision})
		string(LENGTH ${ENV_VER_Revision_STR} ENV_VER_Revision_STR_var)
		if(${ENV_VER_Revision_STR_var})
			set(RVC_VERSION_REVISION "${ENV_VER_Revision_STR}")
			message(STATUS "reset RVC_VERSION_REVISION: ${RVC_VERSION_REVISION}")
		endif(${ENV_VER_Revision_STR_var})
	endif(DEFINED ENV{ENV_VER_Revision})
	if(DEFINED ENV{ENV_VER_Build})
		set(ENV_VER_Build_STR $ENV{ENV_VER_Build})
		string(LENGTH ${ENV_VER_Build_STR} ENV_VER_Build_STR_var)
		if(${ENV_VER_Build_STR_var})
			set(RVC_DEV_NUM "${ENV_VER_Build_STR}")
			set(BUILD_NUMBER "${ENV_VER_Build_STR}")
			message(STATUS "reset BUILD_NUMBER: ${BUILD_NUMBER}")
		endif(${ENV_VER_Build_STR_var})
	elseif((NOT DEVOPS_ON_CMAKE_PRD) AND DEFINED ENV{PIPELINE_NUMBER})
		set(BUILD_NUMBER $ENV{PIPELINE_NUMBER})
	else()
		message(WARN "not set pipe number env virable.")
		set(BUILD_NUMBER ${RVC_DEV_NUM})
	endif(DEFINED ENV{ENV_VER_Build})

	if(DEFINED ENV{BUILD_AS_INSTALLER})
		if($ENV{BUILD_AS_INSTALLER})
			set(PACK_AS_DEB_PKG ON)
			message(STATUS "built as debian installer $ENV{BUILD_AS_INSTALLER}")
		endif($ENV{BUILD_AS_INSTALLER})
	endif(DEFINED ENV{BUILD_AS_INSTALLER})

	if(DEVOPS_ON_CMAKE_PRD)
		set(RVC_VERSION_SUFFIX "PRD")
		if(PACK_AS_DEB_PKG)
		#product version as debian installer, reset the last version element to zero.
			set(BUILD_NUMBER 0)
		endif(PACK_AS_DEB_PKG)
	else()
		set(RVC_VERSION_SUFFIX "$ENV{DEVOPS_ENV}_$ENV{PIPELINE_NAME}")
	endif(DEVOPS_ON_CMAKE_PRD)
	if(NOT FORMAT_WITH_SUFFIX)
		unset(RVC_VERSION_SUFFIX)
	endif(NOT FORMAT_WITH_SUFFIX)

elseif(BUILD_NUMBER EQUAL 0)
	set(BUILD_NUMBER ${RVC_DEV_NUM})
endif(DEVOPS_ON)

message(STATUS "BUILD_NUMBER ${BUILD_NUMBER}")
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(RVC_VERSION_SUFFIX)
set(PACK_VERSION_NAME "${RVC_VERSION_FULL}")

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

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

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) ${BUILD_YEAR}")
set(RVC_DESCRIPTION "${BUILD_YEAR}.${BUILD_MONTH}")


# 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(NOT DEFINED CMAKE_CONFIGURATION_TYPES AND NOT DEFINED CMAKE_BUILD_TYPE)
	message(FATAL_ERROR "User should define CMAKE_CONFIGURATION_TYPES or CMAKE_BUILD_TYPE")
elseif(DEFINED CMAKE_CONFIGURATION_TYPES AND NOT DEFINED CMAKE_BUILD_TYPE)
	set(CMAKE_BUILD_TYPE ${CMAKE_CONFIGURATION_TYPES})
elseif(DEFINED CMAKE_BUILD_TYPE AND NOT DEFINED CMAKE_CONFIGURATION_TYPES)
	set(CMAKE_CONFIGURATION_TYPES ${CMAKE_BUILD_TYPE})
endif()

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

elseif(${CMAKE_GENERATOR} MATCHES "Unix*")
	if(NOT DEFINED CMAKE_BUILD_TYPE)
		set(CMAKE_BUILD_TYPE "Debug")
	endif()
	set(BUILD_TYPE_NAME ${CMAKE_BUILD_TYPE})
	if(NOT CMAKE_GENERATOR_PLATFORM)
	    # uncomment would make "CHECK_SYMBOL_EXISTS" failed !!! 20201014@Gifur Issue#IP1F
		# message(STATUS "set unix platform default: ${CMAKE_SYSTEM_PROCESSOR}")
		# set(CMAKE_GENERATOR_PLATFORM "${CMAKE_SYSTEM_PROCESSOR}")
	endif()
endif()

set(OLD_CONAN_EXPORTED ${CONAN_EXPORTED})

if(CONAN_EXPORTED)
	message(STATUS "Set CONAN_EXPORTED FALSE")
	set(CONAN_EXPORTED FALSE)
endif(CONAN_EXPORTED)


include(conan)
if(CONAN_CACHE_CLEAR)
	conan_local_remove()
endif(CONAN_CACHE_CLEAR)

conan_cmake_run(REQUIRES RvcFramework/1.0.8-dev18@LR04.02_FrameworkLib/testing
	Audio/2023.0509.01@LR04.02_MediaRes/testing
	Video/2022.0622.01@LR04.02_MediaRes/testing
BASIC_SETUP CMAKE_TARGETS)
include(DependencyConanFiles)

set(RVC_CONAN_DEP_LIBS ${CONAN_BIN_DIRS})
if(NOT MSVC)
	set(RVC_CONAN_DEP_LIBS ${RVC_CONAN_DEP_LIBS} ${CONAN_LIB_DIRS})
endif(NOT MSVC)

set(CONAN_EXPORTED ${OLD_CONAN_EXPORTED})

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

message("=-=-=-=-=-=-=-====-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=\n\n")
message(STATUS "RVC_VERSION=${RVC_VERSION_FULL}, Build time: ${BUILD_YEAR}.${BUILD_MONTH}.${BUILD_DAY}")
message("\n\n=-=-=-=-=-=-=-====-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=")

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

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(BUILD_TESTING)
	include(CTest)
	message(STATUS "******** build the tests ********")
	enable_testing()
	set(TESTING_OUTPUT_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
endif()

message(STATUS "CMAKE_GENERATOR_PLATFORM:  ${CMAKE_GENERATOR_PLATFORM}")

set(RVC_DEBUG_MODE TRUE)

string(TOLOWER ${BUILD_TYPE_NAME} _type)
string(TOUPPER ${BUILD_TYPE_NAME} _type_upper)
set(RVC_OUTPUT_SUFFIX "")
if (_type STREQUAL debug)
	add_compile_definitions(_DEBUG)
	set(RVC_OUTPUT_SUFFIX "_${_type_upper}")
elseif(_type STREQUAL release)
	add_compile_definitions(NDEBUG)
	set(RVC_DEBUG_MODE FALSE)
	set(RVC_OUTPUT_SUFFIX "_${_type_upper}")
endif()
if(DEVOPS_ON_CMAKE_ST)
	add_compile_definitions(DEVOPS_ON_ST)
	message(STATUS "add st compile definition")
elseif(DEVOPS_ON_CMAKE_UAT)
	add_compile_definitions(DEVOPS_ON_UAT)
	message(STATUS "add uat compile definition")
elseif(DEVOPS_ON_CMAKE_DEV)
	add_compile_definitions(DEVOPS_ON_DEV)
	message(STATUS "add dev compile definition")
elseif(DEVOPS_ON_CMAKE_PRD)
	add_compile_definitions(DEVOPS_ON_PRD)
	message(STATUS "add product compile definition")
endif(DEVOPS_ON_CMAKE_ST)

# 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)
		if(WITH_CI_NUMBER)
			set(CURRENT_DISK "/opt/")
		else()
			STRING(REGEX MATCH "^/home/([A-Za-z0-9_]*)/" CURRENT_DISK "${CMAKE_CURRENT_SOURCE_DIR}")
			STRING(LENGTH ${CURRENT_DISK} disk_length)
			if(NOT ${disk_length})
				set(CURRENT_DISK "/opt/")
			endif()
		endif()
		set(OUTPUT_CUR_DISK_PATH "${CURRENT_DISK}")
		message(STATUS "OUTPUT_CUR_DISK_PATH: ${OUTPUT_CUR_DISK_PATH}")
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_RVC_DIR "rvc")
set(PACK_INSTALL_PREFIX_VERSION "${PACK_INSTALL_RUN_DIR}/version")
set(PACK_INSTALL_PREFIX_CUR_VER "${PACK_INSTALL_PREFIX_VERSION}/${RVC_VERSION}")
set(PACK_INSTALL_DATA_DIR "${PACK_INSTALL_RVC_DIR}/adData")
set(PACK_INSTALL_MISCS_DIR "${PACK_INSTALL_RVC_DIR}/Other")
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_PLUGINS_PATH "${RVC_RUNTIME_PATH}/plugins")
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(RVC_RESOURCE_PATH   "${PACK_INSTALL_PREFIX_CUR_VER}/res")
set(RVC_CHROMIUM_PATH "${RVC_RUNTIME_PATH}/Chromium")


set(CMAKE_INSTALL_INCLUDEDIR ${RVC_INCLUDE_PATH})
set(CMAKE_INSTALL_BINDIR ${RVC_RUNTIME_PATH})
if(MSVC)
	set(CMAKE_INSTALL_LIBDIR ${RVC_LIBRARY_PATH})
else()
	set(CMAKE_INSTALL_LIBDIR ${RVC_RUNTIME_PATH})
endif(MSVC)

# set(CPACK_SYSTEM_NAME "${TARGET_PLATFORM}-${BUILD_YEAR}${BUILD_MONTH}${BUILD_DAY}")
set(CPACK_SYSTEM_NAME "${TARGET_PLATFORM}-${BUILD_TYPE_NAME}")
set(CPACK_TOPLEVEL_TAG "${TARGET_PLATFORM}-${BUILD_TYPE_NAME}")

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(RVC_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")

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)

if(MSVC)
  # Force to always compile with W4
  if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
    string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
  else()
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
  endif()
elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
  # Update if necessary
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-long-long -pedantic")
endif()

# 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)

# Include directories
include_directories(${CMAKE_CURRENT_BINARY_DIR})

# Configure files
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/ChangeLog.in" ${CMAKE_BINARY_DIR}/ChangeLog @ONLY)
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/addin/cfg/shell.ini.in" ${CMAKE_BINARY_DIR}/shell.ini @ONLY)
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/addin/Run.ini.in" "${CMAKE_BINARY_DIR}/Run.ini" @ONLY NEWLINE_STYLE CRLF)

if(SIMULATE_ON)
	if(EXISTS "${RVC_INSTALL_PREFIX}${CMAKE_INSTALL_BINDIR}" AND IS_DIRECTORY "${RVC_INSTALL_PREFIX}${CMAKE_INSTALL_BINDIR}")
		message(STATUS "install directory existed.")
		set(RVC_RUNTIME_OUTPUT_DIRECTORY "${RVC_INSTALL_PREFIX}${CMAKE_INSTALL_BINDIR}")
	else()
		message(STATUS "install directory \"${RVC_INSTALL_PREFIX}${CMAKE_INSTALL_BINDIR}\" is not existed!")
		set(SIMULATE_ON OFF)
	endif()
endif(SIMULATE_ON)

if(SIMULATE_ON)
	message(STATUS "simulate the real executive path environment, for debug easily")
	rvc_set_library_output_dir(${RVC_RUNTIME_OUTPUT_DIRECTORY})
else()
	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(WIN32)
		set(RVC_PDB_BINARY_DIR "${CMAKE_BINARY_DIR}/bin/${CMAKE_CONFIGURATION_TYPES}")
	else()
		set(RVC_PDB_BINARY_DIR ${CMAKE_BINARY_DIR}/bin)
	endif(WIN32)
	message(STATUS "RVC_PDB_BINARY_DIR: ${RVC_PDB_BINARY_DIR}")

endif(SIMULATE_ON)#end simulate

add_subdirectory(ThirdParty)
if(BUILD_MODULE)
	add_subdirectory(Other)
	add_subdirectory(Module)
else()
	message(WARNING "skipping Other and Module directories.")
endif(BUILD_MODULE)
if(BUILD_TOOLS)
	add_subdirectory(Tool)
else()
	message(WARNING "skipping Tool directory.")
endif(BUILD_TOOLS)
if(BUILD_PLUGINS)
	add_subdirectory(Plugins)
else()
	message(WARNING "skipping Plugins directory.")
endif(BUILD_PLUGINS)

if(BUILD_DEVADAPTER)
	add_subdirectory(DevAdapter)
else()
	message(WARNING "skipping DevAdapter directory.")
endif(BUILD_DEVADAPTER)

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_NAME_PREFIX "${CMAKE_PROJECT_NAME}")
set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME_PREFIX}-${PACK_VERSION_NAME}-${CPACK_SYSTEM_NAME}")
set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME_PREFIX}-${PACK_VERSION_NAME}-${CPACK_SYSTEM_NAME}")
# 
set(CPACK_PACKAGE_NAME "RvcTerminalApplication")
set(CPACK_PACKAGE_VENDOR "RVC-CCDG")
# 
set(CPACK_PACKAGE_VERSION              ${RVC_VERSION})
set(CPACK_PACKAGE_VERSION_MAJOR ${RVC_VERSION_MAJOR})
set(CPACK_PACKAGE_VERSION_MINOR ${RVC_VERSION_MINOR})
set(CPACK_PACKAGE_VERSION_PATCH ${RVC_VERSION_REVISION})
# set(CMAKE_PROJECT_HOMEPAGE_URL "TODO")

# 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(PACK_AS_DEB_PKG)
		# This is not the same purpose as CMAKE_INSTALL_PREFIX 
		# which is used when installing from the build tree without building a package
		set(CPACK_PACKAGING_INSTALL_PREFIX "/opt")
		# set(CPACK_PACKAGE_INSTALL_DIRECTORY "/opt")
		include(debian)
		message(STATUS "set deb package file type")
	else()
		if(NOT CPACK_GENERATOR)
			set(CPACK_GENERATOR "ZIP")
			message(STATUS "set zip package file type for matching head bank publish")
		endif()
	endif(PACK_AS_DEB_PKG)
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(MSVC)
	file(GLOB BIN_FILES "${CMAKE_SOURCE_DIR}/addin/din/win/*")
	install(PROGRAMS ${BIN_FILES} DESTINATION "${RVC_RUNTIME_PATH}" COMPONENT libraries)
else()
	file(GLOB BIN_FILES "${CMAKE_SOURCE_DIR}/addin/din/unix/*")
endif(MSVC)

install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/cfg" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" 
	COMPONENT scripts FILES_MATCHING PATTERN "*.ini")
install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/cfg" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" 
	COMPONENT scripts FILES_MATCHING PATTERN "*.xml")
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)
# Install RunInfo Directory
# install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/runinfo" 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}/rvc_test.bat" DESTINATION ${OUTPUT_CUR_DISK_PATH}  COMPONENT scripts)
	install(FILES "${CMAKE_SOURCE_DIR}/addin/hardwarecfg/${ROOT_INI_NAME}" 
	DESTINATION "${PACK_INSTALL_RUN_DIR}/hardwarecfg" 
	RENAME "root.ini"
	COMPONENT scripts)
else(MSVC)
	file(GLOB BAT_SCRIPTS "${CMAKE_SOURCE_DIR}/addin/startup_scripts/*.sh")
	file(GLOB VENDOR_ROOT_CONFIG_FILES "${CMAKE_SOURCE_DIR}/addin/hardwarecfg/uos/root-*.ini")
	install(FILES ${VENDOR_ROOT_CONFIG_FILES} DESTINATION "${PACK_INSTALL_RUN_DIR}/hardwarecfg" COMPONENT scripts)
endif(MSVC)
install(PROGRAMS ${BAT_SCRIPTS} DESTINATION "${PACK_INSTALL_PREFIX_VERSION}" COMPONENT scripts)

# TODO: rewrite install.sh to match update pacakge.
if(NOT MSVC AND NOT PACK_AS_DEB_PKG)
	install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/install.sh" DESTINATION "${PACK_INSTALL_RUN_DIR}/./.." COMPONENT scripts)
endif(NOT MSVC AND NOT PACK_AS_DEB_PKG)

list(REMOVE_DUPLICATES RVC_CONAN_DEP_LIBS)
if(CONAN_LIB_DIRS_QT)
	list(REMOVE_ITEM RVC_CONAN_DEP_LIBS ${CONAN_LIB_DIRS_QT})# 1.0.5-dev5
	list(REMOVE_ITEM RVC_CONAN_DEP_LIBS ${CONAN_BIN_DIRS_QT})# 1.0.5-dev5
endif(CONAN_LIB_DIRS_QT)

if(CONAN_BIN_DIRS_CEFCLIENT_MUTABLE)
	message(STATUS "remove cefclient dirs")
	list(REMOVE_ITEM RVC_CONAN_DEP_LIBS ${CONAN_BIN_DIRS_CEFCLIENT_MUTABLE})# cly
endif(CONAN_BIN_DIRS_CEFCLIENT_MUTABLE)

if(CONAN_BIN_DIRS_CEFCLIENT_CONST)
	message(STATUS "remove cefclient const dirs")
	list(REMOVE_ITEM RVC_CONAN_DEP_LIBS ${CONAN_BIN_DIRS_CEFCLIENT_CONST})
endif(CONAN_BIN_DIRS_CEFCLIENT_CONST)

foreach(bin_dir ${RVC_CONAN_DEP_LIBS})
	message(STATUS "bin dir: ${bin_dir}")
	# file(GLOB RVC_CONAN_BIN_FILES  LIST_DIRECTORIES false "${bin_dir}/*.so" "${bin_dir}/*.dll")
	file(GLOB RVC_CONAN_BIN_FILES LIST_DIRECTORIES false "${bin_dir}/*")
	foreach(filter_elem ${AARCH64_USELESS_LIBRARY_FILE_NAMES})
		set(filter_args ".*\\${filter_elem}$")
		list(FILTER RVC_CONAN_BIN_FILES EXCLUDE REGEX ${filter_args})
	endforeach()
	list(FILTER RVC_CONAN_BIN_FILES EXCLUDE REGEX ".*\\.a$")
	list(FILTER RVC_CONAN_BIN_FILES EXCLUDE REGEX ".*\\.lib$")
	# list(FILTER RVC_CONAN_BIN_FILES EXCLUDE REGEX ".*libQt5Charts.so*")
	install(PROGRAMS ${RVC_CONAN_BIN_FILES} DESTINATION "${RVC_RUNTIME_PATH}" COMPONENT libraries)
endforeach()
install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/res" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" COMPONENT scripts )
file(GLOB RUN_SCRIPTS_FILES LIST_DIRECTORIES true "${CMAKE_SOURCE_DIR}/addin/res/RunScript/*")
foreach(item ${RUN_SCRIPTS_FILES})
		install(FILES ${item} DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}/res/RunScript" 
		PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_READ WORLD_EXECUTE
		COMPONENT libraries)
endforeach()


file(GLOB ENTITY_INTERFACE_XML_FILES "${MODULE_BASE_DIR}/mod_*/*.xml")
install(FILES ${ENTITY_INTERFACE_XML_FILES} DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}/res/StructConfig" COMPONENT resources)

file(GLOB RVC_RESOURCE_FILES LIST_DIRECTORIES FALSE "${CMAKE_SOURCE_DIR}/addin/assets/*")
install(FILES ${RVC_RESOURCE_FILES} DESTINATION ${RVC_RUNTIME_PATH} COMPONENT resources)

install(DIRECTORY "${CONAN_RES_DIRS_AUDIO}" DESTINATION "${PACK_INSTALL_DATA_DIR}" COMPONENT resources)
install(DIRECTORY "${CONAN_RES_DIRS_VIDEO}" DESTINATION "${PACK_INSTALL_DATA_DIR}" COMPONENT resources)



if(CONAN_RES_DIRS_SOGOUIME)
	message(STATUS "include sogou input installation.")
	install(DIRECTORY "${CONAN_RES_DIRS_SOGOUIME}" DESTINATION "${PACK_INSTALL_DATA_DIR}" COMPONENT resources)
endif(CONAN_RES_DIRS_SOGOUIME)

if(CONAN_RES_DIRS_HYQIHEITTF)
	message(STATUS "include font installation.")
	install(DIRECTORY "${CONAN_RES_DIRS_HYQIHEITTF}" DESTINATION "${PACK_INSTALL_DATA_DIR}" COMPONENT resources)
endif(CONAN_RES_DIRS_HYQIHEITTF)

if(CONAN_RES_DIRS_UOSBROWSER)
	message(STATUS "include uosbrowser installation.")
	install(DIRECTORY "${CONAN_RES_DIRS_UOSBROWSER}" DESTINATION "${PACK_INSTALL_DATA_DIR}" COMPONENT resources)
endif(CONAN_RES_DIRS_UOSBROWSER)

if(CONAN_RES_DIRS_VENDORFILE)
	message(STATUS "include vendor file installation.")
	install(DIRECTORY "${CONAN_RES_DIRS_VENDORFILE}" DESTINATION "${PACK_INSTALL_MISCS_DIR}" COMPONENT resources)
endif(CONAN_RES_DIRS_VENDORFILE)

if(CEF_BIN_DIR)
	file(GLOB RVC_CHROMIUM_BIN_FILES LIST_DIRECTORIES true "${CEF_BIN_DIR}/*")
	foreach(item ${RVC_CHROMIUM_BIN_FILES})
		if(IS_DIRECTORY ${item})
			install(DIRECTORY "${item}" DESTINATION "${RVC_CHROMIUM_PATH}" COMPONENT libraries )
		else()
			install(FILES ${item} DESTINATION "${RVC_CHROMIUM_PATH}" 
			PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_READ WORLD_EXECUTE
			COMPONENT libraries)
		endif()
	endforeach()
endif(CEF_BIN_DIR)

if(NOT MSVC)
	if(DEVOPS_ON)
		set(CHANGELOG_HTML_PATH ${CMAKE_CURRENT_BINARY_DIR}/ChangeLog.html)
		execute_process(COMMAND python3 --version
				RESULT_VARIABLE return_code
				OUTPUT_VARIABLE PYTHON_VERSION_OUTPUT
				ERROR_VARIABLE PYTHON_VERSION_OUTPUT)
		if("${return_code}" STREQUAL "0")
			message("python3 version: ${return_code} =~= ${PYTHON_VERSION_OUTPUT}")
			# execute_process(COMMAND "which pip" COMMAND "pip" COMMAND "type pip" COMMAND "hash -r")
			execute_process(COMMAND python3 ${CMAKE_CURRENT_SOURCE_DIR}/md2html.py 
				${CMAKE_BINARY_DIR}/ChangeLog ${CHANGELOG_HTML_PATH}
				RESULT_VARIABLE return_code
				OUTPUT_VARIABLE PYTHON_MARKDOWN_OUTPUT
				ERROR_VARIABLE PYTHON_MARKDOWN_ERROR)
			message(WARN "exec: ${return_code} =$= ${PYTHON_MARKDOWN_OUTPUT} == ${PYTHON_MARKDOWN_ERROR}")
			string(FIND "${PYTHON_MARKDOWN_ERROR}" "No module named 'markdown'" CheckPos)
			if("${return_code}" STREQUAL "1" AND NOT ("${CheckPos}" STREQUAL "-1"))
				message(WARN "install markdown by pip...")
				execute_process(COMMAND "pip3 install markdown"
					RESULT_VARIABLE return_code
					OUTPUT_VARIABLE PYTHON_MARKDOWN_OUTPUT
					ERROR_VARIABLE PYTHON_MARKDOWN_ERROR)
				message(WARN "install markdown: ${return_code} =$= ${PYTHON_MARKDOWN_OUTPUT} == ${PYTHON_MARKDOWN_ERROR}")
				if("${return_code}" STREQUAL "0")
					execute_process(COMMAND python3 ${CMAKE_CURRENT_SOURCE_DIR}/md2html.py 
						${CMAKE_BINARY_DIR}/ChangeLog ${CHANGELOG_HTML_PATH}
						RESULT_VARIABLE return_code
						OUTPUT_VARIABLE PYTHON_MARKDOWN_OUTPUT
						ERROR_VARIABLE PYTHON_MARKDOWN_ERROR)
					message(WARN "exec again: ${return_code} =$= ${PYTHON_MARKDOWN_OUTPUT} == ${PYTHON_MARKDOWN_ERROR}")
				endif()
			endif()
		else()
			message(WARN "py version failed: ${return_code} =~= ${PYTHON_VERSION_OUTPUT} == ${PYTHON_VERSION_OUTPUT}")
		endif()
	elseif(WITH_UPDATE_CHANGELOG)
		set(LOCAL_WWW_PATH "/var/www/html")
		if(EXISTS ${LOCAL_WWW_PATH} AND IS_DIRECTORY ${LOCAL_WWW_PATH})
			set(CHANGELOG_HTML_PATH ${LOCAL_WWW_PATH}/index.html)
			execute_process(COMMAND python --version
				RESULT_VARIABLE return_code
				OUTPUT_VARIABLE PYTHON_VERSION_OUTPUT
				ERROR_VARIABLE PYTHON_VERSION_OUTPUT)
			if("${return_code}" STREQUAL "0")
				message("python version: ${return_code} =~= ${PYTHON_VERSION_OUTPUT}")
				execute_process(COMMAND python ${CMAKE_CURRENT_SOURCE_DIR}/md2html.py 
					${CMAKE_BINARY_DIR}/ChangeLog ${CHANGELOG_HTML_PATH}
					RESULT_VARIABLE return_code
					OUTPUT_VARIABLE PYTHON_MARKDOWN_OUTPUT
					ERROR_VARIABLE PYTHON_MARKDOWN_ERROR)
				message(WARN "exec: ${return_code} =$= ${PYTHON_MARKDOWN_OUTPUT} == ${PYTHON_MARKDOWN_ERROR}")
				string(FIND "${PYTHON_MARKDOWN_ERROR}" "No module named markdown" CheckPos)
				if("${return_code}" STREQUAL "1" AND NOT ("${CheckPos}" STREQUAL "-1"))
					message(WARN "install markdown by pip...")
					execute_process(COMMAND "pip install markdown"
						RESULT_VARIABLE return_code
						OUTPUT_VARIABLE PYTHON_MARKDOWN_OUTPUT
						ERROR_VARIABLE PYTHON_MARKDOWN_ERROR)
					message(WARN "install markdown: ${return_code} =$= ${PYTHON_MARKDOWN_OUTPUT} == ${PYTHON_MARKDOWN_ERROR}")
					if("${return_code}" STREQUAL "0")
						execute_process(COMMAND python ${CMAKE_CURRENT_SOURCE_DIR}/md2html.py 
							${CMAKE_BINARY_DIR}/ChangeLog ${CHANGELOG_HTML_PATH}
							RESULT_VARIABLE return_code
							OUTPUT_VARIABLE PYTHON_MARKDOWN_OUTPUT
							ERROR_VARIABLE PYTHON_MARKDOWN_ERROR)
						message(WARN "exec again: ${return_code} =$= ${PYTHON_MARKDOWN_OUTPUT} == ${PYTHON_MARKDOWN_ERROR}")
					endif()
				endif()
			else()
				message(WARN "py version failed: ${return_code} =~= ${PYTHON_VERSION_OUTPUT} == ${PYTHON_VERSION_OUTPUT}")
			endif()
		else()
		endif(EXISTS ${LOCAL_WWW_PATH} AND IS_DIRECTORY ${LOCAL_WWW_PATH})
	endif(DEVOPS_ON)

endif(NOT MSVC)

if(EXISTS ${CHANGELOG_HTML_PATH})
	install(FILES ${CHANGELOG_HTML_PATH} DESTINATION ${RVC_RESOURCE_PATH} COMPONENT scripts)
else()
	message(WARN "no any changelog file.")
endif()

#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)