libs/CMakeLists.txt

cmake_minimum_required(VERSION 3.0)
cmake_policy(SET CMP0011 NEW) # don`t affect includer policies
cmake_policy(SET CMP0017 NEW) # need include() with .cmake
cmake_policy(SET CMP0020 NEW) # Automatically link Qt executables to qtmain target on Windows
if (POLICY CMP0053)
	cmake_policy(SET CMP0053 NEW) # simpler variable expansion and escape sequence evaluation rules
endif()
project(libs)
set(PIP_CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/pip/cmake")
set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}" "${PIP_CMAKE_MODULE_PATH}" "${CMAKE_CURRENT_SOURCE_DIR}/qad/cmake")
set(LIBPROJECT 1)
set(_qt_libs )
set(_qt_apps )
set(_qt_plugs)
include(GenerateExportHeader)
include(SDKMacros)
include(QADMacros)
include(DeployMacros)

if(NOT DEFINED BUILD_NUMBER)
	set(BUILD_NUMBER 9999)
endif()
if("x${BUILD_NUMBER}" STREQUAL "x")
	set(BUILD_NUMBER 0)
endif()


if(STATIC_LIB)
	set(QAD_LIB_TYPE STATIC)
	add_definitions(-DQAD_STATIC_DEFINE)
	set(QAD_LIB_TYPE_MSG "Static")
else()
	set(QAD_LIB_TYPE SHARED)
	set(QAD_LIB_TYPE_MSG "Shared")
endif()

set(_QAD_MAJOR    1)
set(_QAD_MINOR    7)
set(_QAD_REVISION 0)
set(_QAD_SUFFIX   )
set(_QAD_COMPANY  SHS)
set(_QAD_DOMAIN   org.SHS)
set(QAD_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/qad/qad_version.h")
set_version(QAD
	MAJOR    "${_QAD_MAJOR}"
	MINOR    "${_QAD_MINOR}"
	REVISION "${_QAD_REVISION}"
	BUILD    "${BUILD_NUMBER}"
	SUFFIX   "${_QAD_SUFFIX}"
	OUTPUT   "${QAD_VERSION_FILE}")
set_deploy_property(QAD ${QAD_LIB_TYPE}
	FULLNAME "${_QAD_DOMAIN}.*"
	COMPANY  "${_QAD_COMPANY}")


if(STATIC_LIB)
	set(PIQt_LIB_TYPE STATIC)
	add_definitions(-DPIQt_STATIC_DEFINE)
	set(PIQt_LIB_TYPE_MSG "Static")
else()
	set(PIQt_LIB_TYPE SHARED)
	set(PIQt_LIB_TYPE_MSG "Shared")
endif()

set(_PIQt_MAJOR    1)
set(_PIQt_MINOR    0)
set(_PIQt_REVISION 0)
set(_PIQt_SUFFIX   )
set(_PIQt_COMPANY  SHS)
set(_PIQt_DOMAIN   org.SHS)
if(NOT DEFINED BUILD_NUMBER)
	set(BUILD_NUMBER 9999)
endif()
set(PIQt_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/piqt/piqt_version.h")
set_version(PIQt
	MAJOR    "${_PIQt_MAJOR}"
	MINOR    "${_PIQt_MINOR}"
	REVISION "${_PIQt_REVISION}"
	BUILD    "${BUILD_NUMBER}"
	SUFFIX   "${_PIQt_SUFFIX}"
	OUTPUT   "${PIQt_VERSION_FILE}")
set_deploy_property(PIQt ${_PIQt_LIB_TYPE}
	FULLNAME "${_PIQt_DOMAIN}.*"
	COMPANY  "${_PIQt_COMPANY}")


include_directories(${CMAKE_CURRENT_BINARY_DIR}/pip)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/qad)
include_directories(${CMAKE_CURRENT_BINARY_DIR}/piqt)
if(MINGW)
	find_package(MinGW REQUIRED)
else()
	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()
		set(CMAKE_INSTALL_RPATH "\$ORIGIN;\$ORIGIN/lib")
	endif()
endif()
if (DEFINED ANDROID_PLATFORM)
	include_directories(${ANDROID_SYSTEM_LIBRARY_PATH}/usr/include)
	#set(TARGET_INSTALL_PATH "${ANDROID_SYSTEM_LIBRARY_PATH}/usr/")
	#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I${ANDROID_NDK}/sysroot/usr/include")
	#message("${ANDROID_SYSTEM_LIBRARY_PATH}/usr/include")
	#message("${ANDROID_NDK}/sysroot/usr/include")
endif()
set(INSTALL_PREFIX "")
set(_plugins_default_ ON)
if(CMAKE_CROSSCOMPILING)
	if (DEFINED ANDROID_PLATFORM)
		set(_plugins_default_ OFF)
		set(INSTALL_PREFIX "${CMAKE_FIND_ROOT_PATH}/")
	else()
		set(INSTALL_PREFIX "${CMAKE_STAGING_PREFIX}")
	endif()
endif()
option(CROSSTOOLS "Crosstools minimal build" OFF)
option(LIB "System install" ON)
option(QGLVIEW "Build QGLview library and utils" OFF)
option(QGLENGINE "Build QGLENGINE library and utils" OFF)
option(UTILS "Build various utils" ${_plugins_default_})
option(DESIGNER_PLUGINS "Build qt designer plugins" ${_plugins_default_})
option(STATIC_LIB OFF)
if (CROSSTOOLS)
	set(LIB 1)
	set(QGLVIEW 0)
	set(QGLENGINE 0)
	set(UTILS 0)
	set(DESIGNER_PLUGINS 0)
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()
set(CMAKE_CXX_STANDARD 11)

set(PIP_LIBRARY pip)
set(PIP_INCLUDES)

if(LIB)
	if(WIN32)
		if(MINGW)
			set(CMAKE_INSTALL_PREFIX ${MINGW_DIR})
		endif()
	else()
		if (DEFINED ANDROID_PLATFORM)
			set(CMAKE_INSTALL_PREFIX ${ANDROID_SYSTEM_LIBRARY_PATH}/usr)
		else()
			if(CMAKE_CROSSCOMPILING)
				set(CMAKE_INSTALL_PREFIX ${CMAKE_STAGING_PREFIX})
			else()
				set(CMAKE_INSTALL_PREFIX ${INSTALL_PREFIX}/usr/local)
			endif()
		endif()
	endif()
	message(STATUS "Install ${PROJECT_NAME} to system \"${CMAKE_INSTALL_PREFIX}\"")
else()
	message(STATUS "Install ${PROJECT_NAME} to local \"bin\", \"lib\" and \"include\"")
endif()

#message(${PIP_INCLUDES})
if(CMAKE_CROSSCOMPILING OR (DEFINED ANDROID_PLATFORM))
	set(PIP_CMG "pip_cmg")
	set(PIP_RC "pip_rc")
	set(PIP_DEPLOY_TOOL "deploy_tool")
else()
	set(PIP_CMG "${CMAKE_CURRENT_BINARY_DIR}/pip/utils/code_model_generator/pip_cmg")
	set(PIP_RC "${CMAKE_CURRENT_BINARY_DIR}/pip/utils/resources_compiler/pip_rc")
	set(PIP_DEPLOY_TOOL "${CMAKE_CURRENT_BINARY_DIR}/pip/utils/deploy_tool/deploy_tool")
endif()
if(WIN32)
	set(PIP_DLL_DIR "${CMAKE_CURRENT_BINARY_DIR}/pip")
endif()

set(QAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/qad)
set(ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR})

if (CROSSTOOLS)

	add_subdirectory(pip)
	file(GLOB CMAKES "qad/cmake/*.cmake" "qad/cmake/*.in")
	install(FILES ${CMAKES} DESTINATION ${CMAKE_ROOT}/Modules)

else()

	include(QtWraps)
	find_qt(Core QUIET)
	set(QtVersions)
	set(SomeQtFound 0)
	foreach(_v ${_QT_VERSIONS_})
		option(Qt${_v} "Build for Qt${_v}" 1)
		if (Qt${_v})
			#message("Qt${_v} -> ${LOCAL_FOUND${_v}}")
			if (LOCAL_FOUND${_v})
				list(APPEND QtVersions Qt${_v})
				set(SomeQtFound 1)
			endif()
		endif()
	endforeach()

	#if(UTILS)
	#	message(STATUS "Building with utils")
	#else()
	#	message(STATUS "Building only libraries")
	#endif()

	add_subdirectory(pip)
	foreach(F ${PIP_MAIN_FOLDERS})
		list(APPEND PIP_INCLUDES "${F}")
	endforeach(F)
	add_subdirectory(cd_utils)
	include_directories("${CMAKE_CURRENT_SOURCE_DIR}/cd_utils" "${CMAKE_CURRENT_BINARY_DIR}/cd_utils")
	set(_DIRS)
	if (SomeQtFound)
		#message(STATUS "Building Qt-derived targets for ${QtVersions}")
		add_subdirectory(qad)
		include_directories(${qad_includes})
		add_subdirectory(piqt)
		include_directories(${piqt_includes})
		set(_DIRS)
		if (Qt5)
			if (QGLVIEW)
				list(APPEND _DIRS qglview)
			endif()
			if (QGLENGINE)
				list(APPEND _DIRS qglengine)
			endif()
		endif()
		foreach(_D ${_DIRS})
			list(APPEND QT_MULTILIB_LIST ${_D})
			add_subdirectory(${_D})
		endforeach(_D)

		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 _name)
			message("")
			if (NOT "x${_list}" STREQUAL "x")
				message(" ${_name}:")
				#align_list("${_list}" _alist)
				foreach(_m ${_list})
					message("  * ${_m}")
				endforeach()
			endif()
		endmacro()

		message("----------Qt-----------")
		message(" Build for ${QtVersions}")
		message(" QAD  Version: ${QAD_VERSION}")
		message(" QAD  Linkage: ${QAD_LIB_TYPE_MSG}")
		message(" PIQt Version: ${PIQt_VERSION}")
		message(" PIQt Linkage: ${PIQt_LIB_TYPE_MSG}")
		print_list("${_qt_libs}"  "Libraries")
		print_list("${_qt_apps}"  "Applications")
		print_list("${_qt_plugs}" "Plugins")
		message("-----------------------")
		message("")

	else()
		message(STATUS "None of Qt found, skip Qt-derived targets")
	endif()

endif()

if(WIN32)
	foreach(PIP_LT ${PIP_MODULES})
		if (SomeQtFound)
			qt_install(FILES "${CMAKE_CURRENT_BINARY_DIR}/pip/lib${PIP_LT}.dll" DESTINATION QtBin)
		endif()
	endforeach()
endif()