Merge branch 'master' of https://git.shstk.ru/SHS/cmake

Reviewed-on: https://git.shs.tools/SHS/cmake/pulls/5

.editorconfig

@@ -0,0 +1,6 @@
+root = true
+
+[*.{h,c,cpp}]
+charset = utf-8
+indent_style = tab
+tab_width = 4

CMakeLists.txt

@@ -1,4 +1,11 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.13)
-project(cmake)
+project(cmake LANGUAGES NONE)
 file(GLOB CMAKES "*.cmake" "*.in" "*.keystore")
+if(INSTALL_DIR)
+	set(INSTFILES "CMakeLists.txt" "install.bat")
+	install(FILES ${CMAKES} ${INSTFILES} DESTINATION ${INSTALL_DIR}/cmake)
+	message(STATUS "Install path for cmake files -> \"${INSTALL_DIR}/cmake\"")
+else()
 	install(FILES ${CMAKES} DESTINATION ${CMAKE_ROOT}/Modules)
+	message(STATUS "Install path for cmake files -> \"${CMAKE_ROOT}/Modules\"")
+endif()

DeployMacros.cmake

@@ -6,6 +6,15 @@ in your top-level CMakeLists.txt
 
 
 
+get_system(OS ARCH)
+
+Set current operating system name to OS and
+target architecture to ARCH
+On Linux try to retrieve OS from "os-release" or "lsb-release"
+
+
+
+
 set_version(<target> [MAJOR <value>] [MINOR <value>] [REVISION <value>] [SUFFIX <value>] [BUILD <value>] [OUTPUT <file>])
 
 Set target version, optionally creates file
@@ -77,10 +86,13 @@ deploy_target(<target> [DEPLOY_DIR <dir>]
 						[PLUGINS <dir|file> [<dir|file> ...] ]
 						[FILES <dir|file> [<dir|file> ...] ]
 						[LIBS <dir|file> [<dir|file> ...] ]
+						[PACKAGE_SUFFIX <suffix>]
 						[OPTIONS <flag> ...]
 						[VERBOSE]
 						[DMG_NO_ZIP]
-						[DEB_USR_DIR] [DEB_ADD_SERVICE])
+						[DEB_USR_DIR]
+						[DEB_ADD_SERVICE]
+						[ADD_MANIFEST])
 
 Create make target "deploy_<target>", depends on target "deploy".
 On this target create release package, containing all dependencies:
@@ -107,11 +119,11 @@ DESTINATION - dir where macro place package
 RESOURCES, PLUGINS and FILES - list of directories and files, copied to:
 
 |           | Windows |             Linux           |    Linux  (DEB_USR_DIR)   |            MacOS            |
-|-----------|---------|-------------------------|---------------------------|---------------------|
+|-----------|---------|-----------------------------|---------------------------|-----------------------------|
-| RESOURCES |  root   | /opt/COMPANY/target     | /usr/share/COMPANY/target | Contents/Resources  |
+| RESOURCES |  root   | /opt/FULLNAME               | /usr/share/FULLNAME       | <*.app>/Contents/Resources  |
-| PLUGINS   |  root   | /opt/COMPANY/target     | /usr/lib/COMPANY/target   | Contents/PlugIns    |
+| PLUGINS   |  root   | /opt/FULLNAME/plugins       | /usr/lib/FULLNAME         | <*.app>/Contents/PlugIns    |
-| FILES     |  root   | /opt/COMPANY/target     | /usr/bin                  | Contents/MacOS      |
+| FILES     |  root   | /opt/FULLNAME               | /usr/bin                  | <*.app>/Contents/MacOS      |
-| LIBS      |  root   | /opt/COMPANY/target/lib | /usr/lib                  | Contents/Frameworks |
+| LIBS      |  root   | /opt/FULLNAME/lib           | /usr/lib                  | <*.app>/Contents/Frameworks |
 
 Relative paths are taken from DEPLOY_DIR
 Also check library dependencies from PLUGINS and FILES
@@ -119,6 +131,14 @@ Important! RESOURCES, PLUGINS, FILES and LIBS lists check
 at cmake-time, so if entry ends with "/" it treat
 as directory, else - file
 
+FILES can be presents as cmake-generator-expressions. In this case
+entry treated as absolute path only if it prepened with "/".
+Examples:
+ * "/$<TARGET_FILE:myexe>" - right, TARGET_FILE is absolute path
+ * "$<TARGET_FILE_NAME:myexe>" - right, relative item and TARGET_FILE_NAME is only filename
+ * "/$<TARGET_FILE_NAME:myexe>" - wrong, absolute item with only filename
+
+PACKAGE_SUFFIX is additional text for package, after base name and before version
 
 This macro using "deploy_tool" from PIP,
 so make sure it can be executed from shell
@@ -135,11 +155,13 @@ If DEB_ADD_SERVICE then <T>-service.deb package will be created.
 This package use contents of CMAKE_CURRENT_SOURCE_DIR/debian-service directory:
   * CMAKE_CURRENT_SOURCE_DIR/debian-service/DEBIAN/
   * CMAKE_CURRENT_SOURCE_DIR/debian-service/*.service
-.service file placed in /opt/COMPANY/target, you should copy it to system with script
+.service file placed in /opt/FULLNAME, you should copy it to system with script
 You can use "postinst,postrm,preinst,prerm,config" files to configure service
 
-]]
+If ADD_MANIFEST then *.manifest file near package will be created.
+This file contains all metainformation about package.
 
+]]
 
 cmake_policy(SET CMP0011 NEW) # don`t affect includer policies
 if (POLICY CMP0057)
@@ -148,268 +170,57 @@ endif()
 if (POLICY CMP0053)
 	cmake_policy(SET CMP0053 NEW)
 endif()
-set(__prop_names "LABEL;FULLNAME;COMPANY;ICON;INFO")
+
-list(APPEND __prop_names "ANDROID_TARGET_SDK;ANDROID_STORE_FILE;ANDROID_STORE_PASSWORD;ANDROID_KEY_PASSWORD;ANDROID_KEY_ALIAS;ANDROID_NEW_LOADER")
+if (NOT _dep_exists AND NOT PIP_MICRO)
-set(__version_names "MAJOR;MINOR;REVISION;BUILD;SUFFIX")
-include(TargetArch)
-if (NOT MY_ARCH)
-	target_architecture(MY_ARCH)
-endif()
-if (NOT _dep_exists)
 	set(_dep_exists 1)
 	add_custom_target(deploy COMMENT "Deploy")
 endif()
 set(_modules_dir "${CMAKE_ROOT}/Modules")
-if (LIBPROJECT)
+if (DEFINED SHSTKPROJECT)
-	set(_modules_dir ${PIP_CMAKE_MODULE_PATH})
+	set(_modules_dir "${ROOT_DIR}/cmake")
+endif()
+if (NOT "x${GIT_CMAKE_DIR}" STREQUAL "x")
+	set(_modules_dir "${GIT_CMAKE_DIR}")
 endif()
 set(_dt_delim "::")
 
-
+include(DeployVersionMacros)
-macro(set_version _T)
+if (NOT MY_ARCH)
-	set(_VERSION_ 2) # macro version
+	target_architecture(MY_ARCH)
-	set(_name)
-	set(_is_name 1)
-	set(_is_out 0)
-	set(_out)
-	#message("set_version \"${_T}\"")
-	foreach(_i ${ARGN})
-		if (_is_out)
-			set(_is_out 0)
-			set(_out "${_i}")
-		elseif ("x${_i}" STREQUAL "xOUTPUT")
-			set(_is_out 1)
-		elseif(_is_name)
-			#message("set_version component \"${_i}\"")
-			set(_is_name 0)
-			if (_i IN_LIST __version_names)
-			else()
-				message(FATAL_ERROR "Invalid version component \"${_i}\"!")
 endif()
-			set(_name ${_i})
-			set(${_T}_VERSION_${_name})
-		else()
-			#message("set_version value \"${_name}\" = \"${_i}\"")
-			set(_is_name 1)
-			set(${_T}_VERSION_${_name} ${_i})
-		endif()
-	endforeach()
-	set(${_T}_VERSION_FULLSUFFIX "${${_T}_VERSION_SUFFIX}")
-	if (NOT ("x${${_T}_VERSION_FULLSUFFIX}" STREQUAL "x"))
-		if(NOT ("${${_T}_VERSION_FULLSUFFIX}" MATCHES "_.*"))
-			set(${_T}_VERSION_FULLSUFFIX "_${${_T}_VERSION_FULLSUFFIX}")
-		endif()
-	endif()
-	if ("x${${_T}_VERSION_MAJOR}" STREQUAL "x")
-		set(${_T}_VERSION_MAJOR "0")
-	endif()
-	if ("x${${_T}_VERSION_MINOR}" STREQUAL "x")
-		set(${_T}_VERSION_MINOR "0")
-	endif()
-	if ("x${${_T}_VERSION_REVISION}" STREQUAL "x")
-		set(${_T}_VERSION_REVISION "0")
-	endif()
-	if ("x${${_T}_VERSION_BUILD}" STREQUAL "x")
-		set(${_T}_VERSION_BUILD "0")
-	endif()
-	set(${_T}_VERSION "${${_T}_VERSION_MAJOR}.${${_T}_VERSION_MINOR}.${${_T}_VERSION_REVISION}${${_T}_VERSION_FULLSUFFIX}")
-	set(_${_T}_VERSION_WB "${${_T}_VERSION}-${${_T}_VERSION_BUILD}")
-	if (_out)
-		set(_${_T}_VERSION_CHANGED 0)
-		if ((NOT _${_T}_CACHED_VERSION) OR (NOT ("x${_${_T}_CACHED_VERSION}" STREQUAL "x${_${_T}_VERSION_WB}")))
-			set(_${_T}_CACHED_VERSION "${_${_T}_VERSION_WB}" CACHE STRING "" FORCE)
-			set(_${_T}_VERSION_CHANGED 1)
-		endif()
-		if ((NOT _${_T}_CACHED_VERSION_VER) OR (NOT ("x${_${_T}_CACHED_VERSION_VER}" STREQUAL "x${_VERSION_}")))
-			set(_${_T}_CACHED_VERSION_VER "${_VERSION_}" CACHE STRING "" FORCE)
-			set(_${_T}_VERSION_CHANGED 1)
-		endif()
-		if ((NOT EXISTS "${_out}") OR _${_T}_VERSION_CHANGED)
-			get_filename_component(_def "${_out}" NAME)
-			string(MAKE_C_IDENTIFIER "${_T}_${_def}" _def)
-			string(TOUPPER "${_def}" _def)
-			string(TOUPPER "${_T}" _TN)
-			string(TIMESTAMP _cur_date "%d.%m.%Y %H:%M")
-			file(WRITE "${_out}"
-"// This file generated by CMake set_version() version ${_VERSION_}
-
-#ifndef ${_def}
-#define ${_def}
-
-
-// Project
-
-#define ${_TN}_VERSION_MAJOR    ${${_T}_VERSION_MAJOR}
-#define ${_TN}_VERSION_MINOR    ${${_T}_VERSION_MINOR}
-#define ${_TN}_VERSION_REVISION ${${_T}_VERSION_REVISION}
-#define ${_TN}_VERSION_BUILD    ${${_T}_VERSION_BUILD}
-#define ${_TN}_VERSION_SUFFIX   \"${${_T}_VERSION_SUFFIX}\"
-#define ${_TN}_VERSION_NAME     \"${${_T}_VERSION}\"
-#define ${_TN}_MAKE_VERSION(major, minor, revision)  ((major << 16) | (minor << 8) | revision)
-#define ${_TN}_VERSION  ${_TN}_MAKE_VERSION(${_TN}_VERSION_MAJOR, ${_TN}_VERSION_MINOR, ${_TN}_VERSION_REVISION)
-
-
-// Tools
-
-#define ${_TN}_CMAKE_VERSION    \"${CMAKE_VERSION}\"
-#define ${_TN}_CXX_COMPILER     \"${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}\"
-#define ${_TN}_BUILD_DATE       \"${_cur_date}\"
-#define ${_TN}_ARCH             \"${MY_ARCH}\"
-
-
-#endif // ${_def}
-")
-		endif()
-	endif()
-endmacro()
-
-
-macro(set_lang _T)
-	set(${_T}_LANG)
-	foreach(_i ${ARGN})
-		list(APPEND ${_T}_LANG "${_i}")
-	endforeach()
-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()
-
-
-macro(set_deploy_property _T)
-	set(_name)
-	set(_is_name 1)
-	foreach(_i ${ARGN})
-		if (("x${_i}" STREQUAL "xSHARED") OR ("x${_i}" STREQUAL "xSTATIC"))
-			set(${_T}_TYPE "${_i}")
-		elseif(_is_name)
-			set(_is_name 0)
-			if (_i IN_LIST __prop_names)
-			else()
-				message(FATAL_ERROR "Invalid property name \"${_i}\"!")
-			endif()
-			set(_name ${_i})
-		else()
-			set(_is_name 1)
-			set(${_T}_${_name} ${_i})
-		endif()
-	endforeach()
-endmacro()
-
-
-macro(make_rc _T _out)
-	if (WIN32)
-		if ("x${${_T}_VERSION_MAJOR}" STREQUAL "x")
-			message(FATAL_ERROR "Version for \"${_T}\" not set, use set_version()!")
-		endif()
-		string(REPLACE "\"" "\"\"" WINDOWS_RC_FULLNAME "${${_T}_FULLNAME}")
-		string(REPLACE "\"" "\"\"" WINDOWS_RC_VERSION  "${${_T}_VERSION}" )
-		string(REPLACE "\"" "\"\"" WINDOWS_RC_LABEL    "${${_T}_LABEL}"   )
-		string(REPLACE "\"" "\"\"" WINDOWS_RC_COMPANY  "${${_T}_COMPANY}" )
-		string(REPLACE "\"" "\"\"" WINDOWS_RC_INFO     "${${_T}_INFO}"    )
-		if (("x${${_T}_TYPE}" STREQUAL "x") OR ("x${${_T}_TYPE}" STREQUAL "xEXECUTABLE"))
-			set(WINDOWS_RC_FILETYPE "0x1L")
-			set(_rc_prefix "")
-			set(_rc_ext "exe")
-		elseif ("x${${_T}_TYPE}" STREQUAL "xSHARED")
-			set(WINDOWS_RC_FILETYPE "0x2L")
-			set(_rc_prefix "lib")
-			set(_rc_ext "dll")
-		elseif ("x${${_T}_TYPE}" STREQUAL "xSTATIC")
-			set(WINDOWS_RC_FILETYPE "0x7L")
-			set(_rc_prefix "lib")
-			set(_rc_ext "a")
-		endif()
-		set(_rc_version "${${_T}_VERSION_MAJOR},${${_T}_VERSION_MINOR},${${_T}_VERSION_REVISION},${${_T}_VERSION_BUILD}")
-		set(_icon)
-		if (NOT ("x${${_T}_ICON}" STREQUAL "x"))
-			get_filename_component(WINDOWS_RC_ICON "${${_T}_ICON}" REALPATH BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-			set(_icon "1 ICON \"${WINDOWS_RC_ICON}\"")
-		endif()
-		set(_rc_file "${CMAKE_CURRENT_BINARY_DIR}/${_T}_winres.rc")
-		file(WRITE "${_rc_file}"
-"# if defined(UNDER_CE)
-#  include <winbase.h>
-# else
-#  include <winver.h>
-# endif
-#pragma code_page(65001)
-${_icon}
-VS_VERSION_INFO VERSIONINFO
-FILEVERSION ${_rc_version}
-PRODUCTVERSION ${_rc_version}
-FILEFLAGSMASK 0x3fL
-FILEFLAGS 0x0L
-FILEOS 0x40004L
-FILETYPE ${WINDOWS_RC_FILETYPE}
-FILESUBTYPE 0x0L
-BEGIN
-BLOCK \"StringFileInfo\"
-BEGIN
-BLOCK \"041904B0\"
-BEGIN
-VALUE \"Comments\", \"\\0\"
-VALUE \"CompanyName\", \"${WINDOWS_RC_COMPANY}\\0\"
-VALUE \"FileDescription\", \"${WINDOWS_RC_INFO}\\0\"
-VALUE \"FileVersion\", \"${WINDOWS_RC_VERSION}\\0\"
-VALUE \"InternalName\", \"${WINDOWS_RC_FULLNAME}\\0\"
-VALUE \"LegalTrademarks\", \"\\0\"
-VALUE \"LegalCopyright\", \"${WINDOWS_RC_COMPANY}\\0\"
-VALUE \"OriginalFilename\", \"${_rc_prefix}${_T}.${_rc_ext}\\0\"
-VALUE \"ProductName\", \"${WINDOWS_RC_LABEL}\\0\"
-VALUE \"ProductVersion\", \"${WINDOWS_RC_VERSION}\\0\"
-END
-END
-BLOCK \"VarFileInfo\"
-BEGIN
-VALUE \"Translation\", 0x0419, 0x04B0, 0x0409, 0x04B0
-END
-END
-")
-		set(${_out} ${_rc_file})
-	else()
-		set(${_out})
-	endif()
-endmacro()
 
 
 # Help macros begin
 
 macro(__add_file_or_dir _DIR_VAR _FILE_VAR _PATH _RELPATH)
 	set(_p)
+	set(_remabs 0)
 	set(_abs 0)
 	if (IS_ABSOLUTE "${_PATH}")
 		set(_abs 1)
 	endif()
-	if ("${_PATH}" MATCHES "^\$<")
+	if ("${_PATH}" MATCHES "^\\/\\$")
 		set(_abs 1)
+		set(_remabs 1)
 	endif()
 	if (_abs)
 		set(_p "${_PATH}")
 	else()
 		set(_p "${_RELPATH}/${_PATH}")
 	endif()
-	if ("${_p}" MATCHES ".*/$")
+	if (_remabs)
+		#message("b \"${_p}\"")
+		string(LENGTH "${_p}" __sl)
+		math(EXPR __sl ${__sl}-1)
+		string(SUBSTRING "${_p}" 1 ${__sl} _p)
+		#message("a \"${_p}\"")
+	endif()
+	if ("${_p}" MATCHES ".*\\/\$")
+		#message("b \"${_p}\"")
 		string(LENGTH "${_p}" __sl)
 		math(EXPR __sl ${__sl}-1)
 		string(SUBSTRING "${_p}" 0 ${__sl} _p)
+		#message("a \"${_p}\"")
 		list(APPEND ${_DIR_VAR} "${_p}")
 	else()
 		list(APPEND ${_FILE_VAR} "${_p}")
@@ -425,30 +236,8 @@ if ("x${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "xDarwin")
 	set(__mac_host 1)
 endif()
 
-macro(__make_win_path _in_path _out_var _is_dir _out_dir)
-	set(_add "")
-	if (${_is_dir})
-		set(_add "/")
-	endif()
-	file(TO_NATIVE_PATH "${_in_path}" ${_out_var})
-	string(REPLACE "//" "/" ${_out_var} "${${_out_var}}${_add}")
-	if (NOT "x${_out_dir}" STREQUAL "x")
-		string(LENGTH "${${_out_var}}" __sl)
-		math(EXPR __sl ${__sl}-1)
-		string(SUBSTRING "${${_out_var}}" 0 ${__sl} __substr)
-		get_filename_component(${_out_dir} "${__substr}" NAME)
-		#message("dirname src=\"${${_out_var}}\", len=${__sl} \"${__substr}\" = \"${${_out_dir}}\"")
-	endif()
-	string(REPLACE "/" "\\" ${_out_var} "${${_out_var}}")
-endmacro()
-
 macro(__make_dir _cmd _dest)
-	if (__win_host)
+	set(${_cmd} ${${_cmd}} COMMAND "${CMAKE_COMMAND}" -E make_directory "${_dest}")
-		__make_win_path("${_dest}" __d 1 "")
-		set(${_cmd} ${${_cmd}} COMMAND if not exist "\"${__d}\"" mkdir "\"${__d}\"")
-	else()
-		set(${_cmd} ${${_cmd}} COMMAND mkdir ${_VERB} -p "${_dest}")
-	endif()
 endmacro()
 
 macro(__make_copy _cmd _dirs _files _dest)
@@ -456,15 +245,12 @@ macro(__make_copy _cmd _dirs _files _dest)
 		__make_dir(${_cmd} "${_dest}")
 	endif()
 	if(__win_host)
-		__make_win_path("${_dest}" _wdest 1 "")
 		foreach(_d ${${_dirs}})
-			__make_win_path("${_d}" _wsrc 1 _dirname)
+			get_filename_component(_dname "${_d}" NAME)
-			__make_dir(${_cmd} "${_dest}/${_dirname}")
+			set(${_cmd} ${${_cmd}} COMMAND "${CMAKE_COMMAND}" -E copy_directory "${_d}" "${_dest}/${_dname}/")
-			set(${_cmd} ${${_cmd}} COMMAND xcopy /y /r /e "${_wsrc}*" "\"${_wdest}${_dirname}\\\"" ${_WVERB})
 		endforeach()
 		foreach(_f ${${_files}})
-			__make_win_path("${_f}" _wsrc 0 "")
+			set(${_cmd} ${${_cmd}} COMMAND "${CMAKE_COMMAND}" -E copy "${_f}" "${_dest}/")
-			set(${_cmd} ${${_cmd}} COMMAND xcopy /y /r "\"${_wsrc}\"" "\"${_wdest}\"" ${_WVERB})
 		endforeach()
 	else()
 		foreach(_d ${${_dirs}})
@@ -578,9 +364,64 @@ set(__gradle_sign
 # Help macros end
 
 
+macro(get_system _OS _ARCH)
+	if (NOT MY_ARCH)
+		target_architecture(MY_ARCH)
+	endif()
+	if ("x${CMAKE_SYSTEM_NAME}" STREQUAL "xLinux")
+		set(_os_id "")
+		set(_os_ver "")
+		set(_paths "/usr/lib" "/etc")
+		if (CMAKE_CROSSCOMPILING)
+			set(_paths "")
+			foreach (_c ${CMAKE_PREFIX_PATH})
+				list(APPEND _paths "${_c}/lib" "${_c}/../etc")
+			endforeach()
+		endif()
+		find_file(_release_file NAMES os-release lsb-release PATHS ${_paths} NO_DEFAULT_PATH)
+		if (_release_file)
+			file(STRINGS "${_release_file}" _lines)
+			foreach(_l ${_lines})
+				if ("${_l}" MATCHES "VERSION_ID=.*")
+					string(SUBSTRING "${_l}" 11 -1 _os_ver)
+					string(REPLACE "\"" "" _os_ver "${_os_ver}")
+					#message("VERSION_ID ${_os_ver}")
+				elseif ("${_l}" MATCHES "ID=.*")
+					string(SUBSTRING "${_l}" 3 -1 _os_id)
+					string(REPLACE "\"" "" _os_id "${_os_id}")
+					#message("ID ${_os_id}")
+				endif()
+			endforeach()
+			string(TOLOWER "${_os_id}${_os_ver}" ${_OS})
+			if ("x${${_OS}}" STREQUAL "x")
+				set(${_OS} "linux")
+			endif()
+		else()
+			set(${_OS} "linux")
+		endif()
+		set(${_ARCH} "${MY_ARCH}")
+	elseif(WIN32)
+		set(${_OS} "windows")
+		set(${_ARCH} "${MY_ARCH}")
+	elseif (APPLE)
+		set(${_OS} "macosx")
+		set(${_ARCH} "x64")
+	elseif (DEFINED ANDROID_PLATFORM)
+		set(${_OS} "android")
+		set(${_ARCH} "all")
+	endif()
+endmacro()
+
+
 macro(deploy_target _T)
 	set(_DESTINATION "${CMAKE_INSTALL_PREFIX}")
 	set(_DEPLOY_DIR "${CMAKE_INSTALL_PREFIX}")
+	set(_Qt_)
+	if (${LOCAL_FOUND6})
+		set(_Qt_ 6)
+	elseif (${LOCAL_FOUND5})
+		set(_Qt_ 5)
+	endif()
 	set(_RES_DIRS)
 	set(_RES_FILES)
 	set(_PLUG_DIRS)
@@ -589,49 +430,61 @@ macro(deploy_target _T)
 	set(_FILE_FILES)
 	set(_LIBS_DIRS)
 	set(_LIBS_FILES)
+	set(_SUFFIX)
 	set(_VERB)
 	set(_WVERB 1> NUL)
+	set(_DEBUG_SUFFIX)
 	set(_OPTIONS "--strip;${CMAKE_STRIP}")
+	if (CMAKE_BUILD_TYPE MATCHES Debug)
+		list(APPEND _OPTIONS "--no-strip")
+		set(_DEBUG_SUFFIX "_debug")
+	endif()
 	set(_ZIP_DMG 1)
 	set(_DEB_OPT 1)
 	set(_DEB_SERVICE 0)
+	set(_MANIFEST 0)
 	set(_cur_arg)
-	set(__args "DESTINATION;DEPLOY_DIR;RESOURCES;PLUGINS;FILES;LIBS;OPTIONS;VERBOSE;DMG_NO_ZIP;DEB_USR_DIR;DEB_ADD_SERVICE")
+	set(__args "PACKAGE_SUFFIX;DESTINATION;DEPLOY_DIR;RESOURCES;PLUGINS;FILES;LIBS;OPTIONS;VERBOSE;DMG_NO_ZIP;DEB_USR_DIR;DEB_ADD_SERVICE;ADD_MANIFEST")
 	foreach(_i ${ARGN})
 		if (_i IN_LIST __args)
 			set(_cur_arg "${_i}")
-			if ("${_cur_arg}" STREQUAL "VERBOSE")
+			if ("x${_cur_arg}" STREQUAL "VERBOSE")
 				set(_VERB -v)
 				set(_WVERB)
-			elseif("${_cur_arg}" STREQUAL "DMG_NO_ZIP")
+			elseif("x${_cur_arg}" STREQUAL "xDMG_NO_ZIP")
 				set(_ZIP_DMG 0)
-			elseif("${_cur_arg}" STREQUAL "DEB_USR_DIR")
+			elseif("x${_cur_arg}" STREQUAL "xDEB_USR_DIR")
 				set(_DEB_OPT 0)
-			elseif("${_cur_arg}" STREQUAL "DEB_ADD_SERVICE")
+			elseif("x${_cur_arg}" STREQUAL "xDEB_ADD_SERVICE")
 				set(_DEB_SERVICE 1)
+			elseif("x${_cur_arg}" STREQUAL "xADD_MANIFEST")
+				set(_MANIFEST 1)
 			endif()
-		elseif ("${_cur_arg}" STREQUAL "DESTINATION")
+		elseif ("x${_cur_arg}" STREQUAL "xPACKAGE_SUFFIX")
+			set(_cur_arg)
+			set(_SUFFIX "${_i}")
+		elseif ("x${_cur_arg}" STREQUAL "xDESTINATION")
 			set(_cur_arg)
 			set(_DESTINATION "${_i}/")
-		elseif ("${_cur_arg}" STREQUAL "DEPLOY_DIR")
+		elseif ("x${_cur_arg}" STREQUAL "xDEPLOY_DIR")
 			set(_cur_arg)
 			set(_DEPLOY_DIR "${_i}/")
-		elseif ("${_cur_arg}" STREQUAL "RESOURCES")
+		elseif ("x${_cur_arg}" STREQUAL "xRESOURCES")
 			__add_file_or_dir(_RES_DIRS _RES_FILES "${_i}" "${_DEPLOY_DIR}")
-		elseif ("${_cur_arg}" STREQUAL "PLUGINS")
+		elseif ("x${_cur_arg}" STREQUAL "xPLUGINS")
 			__add_file_or_dir(_PLUG_DIRS _PLUG_FILES "${_i}" "${_DEPLOY_DIR}")
-		elseif ("${_cur_arg}" STREQUAL "FILES")
+		elseif ("x${_cur_arg}" STREQUAL "xFILES")
 			__add_file_or_dir(_FILE_DIRS _FILE_FILES "${_i}" "${_DEPLOY_DIR}")
-		elseif ("${_cur_arg}" STREQUAL "LIBS")
+		elseif ("x${_cur_arg}" STREQUAL "xLIBS")
 			__add_file_or_dir(_LIBS_DIRS _LIBS_FILES "${_i}" "${_DEPLOY_DIR}")
-		elseif ("${_cur_arg}" STREQUAL "OPTIONS")
+		elseif ("x${_cur_arg}" STREQUAL "xOPTIONS")
 			list(APPEND _OPTIONS "${_i}")
 		endif()
 		#message("-i = ${_i}")
 	endforeach()
 	get_filename_component(_ICON_NAME "${${_T}_ICON}" NAME)
 	get_filename_component(_ICON_FN "${${_T}_ICON}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
-	set(_TV "${_T}_${${_T}_VERSION}")
+	set(_TV "${_T}${_SUFFIX}_${${_T}_VERSION}")
 	set(_DEP_LIBPATH)
 	set(_DEP_LIBS_CS)
 	set(_DEP_LIBS)
@@ -645,56 +498,50 @@ macro(deploy_target _T)
 	#message("app depend ${_T} libpath ${_add_search_path}")
 	set(_CMD_)
 	set(_deployed)
+
+	set(_TARGET_LABEL "${${_T}_LABEL}")
+	set(_TARGET_FULLNAME "${${_T}_FULLNAME}")
+	set(_TARGET_VERSION "${${_T}_VERSION}")
+	set(_TARGET_BUILD "${${_T}_VERSION_BUILD}")
+	set(_TARGET_COMPANY "${${_T}_COMPANY}")
+	set(_TARGET_INFO "${${_T}_INFO}")
+	set(_TARGET_BUILDTYPE "${${_T}_BUILDTYPE}")
+	set(_TARGET_OS "???")
+	set(_TARGET_ARCH "???")
+	set(_TARGET_PACKAGE "???")
+	string(TIMESTAMP _TARGET_TIMESTAMP "%Y-%m-%d %H:%M:%S")
+	get_system(_TARGET_OS _TARGET_ARCH)
+
 	if ("x${CMAKE_SYSTEM_NAME}" STREQUAL "xLinux")
-		set(_os_id "")
-		set(_os_ver "")
-		set(_paths "/usr/lib" "/etc")
-		if (CMAKE_CROSSCOMPILING)
-			set(_paths "${CMAKE_PREFIX_PATH}/lib" "${CMAKE_PREFIX_PATH}/../etc")
-		endif()
-		find_file(_release_file NAMES os-release lsb-release PATHS ${_paths} NO_DEFAULT_PATH)
-		if (NOT "x${_release_file}" STREQUAL "x")
-			file(STRINGS "${_release_file}" _lines)
-			foreach(_l ${_lines})
-				if ("${_l}" MATCHES "VERSION_ID=.*")
-					string(SUBSTRING "${_l}" 11 -1 _os_ver)
-					string(REPLACE "\"" "" _os_ver "${_os_ver}")
-					#message("VERSION_ID ${_os_ver}")
-				elseif ("${_l}" MATCHES "ID=.*")
-					string(SUBSTRING "${_l}" 3 -1 _os_id)
-					string(REPLACE "\"" "" _os_id "${_os_id}")
-					#message("ID ${_os_id}")
-				endif()
-			endforeach()
-		endif()
 		set(_build "${${_T}_VERSION_BUILD}")
 		if (NOT "x${_build}" STREQUAL "x")
 			set(_build "-${_build}")
 		endif()
-		string(TOLOWER "${_os_id}${_os_ver}" _TARGET_OS)
-		if ("x${_TARGET_OS}" STREQUAL "x")
-			set(_TARGET_OS "linux")
-		endif()
 		string(REPLACE "_" "-" _DEBNAME "${_T}")
 		set(_DEBVERSION "${${_T}_VERSION_MAJOR}.${${_T}_VERSION_MINOR}.${${_T}_VERSION_REVISION}${_build}${${_T}_VERSION_FULLSUFFIX}+${_TARGET_OS}")
 		string(REPLACE "_" "-" _DEBVERSION "${_DEBVERSION}")
 		string(TOLOWER "${_DEBNAME}" _DEBNAME)
 		set(_DEB_ARCH)
-		if("_${MY_ARCH}" STREQUAL "_arm64")
+		if("_${_TARGET_ARCH}" STREQUAL "_arm64")
 			set(_DEB_ARCH "arm64")
-		elseif("_${MY_ARCH}" STREQUAL "_armv7")
+		elseif("_${_TARGET_ARCH}" STREQUAL "_armv7")
 			set(_DEB_ARCH "armhf")
-		elseif("_${MY_ARCH}" STREQUAL "_i386")
+		elseif("_${_TARGET_ARCH}" STREQUAL "_i386")
 			set(_DEB_ARCH "i386")
-		elseif("_${MY_ARCH}" STREQUAL "_x86_64")
+		elseif("_${_TARGET_ARCH}" STREQUAL "_x86_64")
 			set(_DEB_ARCH "amd64")
-		elseif("_${MY_ARCH}" STREQUAL "_ppc")
+		elseif("_${_TARGET_ARCH}" STREQUAL "_ppc")
 			set(_DEB_ARCH "PowerPC")
-		elseif("_${MY_ARCH}" STREQUAL "_ppc64")
+		elseif("_${_TARGET_ARCH}" STREQUAL "_ppc64")
 			set(_DEB_ARCH "PPC64")
-		elseif("_${MY_ARCH}" STREQUAL "_ia64")
+		elseif("_${_TARGET_ARCH}" STREQUAL "_ia64")
 			set(_DEB_ARCH "ia64")
 		endif()
+		if (NOT "x${${_T}_FULLNAME}" STREQUAL "x")
+			set(_app_dir "${${_T}_FULLNAME}")
+		else()
+			set(_app_dir "${_T}")
+		endif()
 		set(_DEB "${_TV}_deb_${_DEB_ARCH}")
 		set(_AGD "${_DEPLOY_DIR}/${_DEB}")
 		set(_C_echof ">" "${_AGD}/DEBIAN/control")
@@ -703,19 +550,19 @@ macro(deploy_target _T)
 		set(_D_echo ">>" "${_AGD}/usr/share/applications/${_DEBNAME}.desktop")
 		set(_bin_path "${_AGD}/usr/bin")
 		set(_lib_path "${_AGD}/usr/lib")
-		set(_pli_path "${_AGD}/usr/lib/${${_T}_COMPANY}/${_T}")
+		set(_pli_path "${_AGD}/usr/lib/${_app_dir}")
-		set(_res_path "${_AGD}/usr/share/${${_T}_COMPANY}/${_T}")
+		set(_res_path "${_AGD}/usr/share/${_app_dir}")
 		set(_ico_path "${_AGD}/usr/share/pixmaps")
 		set(_app_bin_path "/usr/bin")
 		set(_app_ico_path "/usr/share/pixmaps")
 		if(_DEB_OPT)
-			set(_bin_path "${_AGD}/opt/${${_T}_COMPANY}/${_T}")
+			set(_bin_path "${_AGD}/opt/${_app_dir}")
-			set(_lib_path "${_AGD}/opt/${${_T}_COMPANY}/${_T}/lib")
+			set(_lib_path "${_AGD}/opt/${_app_dir}/lib")
-			set(_pli_path "${_AGD}/opt/${${_T}_COMPANY}/${_T}")
+			set(_pli_path "${_AGD}/opt/${_app_dir}/plugins")
-			set(_res_path "${_AGD}/opt/${${_T}_COMPANY}/${_T}")
+			set(_res_path "${_AGD}/opt/${_app_dir}")
-			set(_ico_path "${_AGD}/opt/${${_T}_COMPANY}/${_T}/pixmaps")
+			set(_ico_path "${_AGD}/opt/${_app_dir}/pixmaps")
-			set(_app_bin_path "/opt/${${_T}_COMPANY}/${_T}")
+			set(_app_bin_path "/opt/${_app_dir}")
-			set(_app_ico_path "/opt/${${_T}_COMPANY}/${_T}/pixmaps")
+			set(_app_ico_path "/opt/${_app_dir}/pixmaps")
 		endif()
 		set(_CMD_ ${_CMD_} COMMAND mkdir ${_VERB} -p "${_bin_path}")
 		set(_CMD_ ${_CMD_} COMMAND mkdir ${_VERB} -p "${_lib_path}")
@@ -727,7 +574,7 @@ macro(deploy_target _T)
 		__make_copy(_CMD_ _PLUG_DIRS _PLUG_FILES ${_pli_path})
 		__make_copy(_CMD_ _RES_DIRS  _RES_FILES  ${_res_path})
 		__make_copy(_CMD_ _LIBS_DIRS _LIBS_FILES ${_lib_path})
-		set(_CMD_ ${_CMD_} COMMAND cp ${_VERB} -f "${_DEPLOY_DIR}/${_T}" "${_bin_path}/")
+		set(_CMD_ ${_CMD_} COMMAND cp ${_VERB} -f "${_DEPLOY_DIR}/$<TARGET_FILE_NAME:${_T}>" "${_bin_path}/")
 		if (_DEP_LIBS)
 			set(_CMD_ ${_CMD_} COMMAND cp ${_VERB} -f "${_DEP_LIBS}" "${_lib_path}/")
 		endif()
@@ -736,7 +583,7 @@ macro(deploy_target _T)
 		endif()
 		if(_DEB_OPT)
 			set(_CMD_ ${_CMD_} COMMAND mkdir ${_VERB} -p "${_AGD}/usr/bin")
-			set(_CMD_ ${_CMD_} COMMAND ln -srf ${_VERB} "${_bin_path}/${_T}" "${_AGD}/usr/bin/${_T}")
+			set(_CMD_ ${_CMD_} COMMAND ln -srf ${_VERB} "${_bin_path}/$<TARGET_FILE_NAME:${_T}>" "${_AGD}/usr/bin/$<TARGET_FILE_NAME:${_T}>")
 		endif()
 
 		file(GLOB _files "${CMAKE_CURRENT_SOURCE_DIR}/debian/DEBIAN/*")
@@ -754,21 +601,31 @@ macro(deploy_target _T)
 		endif()
 		set(_dt_opts -l "${CMAKE_LDD}")
 		if (CMAKE_CROSSCOMPILING)
-			set(_dt_searchdirs "${CMAKE_PREFIX_PATH}/lib")
+			set(_dt_searchdirs "")
+			foreach (_c ${CMAKE_PREFIX_PATH})
+				set(_dt_searchdirs "${_dt_searchdirs}${_dt_delim}${_c}/lib")
+			endforeach()
 			if (NOT "x${CMAKE_LIBRARY_ARCHITECTURE}" STREQUAL "x")
-				set(_dt_searchdirs "${_dt_searchdirs}${_dt_delim}${CMAKE_PREFIX_PATH}/lib/${CMAKE_LIBRARY_ARCHITECTURE}")
+				foreach (_c ${CMAKE_PREFIX_PATH})
-				set(_dt_searchdirs "${_dt_searchdirs}${_dt_delim}${CMAKE_PREFIX_PATH}/../lib/${CMAKE_LIBRARY_ARCHITECTURE}")
+					set(_dt_searchdirs "${_dt_searchdirs}${_dt_delim}${_c}/lib/${CMAKE_LIBRARY_ARCHITECTURE}")
+					set(_dt_searchdirs "${_dt_searchdirs}${_dt_delim}${_c}/../lib/${CMAKE_LIBRARY_ARCHITECTURE}")
+				endforeach()
+			endif()
+			if (NOT "x${PIP_DEPLOY_LIBDIR}" STREQUAL "x")
+				set(_dt_searchdirs "${_dt_searchdirs}${_dt_delim}${PIP_DEPLOY_LIBDIR}")
 			endif()
 			set(_dt_opts -L "${CMAKE_READELF}" --dpkg-workdir "${CMAKE_DPKG_WORKDIR}" -s "${_dt_searchdirs}")
 		endif()
-		set(_deb_name "${_TV}_${_TARGET_OS}_${_DEB_ARCH}.deb")
+		list(APPEND _dt_opts -q "${Qt${_Qt_}_ROOT}" --qt-conf-dir "${_bin_path}" --qt-plugins-dir "${_pli_path}" --rpath)
+		set(_deb_name "${_TV}_${_TARGET_OS}_${_DEB_ARCH}${_DEBUG_SUFFIX}.deb")
+		set(_TARGET_PACKAGE "${_deb_name}")
 		#message("VER = \"${_DEBVERSION}\"")
 		#message("DEB = \"${_deb_name}\"")
 		list(APPEND _CMD_ COMMAND echo "Package: ${_DEBNAME}" ${_C_echof})
 		list(APPEND _CMD_ COMMAND echo "Version: ${_DEBVERSION}" ${_C_echo})
 		list(APPEND _CMD_ COMMAND echo "Architecture: ${_DEB_ARCH}" ${_C_echo})
 		list(APPEND _CMD_ COMMAND echo "Maintainer: ${${_T}_COMPANY} <>" ${_C_echo})
-		list(APPEND _CMD_ COMMAND ${PIP_DEPLOY_TOOL} ${_OPTIONS} --prefix "Depends: " --dependencies ${_dt_opts} -a "${_DEP_LIBS_CS}" -o "${_lib_path}" ${_DEPLOY_DIR}/${_T} ${_ADD_DEPS} ${_C_echo})
+		list(APPEND _CMD_ COMMAND ${PIP_DEPLOY_TOOL} ${_OPTIONS} --prefix "Depends: " --dependencies ${_dt_opts} -a "${_DEP_LIBS_CS}" -o "${_lib_path}" "${_bin_path}/$<TARGET_FILE_NAME:${_T}>" ${_ADD_DEPS} ${_C_echo})
 		list(APPEND _CMD_ COMMAND echo "Conflicts:" ${_C_echo})
 		list(APPEND _CMD_ COMMAND echo "Replaces:" ${_C_echo})
 		list(APPEND _CMD_ COMMAND echo "Section: misc" ${_C_echo})
@@ -794,9 +651,9 @@ macro(deploy_target _T)
 			${_CMD_}
 
 			# generate deb
-			COMMAND cd ${_AGD} "&&" md5deep -rl opt usr ">" DEBIAN/md5sums
+			COMMAND cd "${_AGD}" "&&" md5deep -rl opt usr ">" DEBIAN/md5sums
-			COMMAND mkdir ${_VERB} -p ${_DESTINATION}
+			COMMAND mkdir ${_VERB} -p "${_DESTINATION}"
-			COMMAND dpkg-deb -Z gzip -b ${_AGD} ${_DESTINATION}/${_deb_name}
+			COMMAND dpkg-deb -Z gzip -b "${_AGD}" "${_DESTINATION}/${_deb_name}"
 			VERBATIM
 			COMMENT "Generating ${_deb_name}"
 			)
@@ -808,7 +665,7 @@ macro(deploy_target _T)
 			set(_AGD "${_DEPLOY_DIR}/${_DEB}")
 			set(_C_echof ">" "${_AGD}/DEBIAN/control")
 			set(_C_echo ">>" "${_AGD}/DEBIAN/control")
-			set(_opt_path "${_AGD}/opt/${${_T}_COMPANY}/${_T}")
+			set(_opt_path "${_AGD}/opt/${_app_dir}")
 			set(_CMD_ ${_CMD_} COMMAND mkdir ${_VERB} -p "${_opt_path}")
 
 			file(GLOB _files "${CMAKE_CURRENT_SOURCE_DIR}/debian-service/*.service")
@@ -827,7 +684,7 @@ macro(deploy_target _T)
 				set(_CMD_ ${_CMD_} COMMAND chmod 0755 ${_VERB} "${_AGD}/DEBIAN/${_f}")
 			endforeach()
 
-			set(_deb_name "${_TV}-service_${_TARGET_OS}_${_DEB_ARCH}.deb")
+			set(_deb_name "${_TV}-service_${_TARGET_OS}_${_DEB_ARCH}${_DEBUG_SUFFIX}.deb")
 			#message("VER = \"${_DEBVERSION}\"")
 			#message("DEB = \"${_deb_name}\"")
 			list(APPEND _CMD_ COMMAND echo "Package: ${_DEBNAME}-service" ${_C_echof})
@@ -848,8 +705,8 @@ macro(deploy_target _T)
 				${_CMD_}
 
 				# generate deb
-				COMMAND mkdir ${_VERB} -p ${_DESTINATION}
+				COMMAND mkdir ${_VERB} -p "${_DESTINATION}"
-				COMMAND dpkg-deb -Z gzip -b ${_AGD} ${_DESTINATION}/${_deb_name}
+				COMMAND dpkg-deb -Z gzip -b "${_AGD}" "${_DESTINATION}/${_deb_name}"
 				VERBATIM
 				COMMENT "Generating ${_deb_name}"
 				)
@@ -864,7 +721,7 @@ macro(deploy_target _T)
 		if (__win_host)
 			string(REPLACE "/" "\\" CMAKE_OBJDUMP "${CMAKE_OBJDUMP}")
 		endif()
-		set(_var_exe "${_DEPLOY_DIR}/${_T}.exe")
+		set(_var_exe "${_DEPLOY_DIR}/$<TARGET_FILE_NAME:${_T}>")
 		set(_var_empty)
 		__make_dir(_CMD_ "${_AGD}")
 		__make_dir(_CMD_ "${_DESTINATION}")
@@ -873,12 +730,18 @@ macro(deploy_target _T)
 		__make_copy(_CMD_ _PLUG_DIRS _PLUG_FILES "${_AGD}")
 		__make_copy(_CMD_ _FILE_DIRS _FILE_FILES "${_AGD}")
 		__make_copy(_CMD_ _LIBS_DIRS _LIBS_FILES "${_AGD}")
-		set(_zip_name "${_TV}_windows_${MY_ARCH}.zip")
+		set(_zip_name "${_TV}_${_TARGET_OS}_${_TARGET_ARCH}${_DEBUG_SUFFIX}.zip")
+		set(_TARGET_PACKAGE "${_zip_name}")
+		set(_search_path "")
+		foreach (_c ${CMAKE_PREFIX_PATH})
+			set(_search_path "${_search_path}${_dt_delim}${_c}/bin")
+		endforeach()
+		set(_search_path "${_search_path}${_dt_delim}${MINGW_BIN}${_add_search_path}${_dt_delim}${MINGW_LIB}")
 		add_custom_target(deploy_${_T}
 			# gather dir
 			${_CMD_}
 
-			COMMAND ${PIP_DEPLOY_TOOL} ${_VERB} ${_OPTIONS} -W "\"${CMAKE_OBJDUMP}\"" -P windows,minimal -S windows -q "\"${Qt5_ROOT}\"" -s "\"${CMAKE_PREFIX_PATH}/bin${_dt_delim}${MINGW_BIN}${_add_search_path}${_dt_delim}${MINGW_LIB}\"" -o ${_AGD} -p ${_AGD} "\"${_AGD}${_T}.exe\"" ${_ADD_DEPS}
+			COMMAND ${PIP_DEPLOY_TOOL} ${_VERB} ${_OPTIONS} -W "\"${CMAKE_OBJDUMP}\"" -P windows,minimal -S windows -q "\"${Qt${_Qt_}_ROOT}\"" -s "\"${_search_path}\"" -o "${_AGD}" -p "${_AGD}" "\"${_AGD}$<TARGET_FILE_NAME:${_T}>\"" ${_ADD_DEPS}
 			# zip
 			COMMAND cd "\"${_DEPLOY_DIR}\"" "&&" zip -q -r "\"${_DESTINATION}/${_zip_name}\"" "\"${_TV}_win_${MY_ARCH}\""
 			COMMENT "Generating ${_zip_name}"
@@ -899,12 +762,16 @@ macro(deploy_target _T)
 		set_target_properties(${_T} PROPERTIES MACOSX_BUNDLE_INFO_PLIST "${_modules_dir}/SHSMacOSBundle.plist.in")
 		set(_AGD "${_DEPLOY_DIR}/${_T}.app")
 		set(_DMG "${CMAKE_CURRENT_BINARY_DIR}/dmg")
-		__make_copy(_CMD_ _RES_DIRS  _RES_FILES  "${_AGD}/Contents/Resources")
+		set(_bin_path "${_AGD}/Contents/MacOS")
-		__make_copy(_CMD_ _PLUG_DIRS _PLUG_FILES "${_AGD}/Contents/PlugIns")
+		set(_lib_path "${_AGD}/Contents/Frameworks")
-		__make_copy(_CMD_ _FILE_DIRS _FILE_FILES "${_AGD}/Contents/MacOS")
+		set(_pli_path "${_AGD}/Contents/PlugIns")
-		__make_copy(_CMD_ _LIBS_DIRS _LIBS_FILES "${_AGD}/Contents/Frameworks")
+		set(_res_path "${_AGD}/Contents/Resources")
+		__make_copy(_CMD_ _RES_DIRS  _RES_FILES  "${_res_path}")
+		__make_copy(_CMD_ _PLUG_DIRS _PLUG_FILES "${_pli_path}")
+		__make_copy(_CMD_ _FILE_DIRS _FILE_FILES "${_bin_path}")
+		__make_copy(_CMD_ _LIBS_DIRS _LIBS_FILES "${_lib_path}")
 		if (_ICON_NAME)
-			set(_CMD_ ${_CMD_} COMMAND cp ${_VERB} -f ${_ICON_FN} ${_AGD}/Contents/Resources)
+			set(_CMD_ ${_CMD_} COMMAND cp ${_VERB} -f "${_ICON_FN}" "${_res_path}")
 		endif()
 		if (NOT CMAKE_OTOOL)
 			set(CMAKE_OTOOL "otool")
@@ -912,31 +779,36 @@ macro(deploy_target _T)
 		if (NOT CMAKE_PREFIX_PATH)
 			set(CMAKE_PREFIX_PATH "/usr/local")
 		endif()
-		set(_dmg_name "${_TV}_macosx_x64.dmg")
+		set(_dmg_name "${_TV}_${_TARGET_OS}_${_TARGET_ARCH}${_DEBUG_SUFFIX}.dmg")
-		set(_cmd_gen_dmg COMMAND genisoimage -quiet -V "${MACOSX_BUNDLE_BUNDLE_NAME}" -D -R -apple -no-pad -o ${_DESTINATION}/${_dmg_name} ${_DMG})
+		set(_TARGET_PACKAGE "${_dmg_name}")
+		set(_cmd_gen_dmg COMMAND genisoimage -quiet -V "${MACOSX_BUNDLE_BUNDLE_NAME}" -D -R -apple -no-pad -o "${_DESTINATION}/${_dmg_name}" "${_DMG}")
 		if (__mac_host)
-			set(_cmd_gen_dmg COMMAND hdiutil create ${_DESTINATION}/${_dmg_name} -ov -volname "${MACOSX_BUNDLE_BUNDLE_NAME}" -fs HFS+ -srcfolder ${_DMG})
+			set(_cmd_gen_dmg COMMAND hdiutil create "${_DESTINATION}/${_dmg_name}" -ov -volname "${MACOSX_BUNDLE_BUNDLE_NAME}" -fs HFS+ -srcfolder "${_DMG}")
 		endif()
 		if (_ZIP_DMG)
-			set(_cmd_gen_dmg ${_cmd_gen_dmg} COMMAND zip -q -r "\"${_DESTINATION}/${_dmg_name}.zip\"" "\"${_DESTINATION}/${_dmg_name}\"")
+			set(_cmd_gen_dmg ${_cmd_gen_dmg} COMMAND cd "${_DESTINATION}" "&&" zip -q -r "${_dmg_name}.zip" "${_dmg_name}")
 			set(_cmd_gen_dmg ${_cmd_gen_dmg} COMMAND rm "\"${_DESTINATION}/${_dmg_name}\"")
+			set(_TARGET_PACKAGE "${_dmg_name}.zip")
 		endif()
-		set(_comment "Generating ${_dmg_name}")
+		set(_comment "Generating ${_TARGET_PACKAGE}")
-		if (_ZIP_DMG)
+		set(_search_path "")
-			set(_comment "${_comment}.zip")
+		foreach (_c ${CMAKE_PREFIX_PATH})
-		endif()
+			set(_search_path "${_search_path}${_dt_delim}${_c}/lib")
+		endforeach()
+		set(_search_path "${_search_path}${_add_search_path}")
 		add_custom_target(deploy_${_T}
 			# gather .app dir
-			COMMAND mkdir ${_VERB} -p ${_AGD}/Contents/Resources
+			COMMAND mkdir ${_VERB} -p "${_res_path}"
-			COMMAND mkdir ${_VERB} -p ${_AGD}/Contents/Frameworks
+			COMMAND mkdir ${_VERB} -p "${_lib_path}"
-			COMMAND mkdir ${_VERB} -p ${_DESTINATION}
+			COMMAND mkdir ${_VERB} -p "${_pli_path}"
+			COMMAND mkdir ${_VERB} -p "${_DESTINATION}"
 			${_CMD_}
-			COMMAND ${PIP_DEPLOY_TOOL} ${_VERB} ${_OPTIONS} -M "${CMAKE_OTOOL}" -P cocoa,minimal -S mac -q ${Qt5_ROOT} -s "\"${CMAKE_PREFIX_PATH}/lib${_add_search_path}\"" -o ${_AGD}/Contents/Frameworks -p ${_AGD}/Contents/PlugIns ${_AGD}/Contents/MacOS/${_T} ${_ADD_DEPS}
+			COMMAND ${PIP_DEPLOY_TOOL} ${_VERB} ${_OPTIONS} -M "${CMAKE_OTOOL}" -P cocoa,minimal -S mac -q "${Qt5_ROOT}" --qt-conf-dir "${_res_path}" --qt-plugins-dir "${_pli_path}" -s "${_search_path}" -o "${_lib_path}" "${_bin_path}/${_T}" ${_ADD_DEPS}
 			# prepare dmg dir
-			COMMAND rm -rf ${_DMG}
+			COMMAND rm -rf "${_DMG}"
-			COMMAND mkdir ${_VERB} -p ${_DMG}
+			COMMAND mkdir ${_VERB} -p "${_DMG}"
-			COMMAND cp -r ${_AGD} ${_DMG}
+			COMMAND cp -r "${_AGD}" "${_DMG}"
-			COMMAND ln ${_VERB} -s /Applications ${_DMG}
+			COMMAND ln ${_VERB} -s /Applications "${_DMG}"
 			# generate dmg
 			${_cmd_gen_dmg}
 			COMMENT "${_comment}"
@@ -981,11 +853,11 @@ macro(deploy_target _T)
 		set(_dir "${CMAKE_BINARY_DIR}/android-build/libs" "${CMAKE_CURRENT_SOURCE_DIR}/android/res" "${CMAKE_CURRENT_SOURCE_DIR}/android/src")
 		__make_copy(_CMD_ _dir _file "${_AGD}")
 		set(_dir)
-		set(_file "${Qt5_ROOT}/src/android/templates/res/values/libs.xml")
+		set(_file "${Qt${_Qt_}_ROOT}/src/android/templates/res/values/libs.xml")
 		__make_copy(_CMD_ _dir _file "${_AGD}/res/values")
-		set(_dir  "${Qt5_ROOT}/src/3rdparty/gradle/gradle")
+		set(_dir  "${Qt${_Qt_}_ROOT}/src/3rdparty/gradle/gradle")
-		set(_file "${Qt5_ROOT}/src/3rdparty/gradle/gradlew"
+		set(_file "${Qt${_Qt_}_ROOT}/src/3rdparty/gradle/gradlew"
-				  "${Qt5_ROOT}/src/3rdparty/gradle/gradlew.bat")
+				  "${Qt${_Qt_}_ROOT}/src/3rdparty/gradle/gradlew.bat")
 		__make_copy(_CMD_ _dir _file "${_AGD}")
 		#message("bindir = ${CMAKE_CURRENT_SOURCE_DIR}")
 		set(SDK_ROOT "$ENV{ANDROID_SDK_ROOT}")
@@ -1015,7 +887,7 @@ macro(deploy_target _T)
 				string(REPLACE "${ANDROID_SYSROOT_${ANDROID_ABI}}" "${ANDROID_SYSROOT_${_a}}" _lib_${_a} "${_lib_}")
 				#message("search  = ${_a_prefix}/lib")
 				__make_copy(_CMD_ _empty _lib_${_a} "${_AGD}/libs/${_a}")
-				set(_CMD_ ${_CMD_} COMMAND ${PIP_DEPLOY_TOOL} ${_VERB} ${_OPTIONS} -W "\"${CMAKE_OBJDUMP}\"" -s "${_a_prefix}/lib${_dt_delim}${Qt5_ROOT}/lib${_add_search_path}" -o "\"${_AGD}/libs/${_a}\"" --ignore "\"c${_dt_delim}m${_dt_delim}z${_dt_delim}dl${_dt_delim}log\"" "\"${_AGD}/libs/${_a}/lib${_AT}_${_a}.so\"" ${_ADD_DEPS})
+				set(_CMD_ ${_CMD_} COMMAND ${PIP_DEPLOY_TOOL} ${_VERB} ${_OPTIONS} -W "\"${CMAKE_OBJDUMP}\"" -s "${_a_prefix}/lib${_dt_delim}${Qt${_Qt_}_ROOT}/lib${_add_search_path}" -o "\"${_AGD}/libs/${_a}\"" --ignore "\"c${_dt_delim}m${_dt_delim}z${_dt_delim}dl${_dt_delim}log\"" "\"${_AGD}/libs/${_a}/lib${_AT}_${_a}.so\"" ${_ADD_DEPS})
 				#message("c++_${_a} -> ${_lib_${_a}}")
 			endif()
 		endforeach()
@@ -1040,7 +912,7 @@ macro(deploy_target _T)
 			set(ANDROID_NEW_LOADER "false")
 		endif()
 		set(__ANDROID_DEBUG_KEYSTORE__ "${_modules_dir}/android_debug.keystore")
-		set(QT_DIR ${Qt5_ROOT})
+		set(QT_DIR ${Qt${_Qt_}_ROOT})
 		set(_out_json "${CMAKE_CURRENT_BINARY_DIR}/${_T}_android_deployment_settings.json")
 		configure_file("${CMAKE_BINARY_DIR}/android_deployment_settings.json.in" "${_out_json}")
 		configure_file("${CMAKE_CURRENT_SOURCE_DIR}/android/AndroidManifest.xml.in" "${_AGD}/AndroidManifest.xml")
@@ -1059,7 +931,7 @@ macro(deploy_target _T)
 		if ("x${__gradle_lang}" STREQUAL "x")
 			set(__gradle_lang "\"en\"")
 		endif()
-		file(READ "${Qt5_ROOT}/src/android/templates/build.gradle" _file)
+		file(READ "${Qt${_Qt_}_ROOT}/src/android/templates/build.gradle" _file)
 		string(REPLACE "\ndependencies {" "\ndependencies {${_depstr}" _file "${_file}")
 		string(REPLACE "\nandroid {" "\nandroid {\n${__gradle_sign}\n${__gradle_lang_start}${__gradle_lang}\n\t}\n" _file "${_file}")
 		string(REPLACE "['resources']" "['res']" _file "${_file}")
@@ -1068,10 +940,11 @@ macro(deploy_target _T)
 		if (NOT __win_host)
 			set(_gradle_home "-g" "${CMAKE_BINARY_DIR}")
 		endif()
-		set(_CMD_ ${_CMD_} COMMAND "${Qt5_BIN}/androiddeployqt" --aux-mode --android-platform ${ANDROID_PLATFORM} --output "\"${_AGD}\"" --input "\"${_out_json}\"")
+		set(_CMD_ ${_CMD_} COMMAND "${Qt${_Qt_}_BIN}/androiddeployqt" --aux-mode --android-platform ${ANDROID_PLATFORM} --output "\"${_AGD}\"" --input "\"${_out_json}\"")
 		set(_CMD_ ${_CMD_} COMMAND "${_AGD}/gradlew" ${_gradle_home} --no-daemon -p "\"${_AGD}\"" assembleDebug)
 		set(_CMD_ ${_CMD_} COMMAND "${_AGD}/gradlew" ${_gradle_home} --no-daemon -p "\"${_AGD}\"" bundleRelease)
-		set(_base_name "${_TV}_android_all")
+		set(_base_name "${_TV}_${_TARGET_OS}_${_TARGET_ARCH}${_DEBUG_SUFFIX}")
+		set(_TARGET_PACKAGE "${_base_name}.apk")
 		set(_CMD_ ${_CMD_} COMMAND "${CMAKE_COMMAND}" -E copy "${_AGD}/build/outputs/apk/debug/${_T}.android-debug.apk" "${_DESTINATION}/${_base_name}.apk")
 		if (ANDROID_STORE_FILE)
 			set(_CMD_ ${_CMD_} COMMAND "${CMAKE_COMMAND}" -E copy "${_AGD}/build/outputs/bundle/release/${_T}.android-release.aab" "${_DESTINATION}/${_base_name}.aab")
@@ -1083,6 +956,11 @@ macro(deploy_target _T)
 			)
 		set(_deployed "deploy_${_T}")
 	endif()
+
+	if (_MANIFEST)
+		configure_file("${_modules_dir}/DeployTarget.manifest.in" "${_DESTINATION}/${_TARGET_PACKAGE}.manifest")
+	endif()
+
 	foreach (_d ${_deployed})
 		add_dependencies(deploy ${_d})
 	endforeach()

DeployTarget.manifest.in

@@ -0,0 +1,12 @@
+{
+	"label": "${_TARGET_LABEL}",
+	"company": "${_TARGET_COMPANY}",
+	"fullname": "${_TARGET_FULLNAME}",
+	"version": "${_TARGET_VERSION}",
+	"build": "${_TARGET_BUILD}",
+	"info": "${_TARGET_INFO}",
+	"system": "${_TARGET_OS}",
+	"arch": "${_TARGET_ARCH}",
+	"buildtype": "${_TARGET_BUILDTYPE}",
+	"timestamp": "${_TARGET_TIMESTAMP}"
+}

DeployVersionMacros.cmake

@@ -0,0 +1,245 @@
+cmake_policy(SET CMP0011 NEW) # don`t affect includer policies
+if (POLICY CMP0057)
+	cmake_policy(SET CMP0057 NEW) # Support if() IN_LIST
+endif()
+if (POLICY CMP0053)
+	cmake_policy(SET CMP0053 NEW)
+endif()
+set(__prop_names "LABEL;FULLNAME;COMPANY;ICON;INFO;BUILDTYPE")
+list(APPEND __prop_names "ANDROID_TARGET_SDK;ANDROID_STORE_FILE;ANDROID_STORE_PASSWORD;ANDROID_KEY_PASSWORD;ANDROID_KEY_ALIAS;ANDROID_NEW_LOADER")
+set(__version_names "MAJOR;MINOR;REVISION;BUILD;SUFFIX")
+
+include(TargetArch)
+if (NOT MY_ARCH)
+	target_architecture(MY_ARCH)
+endif()
+
+
+macro(set_version _T)
+	set(_VERSION_ 3) # macro version
+	set(_name)
+	set(_is_name 1)
+	set(_is_out 0)
+	set(_out)
+	#message("set_version \"${_T}\"")
+	foreach(_i ${ARGN})
+		if (_is_out)
+			set(_is_out 0)
+			set(_out "${_i}")
+		elseif ("x${_i}" STREQUAL "xOUTPUT")
+			set(_is_out 1)
+		elseif(_is_name)
+			#message("set_version component \"${_i}\"")
+			set(_is_name 0)
+			if (_i IN_LIST __version_names)
+			else()
+				message(FATAL_ERROR "Invalid version component \"${_i}\"!")
+			endif()
+			set(_name ${_i})
+			set(${_T}_VERSION_${_name})
+		else()
+			#message("set_version value \"${_name}\" = \"${_i}\"")
+			set(_is_name 1)
+			set(${_T}_VERSION_${_name} ${_i})
+		endif()
+	endforeach()
+	set(${_T}_VERSION_FULLSUFFIX "${${_T}_VERSION_SUFFIX}")
+	if (NOT ("x${${_T}_VERSION_FULLSUFFIX}" STREQUAL "x"))
+		if(NOT ("${${_T}_VERSION_FULLSUFFIX}" MATCHES "_.*"))
+			set(${_T}_VERSION_FULLSUFFIX "_${${_T}_VERSION_FULLSUFFIX}")
+		endif()
+	endif()
+	if ("x${${_T}_VERSION_MAJOR}" STREQUAL "x")
+		set(${_T}_VERSION_MAJOR "0")
+	endif()
+	if ("x${${_T}_VERSION_MINOR}" STREQUAL "x")
+		set(${_T}_VERSION_MINOR "0")
+	endif()
+	if ("x${${_T}_VERSION_REVISION}" STREQUAL "x")
+		set(${_T}_VERSION_REVISION "0")
+	endif()
+	if ("x${${_T}_VERSION_BUILD}" STREQUAL "x")
+		set(${_T}_VERSION_BUILD "0")
+	endif()
+	set(${_T}_BUILDTYPE "${CMAKE_BUILD_TYPE}")
+	set(${_T}_VERSION "${${_T}_VERSION_MAJOR}.${${_T}_VERSION_MINOR}.${${_T}_VERSION_REVISION}${${_T}_VERSION_FULLSUFFIX}")
+	set(_${_T}_VERSION_WB "${${_T}_VERSION}-${${_T}_VERSION_BUILD}")
+	if (_out)
+		set(_${_T}_VERSION_CHANGED 0)
+		if ((NOT _${_T}_CACHED_VERSION) OR (NOT ("x${_${_T}_CACHED_VERSION}" STREQUAL "x${_${_T}_VERSION_WB}")))
+			set(_${_T}_CACHED_VERSION "${_${_T}_VERSION_WB}" CACHE STRING "" FORCE)
+			set(_${_T}_VERSION_CHANGED 1)
+		endif()
+		if ((NOT _${_T}_CACHED_VERSION_VER) OR (NOT ("x${_${_T}_CACHED_VERSION_VER}" STREQUAL "x${_VERSION_}")))
+			set(_${_T}_CACHED_VERSION_VER "${_VERSION_}" CACHE STRING "" FORCE)
+			set(_${_T}_VERSION_CHANGED 1)
+		endif()
+		if ((NOT EXISTS "${_out}") OR _${_T}_VERSION_CHANGED)
+			get_filename_component(_def "${_out}" NAME)
+			string(MAKE_C_IDENTIFIER "${_T}_${_def}" _def)
+			string(TOUPPER "${_def}" _def)
+			string(TOUPPER "${_T}" _TN)
+			string(TIMESTAMP _cur_date "%d.%m.%Y %H:%M")
+			file(WRITE "${_out}"
+"// This file generated by CMake set_version() version ${_VERSION_}
+
+#ifndef ${_def}
+#define ${_def}
+
+
+// Project
+
+#define ${_TN}_VERSION_MAJOR     ${${_T}_VERSION_MAJOR}
+#define ${_TN}_VERSION_MINOR     ${${_T}_VERSION_MINOR}
+#define ${_TN}_VERSION_REVISION  ${${_T}_VERSION_REVISION}
+#define ${_TN}_VERSION_BUILD     ${${_T}_VERSION_BUILD}
+#define ${_TN}_VERSION_SUFFIX    \"${${_T}_VERSION_SUFFIX}\"
+#define ${_TN}_VERSION_NAME      \"${${_T}_VERSION}\"
+#define ${_TN}_MAKE_VERSION(major, minor, revision)  ((major << 16) | (minor << 8) | revision)
+#define ${_TN}_VERSION  ${_TN}_MAKE_VERSION(${_TN}_VERSION_MAJOR, ${_TN}_VERSION_MINOR, ${_TN}_VERSION_REVISION)
+
+
+// Tools
+
+#define ${_TN}_CMAKE_VERSION    \"${CMAKE_VERSION}\"
+#define ${_TN}_CXX_COMPILER     \"${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}\"
+#define ${_TN}_BUILD_DATE       \"${_cur_date}\"
+#define ${_TN}_BUILD_TYPE       \"${${_T}_BUILDTYPE}\"
+#define ${_TN}_ARCH             \"${MY_ARCH}\"
+
+
+#endif // ${_def}
+")
+		endif()
+	endif()
+endmacro()
+
+
+macro(set_lang _T)
+	set(${_T}_LANG)
+	foreach(_i ${ARGN})
+		list(APPEND ${_T}_LANG "${_i}")
+	endforeach()
+endmacro()
+
+
+macro(import_version _T _F)
+	if (NOT "x${_T}" STREQUAL "x${_F}")
+		set(_names "${__version_names};FULLSUFFIX;BUILDTYPE")
+		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()
+
+
+macro(set_deploy_property _T)
+	set(_name)
+	set(_is_name 1)
+	foreach(_i ${ARGN})
+		if (("x${_i}" STREQUAL "xSHARED") OR ("x${_i}" STREQUAL "xSTATIC"))
+			set(${_T}_TYPE "${_i}")
+		elseif(_is_name)
+			set(_is_name 0)
+			if (_i IN_LIST __prop_names)
+			else()
+				message(FATAL_ERROR "Invalid property name \"${_i}\"!")
+			endif()
+			set(_name ${_i})
+		else()
+			set(_is_name 1)
+			set(${_T}_${_name} ${_i})
+		endif()
+	endforeach()
+	set(${_T}_BUILDTYPE "${CMAKE_BUILD_TYPE}")
+endmacro()
+
+
+macro(make_rc _T _out)
+	if (WIN32)
+		if ("x${${_T}_VERSION_MAJOR}" STREQUAL "x")
+			message(FATAL_ERROR "Version for \"${_T}\" not set, use set_version()!")
+		endif()
+		if ("x${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "xWindows")
+			set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> -O coff <SOURCE> <OBJECT>")
+		endif()
+		string(REPLACE "\"" "\"\"" WINDOWS_RC_FULLNAME "${${_T}_FULLNAME}")
+		string(REPLACE "\"" "\"\"" WINDOWS_RC_VERSION  "${${_T}_VERSION}" )
+		string(REPLACE "\"" "\"\"" WINDOWS_RC_LABEL    "${${_T}_LABEL}"   )
+		string(REPLACE "\"" "\"\"" WINDOWS_RC_COMPANY  "${${_T}_COMPANY}" )
+		string(REPLACE "\"" "\"\"" WINDOWS_RC_INFO     "${${_T}_INFO}"    )
+		if (("x${${_T}_TYPE}" STREQUAL "x") OR ("x${${_T}_TYPE}" STREQUAL "xEXECUTABLE"))
+			set(WINDOWS_RC_FILETYPE "0x1L")
+			set(_rc_prefix "")
+			set(_rc_ext "exe")
+		elseif ("x${${_T}_TYPE}" STREQUAL "xSHARED")
+			set(WINDOWS_RC_FILETYPE "0x2L")
+			set(_rc_prefix "lib")
+			set(_rc_ext "dll")
+		elseif ("x${${_T}_TYPE}" STREQUAL "xSTATIC")
+			set(WINDOWS_RC_FILETYPE "0x7L")
+			set(_rc_prefix "lib")
+			set(_rc_ext "a")
+		endif()
+		set(_rc_version "${${_T}_VERSION_MAJOR},${${_T}_VERSION_MINOR},${${_T}_VERSION_REVISION},${${_T}_VERSION_BUILD}")
+		set(_icon)
+		if (NOT ("x${${_T}_ICON}" STREQUAL "x"))
+			get_filename_component(WINDOWS_RC_ICON "${${_T}_ICON}" REALPATH BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+			set(_icon "1 ICON \"${WINDOWS_RC_ICON}\"")
+		endif()
+		set(_rc_file "${CMAKE_CURRENT_BINARY_DIR}/${_T}_winres.rc")
+		file(WRITE "${_rc_file}"
+"# if defined(UNDER_CE)
+#  include <winbase.h>
+# else
+#  include <winver.h>
+# endif
+#pragma code_page(65001)
+${_icon}
+VS_VERSION_INFO VERSIONINFO
+FILEVERSION ${_rc_version}
+PRODUCTVERSION ${_rc_version}
+FILEFLAGSMASK 0x3fL
+FILEFLAGS 0x0L
+FILEOS 0x40004L
+FILETYPE ${WINDOWS_RC_FILETYPE}
+FILESUBTYPE 0x0L
+BEGIN
+BLOCK \"StringFileInfo\"
+BEGIN
+BLOCK \"041904B0\"
+BEGIN
+VALUE \"Comments\", \"\\0\"
+VALUE \"CompanyName\", \"${WINDOWS_RC_COMPANY}\\0\"
+VALUE \"FileDescription\", \"${WINDOWS_RC_INFO}\\0\"
+VALUE \"FileVersion\", \"${WINDOWS_RC_VERSION}\\0\"
+VALUE \"InternalName\", \"${WINDOWS_RC_FULLNAME}\\0\"
+VALUE \"LegalTrademarks\", \"\\0\"
+VALUE \"LegalCopyright\", \"${WINDOWS_RC_COMPANY}\\0\"
+VALUE \"OriginalFilename\", \"${_rc_prefix}${_T}.${_rc_ext}\\0\"
+VALUE \"ProductName\", \"${WINDOWS_RC_LABEL}\\0\"
+VALUE \"ProductVersion\", \"${WINDOWS_RC_VERSION}\\0\"
+END
+END
+BLOCK \"VarFileInfo\"
+BEGIN
+VALUE \"Translation\", 0x0419, 0x04B0, 0x0409, 0x04B0
+END
+END
+")
+		set(${_out} ${_rc_file})
+	else()
+		set(${_out})
+	endif()
+endmacro()

DownloadGTest.cmake

@@ -1,31 +0,0 @@
-# Download and unpack googletest at configure time
-configure_file(GTestCMakeLists.txt.in googletest-download/CMakeLists.txt)
-execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
-	RESULT_VARIABLE result
-	WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download )
-if(result)
-	message(FATAL_ERROR "CMake step for googletest failed: ${result}")
-endif()
-execute_process(COMMAND ${CMAKE_COMMAND} --build .
-	RESULT_VARIABLE result
-	WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download )
-if(result)
-	message(FATAL_ERROR "Build step for googletest failed: ${result}")
-endif()
-
-# Prevent overriding the parent project's compiler/linker
-# settings on Windows
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-
-# Add googletest directly to our build. This defines
-# the gtest and gtest_main targets.
-add_subdirectory(${CMAKE_CURRENT_BINARY_DIR}/googletest-src
-	${CMAKE_CURRENT_BINARY_DIR}/googletest-build
-	EXCLUDE_FROM_ALL)
-
-# The gtest/gtest_main targets carry header search path
-# dependencies automatically when using CMake 2.8.11 or
-# later. Otherwise we have to add them here ourselves.
-if (CMAKE_VERSION VERSION_LESS 2.8.11)
-	include_directories("${gtest_SOURCE_DIR}/include")
-endif()

FindMinGW.cmake

@@ -15,6 +15,7 @@ if(${MINGW})
 		find_library(_mingw_lib_m m HINTS ${MINGW_BIN}/../lib ${MINGW_INCLUDE}/../lib)
 		get_filename_component(_mingw_lib ${_mingw_lib_m} PATH)
 		set(MINGW_LIB "${_mingw_lib}" CACHE PATH "" FORCE)
+		list(APPEND CMAKE_LIBRARY_PATH "${MINGW_LIB}")
 		if (NOT _MGW_MSG)
 			set(_MGW_MSG 1 CACHE BOOL "msg_mingw" FORCE)
 			message(STATUS "Found MinGW binary path = ${MINGW_BIN}")

SHSTKMacros.cmake

@@ -2,21 +2,21 @@
 
 shstk_define_option(name desc)
 
-shstk_begin_project(domain module)
+shstk_begin_project(name)
 
 shstk_install(dir is_app target h_files)
 
 shstk_is_parent_exists(out)
 
-shstk_copy_to_parent(domain)
+shstk_copy_to_parent()
 
-shstk_add_directories(domain)
+shstk_add_directories()
 
-shstk_add_directories_with_include(is_qt domain)
+shstk_add_directories_with_include(is_qt name)
 
-shstk_set_find_dirs(domain)
+shstk_set_find_dirs(name)
 
-shstk_find_header(module filename add_find_info)
+shstk_find_header(name filename add_find_info)
 
 align_list(list out)
 
@@ -38,7 +38,9 @@ macro(shstk_define_option name desc)
 endmacro()
 
 
-macro(shstk_begin_project domain module)
+macro(shstk_begin_project name)
+	string(TOLOWER "${name}" ${name}_lowercase)
+	string(TOUPPER "${name}" ${name}_uppercase)
 	set(INSTALL_PREFIX)
 	set(_plugins_default_ 1)
 	if (CMAKE_CROSSCOMPILING)
@@ -57,7 +59,12 @@ macro(shstk_begin_project domain module)
 	endif()
 
 	shstk_define_option(LOCAL "Local install" OFF)
-	shstk_define_option(STATIC_LIB "Build static libraries" OFF)
+	if (DEFINED ENV{QNX_HOST} OR PIP_MICRO)
+		set(STATIC_LIB_DEFAULT ON)
+	else()
+		set(STATIC_LIB_DEFAULT OFF)
+	endif()
+	shstk_define_option(STATIC_LIB "Build static libraries" ${STATIC_LIB_DEFAULT})
 	set(_path "local \"bin\", \"lib\" and \"include\"")
 	if (NOT LOCAL)
 		if (WIN32)
@@ -113,45 +120,38 @@ macro(shstk_begin_project domain module)
 	set(_qt_libs )
 	set(_qt_apps )
 	set(_qt_plugs)
-	if (NOT "x${domain}" STREQUAL "x")
+	if (NOT "x${name}" STREQUAL "x")
-		set(BUILDING_${domain} ON CACHE BOOL "build ${domain}")
+		set(BUILDING_${name} ON CACHE BOOL "build ${name}")
-		set(${domain}_ROOT_SRC "${CMAKE_CURRENT_SOURCE_DIR}" CACHE STRING "")
+		set(${name}_ROOT_SRC "${CMAKE_CURRENT_SOURCE_DIR}" CACHE STRING "")
-		set(${domain}_ROOT_BIN "${CMAKE_CURRENT_BINARY_DIR}" CACHE STRING "")
+		set(${name}_ROOT_BIN "${CMAKE_CURRENT_BINARY_DIR}" CACHE STRING "")
-		set(SET_TARGETS_${domain} OFF CACHE BOOL "" FORCE)
+		set(SET_TARGETS_${name} OFF CACHE BOOL "" FORCE)
 
 		if(STATIC_LIB)
-			add_definitions(-D${module}_STATIC_DEFINE)
+			add_definitions(-D${${name}_uppercase}_STATIC_DEFINE)
-			set(${domain}_LIB_TYPE STATIC)
+			set(${name}_LIB_TYPE STATIC)
-			set(${domain}_LIB_TYPE_MSG "Static")
+			set(${name}_LIB_TYPE_MSG "Static")
 		else()
-			set(${domain}_LIB_TYPE SHARED)
+			set(${name}_LIB_TYPE SHARED)
-			set(${domain}_LIB_TYPE_MSG "Shared")
+			set(${name}_LIB_TYPE_MSG "Shared")
 		endif()
 
 		if (CMAKE_BUILD_TYPE MATCHES Debug)
-			set(${domain}_BUILD_TYPE "Debug")
+			set(${name}_BUILD_TYPE "Debug")
-			#add_definitions(-DPIP_DEBUG)
 		else()
-			set(${domain}_BUILD_TYPE "Release")
+			set(${name}_BUILD_TYPE "Release")
 		endif()
 
-		#set(${domain}_MAJOR    1)
+		set(${name}_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/${${name}_lowercase}_version.h")
-		#set(${domain}_MINOR    8)
+		set_version(${name}
-		#set(${domain}_REVISION 0)
+			MAJOR    "${${name}_MAJOR}"
-		#set(${domain}_SUFFIX   )
+			MINOR    "${${name}_MINOR}"
-		#set(${domain}_COMPANY  SHS)
+			REVISION "${${name}_REVISION}"
-		#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}"
+			SUFFIX   "${${name}_SUFFIX}"
-			OUTPUT   "${${domain}_VERSION_FILE}")
+			OUTPUT   "${${name}_VERSION_FILE}")
-		set_deploy_property(${domain} ${${domain}_LIB_TYPE}
+		set_deploy_property(${name} ${${name}_LIB_TYPE}
-			FULLNAME "${${domain}_DOMAIN}.*"
+			FULLNAME "${${name}_DOMAIN}.*"
-			COMPANY  "${${domain}_COMPANY}")
+			COMPANY  "${${name}_COMPANY}")
 
 	endif()
 
@@ -222,7 +222,7 @@ macro(shstk_copy_to_parent)
 endmacro()
 
 
-macro(shstk_add_directories domain)
+macro(shstk_add_directories)
 	file(GLOB _dl "[^.]*")
 	foreach(_d ${_dl})
 		if(IS_DIRECTORY ${_d})
@@ -233,7 +233,7 @@ macro(shstk_add_directories domain)
 endmacro()
 
 
-macro(shstk_add_directories_with_include is_qt domain)
+macro(shstk_add_directories_with_include is_qt name)
 	set(DIRS)
 	file(GLOB _dl "[^.]*")
 	foreach(_d ${_dl})
@@ -245,7 +245,7 @@ macro(shstk_add_directories_with_include is_qt domain)
 	foreach(_d ${DIRS})
 		get_filename_component(_dname "${_d}" NAME)
 		if (${is_qt})
-			list(APPEND QT_MULTILIB_LIST ${domain}${_dname})
+			list(APPEND QT_MULTILIB_LIST ${name}${_dname})
 			#set(QT_MULTILIB_LIST "${QT_MULTILIB_LIST}" CACHE STRING "")
 		endif()
 	endforeach()
@@ -258,35 +258,35 @@ macro(shstk_add_directories_with_include is_qt domain)
 endmacro()
 
 
-macro(shstk_set_find_dirs domain)
+macro(shstk_set_find_dirs name)
-	#set(_PIP_INCDIR "${PIP_DIR}/include/pip")
+	string(TOLOWER "${name}" ${name}_lowercase)
-	#set(_PIP_LIBDIR "${PIP_DIR}/lib")
+	set(${name}_INCDIR)
-	set(${domain}_INCDIR)
+	set(${name}_LIBDIR)
-	set(${domain}_LIBDIR)
+	set(${name}_BINDIR)
-	set(${domain}_BINDIR)
+	set(${name}_FIND_PROGRAM_ARG)
-	set(${domain}_FIND_PROGRAM_ARG)
+	set(${name}_BINEXT "")
-	set(${domain}_BINEXT "")
+	if(DEFINED ${name}_DIR)
-	#if (BUILDING_${domain})
+		list(APPEND ${name}_LIBDIR "${${name}_DIR}/lib")
-	#	list(APPEND ${domain}_INCDIR "${${domain}_ROOT_SRC}")
+		list(APPEND ${name}_INCDIR "${${name}_DIR}/include/${${name}_lowercase}")
-	#	list(APPEND ${domain}_LIBDIR "${${domain}_ROOT_BIN}")
+		list(APPEND ${name}_BINDIR "${${name}_DIR}/bin")
-	#endif()
+	endif()
 	if(MINGW_INCLUDE)
-		list(APPEND ${domain}_INCDIR "${MINGW_INCLUDE}/${domain}")
+		list(APPEND ${name}_INCDIR "${MINGW_INCLUDE}/${${name}_lowercase}")
-		list(APPEND ${domain}_LIBDIR "${MINGW_LIB}")
+		list(APPEND ${name}_LIBDIR "${MINGW_LIB}")
-		list(APPEND ${domain}_BINDIR "${MINGW_BIN}")
+		list(APPEND ${name}_BINDIR "${MINGW_BIN}")
 	endif()
 	if(CMAKE_CROSSCOMPILING)
-		list(APPEND ${domain}_INCDIR "${CMAKE_PREFIX_PATH}/include/${domain}")
+		list(APPEND ${name}_INCDIR "${CMAKE_PREFIX_PATH}/include/${${name}_lowercase}")
-		list(APPEND ${domain}_LIBDIR "${CMAKE_PREFIX_PATH}/lib")
+		list(APPEND ${name}_LIBDIR "${CMAKE_PREFIX_PATH}/lib")
-		set(${domain}_FIND_PROGRAM_ARG "NO_DEFAULT_PATH")
+		set(${name}_FIND_PROGRAM_ARG "NO_DEFAULT_PATH")
-		list(APPEND ${domain}_BINDIR "/usr/bin" "/usr/local/bin")
+		list(APPEND ${name}_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")
+		list(APPEND ${name}_BINDIR "${CMAKE_PREFIX_PATH}/bin")
 		if(NOT WIN32)
-			list(APPEND ${domain}_INCDIR "/usr/include/${domain}" "/usr/local/include/${domain}")
+			list(APPEND ${name}_INCDIR "/usr/include/${${name}_lowercase}" "/usr/local/include/${${name}_lowercase}")
-			list(APPEND ${domain}_LIBDIR "/usr/lib" "/usr/local/lib")
+			list(APPEND ${name}_LIBDIR "/usr/lib" "/usr/local/lib")
 		endif()
 		if(APPLE)
 			include_directories(/usr/local/include)
@@ -294,51 +294,48 @@ macro(shstk_set_find_dirs domain)
 		endif()
 	endif()
 	if ("x${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "xWindows")
-		set(${domain}_BINEXT ".exe")
+		set(${name}_BINEXT ".exe")
 		if (CMAKE_CROSSCOMPILING)
-			set(${domain}_FIND_PROGRAM_ARG)
+			set(${name}_FIND_PROGRAM_ARG)
 		endif()
 	endif()
-	#list(APPEND ${domain}_BINDIR "${PIP_DIR}/bin")
 endmacro()
 
 
-macro(shstk_find_header domain module filename add_find_info)
+macro(shstk_find_header name filename add_find_info)
-	if(NOT ${module}_VERSION)
+	string(TOUPPER "${name}" ${name}_uppercase)
-		find_file(${domain}_H_INCLUDE "${filename}" HINTS ${${domain}_INCDIR})
+	if(NOT ${name}_VERSION)
-		#message("${domain}_H_INCLUDE \"${filename}\" HINTS \"${${domain}_INCDIR}\" = \"${${domain}_H_INCLUDE}\"")
+		find_file(${name}_H_INCLUDE "${filename}" HINTS ${${name}_INCDIR} NO_CMAKE_FIND_ROOT_PATH)
-		if (NOT ${domain}_H_INCLUDE)
+		find_file(${name}_H_INCLUDE "${filename}" HINTS ${${name}_INCDIR})
-			message(FATAL_ERROR "Can`t find ${module} version file (\"${filename}\")!")
+		#message("${name}_H_INCLUDE \"${filename}\" HINTS \"${${name}_INCDIR}\" = \"${${name}_H_INCLUDE}\"")
+		if (NOT ${name}_H_INCLUDE)
+			message(FATAL_ERROR "Can`t find ${name} version file (\"${filename}\")!")
 		endif()
-		#if (DEFINED ANDROID_PLATFORM)
+		get_filename_component(_inc ${${name}_H_INCLUDE} PATH)
-		#	set(CD_INCLUDES ${ANDROID_SYSTEM_LIBRARY_PATH}/usr/include/${domain})
+		set(${name}_INCLUDES "${_inc}" CACHE STRING "")
-		#else()
-			get_filename_component(_inc ${${domain}_H_INCLUDE} PATH)
-		set(${domain}_INCLUDES "${_inc}" CACHE STRING "")
-		#endif()
 		include(CheckSymbolExists)
-		check_symbol_exists(${module}_VERSION_NAME "${${domain}_H_INCLUDE}" _${domain}_version_found)
+		check_symbol_exists(${${name}_uppercase}_VERSION_NAME "${${name}_H_INCLUDE}" _${name}_version_found)
-		if (_${domain}_version_found)
+		if (_${name}_version_found)
-			file(STRINGS "${${domain}_H_INCLUDE}" _version REGEX "^[ \t]*#define[ \t]+${module}_VERSION_NAME+[ \t]+.*$")
+			file(STRINGS "${${name}_H_INCLUDE}" _version REGEX "^[ \t]*#define[ \t]+${${name}_uppercase}_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")
+			set(${name}_VERSION ${_version} CACHE STRING "${name}_VERSION")
-			if (NOT _FIND_${module}_MSG)
+			if (NOT _FIND_${name}_MSG)
-				set(_FIND_${module}_MSG 1 CACHE BOOL "find_msg_${module}" FORCE)
+				set(_FIND_${name}_MSG 1 CACHE BOOL "find_msg_${name}" 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}\")")
+				message(STATUS "Found ${name}${_afi} (version \"${${name}_VERSION}\")")
 			endif()
 		else()
-			message(FATAL_ERROR "Can`t find ${module}_VERSION_NAME in \"${filename}\"!")
+			message(FATAL_ERROR "Can`t find ${${name}_uppercase}_VERSION_NAME in \"${filename}\"!")
 		endif()
 	endif()
-	if(${module}_FIND_VERSION VERSION_GREATER ${module}_VERSION)
+	if(${name}_FIND_VERSION VERSION_GREATER ${name}_VERSION)
-		message(FATAL_ERROR "${module} version ${${module}_VERSION} is available, but ${${module}_FIND_VERSION} requested!")
+		message(FATAL_ERROR "${name} version ${${name}_VERSION} is available, but ${${${name}_uppercase}_FIND_VERSION} requested!")
 	endif()
 endmacro()
 

SHSTKQtMacros.cmake

@@ -1,10 +1,10 @@
 #[[
 
-shstk_qt_install(dir is_app target h_files qm_files)
+shstk_qad_install(dir is_app target h_files qm_files)
 
-shstk_qt_plugin(name modules libs)
+shstk_qad_plugin(name modules libs)
 
-shstk_qt_project(name is_app domain modules libs)
+shstk_qad_project(name is_app root_name modules libs)
 
 ]]
 
@@ -13,7 +13,7 @@ set(_ok TRUE)
 if (NOT BUILDING_qad)
 	include(SHSTKMacros)
 	include(QtWraps)
-	find_qt(Core QUIET)
+	qad_find_qt(Core QUIET)
 	find_package(QAD REQUIRED)
 	set(_ok ${QAD_FOUND})
 endif()
@@ -22,7 +22,7 @@ if (_ok)
 
 
 macro(shstk_qt_founded _out)
-	find_qt(Core QUIET)
+	qad_find_qt(Core QUIET)
 	set(${_out})
 	foreach(_v ${_QT_VERSIONS_})
 		#message("Qt${_v} -> ${LOCAL_FOUND${_v}}")
@@ -33,7 +33,7 @@ macro(shstk_qt_founded _out)
 endmacro()
 
 
-macro(shstk_qt_install _dir is_app _target _h_files _qm_files)
+macro(shstk_qad_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)
@@ -48,38 +48,38 @@ macro(shstk_qt_install _dir is_app _target _h_files _qm_files)
 	endif()
 	if(NOT "x${_qm_files}" STREQUAL "x")
 		if(LOCAL)
-			qt_install(LANG ${_qm_files} DESTINATION lang)
+			qad_install(LANG ${_qm_files} DESTINATION lang)
 		else()
-			qt_install(LANG ${_qm_files} DESTINATION QtLang)
+			qad_install(LANG ${_qm_files} DESTINATION QtLang)
 		endif()
 	endif()
 	if (NOT "x${_target}" STREQUAL "x")
 		if(LOCAL)
 			if(${is_app})
-				qt_install(TARGETS ${_target} DESTINATION bin)
+				qad_install(TARGETS ${_target} DESTINATION bin)
 			else()
 				if(WIN32)
-					qt_install(TARGETS ${_target} RUNTIME DESTINATION bin)
+					qad_install(TARGETS ${_target} RUNTIME DESTINATION bin)
-					qt_install(TARGETS ${_target} ARCHIVE DESTINATION lib)
+					qad_install(TARGETS ${_target} ARCHIVE DESTINATION lib)
 				else()
-					qt_install(TARGETS ${_target} DESTINATION lib)
+					qad_install(TARGETS ${_target} DESTINATION lib)
 				endif()
 			endif()
 		else()
 			if(WIN32)
 				if (${is_app})
-					qt_install(TARGETS ${_target} DESTINATION ${MINGW_BIN})
+					qad_install(TARGETS ${_target} DESTINATION ${MINGW_BIN})
-					qt_install(TARGETS ${_target} DESTINATION QtBin)
+					qad_install(TARGETS ${_target} DESTINATION QtBin)
 				else()
-					qt_install(TARGETS ${_target} ARCHIVE DESTINATION ${MINGW_LIB})
+					qad_install(TARGETS ${_target} ARCHIVE DESTINATION ${MINGW_LIB})
-					qt_install(TARGETS ${_target} RUNTIME DESTINATION ${MINGW_BIN})
+					qad_install(TARGETS ${_target} RUNTIME DESTINATION ${MINGW_BIN})
-					qt_install(TARGETS ${_target} RUNTIME DESTINATION QtBin)
+					qad_install(TARGETS ${_target} RUNTIME DESTINATION QtBin)
 				endif()
 			else()
 				if (${is_app})
-					qt_install(TARGETS ${_target} DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
+					qad_install(TARGETS ${_target} DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
 				else()
-					qt_install(TARGETS ${_target} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
+					qad_install(TARGETS ${_target} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
 				endif()
 			endif()
 		endif()
@@ -87,7 +87,7 @@ macro(shstk_qt_install _dir is_app _target _h_files _qm_files)
 endmacro()
 
 
-macro(shstk_qt_plugin NAME _MODULES _LIBS)
+macro(shstk_qad_plugin NAME _MODULES _LIBS)
 	if (NOT STATIC_LIB)
 		if(DESIGNER_PLUGINS)
 			set(PROJ_NAME ${NAME}_plugin)
@@ -96,15 +96,20 @@ macro(shstk_qt_plugin NAME _MODULES _LIBS)
 			add_definitions(-DQT_NO_DEBUG)
 			add_definitions(-DQT_SHARED)
 			add_definitions(-DQDESIGNER_EXPORT_WIDGETS)
-			find_qt(${QtVersions} Core Designer ${_MODULES})
+			qad_find_qt(${QtVersions} Core Designer ${_MODULES})
-			qt_sources(SRC)
+			qad_sources(SRC)
-			qt_wrap(${SRC} CPPS out_CPP QMS out_QM)
+			qad_wrap(${SRC} CPPS out_CPP QMS out_QM)
-			qt_add_library(${PROJ_NAME} SHARED out_CPP)
+			qad_add_library(${PROJ_NAME} SHARED out_CPP)
-			qt_target_link_libraries(${PROJ_NAME} ${_LIBS} ${_${NAME}_PLUGIN_LIBS})
+			qad_target_link_libraries(${PROJ_NAME} ${_LIBS} ${_${NAME}_PLUGIN_LIBS})
+			foreach(_v ${_QT_VERSIONS_})
+				if (LOCAL_FOUND${_v})
+					target_include_directories(${PROJ_NAME}${TARGET_SUFFIX_Qt${_v}} PRIVATE "${Qt${_v}Designer_PRIVATE_INCLUDE_DIRS}")
+				endif()
+			endforeach()
 			if (WIN32)
-				qt_install(TARGETS ${PROJ_NAME} RUNTIME DESTINATION QtPlugins/designer)
+				qad_install(TARGETS ${PROJ_NAME} RUNTIME DESTINATION QtPlugins/designer)
 			else()
-				qt_install(TARGETS ${PROJ_NAME} DESTINATION QtPlugins/designer)
+				qad_install(TARGETS ${PROJ_NAME} DESTINATION QtPlugins/designer)
 			endif()
 			list(APPEND _qt_plugs ${NAME})
 			shstk_copy_to_parent()
@@ -113,51 +118,56 @@ macro(shstk_qt_plugin NAME _MODULES _LIBS)
 endmacro()
 
 
-macro(shstk_qt_project NAME IS_APP DOMAIN _MODULES _LIBS)
+macro(shstk_qad_project NAME IS_APP ROOT_NAME _MODULES _LIBS)
 	project(${NAME})
-	#message("find_qt ${NAME} \"${QtVersions}\" \"${_MODULES}\"")
+	#message("qad_find_qt ${NAME} ${IS_APP} \"${QtVersions}\" \"${_MODULES}\"")
-	find_qt(${QtVersions} Core ${_MODULES})
+	qad_find_qt(${QtVersions} Core ${_MODULES})
-	qt_sources(SRC)
+	qad_sources(SRC)
-	import_version(${PROJECT_NAME} ${DOMAIN})
+	import_version(${PROJECT_NAME} ${ROOT_NAME})
-	import_deploy_properties(${PROJECT_NAME} ${DOMAIN})
+	import_deploy_properties(${PROJECT_NAME} ${ROOT_NAME})
 	if (${IS_APP})
 		list(APPEND _qt_apps ${PROJECT_NAME})
 		set_deploy_property(${PROJECT_NAME}
 			LABEL 		${PROJECT_NAME}
-			FULLNAME 	"${${DOMAIN}_DOMAIN}.${PROJECT_NAME}"
+			FULLNAME 	"${${ROOT_NAME}_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}"
+			FULLNAME 	"${${ROOT_NAME}_DOMAIN}.${PROJECT_NAME}"
-			INFO 		"${DOMAIN} ${NAME} library")
+			INFO 		"${ROOT_NAME} ${NAME} library")
 	endif()
 	make_rc(${PROJECT_NAME} out_RC)
-	qt_wrap(${SRC} HDRS out_HDR CPPS out_CPP QMS out_QM ${out_RC})
+	qad_wrap(${SRC} HDRS out_HDR CPPS out_CPP QMS out_QM ${out_RC})
+	#message("add_exe proj ${NAME}, ${${ROOT_NAME}_DOMAIN}.${PROJECT_NAME}")
 	if (${IS_APP})
-		qt_add_executable(${PROJECT_NAME} WIN32 out_CPP ${${DOMAIN}_EXPORT_HEADER} ${ARGN})
+		set(_DEBUG_FLAG_)
+		if (NOT CMAKE_BUILD_TYPE MATCHES Debug)
+			set(_DEBUG_FLAG_ "WIN32")
+		endif()
+		qad_add_executable(${PROJECT_NAME} ${_DEBUG_FLAG_} out_CPP ${${ROOT_NAME}_EXPORT_HEADER} ${ARGN})
 	else()
 		set(_libtype SHARED)
-		if (NOT "x${${DOMAIN}_LIB_TYPE}" STREQUAL "x")
+		if (NOT "x${${ROOT_NAME}_LIB_TYPE}" STREQUAL "x")
-			set(_libtype ${${DOMAIN}_LIB_TYPE})
+			set(_libtype ${${ROOT_NAME}_LIB_TYPE})
 		endif()
-		qt_add_library(${PROJECT_NAME} ${_libtype} out_CPP ${${DOMAIN}_EXPORT_HEADER} ${ARGN})
+		qad_add_library(${PROJECT_NAME} ${_libtype} out_CPP ${${ROOT_NAME}_EXPORT_HEADER} ${ARGN})
-		#if(NOT ${DOMAIN}_STATIC_LIB)
+		#if(NOT ${ROOT_NAME}_STATIC_LIB)
-		#	qt_target_compile_definitions(${PROJECT_NAME} PRIVATE ${DOMAIN}_SHARED_DEFINE)
+		#	qad_target_compile_definitions(${PROJECT_NAME} PRIVATE ${ROOT_NAME}_SHARED_DEFINE)
 		#endif()
-		qt_generate_export_header(${PROJECT_NAME})
+		qad_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})
+	qad_target_link_libraries(${PROJECT_NAME} ${_LIBS})
 	file(GLOB_RECURSE PHS  "*_p.h")
 	if ((NOT "x${out_HDR}" STREQUAL "x") AND (NOT "x${PHS}" STREQUAL "x"))
-		list(REMOVE_ITEM out_HDR "${PHS}")
+		list(REMOVE_ITEM out_HDR ${PHS})
 	endif()
 	#message(STATUS "Building ${PROJECT_NAME}")
 	if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/plugin")

cmake_android.bat

@@ -40,11 +40,19 @@ if %~2==x86_64 (
 )
 rem set Qt5_ROOT=%ANDROID_QT5_DIR%\android_%QARCH%\lib\cmake
 set Qt5_ROOT=%ANDROID_QT5_DIR%\lib\cmake
+set Qt6_ROOT=%ANDROID_QT6_DIR%\android_%QARCH%\lib\cmake
 rem set Qt5_DIR=%Qt5_ROOT%\Qt5
 if NOT [%QARCH%]==[] (
 	@echo on
-	cmake_mgw -Wno-dev -DCMAKE_TOOLCHAIN_FILE=%ANDROID_NDK_HOME%\build\cmake\android.toolchain.cmake -DANDROID_STL=c++_shared -DANDROID_PLATFORM=android-%_PLATFORM_% -DANDROID_ABI=%AARCH% -DICU=0 -DQt4=0 -DQt5=1 -DQGLVIEW=0 -DQGLENGINE=0 -DQt5_DIR=%Qt5_ROOT%\Qt5 -DQt5LinguistTools_DIR=%Qt5_ROOT%\Qt5LinguistTools -DQt5UiPlugin_DIR=%Qt5_ROOT%\Qt5UiPlugin -DQt5UiTools_DIR=%Qt5_ROOT%\Qt5UiTools -DQt5Widgets_DIR=%Qt5_ROOT%\Qt5Widgets -DQt5Core_DIR=%Qt5_ROOT%\Qt5Core -DQt5Gui_DIR=%Qt5_ROOT%\Qt5Gui -DQt5Sql_DIR=%Qt5_ROOT%\Qt5Sql -DQt5OpenGL_DIR=%Qt5_ROOT%\Qt5OpenGL -DQt5PrintSupport_DIR=%Qt5_ROOT%\Qt5PrintSupport -DQt5Script_DIR=%Qt5_ROOT%\Qt5Script -DQt5Positioning_DIR=%Qt5_ROOT%\Qt5Positioning -DQt5Network_DIR=%Qt5_ROOT%\Qt5Network -DQt5Qml_DIR=%Qt5_ROOT%\Qt5Qml -DQt5Quick_DIR=%Qt5_ROOT%\Qt5Quick -DQt5QuickWidgets_DIR=%Qt5_ROOT%\Qt5QuickWidgets -DQt5QmlModels_DIR=%Qt5_ROOT%\Qt5QmlModels -DQt5AndroidExtras_DIR=%Qt5_ROOT%\Qt5AndroidExtras %~3 %~4 %~5 %~6
+	cmake_mgw -Wno-dev -DCMAKE_TOOLCHAIN_FILE=%ANDROID_NDK_HOME%\build\cmake\android.toolchain.cmake -DANDROID_STL=c++_shared -DANDROID_PLATFORM=android-%_PLATFORM_% -DANDROID_ABI=%AARCH% -DICU=0 -DQt4=0 -DQt6=0 -DQt6=1 -DQGLVIEW=0 -DQGLENGINE=0 -DQt6_DIR=%Qt6_ROOT%\Qt6 -DQt6LinguistTools_DIR=%Qt6_ROOT%\Qt6LinguistTools -DQt6UiPlugin_DIR=%Qt6_ROOT%\Qt6UiPlugin -DQt6UiTools_DIR=%Qt6_ROOT%\Qt6UiTools -DQt6Widgets_DIR=%Qt6_ROOT%\Qt6Widgets -DQt6Core_DIR=%Qt6_ROOT%\Qt6Core -DQt6Gui_DIR=%Qt6_ROOT%\Qt6Gui -DQt6Sql_DIR=%Qt6_ROOT%\Qt6Sql -DQt6OpenGL_DIR=%Qt6_ROOT%\Qt6OpenGL -DQt6PrintSupport_DIR=%Qt6_ROOT%\Qt6PrintSupport -DQt6Script_DIR=%Qt6_ROOT%\Qt6Script -DQt6Positioning_DIR=%Qt6_ROOT%\Qt6Positioning -DQt6Network_DIR=%Qt6_ROOT%\Qt6Network -DQt6Qml_DIR=%Qt6_ROOT%\Qt6Qml -DQt6Quick_DIR=%Qt6_ROOT%\Qt6Quick -DQt6QuickWidgets_DIR=%Qt6_ROOT%\Qt6QuickWidgets -DQt6QmlModels_DIR=%Qt6_ROOT%\Qt6QmlModels -DQt6AndroidExtras_DIR=%Qt6_ROOT%\Qt6AndroidExtras %~3 %~4 %~5 %~6
 ) else (
 	@echo on
 	cmake_mgw -Wno-dev -DCMAKE_TOOLCHAIN_FILE=%ANDROID_NDK_HOME%\build\cmake\android.toolchain.cmake -DANDROID_STL=c++_shared -DANDROID_PLATFORM=android-%_PLATFORM_% -DANDROID_ABI=%AARCH% -DICU=0 -DQt4=0 -DQt5=0 -DQGLVIEW=0 %~3 %~4 %~5 %~6
 )
+rem if NOT [%QARCH%]==[] (
+rem 	@echo on
+rem 	cmake_mgw -Wno-dev -DCMAKE_TOOLCHAIN_FILE=%ANDROID_NDK_HOME%\build\cmake\android.toolchain.cmake -DANDROID_STL=c++_shared -DANDROID_PLATFORM=android-%_PLATFORM_% -DANDROID_ABI=%AARCH% -DICU=0 -DQt4=0 -DQt5=1 -DQGLVIEW=0 -DQGLENGINE=0 -DQt5_DIR=%Qt5_ROOT%\Qt5 -DQt5LinguistTools_DIR=%Qt5_ROOT%\Qt5LinguistTools -DQt5UiPlugin_DIR=%Qt5_ROOT%\Qt5UiPlugin -DQt5UiTools_DIR=%Qt5_ROOT%\Qt5UiTools -DQt5Widgets_DIR=%Qt5_ROOT%\Qt5Widgets -DQt5Core_DIR=%Qt5_ROOT%\Qt5Core -DQt5Gui_DIR=%Qt5_ROOT%\Qt5Gui -DQt5Sql_DIR=%Qt5_ROOT%\Qt5Sql -DQt5OpenGL_DIR=%Qt5_ROOT%\Qt5OpenGL -DQt5PrintSupport_DIR=%Qt5_ROOT%\Qt5PrintSupport -DQt5Script_DIR=%Qt5_ROOT%\Qt5Script -DQt5Positioning_DIR=%Qt5_ROOT%\Qt5Positioning -DQt5Network_DIR=%Qt5_ROOT%\Qt5Network -DQt5Qml_DIR=%Qt5_ROOT%\Qt5Qml -DQt5Quick_DIR=%Qt5_ROOT%\Qt5Quick -DQt5QuickWidgets_DIR=%Qt5_ROOT%\Qt5QuickWidgets -DQt5QmlModels_DIR=%Qt5_ROOT%\Qt5QmlModels -DQt5AndroidExtras_DIR=%Qt5_ROOT%\Qt5AndroidExtras %~3 %~4 %~5 %~6
+rem ) else (
+rem 	@echo on
+rem 	cmake_mgw -Wno-dev -DCMAKE_TOOLCHAIN_FILE=%ANDROID_NDK_HOME%\build\cmake\android.toolchain.cmake -DANDROID_STL=c++_shared -DANDROID_PLATFORM=android-%_PLATFORM_% -DANDROID_ABI=%AARCH% -DICU=0 -DQt4=0 -DQt5=0 -DQGLVIEW=0 %~3 %~4 %~5 %~6
+rem )

install.bat

@@ -1,6 +1,7 @@
 @echo off
 if not exist build mkdir build
 cd build && ^
-cmake_mgw .. && ^
+cmake -G "CodeBlocks - MinGW Makefiles" .. && ^
-make install && ^
+cmake --build . --target install && ^
 cd ..
+pause