You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
308 lines
9.1 KiB
308 lines
9.1 KiB
#################################################
|
|
# #
|
|
# Auxiliary macros for TQt #
|
|
# #
|
|
#################################################
|
|
|
|
include( TDEMacros )
|
|
|
|
|
|
#################################################
|
|
#####
|
|
##### tqt_install_includes
|
|
#####
|
|
##### The macro is used to determine the headers that are installed,
|
|
##### while the symlinks in the binary include directory are created.
|
|
#####
|
|
##### Syntax:
|
|
##### tqt_install_includes(
|
|
##### [FILES] include_name [include_name]
|
|
##### [DESTINATION subdir]
|
|
##### [ONLY_SYMLINK]
|
|
##### )
|
|
|
|
macro( tqt_install_includes )
|
|
|
|
unset( _files )
|
|
unset( _dest )
|
|
unset( _only_symlink )
|
|
set( _var _files )
|
|
|
|
foreach( _arg ${ARGN} )
|
|
|
|
# found directive "FILES"
|
|
if( "+${_arg}" STREQUAL "+FILES" )
|
|
unset( _files )
|
|
set( _var _files )
|
|
set( _directive 1 )
|
|
endif( )
|
|
|
|
# found directive "DESTINATION"
|
|
if( "+${_arg}" STREQUAL "+DESTINATION" )
|
|
unset( _dest )
|
|
set( _var _dest )
|
|
set( _directive 1 )
|
|
endif( )
|
|
|
|
# found directive "ONLY_SYMLINK"
|
|
if( "+${_arg}" STREQUAL "+ONLY_SYMLINK" )
|
|
unset( _var )
|
|
set( _only_symlink 1 )
|
|
set( _directive 1 )
|
|
endif( )
|
|
|
|
# collect data
|
|
if( _directive )
|
|
unset( _directive )
|
|
elseif( _var )
|
|
list( APPEND ${_var} ${_arg} )
|
|
endif( )
|
|
|
|
endforeach( )
|
|
|
|
# determine destination directory
|
|
if( NOT IS_ABSOLUTE( "${_dest}" ) )
|
|
set( _dest "${QT_INSTALL_HEADERS}/${_dest}" )
|
|
endif()
|
|
file( RELATIVE_PATH _dest_sub "${QT_INSTALL_HEADERS}" "${_dest}" )
|
|
file( MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/include/${_dest_sub}" )
|
|
|
|
# process files
|
|
foreach( _file IN LISTS _files )
|
|
if( NOT TARGET tqt-includes )
|
|
add_custom_target( tqt-includes
|
|
WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
|
|
COMMENT "Prepare includes..." )
|
|
endif()
|
|
|
|
get_filename_component( _source_name "${_file}" NAME )
|
|
get_filename_component( _source_file "${_file}" ABSOLUTE )
|
|
file( RELATIVE_PATH _target_name "${CMAKE_SOURCE_DIR}" "${_source_file}" )
|
|
string( REPLACE "/" "+" _target_name "${_target_name}" )
|
|
|
|
file( RELATIVE_PATH _link_source "${CMAKE_BINARY_DIR}/include/${_dest_sub}" ${_source_file} )
|
|
file( RELATIVE_PATH _link_dest "${QT_INSTALL_HEADERS}" "${_dest}/${_source_name}" )
|
|
|
|
if( NOT TARGET ${_target_name} )
|
|
add_custom_command(
|
|
OUTPUT ${CMAKE_BINARY_DIR}/include/${_link_dest}
|
|
COMMAND
|
|
${CMAKE_COMMAND} -E create_symlink
|
|
${_link_source} ${CMAKE_BINARY_DIR}/include/${_link_dest}
|
|
COMMENT "Include file ${_link_dest}"
|
|
)
|
|
add_custom_target( ${_target_name}
|
|
DEPENDS ${CMAKE_BINARY_DIR}/include/${_link_dest}
|
|
)
|
|
add_dependencies( tqt-includes ${_target_name} )
|
|
endif()
|
|
|
|
if( NOT "${_only_symlink}" )
|
|
install( FILES ${_file} DESTINATION ${_dest} )
|
|
endif()
|
|
endforeach( _file )
|
|
|
|
endmacro( tqt_install_includes )
|
|
|
|
|
|
#################################################
|
|
#####
|
|
##### tqt_automoc
|
|
#####
|
|
##### The macro is used for 'moc' processing specifically for TQt as such
|
|
##### and adding them to an existing target.
|
|
#####
|
|
##### Syntax:
|
|
##### tqt_moc(
|
|
##### [TARGET] target
|
|
##### [INCLUDES include_name [include_name]]
|
|
##### )
|
|
|
|
macro( tqt_automoc )
|
|
|
|
unset( _target )
|
|
set( _includes AUTO )
|
|
set( _var _target )
|
|
|
|
foreach( _arg ${ARGN} )
|
|
|
|
# found directive "TARGET"
|
|
if( "+${_arg}" STREQUAL "+TARGET" )
|
|
unset( _target )
|
|
set( _var _target )
|
|
set( _directive 1 )
|
|
endif( )
|
|
|
|
# found directive "INCLUDES"
|
|
if( "+${_arg}" STREQUAL "+INCLUDES" )
|
|
unset( _includes )
|
|
set( _var _includes )
|
|
set( _directive 1 )
|
|
endif( )
|
|
|
|
# collect data
|
|
if( _directive )
|
|
unset( _directive )
|
|
elseif( _var )
|
|
list( APPEND ${_var} ${_arg} )
|
|
endif( )
|
|
|
|
endforeach( )
|
|
|
|
# target must already exist
|
|
if( NOT TARGET ${_target} )
|
|
tde_message_fatal( "The specified target does not exists." )
|
|
endif()
|
|
|
|
# search include files suitable for processing
|
|
if( _includes STREQUAL "AUTO" )
|
|
file( GLOB _includes RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
|
|
${CMAKE_CURRENT_SOURCE_DIR}/*.h )
|
|
foreach( _include IN LISTS _includes )
|
|
file( READ "${CMAKE_CURRENT_SOURCE_DIR}/${_include}" _src_content )
|
|
string( REGEX REPLACE "(^|\n)[\t ]*#[^\n]*" "" _src_content "${_src_content}" )
|
|
string( REGEX REPLACE "(//|/\\*)[^\n]*T?Q_OBJECT[^\n]*" "" _src_content "${_src_content}" )
|
|
if( NOT _src_content MATCHES "[\n\t ]+T?Q_OBJECT[\n\t ]+" )
|
|
list( REMOVE_ITEM _includes "${_include}" )
|
|
endif()
|
|
endforeach()
|
|
elseif( _includes STREQUAL "-" )
|
|
set( _includes "" )
|
|
endif()
|
|
|
|
# check tmoc executable
|
|
if( NOT DEFINED TMOC_EXECUTABLE )
|
|
find_program( TMOC_EXECUTABLE
|
|
NAMES tmoc
|
|
HINT ${QT_INSTALL_BINS}
|
|
)
|
|
if( "${TMOC_EXECUTABLE}" STREQUAL "TMOC_EXECUTABLE-NOTFOUND" )
|
|
tde_message_fatal( "tmoc is required but not found" )
|
|
endif( )
|
|
endif()
|
|
|
|
# processing sources of specified target
|
|
get_property( _sources TARGET ${_target} PROPERTY SOURCES )
|
|
foreach( _src_file IN LISTS _sources )
|
|
|
|
get_filename_component( _src_file "${_src_file}" ABSOLUTE )
|
|
|
|
if( EXISTS "${_src_file}" )
|
|
|
|
# read source file and check if have moc include
|
|
file( READ "${_src_file}" _src_content )
|
|
string( REGEX MATCHALL "#include +[^ ]+\\.moc[\">]" _moc_includes "${_src_content}" )
|
|
|
|
# found included moc(s)?
|
|
if( _moc_includes )
|
|
foreach( _moc_file ${_moc_includes} )
|
|
|
|
# extracting moc filename
|
|
string( REGEX MATCH "[^ <\"]+\\.moc" _moc_file "${_moc_file}" )
|
|
set( _moc_file "${CMAKE_CURRENT_BINARY_DIR}/${_moc_file}" )
|
|
|
|
# create source filename
|
|
get_filename_component( _src_path "${_src_file}" ABSOLUTE )
|
|
get_filename_component( _src_path "${_src_path}" PATH )
|
|
get_filename_component( _src_header "${_moc_file}" NAME_WE )
|
|
if( NOT TQT_FOUND )
|
|
set( _moc_source "${_src_path}/${_src_header}.cpp" )
|
|
else()
|
|
set( _moc_source "${_src_path}/${_src_header}.h" )
|
|
endif()
|
|
|
|
# if header doesn't exists, check in META_INCLUDES
|
|
if( NOT EXISTS "${_moc_source}" )
|
|
unset( _found )
|
|
foreach( _src_path ${_meta_includes} )
|
|
set( _moc_source "${_src_path}/${_src_header}.h" )
|
|
if( EXISTS "${_moc_source}" )
|
|
set( _found 1 )
|
|
break( )
|
|
endif( )
|
|
endforeach( )
|
|
if( NOT _found )
|
|
get_filename_component( _moc_file "${_moc_file}" NAME )
|
|
tde_message_fatal( "AUTOMOC error: '${_moc_file}' cannot be generated.\n Reason: '${_src_file}.h' not found." )
|
|
endif( )
|
|
endif( )
|
|
|
|
# moc-ing source
|
|
add_custom_command( OUTPUT ${_moc_file}
|
|
COMMAND ${TMOC_EXECUTABLE} ${_moc_source} -o ${_moc_file}
|
|
DEPENDS ${_moc_source}
|
|
)
|
|
|
|
# create dependency between source file and moc file
|
|
set_property( SOURCE ${_src_file} APPEND PROPERTY OBJECT_DEPENDS ${_moc_file} )
|
|
|
|
# remove from includes for processing
|
|
file( RELATIVE_PATH _moc_source ${CMAKE_CURRENT_SOURCE_DIR} ${_moc_source} )
|
|
list( REMOVE_ITEM _includes "${_moc_source}" )
|
|
|
|
endforeach( _moc_file )
|
|
|
|
endif( _moc_includes )
|
|
|
|
endif( EXISTS "${_src_file}" )
|
|
|
|
endforeach( _src_file )
|
|
|
|
# processing headers
|
|
foreach( _include_file IN LISTS _includes )
|
|
get_filename_component( _include_name "${_include_file}" NAME_WE )
|
|
set( _moc_file ${CMAKE_CURRENT_BINARY_DIR}/moc_${_include_name}.cpp )
|
|
|
|
# moc-ing source
|
|
add_custom_command( OUTPUT ${_moc_file}
|
|
COMMAND ${TMOC_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${_include_file} -o ${_moc_file}
|
|
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${_include_file}
|
|
)
|
|
set_property( TARGET ${_target} APPEND PROPERTY SOURCES ${_moc_file} )
|
|
endforeach( _include_file )
|
|
|
|
endmacro( tqt_automoc )
|
|
|
|
|
|
#################################################
|
|
#####
|
|
##### tqt_create_translation
|
|
#####
|
|
##### The macro is used for create binary files for translations
|
|
#####
|
|
##### Syntax:
|
|
##### tqt_create_translation(
|
|
##### )
|
|
|
|
macro( tqt_create_translation )
|
|
|
|
file( GLOB _srcs RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*_*.ts )
|
|
list( SORT _srcs )
|
|
|
|
# generate *.qm files
|
|
foreach( _src ${_srcs} )
|
|
|
|
get_filename_component( _src ${_src} ABSOLUTE )
|
|
|
|
get_filename_component( _out ${_src} NAME_WE )
|
|
string( REPLACE "@" "_" _target ${_out} )
|
|
set( _out_filename "${_out}.qm" )
|
|
set( _install_filename "${_out}.qm" )
|
|
|
|
add_custom_command(
|
|
OUTPUT ${_out_filename}
|
|
COMMAND tqlrelease ${_src} -qm ${_out_filename}
|
|
COMMENT "Build translation ${_out}"
|
|
DEPENDS ${_src}
|
|
)
|
|
add_custom_target( "${_target}-translation" ALL DEPENDS ${_out_filename} )
|
|
install(
|
|
FILES ${CMAKE_CURRENT_BINARY_DIR}/${_out_filename}
|
|
RENAME ${_install_filename}
|
|
DESTINATION ${QT_INSTALL_TRANSLATIONS}
|
|
)
|
|
|
|
endforeach( )
|
|
|
|
endmacro( tqt_create_translation )
|