# Important! You should include this file
# in your top-level CMakeLists.txt
#
#
#
#
# set_version(<target> [MAJOR <value>] [MINOR <value>] [REVISION <value>] [SUFFIX <value>] [BUILD <value>] [OUTPUT <file>])
#
# Set target version, optionally creates file
#
# Create variable <target>_VERSION with full version name
#
# If OUTPUT then generate header <file> with
# version macros - <target>_VERSION_<NAME>
# Also create macro <target>_VERSION_NAME with full string version
# Attention: macro <target>_VERSION is byte-packed integer version!
#
#
#
#
# set_lang(<target> <lang> [<lang> [...]])
#
# Set target translations, e.g. "ru" "fr"
#
#
#
#
# import_version(<target> <source_target>)
#
# Copy all version components and languages from <source_target>
#
#
#
#
# set_deploy_property(<target> [SHARED | STATIC] NAME <value> [NAME <value> [...]])
#
# Set target deploy property, where NAME one of:
#  * LABEL - application icon name
#  * FULLNAME - package name in format "*.*.*"
#  * COMPANY - company name
#  * ICON - icon file path
#  * INFO - additional info
#
# Specify SHARED or STATIC if your target is library
# You can setup several properties in one command
#
#
#
#
# deploy_target(<target> [DEPLOY_DIR <dir>] [DESTINATION <dir>]
#						 [RESOURCES <dir|file> [<dir|file> ...]]
#						 [PLUGINS <dir|file> [<dir|file> ...]]
#						 [FILES <dir|file> [<dir|file> ...]]
#						 [OPTIONS <flag> ...] [VERBOSE])
#
# Create make target "deploy_<target>", depends on target "deploy"
# On this target create release package, containing all dependencies:
# *.zip on Windows, *.deb on Linux and *.dmg an MacOS
#
# You should set version and deploy properties
# before call this macro, see
# "set_version()" and "set_deploy_property()"
#
# Example:
# deploy_target(my_app DESTINATION packages)
#
#
# DEPLOY_DIR - dir where you install
#  * executable on Windows, Linux
#  * <T>.app directory with executable on MacOS
#
# DESTINATION - dir where macro place package
# RESOURCES, PLUGINS and FILES - list of directories and files, copied to:
#
#           | Windows |           Linux           |       MacOS
# ----------|---------|---------------------------|-------------------
# RESOURCES |  root   | /usr/share/COMPANY/target | Contents/Resources
# PLUGINS   |  root   | /usr/lib/COMPANY/target   | Contents/PlugIns
# FILES     |  root   | /usr/bin                  | Contents/MacOS
#
# Relative paths are taken from DEPLOY_DIR
# Also check library dependencies from PLUGINS and FILES
#
#
# This macro using "deploy_tool" from PIP,
# so make sure it can be executed from shell
# OPTIONS allow you to pass custom flags to "deploy_tool"
# You can see flags by launch "deploy_tool" without arguments
#
# Using CMAKE_LDD, CMAKE_OTOOL or CMAKE_OBJDUMP variable,
# depends on target platform
#
# DEPLOY_ADD_LIBPATH variable used as additional
# library search path
#
#
#
#
# make_rc(<target> <rc_out_file>)
#
# Generate Windows *.rc file from deploy properties
# and return file path to <rc_out_file>
# On other platforms this variable set to empty
#
# You should set version and deploy properties
# before call this macro, see
# "set_version()" and "set_deploy_property()"
#
#


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")
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()


macro(set_version _T)
	set(_VERSION_ 1) # macro version
	set(_name)
	set(_is_name 1)
	set(_is_out 0)
	set(_out)
	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)
			set(_is_name 0)
			if (_i IN_LIST __version_names)
			else()
				message(FATAL_ERROR "Invalid version component \"${_i}\"!")
			endif()
			set(_name ${_i})
		else()
			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}_VERSION ((${_TN}_VERSION_MAJOR << 16) | (${_TN}_VERSION_MINOR << 8) | ${_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)
	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}")
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()


macro(__add_file_or_dir _DIR_VAR _FILE_VAR _PATH _RELPATH)
	set(_p)
	if (IS_ABSOLUTE "${_PATH}")
		set(_p "${_PATH}")
	else()
		set(_p "${_RELPATH}/${_PATH}")
	endif()
	if (EXISTS "${_p}")
		if (IS_DIRECTORY "${_p}")
			list(APPEND ${_DIR_VAR} "${_p}")
		else()
			list(APPEND ${_FILE_VAR} "${_p}")
		endif()
	endif()
endmacro()


macro(deploy_target _T)
	set(_DESTINATION "${CMAKE_INSTALL_PREFIX}")
	set(_DEPLOY_DIR "${CMAKE_INSTALL_PREFIX}")
	set(_RES_DIRS)
	set(_RES_FILES)
	set(_PLUG_DIRS)
	set(_PLUG_FILES)
	set(_FILE_DIRS)
	set(_FILE_FILES)
	set(_VERB)
	set(_WVERB 1> NUL)
	set(_OPTIONS)
	set(_cur_arg)
	set(__args "DESTINATION;DEPLOY_DIR;RESOURCES;PLUGINS;FILES;OPTIONS;VERBOSE")
	foreach(_i ${ARGN})
		if (_i IN_LIST __args)
			set(_cur_arg "${_i}")
			if ("${_cur_arg}" STREQUAL "VERBOSE")
				set(_VERB -v)
				set(_WVERB)
			endif()
		elseif ("${_cur_arg}" STREQUAL "DESTINATION")
			set(_cur_arg)
			set(_DESTINATION "${_i}/")
		elseif ("${_cur_arg}" STREQUAL "DEPLOY_DIR")
			set(_cur_arg)
			set(_DEPLOY_DIR "${_i}/")
		elseif ("${_cur_arg}" STREQUAL "RESOURCES")
			__add_file_or_dir(_RES_DIRS _RES_FILES "${_i}" "${_DEPLOY_DIR}")
		elseif ("${_cur_arg}" STREQUAL "PLUGINS")
			__add_file_or_dir(_PLUG_DIRS _PLUG_FILES "${_i}" "${_DEPLOY_DIR}")
		elseif ("${_cur_arg}" STREQUAL "FILES")
			__add_file_or_dir(_FILE_DIRS _FILE_FILES "${_i}" "${_DEPLOY_DIR}")
		elseif ("${_cur_arg}" STREQUAL "OPTIONS")
			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(_DEP_LIBPATH)
	set(_DEP_LIBS_CS)
	set(_DEP_LIBS)
	set(_ADD_DEPS ${_PLUG_DIRS} ${_PLUG_FILES} ${_FILE_DIRS} ${_FILE_FILES})
	get_target_property(_LL ${_T} LINK_LIBRARIES)
	foreach (_L ${_LL})
		if (TARGET ${_L})
			get_target_property(_II ${_L} IMPORTED)
			if (NOT _II)
				#message("depend on ${_L}")
				get_target_property(_LT ${_L} TYPE)
				if ("x${_LT}" STREQUAL "xSHARED_LIBRARY")
					set(_DEP_LIBPATH "${_DEP_LIBPATH};$<TARGET_FILE_DIR:${_L}>")
					set(_DEP_LIBS_CS "${_DEP_LIBS_CS};$<TARGET_FILE_DIR:${_L}>/$<TARGET_FILE_NAME:${_L}>")
					set(_DEP_LIBS "${_DEP_LIBS}" "$<TARGET_FILE_DIR:${_L}>/$<TARGET_FILE_NAME:${_L}>")
				endif()
			endif()
		endif()
	endforeach()
	#message("app depend libpath ${_DEP_LIBPATH}")
	set(_CMD_COPY)
	set(_has_deploy 0)
	if ("x${CMAKE_SYSTEM_NAME}" STREQUAL "xLinux")
		if (NOT CMAKE_LDD)
			find_program(CMAKE_LDD ldd)
		endif()
		string(REPLACE "_" "-" _DEBNAME "${_T}")
		string(REPLACE "_" "-" _DEBVERSION "${${_T}_VERSION}")
		set(_DEB_ARCH)
		if("_${MY_ARCH}" STREQUAL "_arm64")
			set(_DEB_ARCH "arm64")
		elseif("_${MY_ARCH}" STREQUAL "_armv7")
			set(_DEB_ARCH "armhf")
		elseif("_${MY_ARCH}" STREQUAL "_i386")
			set(_DEB_ARCH "i386")
		elseif("_${MY_ARCH}" STREQUAL "_x86_64")
			set(_DEB_ARCH "amd64")
		elseif("_${MY_ARCH}" STREQUAL "_ppc")
			set(_DEB_ARCH "PowerPC")
		elseif("_${MY_ARCH}" STREQUAL "_ppc64")
			set(_DEB_ARCH "PPC64")
		elseif("_${MY_ARCH}" STREQUAL "_ia64")
			set(_DEB_ARCH "ia64")
		endif()
		set(_DEB "${_TV}_deb_${_DEB_ARCH}")
		set(_AGD "${_DEPLOY_DIR}/${_DEB}")
		set(_C_echof ">" "${_AGD}/DEBIAN/control")
		set(_C_echo ">>" "${_AGD}/DEBIAN/control")
		set(_D_echof ">" "${_AGD}/usr/share/applications/${_DEBNAME}.desktop")
		set(_D_echo ">>" "${_AGD}/usr/share/applications/${_DEBNAME}.desktop")
		macro(__make_copy _cmd _dirs _files _dest)
			if (${_dirs} OR ${_files})
				set(${_cmd} ${${_cmd}} COMMAND mkdir ${_VERB} -p "${_dest}")
			endif()
			foreach(_d ${${_dirs}})
				set(${_cmd} ${${_cmd}} COMMAND cp ${_VERB} -rf "${_d}" "${_dest}/")
			endforeach()
			foreach(_f ${${_files}})
				set(${_cmd} ${${_cmd}} COMMAND cp ${_VERB} -f "${_f}" "${_dest}/")
			endforeach()
		endmacro()
		__make_copy(_CMD_COPY _RES_DIRS  _RES_FILES  "${_AGD}/usr/share/${${_T}_COMPANY}/${_T}")
		__make_copy(_CMD_COPY _PLUG_DIRS _PLUG_FILES "${_AGD}/usr/lib/${${_T}_COMPANY}/${_T}")
		__make_copy(_CMD_COPY _FILE_DIRS _FILE_FILES "${_AGD}/usr/bin")
		if (_DEP_LIBS)
			set(_CMD_COPY ${_CMD_COPY} COMMAND cp ${_VERB} -f ${_DEP_LIBS} ${_AGD}/usr/lib)
		endif()
		if (_ICON_NAME)
			set(_CMD_COPY ${_CMD_COPY} COMMAND cp ${_VERB} -f ${_ICON_FN} ${_AGD}/usr/share/pixmaps)
		endif()
		add_custom_target(deploy_${_T}
			# gather deb dir
			COMMAND mkdir ${_VERB} -p ${_AGD}/DEBIAN
			COMMAND mkdir ${_VERB} -p ${_AGD}/usr/bin
			COMMAND mkdir ${_VERB} -p ${_AGD}/usr/lib
			COMMAND mkdir ${_VERB} -p ${_AGD}/usr/share/pixmaps
			COMMAND mkdir ${_VERB} -p ${_AGD}/usr/share/applications
			COMMAND cp ${_VERB} -f ${_DEPLOY_DIR}/${_T} ${_AGD}/usr/bin
			${_CMD_COPY}

			COMMAND echo "Package: ${_DEBNAME}" ${_C_echof}
			COMMAND echo "Version: ${_DEBVERSION}" ${_C_echo}
			COMMAND echo "Architecture: ${_DEB_ARCH}" ${_C_echo}
			COMMAND echo "Maintainer: ${${_T}_COMPANY} <>" ${_C_echo}
			COMMAND deploy_tool ${_OPTIONS} --prefix "Depends: " --dependencies -l ${CMAKE_LDD} -a "${_DEP_LIBS_CS}" -o "${_AGD}/usr/lib" ${_DEPLOY_DIR}/${_T} ${_ADD_DEPS} ${_C_echo}
			COMMAND echo "Conflicts:" ${_C_echo}
			COMMAND echo "Replaces:" ${_C_echo}
			COMMAND echo "Section: misc" ${_C_echo}
			COMMAND echo "Priority: optional" ${_C_echo}
			COMMAND echo "Description: ${${_T}_INFO}" ${_C_echo}

			COMMAND echo "[Desktop Entry]" ${_D_echof}
			COMMAND echo "Encoding=UTF-8" ${_D_echo}
			COMMAND echo "Type=Application" ${_D_echo}
			COMMAND echo "Name=${${_T}_LABEL}" ${_D_echo}
			COMMAND echo "GenericName=${${_T}_LABEL}" ${_D_echo}
			COMMAND echo "Comment=${${_T}_INFO}" ${_D_echo}
			COMMAND echo "Exec=/usr/bin/${_T}" ${_D_echo}
			COMMAND echo "Icon=/usr/share/pixmaps/${_ICON_NAME}" ${_D_echo}
			COMMAND echo "Terminal=false" ${_D_echo}
			COMMAND echo "StartupNotify=true" ${_D_echo}
			#COMMAND echo "X-KDE-StartupNotify=true" ${_D_echo}
			COMMAND echo "Categories=Utility;" ${_D_echo}

			#COMMAND  -l "${CMAKE_LDD}" -P xcb -q ${Qt5_ROOT} -s "\"${CMAKE_PREFIX_PATH}/lib;${DEPLOY_ADD_LIBPATH}${_DEP_LIBPATH}\"" -o ${_AGD}/usr/lib -p ${_AGD}/usr/ ${_AGD}/Contents/MacOS/${_T}
			# generate deb
			COMMAND cd ${_AGD} "&&" md5deep -rl usr ">" DEBIAN/md5sums
			COMMAND mkdir ${_VERB} -p ${_DESTINATION}
			COMMAND dpkg-deb -b ${_AGD} ${_DESTINATION}/${_TV}_${_DEB_ARCH}.deb
			VERBATIM
			COMMENT "Generating ${_TV}_${_DEB_ARCH}.deb"
			)
		set(_has_deploy 1)
	elseif(WIN32)
		if (NOT CMAKE_OBJDUMP)
			find_program(CMAKE_OBJDUMP objdump)
		endif()
		set(_AGD "${_DEPLOY_DIR}/${_TV}_win_${MY_ARCH}/")
		set(_win_host 0)
		if ("x${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "xWindows")
			set(_win_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)
				__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)
			if (${_dirs} OR ${_files})
				__make_dir(${_cmd} "${_dest}")
			endif()
			if (_win_host)
				__make_win_path("${_dest}" _wdest 1 "")
				foreach(_d ${${_dirs}})
					__make_win_path("${_d}" _wsrc 1 _dirname)
					__make_dir(${_cmd} "${_dest}/${_dirname}")
					set(${_cmd} ${${_cmd}} COMMAND xcopy /y /r "${_wsrc}*" "\"${_wdest}${_dirname}\\\"" ${_WVERB})
				endforeach()
				foreach(_f ${${_files}})
					__make_win_path("${_f}" _wsrc 0 "")
					set(${_cmd} ${${_cmd}} COMMAND xcopy /y /r "\"${_wsrc}\"" "\"${_wdest}\"" ${_WVERB})
				endforeach()
			else()
				foreach(_d ${${_dirs}})
					set(${_cmd} ${${_cmd}} COMMAND cp ${_VERB} -rf "${_d}" "${_dest}/")
				endforeach()
				foreach(_f ${${_files}})
					set(${_cmd} ${${_cmd}} COMMAND cp ${_VERB} -f "${_f}" "${_dest}/")
				endforeach()
			endif()
		endmacro()
		if (_win_host)
			string(REPLACE "/" "\\" CMAKE_OBJDUMP "${CMAKE_OBJDUMP}")
		endif()
		set(_var_exe "${_DEPLOY_DIR}/${_T}.exe")
		set(_var_empty)
		__make_dir(_CMD_COPY "${_AGD}")
		__make_dir(_CMD_COPY "${_DESTINATION}")
		__make_copy(_CMD_COPY _var_empty _var_exe "${_AGD}")
		__make_copy(_CMD_COPY _RES_DIRS  _RES_FILES  "${_AGD}")
		__make_copy(_CMD_COPY _PLUG_DIRS _PLUG_FILES "${_AGD}")
		__make_copy(_CMD_COPY _FILE_DIRS _FILE_FILES "${_AGD}")
		add_custom_target(deploy_${_T}
			# gather dir
			${_CMD_COPY}

			COMMAND deploy_tool ${_VERB} ${_OPTIONS} -W "\"${CMAKE_OBJDUMP}\"" -P windows,minimal -S windows -q "\"${Qt5_ROOT}\"" -s "\"${CMAKE_PREFIX_PATH}/bin;${MINGW_BIN};${DEPLOY_ADD_LIBPATH}${_DEP_LIBPATH}\"" -o ${_AGD} -p ${_AGD} "\"${_AGD}${_T}.exe\"" ${_ADD_DEPS}
			# zip
			COMMAND cd "\"${_DEPLOY_DIR}\"" "&&" zip -q -r "\"${_DESTINATION}/${_TV}.zip\"" "\"${_TV}_win_${MY_ARCH}\""
			COMMENT "Generating ${_TV}.zip"
			)
		set(_has_deploy 1)
	elseif (APPLE)
		set(MACOSX_BUNDLE_GUI_IDENTIFIER	   "${${_T}_FULLNAME}")
		set(MACOSX_BUNDLE_SHORT_VERSION_STRING "${${_T}_VERSION}")
		set(MACOSX_BUNDLE_LONG_VERSION_STRING  "${${_T}_VERSION}")
		set(MACOSX_BUNDLE_ICON_FILE			   "${_ICON_NAME}")
		set(MACOSX_BUNDLE_BUNDLE_NAME		   "${${_T}_LABEL}")
		set(MACOSX_BUNDLE_COPYRIGHT			   "${${_T}_COMPANY}")
		set(MACOSX_BUNDLE_INFO_STRING		   "${${_T}_INFO}")
		set(MACOSX_BUNDLE_BUNDLE_VERSION	   "6.0")
		set(MACOSX_BUNDLE_SIGNATURE			   "????")
		set_target_properties(${_T} PROPERTIES MACOSX_BUNDLE TRUE)
		set_target_properties(${_T} PROPERTIES MACOSX_BUNDLE_INFO_PLIST "${CMAKE_ROOT}/Modules/PIMacOSBundle.plist.in")
		set(_AGD "${_DEPLOY_DIR}/${_T}.app")
		set(_DMG "${CMAKE_CURRENT_BINARY_DIR}/dmg")
		macro(__make_copy _cmd _dirs _files _dest)
			if (${_dirs} OR ${_files})
				set(${_cmd} ${${_cmd}} COMMAND mkdir ${_VERB} -p "${_dest}")
			endif()
			foreach(_d ${${_dirs}})
				set(${_cmd} ${${_cmd}} COMMAND cp ${_VERB} -rf "${_d}" "${_dest}/")
			endforeach()
			foreach(_f ${${_files}})
				set(${_cmd} ${${_cmd}} COMMAND cp ${_VERB} -f "${_f}" "${_dest}/")
			endforeach()
		endmacro()
		__make_copy(_CMD_COPY _RES_DIRS  _RES_FILES  "${_AGD}/Contents/Resources")
		__make_copy(_CMD_COPY _PLUG_DIRS _PLUG_FILES "${_AGD}/Contents/PlugIns")
		__make_copy(_CMD_COPY _FILE_DIRS _FILE_FILES "${_AGD}/Contents/MacOS")
		if (_ICON_NAME)
			set(_CMD_COPY ${_CMD_COPY} COMMAND cp ${_VERB} -f ${_ICON_FN} ${_AGD}/Contents/Resources)
		endif()
		add_custom_target(deploy_${_T}
			# gather .app dir
			COMMAND mkdir ${_VERB} -p ${_AGD}/Contents/Resources
			COMMAND mkdir ${_VERB} -p ${_AGD}/Contents/Frameworks
			COMMAND mkdir ${_VERB} -p ${_DESTINATION}
			${_CMD_COPY}
			#COMMAND cp ${_ICON_FN} ${_AGD}/Contents/Resources
			#COMMAND cp -r ${_DEPLOY_DIR}/lang ${_AGD}/Contents/Resources
			COMMAND deploy_tool ${_VERB} ${_OPTIONS} -M "${CMAKE_OTOOL}" -P cocoa,minimal -S mac -q ${Qt5_ROOT} -s "\"${CMAKE_PREFIX_PATH}/lib;${DEPLOY_ADD_LIBPATH}${_DEP_LIBPATH}\"" -o ${_AGD}/Contents/Frameworks -p ${_AGD}/Contents/PlugIns ${_AGD}/Contents/MacOS/${_T} ${_ADD_DEPS}
			# prepare dmg dir
			COMMAND rm -rf ${_DMG}
			COMMAND mkdir ${_VERB} -p ${_DMG}
			COMMAND cp -r ${_AGD} ${_DMG}
			COMMAND ln ${_VERB} --symbolic /Applications ${_DMG}
			# generate dmg
			COMMAND genisoimage -quiet -V "${MACOSX_BUNDLE_BUNDLE_NAME}" -D -R -apple -no-pad -o ${_DESTINATION}/${_TV}.dmg ${_DMG}
			COMMENT "Generating ${_TV}.dmg"
			)
		set(_has_deploy 1)
	elseif (DEFINED ANDROID_PLATFORM)
		set(_AT ${_T})
		get_target_property(_TT ${_T} TYPE)
		if (NOT "x${_TT}" STREQUAL "xSHARED_LIBRARY")
			set(_AT ${_T}_lib)
			get_target_property(_sources ${_T} SOURCES)
			get_target_property(_libs ${_T} LINK_LIBRARIES)
			get_target_property(_incs ${_T} INCLUDE_DIRECTORIES)
			add_library(${_AT} SHARED ${_sources})
			target_link_libraries(${_AT} ${_libs})
			target_include_directories(${_AT} PRIVATE ${_incs})
			message("create new target ${_AT} ${_sources} ${_libs}")
		endif()
		#get_target_property(_LL ${_T} )
		add_custom_target(deploy_${_T})
		set(_has_deploy 1)
	endif()
	if (_has_deploy)
		add_dependencies(deploy deploy_${_T})
	endif()
endmacro()