MahnoKropotkinvich/SPEC.tde-cmake-trinity
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
6318f6ee91
SPEC.tde-cmake-trinity/findtqt-name-fix.patch
Mahno 6318f6ee91 fix patch issues
2025-04-08 14:37:52 +08:00

6800 lines
219 KiB
Diff
Raw Blame History

diff -Naur orig/.tdescminfo tde-cmake-trinity-14.1.3/.tdescminfo
--- orig/.tdescminfo 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/.tdescminfo 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,5 @@
+# TDE SCM module information
+Name: dependencies/tde-cmake
+Version: R14.1.3
+Revision: r14.1.x-b7e338003b6d2adca0340b3c8d04ebce9dec61f6
+DateTime: 10/14/2024 16:00
diff -Naur orig/CMakeLists.txt tde-cmake-trinity-14.1.3/CMakeLists.txt
--- orig/CMakeLists.txt 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/CMakeLists.txt 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,39 @@
+#################################################
+#
+# (C) 2021 Slávek Banko
+# slavek.banko (at) axis.cz
+#
+# Improvements and feedback are welcome
+#
+# This file is released under GPL >= 2
+#
+#################################################
+
+## Process only if it is built as a standalone package
+if( "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_SOURCE_DIR}" )
+
+##### general package setup #####################
+
+ # building tde-cmake requires reading the minimum required version
+ # from the source files, because there may be a different version
+ # of tde-cmake already installed in the system. Trying to build
+ # tde-cmake with a lower minimum version would not be allowed then.
+
+ include( ${CMAKE_SOURCE_DIR}/modules/TDEVersion.cmake )
+ cmake_minimum_required( VERSION ${TDE_CMAKE_MINIMUM_VERSION} )
+ project( tde-cmake-rules )
+
+
+##### install TDE CMake files ###################
+
+ file( GLOB_RECURSE _modules
+ RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR}/modules/* )
+ install( FILES ${_modules} DESTINATION ${CMAKE_ROOT}/Modules )
+
+ file( GLOB_RECURSE _templates
+ RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR}/templates/* )
+ install( FILES ${_templates} DESTINATION ${CMAKE_ROOT}/Templates )
+
+endif()
diff -Naur orig/generate_apidox tde-cmake-trinity-14.1.3/generate_apidox
--- orig/generate_apidox 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/generate_apidox 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+top_srcdir=${1}
+top_builddir=${2}
+kde_libs_htmldir=${3}
+export TQTDOCDIR=${4}
+
+if [[ ! -d "${top_srcdir}/doc/common/" ]]; then
+ export DOXDATA=${kde_libs_htmldir}/en/common
+fi
+
+abs_top_srcdir=$(cd ${top_srcdir} && pwd)
+
+rm -rf ${top_builddir}/${kde_libs_htmldir}/en
+mkdir -p ${top_builddir}/${kde_libs_htmldir}/en
+cd ${top_builddir}/${kde_libs_htmldir}/en
+${abs_top_srcdir}/admin/doxygen.sh --modulename --installdir=${top_builddir}/${kde_libs_htmldir}/en ${abs_top_srcdir}
diff -Naur orig/install_apidox tde-cmake-trinity-14.1.3/install_apidox
--- orig/install_apidox 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/install_apidox 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+top_srcdir=${1}
+top_builddir=${2}
+kde_libs_htmldir=${3}
+installdir=${DESTDIR}
+
+abs_top_srcdir=$(cd ${top_srcdir} && pwd)
+
+cd ${top_builddir}
+mkdir -p ${installdir}/${kde_libs_htmldir}/en
+cp -Rp ${top_builddir}/${kde_libs_htmldir}/en ${installdir}/${kde_libs_htmldir}/
diff -Naur orig/modules/FindTDE.cmake tde-cmake-trinity-14.1.3/modules/FindTDE.cmake
--- orig/modules/FindTDE.cmake 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/modules/FindTDE.cmake 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,107 @@
+#################################################
+#
+# (C) 2010-2011 Serghei Amelian
+# serghei (DOT) amelian (AT) gmail.com
+#
+# Improvements and feedback are welcome
+#
+# This file is released under GPL >= 2
+#
+#################################################
+
+if( NOT TDE_FOUND )
+
+ message( STATUS "checking for 'TDE'")
+
+ pkg_search_module( TDE tqt )
+
+ if( NOT TDE_FOUND )
+ tde_message_fatal( "Unable to find tdelibs!\n Try adding the directory in which the tdelibs.pc file is located\nto the PKG_CONFIG_PATH variable." )
+ endif( )
+
+ # if the path is not already defined by user,
+ # find tde-config executable
+ if( NOT DEFINED KDECONFIG_EXECUTABLE )
+ find_program( KDECONFIG_EXECUTABLE
+ NAMES tde-config
+ HINTS "${TDE_PREFIX}/bin" ${BIN_INSTALL_DIR} )
+ if( NOT KDECONFIG_EXECUTABLE )
+ tde_message_fatal( "tde-config are NOT found." )
+ endif( NOT KDECONFIG_EXECUTABLE )
+ set( KDECONFIG_EXECUTABLE ${KDECONFIG_EXECUTABLE}
+ CACHE INTERNAL "tde-config executable" )
+ endif( NOT DEFINED KDECONFIG_EXECUTABLE )
+
+ set( ENV{LD_LIBRARY_PATH} "${TDE_LIBDIR}:$ENV{LD_LIBRARY_PATH}" )
+ # check for installed trinity version
+ tde_execute_process(
+ COMMAND ${KDECONFIG_EXECUTABLE} --version
+ OUTPUT_VARIABLE _version
+ RESULT_VARIABLE _result
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ MESSAGE "Unable to run tde-config!\n TDELIBS are correctly installed?\n Path to tde-config are corect?" )
+
+ # parse tde-config output, to extract TDE version
+ string( REGEX MATCH "TDE: R([0-9\\.]+).*" __dummy "${_version}" )
+ set( TDE_VERSION "${CMAKE_MATCH_1}" CACHE INTERNAL "" )
+
+ # ask tde-config for few paths
+ macro( __internal_get_path __type __var )
+ tde_execute_process(
+ COMMAND ${KDECONFIG_EXECUTABLE} --expandvars --install ${__type}
+ OUTPUT_VARIABLE ${__var}
+ CACHE INTERNAL "TDE ${__type} path" FORCE
+ OUTPUT_STRIP_TRAILING_WHITESPACE )
+ endmacro( __internal_get_path )
+
+ __internal_get_path( include TDE_INCLUDE_DIR )
+ __internal_get_path( lib TDE_LIB_DIR )
+ __internal_get_path( exe TDE_BIN_DIR )
+ __internal_get_path( data TDE_DATA_DIR )
+ __internal_get_path( config TDE_CONFIG_DIR )
+ __internal_get_path( html TDE_HTML_DIR )
+ __internal_get_path( cmake TDE_CMAKE_DIR )
+ __internal_get_path( tqtplugins TDE_TQTPLUGINS_DIR )
+
+ # find kde tools
+ macro( __internal_find_program __prog __var )
+ find_program( ${__var}
+ NAMES ${__prog}
+ HINTS "${TDE_PREFIX}/bin" ${BIN_INSTALL_DIR}
+ OUTPUT_STRIP_TRAILING_WHITESPACE )
+ if( NOT ${__var} )
+ tde_message_fatal( "${__prog} is NOT found.\n TDELIBS are correctly installed?" )
+ endif( NOT ${__var} )
+ set( ${__var} ${${__var}} CACHE INTERNAL "${__prog} executable" FORCE )
+ endmacro( __internal_find_program )
+
+ __internal_find_program( dcopidl KDE3_DCOPIDL_EXECUTABLE )
+ __internal_find_program( dcopidlng KDE3_DCOPIDLNG_EXECUTABLE )
+ __internal_find_program( dcopidl2cpp KDE3_DCOPIDL2CPP_EXECUTABLE )
+ __internal_find_program( meinproc KDE3_MEINPROC_EXECUTABLE )
+ __internal_find_program( tdeconfig_compiler KDE3_KCFGC_EXECUTABLE )
+ __internal_find_program( maketdewidgets KDE3_MAKETDEWIDGETS_EXECUTABLE )
+ # Don't use __internal_find_program due to it's not mandatory
+ if( NOT DEFINED TDELFEDITOR_EXECUTABLE )
+ find_program( TDELFEDITOR_EXECUTABLE NAMES tdelfeditor
+ HINTS "${TDE_PREFIX}/bin" ${BIN_INSTALL_DIR} OUTPUT_STRIP_TRAILING_WHITESPACE )
+ set( TDELFEDITOR_EXECUTABLE ${TDELFEDITOR_EXECUTABLE}
+ CACHE INTERNAL "tdelfeditor executable" )
+ endif( )
+
+ # dcopidlng is a bash script which using tde-config;
+ # if PATH to tde-config is not set, dcopidlng will fail;
+ # for this reason we set KDECONFIG environment variable before running dcopidlng
+ set( KDE3_DCOPIDLNG_EXECUTABLE env KDECONFIG=${KDECONFIG_EXECUTABLE} ${KDE3_DCOPIDLNG_EXECUTABLE}
+ CACHE INTERNAL "dcopidlng executable" FORCE )
+
+ # read source metadata
+ tde_read_src_metadata()
+
+ message( STATUS " found 'TDE', version ${TDE_VERSION}" )
+
+endif( NOT TDE_FOUND )
+
+if( NOT TARGET tdecore-shared )
+ include( "${TDE_CMAKE_DIR}/tdelibs.cmake" )
+endif()
diff -Naur orig/modules/FindTQt.cmake tde-cmake-trinity-14.1.3/modules/FindTQt.cmake
--- orig/modules/FindTQt.cmake 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/modules/FindTQt.cmake 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,122 @@
+#################################################
+#
+# (C) 2010-2011 Serghei Amelian
+# serghei (DOT) amelian (AT) gmail.com
+#
+# Improvements and feedback are welcome
+#
+# This file is released under GPL >= 2
+#
+#################################################
+
+macro( tqt_message )
+ message( STATUS "${ARGN}" )
+endmacro( )
+
+if( NOT TQT_FOUND )
+ pkg_search_module( TQT tqt )
+
+ if( NOT TQT_FOUND )
+ tde_message_fatal( "Unable to find tqt!\n Try adding the directory in which the tqt.pc file is located\nto the PKG_CONFIG_PATH variable." )
+ endif( )
+
+ mark_as_advanced(
+ TMOC_EXECUTABLE
+ MOC_EXECUTABLE
+ UIC_EXECUTABLE
+ )
+
+ # tmoc_executable
+ tde_execute_process(
+ COMMAND pkg-config tqt --variable=tmoc_executable
+ OUTPUT_VARIABLE TMOC_EXECUTABLE
+ CACHE FILEPATH "TQt tmoc executable path"
+ OUTPUT_STRIP_TRAILING_WHITESPACE )
+
+ if( NOT EXISTS ${TMOC_EXECUTABLE} )
+ tde_message_fatal( "tmoc is not found!\n tqt is correctly installed?" )
+ endif( )
+
+ tqt_message( " tmoc path: ${TMOC_EXECUTABLE}" )
+
+
+ # moc_executable
+ tde_execute_process(
+ COMMAND pkg-config tqt --variable=moc_executable
+ OUTPUT_VARIABLE MOC_EXECUTABLE
+ CACHE FILEPATH "TQt moc executable path"
+ OUTPUT_STRIP_TRAILING_WHITESPACE )
+
+ if( NOT EXISTS ${MOC_EXECUTABLE} )
+ tde_message_fatal( "Path to moc is not set.\n tqt is correctly installed?" )
+ endif( )
+
+ tqt_message( " moc path: ${MOC_EXECUTABLE}" )
+
+
+ # uic_executable
+ tde_execute_process(
+ COMMAND pkg-config tqt --variable=uic_executable
+ OUTPUT_VARIABLE UIC_EXECUTABLE
+ CACHE FILEPATH "TQt uic executable path"
+ OUTPUT_STRIP_TRAILING_WHITESPACE )
+
+ if( NOT EXISTS ${UIC_EXECUTABLE} )
+ tde_message_fatal( "uic not found!\n tqt is correctly installed?" )
+ endif( )
+
+ tqt_message( " uic path: ${UIC_EXECUTABLE}" )
+
+
+ # tqt-replace script
+ set( TQT_REPLACE_SCRIPT "${TQT_PREFIX}/bin/tqt-replace"
+ CACHE FILEPATH "TQt replace script path" )
+
+ if( NOT EXISTS ${TQT_REPLACE_SCRIPT} )
+ tde_message_fatal( "tqt-replace not found!\n Check tqt installation." )
+ endif( )
+
+ tqt_message( " tqt-replace path: ${TQT_REPLACE_SCRIPT}" )
+
+
+ # check if tqt is usable
+ tde_save( CMAKE_REQUIRED_INCLUDES CMAKE_REQUIRED_LIBRARIES )
+ set( CMAKE_REQUIRED_INCLUDES ${TQT_INCLUDE_DIRS} )
+ foreach( _dirs ${TQT_LIBRARY_DIRS} )
+ list( APPEND CMAKE_REQUIRED_LIBRARIES "-L${_dirs}" )
+ endforeach()
+ list( APPEND CMAKE_REQUIRED_LIBRARIES ${TQT_LIBRARIES} )
+
+ check_cxx_source_compiles("
+ #include <tqapplication.h>
+ int main(int argc, char **argv) { TQApplication app(argc, argv); return 0; } "
+ HAVE_USABLE_TQT )
+
+ if( NOT HAVE_USABLE_TQT )
+ tde_message_fatal( "Unable to build a simple tqt test." )
+ endif( )
+
+ tde_restore( CMAKE_REQUIRED_INCLUDES CMAKE_REQUIRED_LIBRARIES )
+
+
+ # TQT_CMAKE_DIR
+ if( NOT DEFINED TQT_CMAKE_DIR )
+ set( TQT_CMAKE_DIR "${TQT_LIBDIR}/cmake"
+ CACHE FILEPATH "Path for shared TQt CMake targets" )
+ endif()
+
+
+ # TQT_CXX_FLAGS
+ foreach( _flag ${TQT_CFLAGS} ${TQT_CFLAGS_OTHER} )
+ set( TQT_CXX_FLAGS "${TQT_CXX_FLAGS} ${_flag}" )
+ endforeach()
+ set( TQT_CXX_FLAGS "${TQT_CXX_FLAGS}" CACHE INTERNAL "" )
+
+endif( NOT TQT_FOUND )
+
+# Set compiler flags according to build type
+set( CMAKE_CXX_FLAGS_RELWITHDEBINFO "-DNDEBUG" )
+set( CMAKE_C_FLAGS_RELWITHDEBINFO "-DNDEBUG" )
+
+# Set the required minimum C++ standard
+set( TDE_CXX_FEATURES cxx_nullptr )
diff -Naur orig/modules/FindTQtQUI.cmake tde-cmake-trinity-14.1.3/modules/FindTQtQUI.cmake
--- orig/modules/FindTQtQUI.cmake 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/modules/FindTQtQUI.cmake 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,45 @@
+#################################################
+#
+# (C) 2010-2011 Serghei Amelian
+# serghei (DOT) amelian (AT) gmail.com
+#
+# Improvements and feedback are welcome
+#
+# This file is released under GPL >= 2
+#
+#################################################
+
+macro( tqtqui_message )
+ message( STATUS "${ARGN}" )
+endmacro( )
+
+pkg_search_module( TQTQUI tqtqui )
+
+if( NOT TQTQUI_FOUND )
+ tde_message_fatal( "Unable to find tqtqui!\n Try adding the directory in which the tqtqui.pc file is located\nto the PKG_CONFIG_PATH variable." )
+endif( )
+
+# check if tqtqui is usable
+tde_save( CMAKE_REQUIRED_INCLUDES CMAKE_REQUIRED_LIBRARIES )
+set( CMAKE_REQUIRED_INCLUDES ${TQTQUI_INCLUDE_DIRS} )
+foreach( _dirs ${TQTQUI_LIBRARY_DIRS} )
+ list( APPEND CMAKE_REQUIRED_LIBRARIES "-L${_dirs}" )
+endforeach()
+list( APPEND CMAKE_REQUIRED_LIBRARIES ${TQTQUI_LIBRARIES} )
+
+check_cxx_source_compiles("
+ #include <tqapplication.h>
+ int main(int argc, char **argv) { TQApplication app(argc, argv); return 0; } "
+ HAVE_USABLE_TQTQUI )
+
+if( NOT HAVE_USABLE_TQTQUI )
+ tde_message_fatal( "Unable to build a simple tqtqui test." )
+endif( )
+
+tde_restore( CMAKE_REQUIRED_INCLUDES CMAKE_REQUIRED_LIBRARIES )
+
+
+# TQTQUI_CXX_FLAGS
+foreach( _flag ${TQTQUI_CFLAGS_OTHER} )
+ set( TQTQUI_CXX_FLAGS "${TQTQUI_CXX_FLAGS} ${_flag}" )
+endforeach()
diff -Naur orig/modules/TDEL10n.cmake tde-cmake-trinity-14.1.3/modules/TDEL10n.cmake
--- orig/modules/TDEL10n.cmake 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/modules/TDEL10n.cmake 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,1281 @@
+#################################################
+#
+# (C) 2018-2020 Slávek Banko
+# slavek (DOT) banko (AT) axis.cz
+#
+# Improvements and feedback are welcome
+#
+# This file is released under GPL >= 2
+#
+#################################################
+
+
+##### include essential TDE macros ##############
+
+set( MASTER_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}" )
+include( TDEMacros )
+
+
+##### verify required programs ##################
+
+if( NOT DEFINED TDE_PREFIX AND IS_DIRECTORY /opt/trinity )
+ set( TDE_PREFIX "/opt/trinity" )
+else( )
+ set( TDE_PREFIX "/usr" )
+endif( )
+
+if( NOT DEFINED KDE_XGETTEXT_EXECUTABLE )
+ find_program( KDE_XGETTEXT_EXECUTABLE
+ NAMES kde-xgettext
+ HINTS "${TDE_PREFIX}/bin"
+ )
+ if( "${KDE_XGETTEXT_EXECUTABLE}" STREQUAL "KDE_XGETTEXT_EXECUTABLE-NOTFOUND" )
+ tde_message_fatal( "kde-xgettext is required but not found" )
+ endif( )
+endif( )
+
+if( NOT DEFINED XGETTEXT_EXECUTABLE )
+ find_program( XGETTEXT_EXECUTABLE
+ NAMES xgettext
+ HINTS "${TDE_PREFIX}/bin"
+ )
+ if( "${XGETTEXT_EXECUTABLE}" STREQUAL "XGETTEXT_EXECUTABLE-NOTFOUND" )
+ tde_message_fatal( "xgettext is required but not found" )
+ endif( )
+endif( )
+
+if( NOT DEFINED MSGUNIQ_EXECUTABLE )
+ find_program( MSGUNIQ_EXECUTABLE
+ NAMES msguniq
+ HINTS "${TDE_PREFIX}/bin"
+ )
+ if( "${MSGUNIQ_EXECUTABLE}" STREQUAL "MSGUNIQ_EXECUTABLE-NOTFOUND" )
+ tde_message_fatal( "msguniq is required but not found" )
+ endif( )
+endif( )
+
+if( NOT DEFINED PO4A_GETTEXTIZE_EXECUTABLE )
+ find_program( PO4A_GETTEXTIZE_EXECUTABLE
+ NAMES po4a-gettextize
+ HINTS "${TDE_PREFIX}/bin"
+ )
+ if( "${PO4A_GETTEXTIZE_EXECUTABLE}" STREQUAL "PO4A_GETTEXTIZE_EXECUTABLE-NOTFOUND" )
+ tde_message_fatal( "po4a-gettextize is required but not found" )
+ endif( )
+ execute_process(
+ COMMAND ${PO4A_GETTEXTIZE_EXECUTABLE} --version
+ OUTPUT_VARIABLE _po4a_version
+ ERROR_VARIABLE _po4a_version
+ )
+ string( REGEX REPLACE "^po4a-gettextize[^\n]* ([^ ]*)\n.*" "\\1" _po4a_version ${_po4a_version} )
+ if( "${_po4a_version}" VERSION_LESS "0.45" )
+ tde_message_fatal( "po4a version >= 0.45 is required but found only ${_po4_version}" )
+ endif( )
+endif( )
+
+if( NOT DEFINED TDE_COMMON_TEXTS_POT )
+ get_filename_component( TDE_SOURCE_BASE "${CMAKE_CURRENT_SOURCE_DIR}" ABSOLUTE )
+ while( (NOT EXISTS "${TDE_SOURCE_BASE}/core/tdelibs"
+ OR NOT IS_DIRECTORY "${TDE_SOURCE_BASE}/core/tdelibs" )
+ AND NOT "${TDE_SOURCE_BASE}" STREQUAL "/" )
+ get_filename_component( TDE_SOURCE_BASE "${TDE_SOURCE_BASE}" PATH )
+ endwhile( )
+ find_file( TDE_COMMON_TEXTS_POT
+ NAMES tde.pot
+ HINTS "${TDE_SOURCE_BASE}/core/tdelibs" "${TDE_PREFIX}/include" "${TDE_PREFIX}/include/tde"
+ )
+ if( "${TDE_COMMON_TEXTS_POT}" STREQUAL "TDE_COMMON_TEXTS_POT-NOTFOUND" )
+ tde_message_fatal( "translation template with common texts not found" )
+ endif( )
+endif( )
+
+
+#################################################
+#####
+##### tde_l10n_add_subdirectory
+#####
+##### The function simulates the add_subdirectory() behavior, but
+##### the CMakeL10n.txt file is used instead of CMakeLists.txt.
+#####
+
+function( tde_l10n_add_subdirectory _dir )
+ set( CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/${_dir}" )
+ set( CMAKE_CURRENT_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/${_dir}" )
+ include( ${CMAKE_CURRENT_SOURCE_DIR}/CMakeL10n.txt )
+endfunction( )
+
+
+#################################################
+#####
+##### tde_l10n_auto_add_subdirectories
+#####
+##### The function is equivalent to tde_auto_add_subdirectories, but
+##### the CMakeL10n.txt file is used instead of CMakeLists.txt.
+#####
+
+function( tde_l10n_auto_add_subdirectories )
+ file( GLOB _dirs RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "${CMAKE_CURRENT_SOURCE_DIR}/*" )
+ foreach( _dir ${_dirs} )
+ if( IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${_dir}
+ AND NOT ${_dir} STREQUAL ".svn"
+ AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${_dir}/CMakeL10n.txt )
+ tde_l10n_add_subdirectory( ${_dir} )
+ endif( )
+ endforeach( )
+endfunction( )
+
+
+#################################################
+#####
+##### tde_l10n_create_template
+#####
+##### Macro is used to generate a translation template - POT file.
+#####
+##### Syntax:
+##### tde_l10n_create_template(
+##### [CATALOG] file_name
+##### [SOURCES source_spec [source_spec]]
+##### [COMMENT tag]
+##### [EXCLUDES regex [regex]]
+##### [KEYWORDS keyword [keyword]]
+##### [ATTRIBUTES attrib_spec [attrib_spec]]
+##### [X-POT common_texts.pot]
+##### [DESTINATION directory]
+##### )
+#####
+##### Where:
+##### CATALOG determines the target file name (without pot suffix).
+##### If the name ends with '/', a catalog of the same name
+##### will be created in the specified directory.
+##### SOURCES can be specified by several options:
+##### a) Do not specify anything
+##### - all usual source files will be automatically searched.
+##### b) Enter the directory name - for example, '.' or 'src'
+##### - all the usual source files in the specified directory
+##### and subdirectories will be searched.
+##### c) Enter the mask - for example '*.cpp'
+##### - all files with the specified mask will be searched.
+##### d) Specify the name of the individual file.
+##### The methods from b) to d) can be combined.
+##### EXCLUDES determines which files are to be excluded from processing
+##### COMMENT determines additional comment to extract by xgettext.
+##### KEYWORDS determines additional keywords for xgettext.
+##### Use "-" if is needed to disable default keywords.
+##### ATTRIBUTES determines files and specification for extractattr:
+##### source_spec:element,attribute[,context][[:element,attribute[,context]]...]
+##### X-POT entries from common_texts.pot are not extracted
+##### By default, "tde.pot" is searched for and used.
+##### Use "-" to skip this.
+##### DESTINATION determines directory to save translation template.
+##### The destination directory is determined as follows:
+##### a) Directory is specified as an argument.
+##### b) The variable POT_SOURCE_DIR is set.
+##### c) There is a 'translations' directory.
+##### d) There is a 'po' directory.
+#####
+##### Note:
+##### Editing the _files list inside foreach( ${_files} ) below in the
+##### code is safe, because in CMake foreach parameters are evaluated
+##### before the loop starts. Therefore, the changes in the list inside
+##### the loop do not have an unwanted impact on the loop processing.
+#####
+
+macro( tde_l10n_create_template )
+
+ unset( _catalog )
+ unset( _sources )
+ unset( _excludes )
+ unset( _files )
+ unset( _desktops )
+ unset( _pots )
+ unset( _dest )
+ unset( _keywords_add )
+ unset( _comment )
+ unset( _attributes )
+ unset( _exclude_pots )
+ unset( _pot )
+ unset( _directive )
+ set( _var _catalog )
+ set( _keywords_c_default "i18n" "i18n:1,2" "tr2i18n" "tr2i18n:1,2" "I18N_NOOP" "I18N_NOOP2" )
+ set( _keywords_desktop_default
+ "-" "Name" "GenericName" "Comment" "Keywords"
+ "Description" "ExtraNames" "X-TDE-Submenu" )
+
+ foreach( _arg ${ARGN} )
+
+ # found directive "CATALOG"
+ if( "+${_arg}" STREQUAL "+CATALOG" )
+ unset( _catalog )
+ set( _var _catalog )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "SOURCES"
+ if( "+${_arg}" STREQUAL "+SOURCES" )
+ unset( _sources )
+ set( _var _sources )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "SOURCES_DESKTOP"
+ if( "+${_arg}" STREQUAL "+SOURCES_DESKTOP" )
+ unset( _desktops )
+ set( _var _desktops )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "EXCLUDES"
+ if( "+${_arg}" STREQUAL "+EXCLUDES" )
+ unset( _excludes )
+ set( _var _excludes )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "DESTINATION"
+ if( "+${_arg}" STREQUAL "+DESTINATION" )
+ unset( _dest )
+ set( _var _dest )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "COMMENT"
+ if( "+${_arg}" STREQUAL "+COMMENT" )
+ unset( _comment )
+ set( _var _comment )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "KEYWORDS"
+ if( "+${_arg}" STREQUAL "+KEYWORDS" )
+ unset( _keywords_add )
+ set( _var _keywords_add )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "ATTRIBUTES"
+ if( "+${_arg}" STREQUAL "+ATTRIBUTES" )
+ unset( _attributes )
+ set( _var _attributes )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "X-POT"
+ if( "+${_arg}" STREQUAL "+X-POT" )
+ unset( _exclude_pots )
+ set( _var _exclude_pots )
+ set( _directive 1 )
+ endif( )
+
+ # collect data
+ if( _directive )
+ unset( _directive )
+ elseif( _var )
+ list( APPEND ${_var} ${_arg} )
+ endif( )
+
+ endforeach( )
+
+ # verify catalog
+ if( NOT _catalog )
+ tde_message_fatal( "the name of the translation catalog is not defined" )
+ endif( )
+
+ # determine the destination directory
+ if( NOT _dest )
+ if( POT_SOURCE_DIR )
+ set( _dest ${POT_SOURCE_DIR} )
+ elseif( EXISTS "${MASTER_SOURCE_DIR}/translations" )
+ set( _dest "${MASTER_SOURCE_DIR}/translations/" )
+ elseif( EXISTS "${MASTER_SOURCE_DIR}/po" )
+ set( _dest "${MASTER_SOURCE_DIR}/po/" )
+ else( )
+ tde_message_fatal( "cannot determine destination directory" )
+ endif( )
+ endif( )
+ if( ${_dest} MATCHES "[^/]$" )
+ set( _dest "${_dest}/" )
+ endif( )
+ if( NOT IS_ABSOLUTE ${_dest} )
+ set( _dest "${CMAKE_CURRENT_SOURCE_DIR}/${_dest}" )
+ endif( )
+
+ if( ${_catalog} MATCHES "/$" )
+ string( REGEX REPLACE "/$" "" _catalog "${_catalog}" )
+ get_filename_component( _catalog_base "${_catalog}" NAME )
+ set( _catalog "${_catalog}/${_catalog_base}" )
+ endif( )
+ get_filename_component( _potFilename "${_dest}${_catalog}.pot" ABSOLUTE )
+ file( RELATIVE_PATH _potFilename ${CMAKE_SOURCE_DIR} ${_potFilename} )
+ message( STATUS "Create translation template ${_potFilename}" )
+
+ # verify sources
+ if( NOT _sources AND NOT _attributes AND NOT _desktops )
+ # add current directory
+ list( APPEND _sources "." )
+ endif( )
+ foreach( _src ${_sources} )
+
+ # add all source files from directory
+ if( IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${_src} )
+ if( ${_src} STREQUAL "." )
+ set( _dir "${CMAKE_CURRENT_SOURCE_DIR}" )
+ else( )
+ set( _dir "${CMAKE_CURRENT_SOURCE_DIR}/${_src}" )
+ endif( )
+ file( GLOB_RECURSE _add_files
+ RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+ ${_dir}/*.c
+ ${_dir}/*.cc
+ ${_dir}/*.cpp
+ ${_dir}/*.cxx
+ ${_dir}/*.h
+ ${_dir}/*.hh
+ ${_dir}/*.hpp
+ ${_dir}/*.hxx
+ ${_dir}/*.kcfg
+ ${_dir}/*.rc
+ ${_dir}/*.ui
+ )
+ list( SORT _add_files )
+ list( APPEND _files ${_add_files} )
+
+ # add files by the specified mask
+ elseif( ${_src} MATCHES "(\\*|\\?)" )
+ file( GLOB_RECURSE _add_files
+ RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR}/${_src}
+ )
+ list( SORT _add_files )
+ list( APPEND _files ${_add_files} )
+
+ # add a individual file
+ elseif( EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${_src} )
+ list( APPEND _files ${_src} )
+ endif( )
+
+ endforeach( )
+
+ # filter files by excludes
+ if( _excludes )
+ foreach( _src ${_files} )
+ foreach( _exclude ${_excludes} )
+ if( ${_src} MATCHES ${_exclude} )
+ list( REMOVE_ITEM _files ${_src} )
+ endif( )
+ endforeach( )
+ endforeach( )
+ endif( )
+ if( NOT _files AND NOT _attributes AND NOT _desktops )
+ tde_message_fatal( "no source files found" )
+ endif( )
+
+ # prepare x-pot
+ foreach( _exclude_pot_file ${TDE_COMMON_TEXTS_POT} ${_exclude_pots} )
+ if( "${_exclude_pot_file}" STREQUAL "-" )
+ unset( _exclude_pot )
+ else()
+ if( NOT IS_ABSOLUTE "${_exclude_pot_file}" )
+ set( _exclude_pot_file "${CMAKE_CURRENT_SOURCE_DIR}/${_exclude_pot_file}" )
+ endif()
+ list( APPEND _exclude_pot "-x${_exclude_pot_file}" )
+ endif( )
+ endforeach( )
+
+ # prepare comment
+ if( NOT "${_comment}" STREQUAL "" )
+ if( "${_comment}" STREQUAL "-" OR "${_comment}" STREQUAL "all" )
+ set( _comment "-c" )
+ else( )
+ set( _comment "-c${_comment}" )
+ endif( )
+ endif( )
+
+ # prepare keywords
+ unset( _keywords_c )
+ unset( _keywords_desktop )
+ foreach( _keyword ${_keywords_c_default} ${_keywords_add} )
+ if( "${_keyword}" STREQUAL "-" )
+ unset( _keywords_c )
+ unset( _keyword )
+ endif( )
+ list( APPEND _keywords_c "-k${_keyword}" )
+ endforeach( )
+ foreach( _keyword ${_keywords_desktop_default} ${_keywords_add} )
+ if( "${_keyword}" STREQUAL "-" )
+ unset( _keywords_desktop )
+ unset( _keyword )
+ endif( )
+ if( _keyword )
+ list( APPEND _keywords_desktop "${_keyword}" )
+ endif( )
+ endforeach( )
+
+ # prepare resource files *.kcfg, *.rc and *.ui
+ foreach( _src ${_files} )
+ if( ${_src} MATCHES "\\.(kcfg|rc|ui)(\\.cmake)?$" )
+ set( _src_index 0 )
+ set( _src_l10n "${_src}.tde_l10n" )
+ list( FIND _files "${_src_l10n}" _src_file_index )
+ while( "${_src_file_index}" GREATER -1 )
+ set( _src_l10n "${_src}.tde_l10n${_src_index}" )
+ list( FIND _files "${_src_l10n}" _src_file_index )
+ math( EXPR _src_index "${_src_index}+1" )
+ endwhile( )
+ tde_l10n_prepare_xml( SOURCE ${_src} TARGET ${_src_l10n} )
+ list( REMOVE_ITEM _files ${_src} )
+ list( APPEND _files "${_src_l10n}" )
+ endif( )
+ endforeach( )
+
+ # prepare attributes
+ if( _attributes )
+ foreach( _attrib ${_attributes} )
+ if( ${_attrib} MATCHES "^([^:]+):(.+)$" )
+ string( REGEX REPLACE "^([^:]+):(.+)$" "\\1" _attrib_glob ${_attrib} )
+ string( REGEX REPLACE "^([^:]+):(.+)$" "\\2" _attrib_spec ${_attrib} )
+ file( GLOB_RECURSE _attrib_files
+ RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR}/${_attrib_glob}
+ )
+ if( _excludes )
+ foreach( _src ${_attrib_files} )
+ foreach( _exclude ${_excludes} )
+ if( ${_src} MATCHES ${_exclude} )
+ list( REMOVE_ITEM _attrib_files ${_src} )
+ endif( )
+ endforeach( )
+ endforeach( )
+ endif( )
+ if( _attrib_files )
+ list( SORT _attrib_files )
+ string( REGEX MATCHALL "[^:]+" _attrib_spec "${_attrib_spec}" )
+ foreach( _src ${_attrib_files} )
+ set( _src_index 0 )
+ set( _src_l10n "${_src}.tde_l10n" )
+ list( FIND _files "${_src_l10n}" _src_file_index )
+ while( "${_src_file_index}" GREATER -1 )
+ set( _src_l10n "${_src}.tde_l10n${_src_index}" )
+ list( FIND _files "${_src_l10n}" _src_file_index )
+ math( EXPR _src_index "${_src_index}+1" )
+ endwhile( )
+ tde_l10n_prepare_xmlattr(
+ SOURCE ${_src}
+ TARGET ${_src_l10n}
+ ATTRIBUTES ${_attrib_spec}
+ )
+ list( APPEND _files "${_src_l10n}" )
+ endforeach( )
+ endif( )
+ endif( )
+ endforeach( )
+ endif( )
+
+ # prepare tips
+ foreach( _src ${_files} )
+ if( ${_src} MATCHES "(^|/)tips$" )
+ tde_l10n_preparetips( ${_src} )
+ list( REMOVE_ITEM _files ${_src} )
+ list( APPEND _files "${_src}.tde_l10n" )
+ endif( )
+ endforeach( )
+
+ # prepare documentation
+ foreach( _src ${_files} )
+ if( ${_src} MATCHES "\\.(ad|adoc|docbook|[1-8])(\\.cmake)?$" )
+ if( ${_src} MATCHES "\\.(ad|adoc)(\\.cmake)?$" )
+ set( _doc_format "asciidoc" )
+ elseif( ${_src} MATCHES "\\.(docbook)(\\.cmake)?$" )
+ set( _doc_format "docbook" )
+ elseif( ${_src} MATCHES "\\.([1-8])(\\.cmake)?$" )
+ set( _doc_format "man" )
+ else( )
+ set( _doc_format "text" )
+ endif( )
+ execute_process(
+ COMMAND ${PO4A_GETTEXTIZE_EXECUTABLE}
+ -f ${_doc_format} -m ${_src}
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ OUTPUT_VARIABLE _potDoc
+ )
+ if( _potDoc )
+ string( REPLACE "Content-Type: text/plain; charset=CHARSET" "Content-Type: text/plain; charset=UTF-8" _potDoc "${_potDoc}" )
+ string( REPLACE "Content-Transfer-Encoding: ENCODING" "Content-Transfer-Encoding: 8bit" _potDoc "${_potDoc}" )
+ file( WRITE ${CMAKE_CURRENT_SOURCE_DIR}/${_src}.tde_l10n "${_potDoc}" )
+ list( APPEND _pots ${_src}.tde_l10n )
+ endif( )
+ list( REMOVE_ITEM _files ${_src} )
+ endif( )
+ endforeach( )
+
+ # pick desktop files - *.desktop, *.directory, *.kcsrc, *.protocol, *.theme, *.themerc and eventsrc
+ foreach( _src ${_files} )
+ if( ${_src} MATCHES "\\.(desktop|directory|kcsrc|protocol|theme|themerc)(\\.cmake)?$"
+ OR ${_src} MATCHES "(^|/)eventsrc(\\.cmake)?$" )
+ list( APPEND _desktops ${_src} )
+ list( REMOVE_ITEM _files ${_src} )
+ endif( )
+ endforeach( )
+
+ # pick pot files *.pot
+ foreach( _src ${_files} )
+ if( ${_src} MATCHES "\\.pot(\\.cmake)?(\\.tde_l10n)?$" )
+ list( APPEND _pots ${_src} )
+ list( REMOVE_ITEM _files ${_src} )
+ endif( )
+ endforeach( )
+
+ # add common translator info
+ unset( _tranlatorinfo_pot )
+ if( _files )
+ list( FIND _excludes "_translatorinfo" _translatorinfo_index )
+ if( "${_translatorinfo_index}" LESS 0 )
+ set( _translatorinfo
+ "i18n(\"NAME OF TRANSLATORS\", \"Your names\")\n"
+ "i18n(\"EMAIL OF TRANSLATORS\", \"Your emails\")\n"
+ )
+ file( WRITE ${CMAKE_CURRENT_SOURCE_DIR}/_translatorinfo.tde_l10n ${_translatorinfo} )
+ execute_process(
+ COMMAND ${KDE_XGETTEXT_EXECUTABLE} --foreign-user -C
+ ${_keywords_c} -o - _translatorinfo.tde_l10n
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ OUTPUT_VARIABLE _translatorinfo_pot
+ )
+ file( REMOVE ${CMAKE_CURRENT_SOURCE_DIR}/_translatorinfo.tde_l10n )
+ endif( )
+ endif( )
+
+ # create translation template
+ if( _files )
+ execute_process(
+ COMMAND ${KDE_XGETTEXT_EXECUTABLE} --foreign-user -C
+ ${_comment} ${_keywords_c} ${_exclude_pot} -o - ${_files}
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ OUTPUT_VARIABLE _pot
+ )
+ if( _translatorinfo_pot )
+ if( _pot )
+ set( _pot "${_translatorinfo_pot}\n${_pot}" )
+ else( )
+ set( _pot "${_translatorinfo_pot}" )
+ endif( )
+ endif( )
+ endif( )
+
+ # process desktop files
+ if( _desktops )
+ # prepare desktop files
+ foreach( _src ${_desktops} )
+ tde_l10n_prepare_desktop( ${_src} KEYWORDS ${_keywords_desktop} )
+ list( REMOVE_ITEM _desktops ${_src} )
+ list( APPEND _desktops "${_src}.tde_l10n" )
+ endforeach( )
+
+ # create translation template for desktop files
+ execute_process(
+ COMMAND ${XGETTEXT_EXECUTABLE} --foreign-user
+ --from-code=UTF-8 -C -c -ki18n -o - ${_desktops}
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ OUTPUT_VARIABLE _potDesktop
+ )
+
+ # merge translation templates
+ if( _potDesktop )
+ if( _pot )
+ set( _pot "${_pot}\n${_potDesktop}" )
+ else( )
+ set( _pot "${_potDesktop}" )
+ endif( )
+ endif( )
+ endif( )
+
+ # join additional pot files
+ if( _pots )
+ foreach( _extra_pot IN LISTS _pots )
+ file( READ ${CMAKE_CURRENT_SOURCE_DIR}/${_extra_pot} _extra_pot )
+ if( _extra_pot )
+ if( _pot )
+ set( _pot "${_pot}\n${_extra_pot}" )
+ else( )
+ set( _pot "${_extra_pot}" )
+ endif( )
+ endif( )
+ endforeach( )
+ endif( )
+
+ # finalize translation template
+ if( _pot )
+
+ # set charset and encoding headers
+ string( REPLACE "Content-Type: text/plain; charset=CHARSET" "Content-Type: text/plain; charset=UTF-8" _pot "${_pot}" )
+ string( REPLACE "Content-Transfer-Encoding: ENCODING" "Content-Transfer-Encoding: 8bit" _pot "${_pot}" )
+
+ # update references for resources to original files and line numbers
+ list( FIND _files "extracted-rc.tde_l10n" _extractedRC_index )
+ if( "${_extractedRC_index}" GREATER -1
+ AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/extracted-rc.tde_l10n )
+ file( READ "${CMAKE_CURRENT_SOURCE_DIR}/extracted-rc.tde_l10n" _extractedRC )
+ string( REGEX REPLACE "[^\n]" "" _extractedRC_len "${_extractedRC}" )
+ string( LENGTH "+${_extractedRC_len}" _extractedRC_len )
+ set( _rcPos 0 )
+ while( _rcPos LESS ${_extractedRC_len} )
+ string( REGEX REPLACE "^([^\n]*)\n(.*)" "\\1" _rcLine "${_extractedRC}" )
+ string( REGEX REPLACE "^([^\n]*)\n(.*)" "\\2" _extractedRC "${_extractedRC}" )
+ math( EXPR _rcPos "${_rcPos}+1" )
+ if( "${_rcLine}" MATCHES "^//i18n: file .* line [0-9]*$" )
+ string( REGEX REPLACE "^//i18n: file (.*) line ([0-9]*)$" "\\1:\\2" _rcOrig ${_rcLine} )
+ endif( )
+ if( "${_rcLine}" MATCHES "^i18n\\(" AND _rcOrig )
+ string( REGEX REPLACE "(^|\n)(#:.*) extracted-rc.tde_l10n:${_rcPos}( |\n)" "\\1\\2 ${_rcOrig}\\3" _pot "${_pot}" )
+ unset( _rcOrig )
+ endif( )
+ endwhile( )
+ endif( )
+
+ # update references for modified source files (".tde_l10n" extension)
+ string( REGEX REPLACE "\\.tde_l10n[0-9]*(:[0-9]+)" "\\1" _pot "${_pot}" )
+
+ # merge unique strings
+ string( REGEX REPLACE "\n\n(#[^\n]*\n)*msgid \"\"\nmsgstr \"\"\n(\"[^\n]*\n)*\n" "\n\n" _pot "${_pot}" )
+ file( WRITE ${CMAKE_CURRENT_SOURCE_DIR}/extracted-pot.tmp "${_pot}" )
+ execute_process(
+ COMMAND ${MSGUNIQ_EXECUTABLE}
+ INPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/extracted-pot.tmp
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ OUTPUT_VARIABLE _pot
+ )
+ file( REMOVE ${CMAKE_CURRENT_SOURCE_DIR}/extracted-pot.tmp )
+ string( REGEX REPLACE "(^|\n)#.? #-#-#-#-# [^\n]* #-#-#-#-#\n" "\\1" _pot "${_pot}" )
+
+ # replace the references for _translatorinfo with instructions in the comment
+ string( REGEX REPLACE
+ "(^|\n)(#:[^\n]*) _translatorinfo:1($|[^\n]*)"
+ "\\1#. Instead of a literal translation, add your name to the end of the list (separated by a comma).\n\\2\\3\n#, ignore-inconsistent"
+ _pot "${_pot}"
+ )
+ string( REGEX REPLACE
+ "(^|\n)(#:[^\n]*) _translatorinfo:2($|[^\n]*)"
+ "\\1#. Instead of a literal translation, add your email to the end of the list (separated by a comma).\n\\2\\3\n#, ignore-inconsistent"
+ _pot "${_pot}"
+ )
+ string( REGEX REPLACE "(^|\n)#:($|\n)" "\\1" _pot "${_pot}" )
+
+ # save translation template
+ if( EXISTS "${_dest}${_catalog}.pot" )
+ file( READ "${_dest}${_catalog}.pot" _potOrig )
+ else( )
+ unset( _potOrig )
+ endif( )
+ if( _potOrig )
+ string( REGEX REPLACE "\n\"POT-Creation-Date: [^\"]*\"\n" "" _potOrig "${_potOrig}" )
+ string( REGEX REPLACE "\n\"POT-Creation-Date: [^\"]*\"\n" "" _potNew "${_pot}" )
+ endif( )
+ if( NOT _potOrig OR NOT "${_potNew}" STREQUAL "${_potOrig}" )
+ file( WRITE "${_dest}${_catalog}.pot" "${_pot}" )
+ endif( )
+
+ endif( _pot )
+
+ # cleanup
+ foreach( _file ${_files} ${_desktops} ${_pots} )
+ if( "${_file}" MATCHES "\\.tde_l10n[0-9]*$" )
+ file( REMOVE ${CMAKE_CURRENT_SOURCE_DIR}/${_file} )
+ endif( )
+ endforeach( )
+
+endmacro( )
+
+
+#################################################
+#####
+##### tde_l10n_preparetips
+#####
+##### Macro is used to prepare tips file for xgettext
+#####
+
+macro( tde_l10n_preparetips _tips )
+
+ tde_l10n_prepare_xml(
+ SOURCE ${_tips}
+ TAGS html
+ C_FORMAT
+ PRESERVE entities line-wrap spaces-leading spaces-trailing spaces-multi
+ )
+
+endmacro( )
+
+
+#################################################
+#####
+##### tde_l10n_prepare_xml
+#####
+##### The function is used to prepare XML file for xgettext.
+##### The default settings are identical to extractrc.
+#####
+
+function( tde_l10n_prepare_xml )
+
+ unset( _source )
+ unset( _target )
+ unset( _context )
+ set( _skip_properties "database|associations|populationText" )
+ set( _tags "[tT][eE][xX][tT]|title|string|whatsthis|tooltip|label" )
+ set( _preserve "line-wrap" "lines-leading" "lines-multi" "spaces-leading" "spaces-trailing" "spaces-multi" )
+ set( _no_c_format 1 )
+ unset( _directive )
+ set( _var _source )
+
+ foreach( _arg ${ARGN} )
+
+ # found directive "SOURCE"
+ if( "+${_arg}" STREQUAL "+SOURCE" )
+ unset( _source )
+ set( _var _source )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "TARGET"
+ if( "+${_arg}" STREQUAL "+TARGET" )
+ unset( _target )
+ set( _var _target )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "CONTEXT"
+ if( "+${_arg}" STREQUAL "+CONTEXT" )
+ unset( _context )
+ set( _var _context )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "SKIP-PROPERTIES"
+ if( "+${_arg}" STREQUAL "+SKIP-PROPERTIES" )
+ unset( _skip_properties )
+ set( _var _skip_properties )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "TAGS"
+ if( "+${_arg}" STREQUAL "+TAGS" )
+ unset( _tags )
+ set( _var _tags )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "PRESERVE"
+ if( "+${_arg}" STREQUAL "+PRESERVE" )
+ unset( _preserve )
+ set( _var _preserve )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "C_FORMAT"
+ if( "+${_arg}" STREQUAL "+C_FORMAT" )
+ unset( _no_c_format )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "NO_C_FORMAT"
+ if( "+${_arg}" STREQUAL "+NO_C_FORMAT" )
+ set( _no_c_format 1 )
+ set( _directive 1 )
+ endif( )
+
+ # collect data
+ if( _directive )
+ unset( _directive )
+ elseif( _var )
+ list( APPEND ${_var} ${_arg} )
+ endif( )
+
+ endforeach( )
+
+ # verify source
+ if( NOT _source )
+ tde_message_fatal( "no source XML file" )
+ endif( )
+ if( NOT IS_ABSOLUTE "${_source}" )
+ set( _source "${CMAKE_CURRENT_SOURCE_DIR}/${_source}" )
+ endif( )
+ if( NOT _target )
+ set( _target "${_source}.tde_l10n" )
+ endif( )
+ if( NOT IS_ABSOLUTE "${_target}" )
+ set( _target "${CMAKE_CURRENT_SOURCE_DIR}/${_target}" )
+ endif( )
+
+ # prepare tags to regexp
+ string( REPLACE ";" "|" _tags "${_tags}" )
+ if( "${_skip_properties}" STREQUAL "-" )
+ unset( _skip_properties )
+ endif( )
+ if( DEFINED _skip_properties )
+ string( REPLACE ";" "|" _skip_properties "${_skip_properties}" )
+ set( _tags "property|${_tags}" )
+ endif( )
+
+ # read file
+ file( READ ${_source} _xml_data )
+ string( REGEX REPLACE "[^\n]" "" _xml_len ${_xml_data} )
+ string( LENGTH "+${_xml_len}" _xml_len )
+
+ # process lines
+ set( _xml_pos 0 )
+ unset( _xml_l10n )
+ unset( _xml_inside )
+ unset( _xml_tag_empty )
+ unset( _xml_skipped_prop )
+ while( _xml_pos LESS ${_xml_len} )
+ # pick line
+ string( REGEX REPLACE "^([^\n]*)\n(.*)" "\\1" _xml_line "${_xml_data}" )
+ string( REGEX REPLACE "^([^\n]*)\n(.*)" "\\2" _xml_data "${_xml_data}" )
+ math( EXPR _xml_pos "${_xml_pos}+1" )
+ set( _xml_newline 1 )
+
+ # process tags on line
+ while( _xml_newline OR NOT "${_xml_line}" STREQUAL "" )
+ unset( _xml_newline )
+ unset( _xml_line_prefix )
+ unset( _xml_line_suffix )
+ unset( _xml_line_rest )
+ if( NOT _xml_inside )
+ if( _xml_skipped_prop AND "${_xml_line}" MATCHES "</property>" )
+ unset( _xml_skipped_prop )
+ string( REGEX MATCH "</property>(.*)" _xml_line "${_xml_line}" )
+ string( REGEX REPLACE "^</property>(.*)" "\\1" _xml_line "${_xml_line}" )
+ endif( )
+ if( NOT _xml_skipped_prop AND "${_xml_line}" MATCHES "<(${_tags})([ \t][^>]*)*>" )
+ string( REGEX MATCH "<(${_tags})([ \t][^>]*)*>(.*)" _xml_line "${_xml_line}" )
+ string( REGEX MATCH "^<(${_tags})([ \t][^>]*)*>" _xml_attr "${_xml_line}" )
+ string( REGEX REPLACE "^<(${_tags})([ \t][^>]*)*>(.*)" "\\3" _xml_line "${_xml_line}" )
+ if( "${_xml_attr}" MATCHES "^<property([ \t][^>]*)*>" AND DEFINED _skip_properties )
+ if( "${_xml_attr}" MATCHES "[ \t]name=\"(${_skip_properties})\"" )
+ set( _xml_skipped_prop 1 )
+ endif( )
+ set( _xml_line_rest "${_xml_line}" )
+ set( _xml_line "" )
+ else( )
+ set( _xml_inside 1 )
+ set( _xml_context "${_context}" )
+ if( "${_xml_attr}" MATCHES "[ \t]context=\"([^\"]*)\"" )
+ string( REGEX REPLACE ".* context=\"([^\"]*)\".*" "\\1" _xml_context "${_xml_attr}" )
+ endif( )
+ set( _xml_line_prefix "i18n(" )
+ if( _no_c_format )
+ set( _xml_line_prefix "${_xml_line_prefix}/* xgettext: no-c-format */" )
+ endif( )
+ if( _xml_context )
+ set( _xml_line_prefix "${_xml_line_prefix}\"${_xml_context}\", " )
+ endif( )
+ set( _xml_tag_empty 1 )
+ endif( )
+ else( )
+ set( _xml_line "" )
+ endif( )
+ endif( )
+
+ if( _xml_inside )
+ if( "${_xml_line}" MATCHES "</(${_tags})>" )
+ unset( _xml_inside )
+ string( REGEX REPLACE "</(${_tags})>(.*)" "\\2" _xml_line_rest "${_xml_line}" )
+ string( REGEX REPLACE "</(${_tags})>(.*)" "" _xml_line "${_xml_line}" )
+ set( _xml_line_suffix ");" )
+ endif( )
+
+ string( REGEX REPLACE "\\\\" "\\\\\\\\" _xml_line "${_xml_line}" )
+ string( REGEX REPLACE "\\\"" "\\\\\"" _xml_line "${_xml_line}" )
+ string( REGEX REPLACE "\t" "\\\\t" _xml_line "${_xml_line}" )
+ if( NOT ";${_preserve};" MATCHES ";entities;" )
+ string( REGEX REPLACE "&lt;" "<" _xml_line "${_xml_line}" )
+ string( REGEX REPLACE "&gt;" ">" _xml_line "${_xml_line}" )
+ string( REGEX REPLACE "&amp;" "&" _xml_line "${_xml_line}" )
+ endif( )
+ if( NOT ";${_preserve};" MATCHES ";spaces-leading;" )
+ string( REGEX REPLACE "^ +" "" _xml_line "${_xml_line}" )
+ endif( )
+ if( NOT ";${_preserve};" MATCHES ";spaces-trailing;" )
+ string( REGEX REPLACE " +$" "" _xml_line "${_xml_line}" )
+ endif( )
+ if( NOT ";${_preserve};" MATCHES ";spaces-multi;" )
+ string( REGEX REPLACE " +" " " _xml_line "${_xml_line}" )
+ endif( )
+
+ if( _xml_inside )
+ if( ";${_preserve};" MATCHES ";line-wrap;" )
+ if( NOT "${_xml_line}" STREQUAL ""
+ OR ( ";${_preserve};" MATCHES ";lines-leading;" AND _xml_tag_empty )
+ OR ( ";${_preserve};" MATCHES ";lines-multi;" AND NOT _xml_tag_empty ) )
+ set( _xml_line "${_xml_line}\\n" )
+ endif( )
+ elseif( NOT "${_xml_line}" STREQUAL "" AND NOT _xml_tag_empty )
+ set( _xml_line " ${_xml_line}" )
+ endif( )
+ endif( )
+ if( NOT "${_xml_line}" STREQUAL "" )
+ unset( _xml_tag_empty )
+ endif( )
+ endif( )
+
+ # drop empty tag on single line
+ if( _xml_line_prefix AND _xml_line_suffix AND _xml_tag_empty )
+ # skip empty string for translation
+
+ # add current tag to output
+ else( )
+ set( _xml_l10n "${_xml_l10n}${_xml_line_prefix}" )
+ if( NOT "${_xml_line}" STREQUAL "" OR ( _xml_line_suffix AND _xml_tag_empty ) )
+ set( _xml_l10n "${_xml_l10n}\"${_xml_line}\"" )
+ endif( )
+ set( _xml_l10n "${_xml_l10n}${_xml_line_suffix}" )
+ endif( )
+
+ # take the rest of the line for processing
+ set( _xml_line "${_xml_line_rest}" )
+ endwhile( )
+ set( _xml_l10n "${_xml_l10n}\n" )
+ endwhile( )
+
+ # write file
+ file( WRITE ${_target} "${_xml_l10n}" )
+
+endfunction( )
+
+
+#################################################
+#####
+##### tde_l10n_prepare_xmlattr
+#####
+##### The function is used to prepare attributes in XML file
+##### for xgettext, comparable to extractattr.
+#####
+
+function( tde_l10n_prepare_xmlattr )
+
+ unset( _source )
+ unset( _target )
+ unset( _context )
+ unset( _attribs )
+ unset( _directive )
+ set( _preserve "line-wrap" "lines-leading" "spaces-leading" "spaces-trailing" "spaces-multi" )
+ set( _var _source )
+
+ foreach( _arg ${ARGN} )
+
+ # found directive "SOURCE"
+ if( "+${_arg}" STREQUAL "+SOURCE" )
+ unset( _source )
+ set( _var _source )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "TARGET"
+ if( "+${_arg}" STREQUAL "+TARGET" )
+ unset( _target )
+ set( _var _target )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "CONTEXT"
+ if( "+${_arg}" STREQUAL "+CONTEXT" )
+ unset( _context )
+ set( _var _context )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "ATTRIBUTES"
+ if( "+${_arg}" STREQUAL "+ATTRIBUTES" )
+ unset( _attribs )
+ set( _var _attribs )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "PRESERVE"
+ if( "+${_arg}" STREQUAL "+PRESERVE" )
+ unset( _preserve )
+ set( _var _preserve )
+ set( _directive 1 )
+ endif( )
+
+ # collect data
+ if( _directive )
+ unset( _directive )
+ elseif( _var )
+ list( APPEND ${_var} ${_arg} )
+ endif( )
+
+ endforeach( )
+
+ # verify source
+ if( NOT _source )
+ tde_message_fatal( "no source XML file" )
+ endif( )
+ if( NOT IS_ABSOLUTE "${_source}" )
+ set( _source "${CMAKE_CURRENT_SOURCE_DIR}/${_source}" )
+ endif( )
+ if( NOT _target )
+ set( _target "${_source}.tde_l10n" )
+ endif( )
+ if( NOT IS_ABSOLUTE "${_target}" )
+ set( _target "${CMAKE_CURRENT_SOURCE_DIR}/${_target}" )
+ endif( )
+
+ # prepare tags to regexp
+ if( NOT _attribs )
+ tde_message_fatal( "no attributes specified" )
+ endif( )
+ unset( _tags )
+ foreach( _attrib ${_attribs} )
+ string( REGEX REPLACE "^([^,]+),.*" "\\1" _tag "${_attrib}" )
+ list( APPEND _tags "${_tag}" )
+ endforeach( )
+ list( REMOVE_DUPLICATES _tags )
+ string( REPLACE ";" "|" _tags "${_tags}" )
+
+ # read file
+ file( READ ${_source} _xml_data )
+ string( REGEX REPLACE "[^\n]" "" _xml_len ${_xml_data} )
+ string( LENGTH "+${_xml_len}" _xml_len )
+
+ # process lines
+ set( _xml_pos 0 )
+ unset( _xml_l10n )
+ unset( _xml_inside_tag )
+ unset( _xml_inside_attrib )
+ unset( _xml_attrib_empty )
+ while( _xml_pos LESS ${_xml_len} )
+ # pick line
+ string( REGEX REPLACE "^([^\n]*)\n(.*)" "\\1" _xml_line "${_xml_data}" )
+ string( REGEX REPLACE "^([^\n]*)\n(.*)" "\\2" _xml_data "${_xml_data}" )
+ math( EXPR _xml_pos "${_xml_pos}+1" )
+ set( _xml_newline 1 )
+
+ # process tags on line
+ while( _xml_newline OR NOT "${_xml_line}" STREQUAL "" )
+ unset( _xml_line_rest )
+ if( NOT _xml_inside_tag )
+ if( "${_xml_line}" MATCHES "<(${_tags})([ \t\n][^>]*|$)" )
+ set( _xml_inside_tag 1 )
+ string( REGEX MATCH "<(${_tags})([ \t\n][^>]*|$)(.*)" _xml_line "${_xml_line}" )
+ string( REGEX REPLACE "^<(${_tags})[ \t\n]*.*" "\\1" _xml_tag "${_xml_line}" )
+ string( REGEX REPLACE "^<(${_tags})[ \t\n]*" "" _xml_line "${_xml_line}" )
+ unset( _tag_attribs )
+ foreach( _attrib ${_attribs} )
+ if( "${_attrib}" MATCHES "^${_xml_tag}," )
+ string( REGEX REPLACE "^([^,]+),([^,]+),?(.*)" "\\2" _attrib "${_attrib}" )
+ list( APPEND _tag_attribs "${_attrib}" )
+ endif( )
+ endforeach( )
+ string( REPLACE ";" "|" _tag_attribs "${_tag_attribs}" )
+ unset( _xml_inside_attrib )
+ else( )
+ set( _xml_line "" )
+ endif( )
+ endif( )
+
+ if( _xml_inside_tag )
+ if( "${_xml_line}" MATCHES "^(([ \t]*[^>=]+=\"[^\"]*\")*)[ \t]*/?>" )
+ unset( _xml_inside_tag )
+ string( REGEX REPLACE "^(([ \t]*[^>=]+=\"[^\"]*\")*)[ \t]*/?>(.*)" "\\3" _xml_line_rest "${_xml_line}" )
+ string( REGEX REPLACE "^(([ \t]*[^>=]+=\"[^\"]*\")*)[ \t]*/?>(.*)" "\\1" _xml_line "${_xml_line}" )
+ endif( )
+
+ # process attribs on line
+ set( _xml_attrib_line "${_xml_line}" )
+ while( _xml_newline OR NOT "${_xml_attrib_line}" STREQUAL "" )
+ unset( _xml_newline )
+ unset( _xml_line_prefix )
+ unset( _xml_line_suffix )
+ unset( _xml_attrib_line_rest )
+
+ if( NOT _xml_inside_attrib )
+ if( "${_xml_attrib_line}" MATCHES "(^|[ \t]+)(${_tag_attribs})=\"" )
+ set( _xml_inside_attrib 1 )
+ string( REGEX MATCH "(^|[ \t]+)(${_tag_attribs})=\"(.*)" _xml_attrib_line "${_xml_attrib_line}" )
+ string( REGEX REPLACE "^[ \t]*(${_tag_attribs})=\".*" "\\1" _xml_attrib "${_xml_attrib_line}" )
+ string( REGEX REPLACE "^[ \t]*(${_tag_attribs})=\"" "" _xml_attrib_line "${_xml_attrib_line}" )
+ set( _xml_context "${_context}" )
+ foreach( _attrib ${_attribs} )
+ if( "${_attrib}" MATCHES "^${_xml_tag},${_xml_attrib}," )
+ string( REGEX REPLACE "^([^,]+),([^,]+),?(.*)" "\\3" _xml_context "${_attrib}" )
+ endif( )
+ endforeach( )
+ set( _xml_line_prefix "i18n(" )
+ if( _xml_context )
+ set( _xml_line_prefix "${_xml_line_prefix}\"${_xml_context}\", " )
+ endif( )
+ set( _xml_attrib_empty 1 )
+ else( )
+ set( _xml_attrib_line "" )
+ endif( )
+ endif( )
+
+ if( _xml_inside_attrib )
+ if( "${_xml_attrib_line}" MATCHES "\"" )
+ unset( _xml_inside_attrib )
+ string( REGEX REPLACE "\"(.*)" "\\1" _xml_attrib_line_rest "${_xml_attrib_line}" )
+ string( REGEX REPLACE "\"(.*)" "" _xml_attrib_line "${_xml_attrib_line}" )
+ set( _xml_line_suffix ");" )
+ endif( )
+
+ string( REGEX REPLACE "\\\\" "\\\\\\\\" _xml_attrib_line "${_xml_attrib_line}" )
+ string( REGEX REPLACE "\\\"" "\\\\\"" _xml_attrib_line "${_xml_attrib_line}" )
+ string( REGEX REPLACE "\t" "\\\\t" _xml_attrib_line "${_xml_attrib_line}" )
+ if( NOT ";${_preserve};" MATCHES ";entities;" )
+ string( REGEX REPLACE "&lt;" "<" _xml_attrib_line "${_xml_attrib_line}" )
+ string( REGEX REPLACE "&gt;" ">" _xml_attrib_line "${_xml_attrib_line}" )
+ string( REGEX REPLACE "&amp;" "&" _xml_attrib_line "${_xml_attrib_line}" )
+ endif( )
+ if( NOT ";${_preserve};" MATCHES ";spaces-leading;" )
+ string( REGEX REPLACE "^ +" "" _xml_attrib_line "${_xml_attrib_line}" )
+ endif( )
+ if( NOT ";${_preserve};" MATCHES ";spaces-trailing;" )
+ string( REGEX REPLACE " +$" "" _xml_attrib_line "${_xml_attrib_line}" )
+ endif( )
+ if( NOT ";${_preserve};" MATCHES ";spaces-multi;" )
+ string( REGEX REPLACE " +" " " _xml_attrib_line "${_xml_attrib_line}" )
+ endif( )
+
+ if( NOT "${_xml_inside_attrib}" STREQUAL "" )
+ if( ";${_preserve};" MATCHES ";line-wrap;" )
+ if( ";${_preserve};" MATCHES ";lines-leading;"
+ OR NOT "${_xml_attrib_line}" STREQUAL "" OR NOT _xml_attrib_empty )
+ set( _xml_attrib_line "${_xml_attrib_line}\\n" )
+ endif( )
+ elseif( NOT "${_xml_attrib_line}" STREQUAL "" AND NOT _xml_attrib_empty )
+ set( _xml_attrib_line " ${_xml_attrib_line}" )
+ endif( )
+ endif( )
+ if( NOT "${_xml_attrib_line}" STREQUAL "" )
+ unset( _xml_attrib_empty )
+ endif( )
+ endif( )
+
+ # drop empty attrib on single line
+ if( _xml_line_prefix AND _xml_line_suffix AND _xml_attrib_empty )
+ # skip empty translation
+
+ # add current attrib to output
+ else( )
+ set( _xml_l10n "${_xml_l10n}${_xml_line_prefix}" )
+ if( NOT "${_xml_attrib_line}" STREQUAL "" OR ( _xml_line_suffix AND _xml_attrib_empty ) )
+ set( _xml_l10n "${_xml_l10n}\"${_xml_attrib_line}\"" )
+ endif( )
+ set( _xml_l10n "${_xml_l10n}${_xml_line_suffix}" )
+ endif( )
+
+ # take the rest of the line for processing
+ set( _xml_attrib_line "${_xml_attrib_line_rest}" )
+ endwhile( )
+ endif( )
+
+ # take the rest of the line for processing
+ unset( _xml_newline )
+ set( _xml_line "${_xml_line_rest}" )
+ endwhile( )
+ set( _xml_l10n "${_xml_l10n}\n" )
+ endwhile( )
+
+ # write file
+ file( WRITE ${_target} "${_xml_l10n}" )
+
+endfunction( )
+
+
+#################################################
+#####
+##### tde_l10n_prepare_desktop
+#####
+##### The function is used to prepare desktop style file
+##### for xgettext.
+#####
+##### Note: gettext >= 0.19 includes support for extracting
+##### strings from desktop files, but there are some drawbacks.
+#####
+
+function( tde_l10n_prepare_desktop )
+
+ unset( _source )
+ unset( _target )
+ unset( _keywords )
+ unset( _directive )
+ set( _var _source )
+
+ foreach( _arg ${ARGN} )
+
+ # found directive "SOURCE"
+ if( "+${_arg}" STREQUAL "+SOURCE" )
+ unset( _source )
+ set( _var _source )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "TARGET"
+ if( "+${_arg}" STREQUAL "+TARGET" )
+ unset( _target )
+ set( _var _target )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "KEYWORDS"
+ if( "+${_arg}" STREQUAL "+KEYWORDS" )
+ unset( _keywords )
+ set( _var _keywords )
+ set( _directive 1 )
+ endif( )
+
+ # collect data
+ if( _directive )
+ unset( _directive )
+ elseif( _var )
+ list( APPEND ${_var} ${_arg} )
+ endif( )
+
+ endforeach( )
+
+ # verify source
+ if( NOT _source )
+ tde_message_fatal( "no source desktop file" )
+ endif( )
+ if( NOT IS_ABSOLUTE "${_source}" )
+ set( _source "${CMAKE_CURRENT_SOURCE_DIR}/${_source}" )
+ endif( )
+ if( NOT _target )
+ set( _target "${_source}.tde_l10n" )
+ endif( )
+ if( NOT IS_ABSOLUTE "${_target}" )
+ set( _target "${CMAKE_CURRENT_SOURCE_DIR}/${_target}" )
+ endif( )
+
+ # prepare keywords
+ if( NOT _keywords )
+ tde_message_fatal( "the keywords whose strings are to be extracted are not specified" )
+ endif( )
+ string( REPLACE ";" "|" _keywords_match "(${_keywords})" )
+
+ # read file
+ file( READ ${_source} _desktop_data )
+ string( REGEX REPLACE "[^\n]" "" _desktop_len ${_desktop_data} )
+ string( LENGTH "+${_desktop_len}" _desktop_len )
+
+ # process lines
+ set( _desktop_pos 0 )
+ unset( _desktop_l10n )
+ while( _desktop_pos LESS ${_desktop_len} )
+ # pick line
+ string( REGEX REPLACE "^([^\n]*)\n(.*)" "\\1" _desktop_line "${_desktop_data}" )
+ string( REGEX REPLACE "^([^\n]*)\n(.*)" "\\2" _desktop_data "${_desktop_data}" )
+ math( EXPR _desktop_pos "${_desktop_pos}+1" )
+
+ # process line
+ if( "${_desktop_line}" MATCHES "^${_keywords_match}[ ]*=" )
+ string( REGEX REPLACE "\\\"" "\\\\\"" _desktop_line "${_desktop_line}" )
+ string( REGEX REPLACE "^${_keywords_match}[ ]*=[ ]*([^\n]*)" "/*\\1*/i18n(\"\\2\");" _desktop_line "${_desktop_line}" )
+ else( )
+ set( _desktop_line "" )
+ endif( )
+ set( _desktop_l10n "${_desktop_l10n}${_desktop_line}\n" )
+ endwhile( )
+
+ # write file
+ file( WRITE ${_target} "${_desktop_l10n}" )
+
+endfunction( )
diff -Naur orig/modules/TDEMacros.cmake tde-cmake-trinity-14.1.3/modules/TDEMacros.cmake
--- orig/modules/TDEMacros.cmake 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/modules/TDEMacros.cmake 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,3257 @@
+#################################################
+#
+# (C) 2010-2012 Serghei Amelian
+# serghei (DOT) amelian (AT) gmail.com
+#
+# (C) 2011-2012 Timothy Pearson
+# kb9vqf (AT) pearsoncomputing.net
+#
+# (C) 2012-2020 Slávek Banko
+# slavek (DOT) banko (AT) axis.cz
+#
+# Improvements and feedback are welcome
+#
+# This file is released under GPL >= 2
+#
+#################################################
+
+
+#################################################
+#####
+##### Need cmake minimum version
+
+include( TDEVersion )
+
+
+#################################################
+#####
+##### initialization...
+
+if( NOT TDE_CMAKE_ROOT )
+ if( "${CMAKE_VERSION}" VERSION_LESS "${TDE_CMAKE_MINIMUM_VERSION}" )
+ message( FATAL_ERROR "CMake >= ${TDE_CMAKE_MINIMUM_VERSION} required" )
+ endif()
+
+ if( ${CMAKE_CURRENT_LIST_DIR} STREQUAL ${CMAKE_ROOT}/Modules )
+
+ # TDE CMake is installed in the system directory
+ set( TDE_CMAKE_ROOT ${CMAKE_ROOT}
+ CACHE FILEPATH "TDE CMake root" )
+ set( TDE_CMAKE_MODULES ${TDE_CMAKE_ROOT}/Modules
+ CACHE FILEPATH "TDE CMake modules" )
+ set( TDE_CMAKE_TEMPLATES ${TDE_CMAKE_ROOT}/Templates
+ CACHE FILEPATH "TDE CMake templates" )
+
+ else()
+
+ # TDE CMake is part of the source code
+ get_filename_component( TDE_CMAKE_ROOT ${CMAKE_CURRENT_LIST_DIR} PATH )
+ set( TDE_CMAKE_ROOT ${TDE_CMAKE_ROOT}
+ CACHE FILEPATH "TDE CMake root" )
+ set( TDE_CMAKE_MODULES ${TDE_CMAKE_ROOT}/modules
+ CACHE FILEPATH "TDE CMake modules" )
+ set( TDE_CMAKE_TEMPLATES ${TDE_CMAKE_ROOT}/templates
+ CACHE FILEPATH "TDE CMake templates" )
+
+ endif()
+
+
+ option( FORCE_COLORED_OUTPUT "Always produce ANSI-colored output (GNU/Clang only)." FALSE )
+ if( ${FORCE_COLORED_OUTPUT} )
+ if( "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" )
+ if( NOT "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "4.9" )
+ add_compile_options (-fdiagnostics-color=always)
+ endif()
+ elseif( "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" )
+ add_compile_options (-fcolor-diagnostics)
+ endif()
+ endif()
+
+endif()
+
+
+#################################################
+#####
+##### set necessary CMake policies
+
+cmake_policy( PUSH )
+if( POLICY CMP0057 )
+ # necessary for CheckLinkerFlag
+ cmake_policy( SET CMP0057 NEW )
+endif()
+
+
+#################################################
+#####
+##### necessary includes
+
+include( CheckCXXCompilerFlag )
+include( CheckCXXSourceCompiles )
+include( CheckLinkerFlag OPTIONAL )
+include( CheckSymbolExists )
+include( CheckTypeSize )
+
+
+#################################################
+#####
+##### tde_concat_msg
+
+macro( tde_concat_msg _msg )
+ unset( ${_msg} )
+ foreach( _arg ${ARGN} )
+ string( APPEND ${_msg} " ${_arg}\n" )
+ endforeach()
+endmacro( tde_concat_msg )
+
+
+#################################################
+#####
+##### tde_message_author_warning
+
+function( tde_message_author_warning )
+ tde_concat_msg( _msg ${ARGV} )
+ message( AUTHOR_WARNING
+ "-------------------------------------------------\n"
+ "${_msg}"
+ "-------------------------------------------------" )
+endfunction( tde_message_author_warning )
+
+
+#################################################
+#####
+##### tde_message_fatal
+
+macro( tde_message_fatal )
+ tde_concat_msg( _msg ${ARGV} )
+
+ message( FATAL_ERROR
+ "#################################################\n"
+ "${_msg}"
+ "#################################################" )
+endmacro( tde_message_fatal )
+
+
+#################################################
+#####
+##### tde_get_arg( <ARG_NAME> <COUNT> <RETURN> <REST> <ARGS...> )
+##### ARG_NAME(string): name of an argument to find in ARGS
+##### COUNT(number): argument dimension, a number of items returned in RETURN
+##### RETURN(list ref): items returned for argument as they found in ARGS
+##### REST(list ref): rest of items except argument name and items returned in RETURN
+##### ARGS(list): source list of arguments
+
+macro( tde_get_arg ARG_NAME COUNT RETURN REST )
+ unset( ${RETURN} )
+ unset( ${REST} )
+ list( APPEND ${REST} ${ARGN} )
+ list( FIND ${REST} ${ARG_NAME} _arg_idx)
+ if( NOT ${_arg_idx} EQUAL -1 )
+ list( REMOVE_AT ${REST} ${_arg_idx} )
+ set( _i 0 )
+ while( ${_i} LESS ${COUNT} )
+ list( GET ${REST} ${_arg_idx} _arg )
+ list( REMOVE_AT ${REST} ${_arg_idx} )
+ list( APPEND ${RETURN} ${_arg} )
+ math( EXPR _i "${_i} + 1" )
+ endwhile()
+ endif()
+endmacro( tde_get_arg )
+
+
+################################################
+#####
+##### tde_execute_process( <ARGS...> [MESSAGE <MSG>] )
+##### MSG: fatal error message (standard message will be written if not supplied)
+##### ARGS: execute_process arguments
+
+macro( tde_execute_process )
+ tde_get_arg( MESSAGE 1 _message _rest_args ${ARGV} )
+ tde_get_arg( RESULT_VARIABLE 1 _result_variable _tmp ${_rest_args} )
+ tde_get_arg( COMMAND 1 _command _tmp ${_rest_args} )
+ tde_get_arg( OUTPUT_VARIABLE 1 _output_variable _tmp ${_rest_args} )
+ tde_get_arg( CACHE 3 _cache _rest_args2 ${_rest_args} )
+
+ # handle optional FORCE parameter
+ if( DEFINED _cache )
+ list( GET _cache 2 _tmp )
+ if( _tmp STREQUAL FORCE )
+ set( _rest_args ${_rest_args2} )
+ else()
+ tde_get_arg( CACHE 2 _cache _rest_args ${_rest_args} )
+ endif()
+ endif()
+
+ if( NOT DEFINED _result_variable )
+ list( APPEND _rest_args RESULT_VARIABLE _exec_result )
+ set( _result_variable _exec_result )
+ endif()
+
+ execute_process( ${_rest_args} )
+
+ if( DEFINED _output_variable AND DEFINED _cache )
+ set( ${_output_variable} ${${_output_variable}} CACHE ${_cache} )
+ endif()
+
+ if( ${_result_variable} )
+ if( DEFINED _message )
+ tde_message_fatal( ${_message} )
+ else()
+ if( ${${_result_variable}} MATCHES "^[0-9]+$" )
+ set( ${_result_variable} "status ${${_result_variable}} returned!" )
+ endif()
+ tde_message_fatal( "Error executing '${_command}': ${${_result_variable}}" )
+ endif()
+ endif()
+endmacro( tde_execute_process )
+
+
+################################################
+#####
+##### tde_read_src_metadata
+
+macro( tde_read_src_metadata )
+ # look for SCM data if present
+ if( EXISTS "${CMAKE_SOURCE_DIR}/.tdescminfo" )
+ file( READ "${CMAKE_SOURCE_DIR}/.tdescminfo" TDE_SCM_INFO )
+ string( REGEX MATCH "(^|\n)Name: ([^\n]*)" TDE_SCM_MODULE_NAME "${TDE_SCM_INFO}" )
+ string( REGEX REPLACE "^[^:]*: " "" TDE_SCM_MODULE_NAME "${TDE_SCM_MODULE_NAME}" )
+ string( REGEX MATCH "(^|\n)Revision: ([^\n]*)" TDE_SCM_MODULE_REVISION "${TDE_SCM_INFO}" )
+ string( REGEX REPLACE "^[^:]*: " "" TDE_SCM_MODULE_REVISION "${TDE_SCM_MODULE_REVISION}" )
+ string( REGEX MATCH "(^|\n)DateTime: ([^\n]*)" TDE_SCM_MODULE_DATETIME "${TDE_SCM_INFO}" )
+ string( REGEX REPLACE "^[^:]*: " "" TDE_SCM_MODULE_DATETIME "${TDE_SCM_MODULE_DATETIME}" )
+ else( )
+ if( EXISTS "${CMAKE_SOURCE_DIR}/.tdescmmodule" )
+ file( STRINGS "${CMAKE_SOURCE_DIR}/.tdescmmodule" TDE_SCM_MODULE_NAME )
+ endif( EXISTS "${CMAKE_SOURCE_DIR}/.tdescmmodule" )
+ if( EXISTS "${CMAKE_SOURCE_DIR}/.tdescmrevision" )
+ file( STRINGS "${CMAKE_SOURCE_DIR}/.tdescmrevision" TDE_SCM_MODULE_REVISION )
+ endif( EXISTS "${CMAKE_SOURCE_DIR}/.tdescmrevision" )
+ endif( )
+
+ # look for package data if present
+ if( EXISTS "${CMAKE_SOURCE_DIR}/.tdepkginfo" )
+ file( READ "${CMAKE_SOURCE_DIR}/.tdepkginfo" TDE_PKG_INFO )
+ endif( )
+ if( EXISTS "${CMAKE_BINARY_DIR}/.tdepkginfo" )
+ file( READ "${CMAKE_BINARY_DIR}/.tdepkginfo" TDE_PKG_INFO )
+ endif( )
+ if( TDE_PKG_INFO )
+ string( REGEX MATCH "(^|\n)Name: ([^\n]*)" TDE_PKG_NAME "${TDE_PKG_INFO}" )
+ string( REGEX REPLACE "^[^:]*: " "" TDE_PKG_NAME "${TDE_PKG_NAME}" )
+ string( REGEX MATCH "(^|\n)Version: ([^\n]*)" TDE_PKG_VERSION "${TDE_PKG_INFO}" )
+ string( REGEX REPLACE "^[^:]*: " "" TDE_PKG_VERSION "${TDE_PKG_VERSION}" )
+ string( REGEX MATCH "(^|\n)DateTime: ([^\n]*)" TDE_PKG_DATETIME "${TDE_PKG_INFO}" )
+ string( REGEX REPLACE "^[^:]*: " "" TDE_PKG_DATETIME "${TDE_PKG_DATETIME}" )
+ endif( )
+endmacro( tde_read_src_metadata )
+
+
+################################################
+#####
+##### finalization as a slave part
+
+if( DEFINED MASTER_SOURCE_DIR )
+ cmake_policy( POP )
+ return( )
+endif( )
+
+########### slave part ends here ###############
+
+
+################################################
+#####
+##### tde_install_icons( <icons...> THEME <svgicons> DESTINATION <destdir> )
+##### default theme: hicolor
+##### default destination: ${SHARE_INSTALL_DIR}/icons
+
+macro( tde_install_icons )
+ tde_get_arg( DESTINATION 1 _dest _args ${ARGV} )
+ tde_get_arg( THEME 1 _req_theme _icons ${_args} )
+
+ #defaults
+ if( NOT _icons )
+ set( _icons "*" )
+ endif( NOT _icons )
+ if( NOT _dest )
+ set( _dest "${ICON_INSTALL_DIR}" )
+ endif( NOT _dest )
+
+ foreach( _icon ${_icons} )
+ unset( _theme ) # clearing
+
+ file(GLOB _icon_files *-${_icon}.png *-${_icon}.mng _icon_files *-${_icon}.svg* )
+ foreach( _icon_file ${_icon_files} )
+ # FIXME need a review
+ string( REGEX MATCH "^.*/([a-zA-Z][a-zA-Z])([0-9a-zA-Z]+)\\-([a-z]+)\\-([^/]+)$" _dummy "${_icon_file}" )
+ set( _type "${CMAKE_MATCH_1}" )
+ set( _size "${CMAKE_MATCH_2}" )
+ set( _group "${CMAKE_MATCH_3}" )
+ set( _name "${CMAKE_MATCH_4}" )
+
+ # we must ignore invalid icon names
+ if( _type AND _size AND _group AND _name )
+
+ # autodetect theme
+ if( NOT _req_theme )
+ unset( _theme )
+ if( "${_type}" STREQUAL "cr" )
+ set( _theme crystalsvg )
+ elseif( "${_type}" STREQUAL "lo" )
+ set( _theme locolor )
+ endif( "${_type}" STREQUAL "cr" )
+ # defaulting
+ if( NOT _theme )
+ set( _theme hicolor )
+ endif( NOT _theme )
+ else( NOT _req_theme )
+ set( _theme ${_req_theme} )
+ endif( NOT _req_theme )
+
+ # fix "group" name
+ if( "${_group}" STREQUAL "mime" )
+ set( _group "mimetypes" )
+ endif( "${_group}" STREQUAL "mime" )
+ if( "${_group}" STREQUAL "filesys" )
+ set( _group "places" )
+ endif( "${_group}" STREQUAL "filesys" )
+ if( "${_group}" STREQUAL "category" )
+ set( _group "categories" )
+ endif( "${_group}" STREQUAL "category" )
+ if( "${_group}" STREQUAL "device" )
+ set( _group "devices" )
+ endif( "${_group}" STREQUAL "device" )
+ if( "${_group}" STREQUAL "app" )
+ set( _group "apps" )
+ endif( "${_group}" STREQUAL "app" )
+ if( "${_group}" STREQUAL "action" )
+ set( _group "actions" )
+ endif( "${_group}" STREQUAL "action" )
+
+ if( "${_size}" STREQUAL "sc" )
+ install( FILES ${_icon_file} DESTINATION ${_dest}/${_theme}/scalable/${_group}/ RENAME ${_name} )
+ else( "${_size}" STREQUAL "sc" )
+ install( FILES ${_icon_file} DESTINATION ${_dest}/${_theme}/${_size}x${_size}/${_group}/ RENAME ${_name} )
+ endif( "${_size}" STREQUAL "sc" )
+
+ endif( _type AND _size AND _group AND _name )
+
+ endforeach( _icon_file )
+ endforeach( _icon )
+
+endmacro( tde_install_icons )
+
+
+#################################################
+#####
+##### tde_add_lut( <source> <result> [depends] )
+##### default depends: source
+
+macro( tde_add_lut _src _lut _dep )
+ set( create_hash_table ${CMAKE_SOURCE_DIR}/kjs/create_hash_table )
+ if( NOT _dep )
+ set( _dep ${_src} )
+ endif( NOT _dep )
+ add_custom_command( OUTPUT ${_lut}
+ COMMAND perl ARGS ${create_hash_table} ${CMAKE_CURRENT_SOURCE_DIR}/${_src} -i > ${_lut}
+ DEPENDS ${_src} )
+ set_source_files_properties( ${_dep} PROPERTIES OBJECT_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${_lut} )
+ unset( _dep )
+endmacro( tde_add_lut )
+
+
+#################################################
+#####
+##### tde_add_luts( <sources...> )
+
+macro( tde_add_luts )
+ foreach( _src ${ARGV} )
+ get_filename_component( _lut ${_src} NAME_WE )
+ set( _lut "${_lut}.lut.h" )
+ tde_add_lut( ${_src} ${_lut} ${_src} )
+ endforeach( _src )
+endmacro( tde_add_luts )
+
+
+#################################################
+#####
+##### tde_file_to_cpp( <source> <destination> <variable> )
+
+macro( tde_file_to_cpp _src _dst _var )
+ if( IS_ABSOLUTE ${_dst} )
+ set( dst ${_dst} )
+ else( )
+ set( dst "${CMAKE_CURRENT_BINARY_DIR}/${_dst}" )
+ endif( )
+ file( READ ${_src} text )
+ string( REGEX REPLACE "\n" "\\\\n\"\n\"" text "${text}" )
+ set( text "/* Generated by CMake */\n\nconst char *${_var} = \n\n\"${text}\";\n" )
+ string( REGEX REPLACE "\n\"\";\n$" ";\n" text "${text}" )
+ file( WRITE ${dst} "${text}" )
+endmacro( )
+
+
+#################################################
+#####
+##### tde_get_library_filename( <var> <target> )
+
+function( tde_get_library_filename _filename _target )
+ get_target_property( _type ${_target} TYPE )
+ if( "${_type}" MATCHES "_LIBRARY" )
+ get_target_property( _output_prefix ${_target} PREFIX )
+ if( "${_output_prefix}" STREQUAL "_output_prefix-NOTFOUND" )
+ if( "${_type}" MATCHES "STATIC_" )
+ set( _output_prefix "${CMAKE_STATIC_LIBRARY_PREFIX}" )
+ elseif( "${_type}" MATCHES "SHARED_" )
+ set( _output_prefix "${CMAKE_SHARED_LIBRARY_PREFIX}" )
+ elseif( "${_type}" MATCHES "MODULE_" )
+ set( _output_prefix "${CMAKE_SHARED_MODULE_PREFIX}" )
+ else( )
+ set( _output_prefix "" )
+ endif( )
+ endif( )
+ get_target_property( _output_suffix ${_target} SUFFIX )
+ if( "${_output_suffix}" STREQUAL "_output_suffix-NOTFOUND" )
+ if( "${_type}" MATCHES "STATIC_" )
+ set( _output_suffix "${CMAKE_STATIC_LIBRARY_SUFFIX}" )
+ elseif( "${_type}" MATCHES "SHARED_" )
+ set( _output_suffix "${CMAKE_SHARED_LIBRARY_SUFFIX}" )
+ elseif( "${_type}" MATCHES "MODULE_" )
+ set( _output_suffix "${CMAKE_SHARED_MODULE_SUFFIX}" )
+ else( )
+ set( _output_suffix "" )
+ endif( )
+ endif( )
+ get_target_property( _output ${_target} OUTPUT_NAME )
+ set( ${_filename} "${_output_prefix}${_output}${_output_suffix}" PARENT_SCOPE )
+ else( )
+ set( ${_filename} "" PARENT_SCOPE )
+ endif( )
+endfunction( )
+
+
+#################################################
+#####
+##### tde_install_la_file( <target> <destination> )
+
+macro( tde_install_la_file _target _destination )
+
+ tde_get_library_filename( _soname ${_target} )
+ get_target_property( _target_release ${_target} RELEASE )
+ if( _target_release )
+ string( REPLACE "-${_target_release}" "" _soname_base "${_soname}" )
+ else( )
+ set( _soname_base ${_soname} )
+ endif( )
+ string( REGEX REPLACE "\\.so(\\.[0-9]+)*$" "" _laname "${_soname_base}" )
+ set( _laname ${CMAKE_CURRENT_BINARY_DIR}/${_laname}.la )
+
+ file( WRITE ${_laname}
+"# ${_laname} - a libtool library file, generated by cmake
+# The name that we can dlopen(3).
+dlname='${_soname}'
+# Names of this library
+library_names='${_soname} ${_soname} ${_soname_base}'
+# The name of the static archive
+old_library=''
+# Libraries that this one depends upon.
+dependency_libs=''
+# Version information.\ncurrent=0\nage=0\nrevision=0
+# Is this an already installed library?\ninstalled=yes
+# Should we warn about portability when linking against -modules?\nshouldnotlink=yes
+# Files to dlopen/dlpreopen\ndlopen=''\ndlpreopen=''
+# Directory that this library needs to be installed in:
+libdir='${_destination}'
+" )
+
+ install( FILES ${_laname} DESTINATION ${_destination} )
+
+endmacro( tde_install_la_file )
+
+
+#################################################
+#####
+##### tde_add_ui_files
+
+macro( tde_add_ui_files _sources )
+ if( TDE_FOUND OR "${CMAKE_PROJECT_NAME}" STREQUAL "tdelibs" )
+ set( HAVE_TDE 1 )
+ endif()
+
+ foreach( _ui_file ${ARGN} )
+
+ get_filename_component( _ui_basename ${_ui_file} NAME_WE )
+ get_filename_component( _ui_absolute_path ${_ui_file} ABSOLUTE )
+
+ list( APPEND ${_sources} ${_ui_basename}.cpp )
+
+ add_custom_command( OUTPUT ${_ui_basename}.h ${_ui_basename}.cpp
+ COMMAND ${CMAKE_COMMAND}
+ -DUIC_EXECUTABLE:FILEPATH=${UIC_EXECUTABLE}
+ -DTQT_REPLACE_SCRIPT:FILEPATH=${TQT_REPLACE_SCRIPT}
+ -DTDE_TQTPLUGINS_DIR:FILEPATH=${TDE_TQTPLUGINS_DIR}
+ -DMOC_EXECUTABLE:FILEPATH=${MOC_EXECUTABLE}
+ -DUI_FILE:FILEPATH=${_ui_absolute_path}
+ -DMASTER_SOURCE_DIR:FILEPATH=${CMAKE_SOURCE_DIR}
+ -DMASTER_BINARY_DIR:FILEPATH=${CMAKE_BINARY_DIR}
+ -DTDE_FOUND=${HAVE_TDE}
+ -DTQT_ONLY=${TQT_ONLY}
+ -P ${TDE_CMAKE_MODULES}/tde_uic.cmake
+ DEPENDS ${_ui_absolute_path} )
+
+ endforeach( _ui_file )
+endmacro( tde_add_ui_files )
+
+
+#################################################
+#####
+##### tde_moc
+
+macro( tde_moc _sources )
+ foreach( _input_file ${ARGN} )
+
+ get_filename_component( _input_file "${_input_file}" ABSOLUTE )
+ get_filename_component( _basename ${_input_file} NAME_WE )
+ set( _output_file "${_basename}.moc.cpp" )
+ add_custom_command( OUTPUT ${_output_file}
+ COMMAND
+ ${TMOC_EXECUTABLE} ${_input_file} -o ${_output_file}
+ DEPENDS
+ ${_input_file} )
+ list( APPEND ${_sources} ${_output_file} )
+
+ endforeach( )
+endmacro( )
+
+
+#################################################
+#####
+##### tde_automoc
+
+macro( tde_automoc )
+ foreach( _src_file ${ARGN} )
+
+ 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 header 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 )
+ set( _header_file "${_src_path}/${_src_header}.h" )
+
+ # if header doesn't exists, check in META_INCLUDES
+ if( NOT EXISTS "${_header_file}" )
+ unset( _found )
+ foreach( _src_path ${_meta_includes} )
+ set( _header_file "${_src_path}/${_src_header}.h" )
+ if( EXISTS "${_header_file}" )
+ 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_header}.h' not found." )
+ endif( )
+ endif( )
+
+ # moc-ing header
+ file( RELATIVE_PATH _moc_file_relative "${CMAKE_BINARY_DIR}" "${_moc_file}" )
+ add_custom_command( OUTPUT ${_moc_file}
+ COMMAND ${TMOC_EXECUTABLE} ${_header_file} -o ${_moc_file}
+ COMMENT "Generating ${_moc_file_relative}"
+ DEPENDS ${_header_file} )
+
+ # create dependency between source file and moc file
+ set_property( SOURCE ${_src_file} APPEND PROPERTY OBJECT_DEPENDS ${_moc_file} )
+
+ endforeach( _moc_file )
+
+ endif( _moc_includes )
+
+ else( EXISTS "${_src_file}" )
+
+ # for generated file, the path must match the binary directory
+ string( LENGTH "${CMAKE_BINARY_DIR}" CMAKE_BINARY_DIR_LEN )
+ string( LENGTH "${_src_file}" _basename_len )
+ if( ${_basename_len} LESS ${CMAKE_BINARY_DIR_LEN} )
+ set( _basedir_prefix "${CMAKE_SOURCE_DIR}" )
+ else( )
+ string( SUBSTRING "${_src_file}" 0 ${CMAKE_BINARY_DIR_LEN} _basedir_prefix )
+ endif( )
+ if( ${_basedir_prefix} STREQUAL "${CMAKE_BINARY_DIR}" )
+ file( RELATIVE_PATH _sourcename "${CMAKE_BINARY_DIR}" "${_src_file}" )
+ file( RELATIVE_PATH _basename "${CMAKE_CURRENT_BINARY_DIR}" "${_src_file}" )
+ else( )
+ file( RELATIVE_PATH _sourcename "${CMAKE_SOURCE_DIR}" "${_src_file}" )
+ file( RELATIVE_PATH _basename "${CMAKE_CURRENT_SOURCE_DIR}" "${_src_file}" )
+ endif( )
+
+ # automocing generated file
+ get_filename_component( _automoc_file "${_src_file}+automoc" NAME )
+ set( _automoc_file "${CMAKE_CURRENT_BINARY_DIR}/${_automoc_file}" )
+
+ add_custom_command( OUTPUT ${_automoc_file}
+ COMMAND ${CMAKE_COMMAND}
+ -DTMOC_EXECUTABLE:FILEPATH=${TMOC_EXECUTABLE}
+ -DSRC_FILE:FILEPATH=${CMAKE_CURRENT_BINARY_DIR}/${_basename}
+ -DMETA_INCLUDES:STRING="${_meta_includes}"
+ -DMASTER_SOURCE_DIR:FILEPATH=${CMAKE_SOURCE_DIR}
+ -DMASTER_BINARY_DIR:FILEPATH=${CMAKE_BINARY_DIR}
+ -P ${TDE_CMAKE_MODULES}/tde_automoc.cmake
+ COMMENT "Automocing ${_sourcename}"
+ DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${_basename}"
+ )
+
+ # create dependency between source file and moc file
+ set_property( SOURCE "${CMAKE_CURRENT_BINARY_DIR}/${_basename}"
+ APPEND PROPERTY OBJECT_DEPENDS ${_automoc_file} )
+
+ endif( EXISTS "${_src_file}" )
+
+ endforeach( _src_file )
+endmacro( tde_automoc )
+
+
+#################################################
+#####
+##### tde_create_dcop_kidl
+
+macro( tde_create_dcop_kidl _kidl _kidl_source )
+
+ get_filename_component( _kidl_source ${_kidl_source} ABSOLUTE )
+ get_filename_component( _kidl_basename ${_kidl_source} NAME_WE )
+ set( _kidl_output ${CMAKE_CURRENT_BINARY_DIR}/${_kidl_basename}.kidl )
+ file( RELATIVE_PATH _kidl_target "${CMAKE_BINARY_DIR}" "${_kidl_output}" )
+ string( REPLACE "/" "+" _kidl_target "${_kidl_target}" )
+
+ if( NOT TARGET ${_kidl_target} )
+ add_custom_command(
+ OUTPUT ${_kidl_output}
+ COMMAND ${KDE3_DCOPIDLNG_EXECUTABLE}
+ ARGS ${_kidl_source} > ${_kidl_output}
+ DEPENDS ${_kidl_source}
+ )
+ add_custom_target( ${_kidl_target} DEPENDS ${_kidl_output} )
+ endif( )
+
+ set( ${_kidl} ${_kidl_output} )
+
+endmacro( tde_create_dcop_kidl )
+
+
+#################################################
+#####
+##### tde_add_dcop_skels
+
+macro( tde_add_dcop_skels _sources )
+ foreach( _current_FILE ${ARGN} )
+
+ get_filename_component( _tmp_FILE ${_current_FILE} ABSOLUTE )
+ get_filename_component( _basename ${_tmp_FILE} NAME_WE )
+
+ set( _skel ${CMAKE_CURRENT_BINARY_DIR}/${_basename}_skel.cpp )
+ file( RELATIVE_PATH _skel_target "${CMAKE_BINARY_DIR}" "${_skel}" )
+ string( REPLACE "/" "+" _skel_target "${_skel_target}" )
+
+ tde_create_dcop_kidl( _kidl ${_tmp_FILE} )
+
+ if( NOT TARGET ${_skel_target} )
+ add_custom_command(
+ OUTPUT ${_skel}
+ COMMAND ${KDE3_DCOPIDL2CPP_EXECUTABLE}
+ ARGS --c++-suffix cpp --no-signals --no-stub ${_kidl}
+ DEPENDS ${_kidl_target}
+ )
+ add_custom_target( ${_skel_target} DEPENDS ${_skel} )
+ endif( )
+
+ list( APPEND ${_sources} ${_skel} )
+
+ endforeach( _current_FILE )
+endmacro( tde_add_dcop_skels )
+
+
+#################################################
+#####
+##### tde_add_dcop_stubs
+
+macro( tde_add_dcop_stubs _sources )
+ foreach( _current_FILE ${ARGN} )
+
+ get_filename_component( _tmp_FILE ${_current_FILE} ABSOLUTE )
+ get_filename_component( _basename ${_tmp_FILE} NAME_WE )
+
+ set( _stub_CPP ${CMAKE_CURRENT_BINARY_DIR}/${_basename}_stub.cpp )
+ set( _stub_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${_basename}_stub.h )
+ file( RELATIVE_PATH _stub_target "${CMAKE_BINARY_DIR}" "${_stub_CPP}" )
+ string( REPLACE "/" "+" _stub_target "${_stub_target}" )
+
+ tde_create_dcop_kidl( _kidl ${_tmp_FILE} )
+
+ if( NOT TARGET ${_stub_target} )
+ add_custom_command(
+ OUTPUT ${_stub_CPP} ${_stub_HEADER}
+ COMMAND ${KDE3_DCOPIDL2CPP_EXECUTABLE}
+ ARGS --c++-suffix cpp --no-signals --no-skel ${_kidl}
+ DEPENDS ${_kidl_target}
+ )
+ add_custom_target( ${_stub_target} DEPENDS ${_stub_CPP} ${_stub_HEADER} )
+ endif( )
+
+ list( APPEND ${_sources} ${_stub_CPP} )
+
+ endforeach( _current_FILE )
+endmacro( tde_add_dcop_stubs )
+
+
+#################################################
+#####
+##### tde_add_kcfg_files
+
+macro( tde_add_kcfg_files _sources )
+ foreach( _current_FILE ${ARGN} )
+
+ get_filename_component( _tmp_FILE ${_current_FILE} ABSOLUTE )
+ get_filename_component( _basename ${_tmp_FILE} NAME_WE )
+
+ file( READ ${_tmp_FILE} _contents )
+ string( REGEX REPLACE "^(.*\n)?File=([^\n]+)\n.*$" "\\2" _kcfg_FILE "${_contents}" )
+
+ set( _src_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp )
+ set( _header_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h )
+ file( RELATIVE_PATH _kcfg_target "${CMAKE_BINARY_DIR}" "${_src_FILE}" )
+ string( REPLACE "/" "+" _kcfg_target "${_kcfg_target}" )
+
+ if( NOT TARGET ${_kcfg_target} )
+ add_custom_command(
+ OUTPUT ${_src_FILE} ${_header_FILE}
+ COMMAND ${KDE3_KCFGC_EXECUTABLE}
+ ARGS ${CMAKE_CURRENT_SOURCE_DIR}/${_kcfg_FILE} ${_tmp_FILE}
+ DEPENDS ${_tmp_FILE} ${CMAKE_CURRENT_SOURCE_DIR}/${_kcfg_FILE}
+ )
+ add_custom_target( ${_kcfg_target} DEPENDS ${_src_FILE} ${_header_FILE} )
+ endif( )
+
+ list( APPEND ${_sources} ${_src_FILE} )
+
+ endforeach( _current_FILE )
+endmacro( tde_add_kcfg_files )
+
+
+#################################################
+#####
+##### __tde_internal_process_sources
+
+macro( __tde_internal_process_sources _sources )
+
+ unset( ${_sources} )
+
+ foreach( _arg ${ARGN} )
+ get_filename_component( _ext ${_arg} EXT )
+ get_filename_component( _name ${_arg} NAME_WE )
+ get_filename_component( _path ${_arg} PATH )
+
+ # if not path, set it to "."
+ if( NOT _path )
+ set( _path "./" )
+ endif( NOT _path )
+
+ # handle .ui files
+ if( ${_ext} STREQUAL ".ui" )
+ tde_add_ui_files( ${_sources} ${_arg} )
+
+ # handle .skel files
+ elseif( ${_ext} STREQUAL ".skel" )
+ tde_add_dcop_skels( ${_sources} ${_path}/${_name}.h )
+
+ # handle .stub files
+ elseif( ${_ext} STREQUAL ".stub" )
+ tde_add_dcop_stubs( ${_sources} ${_path}/${_name}.h )
+
+ # handle .kcfgc files
+ elseif( ${_ext} STREQUAL ".kcfgc" )
+ tde_add_kcfg_files( ${_sources} ${_arg} )
+
+ # handle any other files
+ else( ${_ext} STREQUAL ".ui" )
+ list(APPEND ${_sources} ${_arg} )
+ endif( ${_ext} STREQUAL ".ui" )
+ endforeach( _arg )
+
+endmacro( __tde_internal_process_sources )
+
+
+#################################################
+#####
+##### tde_install_libtool_file
+
+macro( tde_install_libtool_file _target _destination )
+
+ # get .so name
+ tde_get_library_filename( _soname ${_target} )
+ get_target_property( _target_release ${_target} RELEASE )
+ if( _target_release )
+ string( REPLACE "-${_target_release}" "" _soname_base "${_soname}" )
+ else( )
+ set( _soname_base ${_soname} )
+ endif( )
+
+ # get .la name
+ string( REGEX REPLACE "\\.so(\\.[0-9]+)*$" "" _laname "${_soname_base}" )
+ set( _laname ${_laname}.la )
+
+ # get version of target
+ get_target_property( _target_version ${_target} VERSION )
+ get_target_property( _target_soversion ${_target} SOVERSION )
+
+ # we have so version
+ if( _target_version )
+ set( _library_name_1 "${_soname}.${_target_version}" )
+ set( _library_name_2 "${_soname}.${_target_soversion}" )
+ set( _library_name_3 "${_soname_base}" )
+
+ string( REGEX MATCH "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" _dummy "${_target_version}" )
+ set( _version_current "${CMAKE_MATCH_1}" )
+ set( _version_age "${CMAKE_MATCH_2}" )
+ set( _version_revision "${CMAKE_MATCH_3}" )
+
+ # we have no so version (module?)
+ else( _target_version )
+ set( _library_name_1 "${_soname}" )
+ set( _library_name_2 "${_soname}" )
+ set( _library_name_3 "${_soname_base}" )
+ set( _version_current "0" )
+ set( _version_age "0" )
+ set( _version_revision "0" )
+ endif( _target_version )
+
+ if( IS_ABSOLUTE ${_destination} )
+ set( _libdir "${_destination}" )
+ else( IS_ABSOLUTE ${_destination} )
+ set( _libdir "${CMAKE_INSTALL_PREFIX}/${_destination}" )
+ endif( IS_ABSOLUTE ${_destination} )
+
+ configure_file( ${TDE_CMAKE_TEMPLATES}/tde_libtool_file.cmake "${_laname}" @ONLY )
+
+ install( FILES "${CMAKE_CURRENT_BINARY_DIR}/${_laname}" DESTINATION ${_destination} )
+
+endmacro( tde_install_libtool_file )
+
+
+#################################################
+#####
+##### tde_install_export / tde_import
+
+function( tde_install_export )
+ file( GLOB export_files ${CMAKE_CURRENT_BINARY_DIR}/export-*.cmake )
+ list( SORT export_files )
+
+ set( mode "WRITE" )
+ foreach( filename ${export_files} )
+ file( READ ${filename} content )
+ file( ${mode} "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.cmake" "${content}" )
+ set( mode "APPEND" )
+ endforeach( )
+
+ install( FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.cmake" DESTINATION ${CMAKE_INSTALL_DIR} )
+endfunction( )
+
+
+macro( tde_import _library )
+ if( NOT DEFINED TDE_IMPORT_${_library} )
+ message( STATUS "Checking for '${_library}'" )
+ string( TOUPPER "BUILD_${_library}" _build )
+ if( ${_build} )
+ message( STATUS "Checking for '${_library}' - ok, activated for build" )
+ set( TDE_IMPORT_${_library} "build" CACHE INTERNAL "Library ${_library} activated for build" )
+ else()
+ if( EXISTS "${TDE_CMAKE_DIR}/${_library}.cmake" )
+ set( tde_import_include "${TDE_CMAKE_DIR}/${_library}.cmake" )
+ elseif( EXISTS "${TQT_CMAKE_DIR}/${_library}.cmake" )
+ set( tde_import_include "${TQT_CMAKE_DIR}/${_library}.cmake" )
+ else()
+ tde_message_fatal( "'${_library}' is required, but is not installed nor selected for build" )
+ endif()
+ include( "${tde_import_include}" )
+ message( STATUS "Checking for '${_library}' - ok, found import file" )
+ set( TDE_IMPORT_${_library} "import:${tde_import_include}" CACHE INTERNAL "Library ${_library} imported" )
+ endif()
+ else()
+ if( "${TDE_IMPORT_${_library}}" MATCHES "^import:" )
+ string( REGEX REPLACE "^import:" "" tde_import_include "${TDE_IMPORT_${_library}}" )
+ include( "${tde_import_include}" )
+ endif()
+ endif()
+endmacro()
+
+
+#################################################
+#####
+##### tde_add_library
+
+macro( tde_add_library _arg_target )
+
+ unset( _target )
+ unset( _type )
+ unset( _static_pic )
+ unset( _automoc )
+ unset( _meta_includes )
+ unset( _no_libtool_file )
+ unset( _no_export )
+ unset( _version )
+ unset( _release )
+ unset( _sources )
+ unset( _cxx_features )
+ unset( _cxx_features_private )
+ unset( _destination )
+ unset( _embed )
+ unset( _link )
+ unset( _link_private )
+ unset( _dependencies )
+ unset( _storage )
+ unset( _exclude_from_all )
+
+ set( _shouldnotlink no )
+
+ # metadata
+ unset( _description )
+ unset( _license )
+ unset( _copyright )
+ unset( _authors )
+ unset( _product )
+ unset( _organization )
+ unset( _version )
+ unset( _datetime )
+ unset( _notes )
+
+ # default metadata
+ set( _product "Trinity Desktop Environment" )
+ tde_curdatetime( _datetime )
+
+ foreach( _arg ${ARGV} )
+
+ # this variable help us to skip
+ # storing unapropriate values (i.e. directives)
+ unset( _skip_store )
+
+ # found one of directives: "SHARED", "STATIC", "MODULE"
+ if( "+${_arg}" STREQUAL "+SHARED" OR "+${_arg}" STREQUAL "+STATIC" OR "+${_arg}" STREQUAL "+MODULE" )
+ set( _skip_store 1 )
+ set( _type "${_arg}" )
+ endif( "+${_arg}" STREQUAL "+SHARED" OR "+${_arg}" STREQUAL "+STATIC" OR "+${_arg}" STREQUAL "+MODULE" )
+
+ # found directive "STATIC_PIC"
+ if( "+${_arg}" STREQUAL "+STATIC_PIC" )
+ set( _skip_store 1 )
+ set( _type "STATIC" )
+ set( _static_pic 1 )
+ endif( "+${_arg}" STREQUAL "+STATIC_PIC" )
+
+ # found directive "AUTOMOC"
+ if( "+${_arg}" STREQUAL "+AUTOMOC" )
+ set( _skip_store 1 )
+ set( _automoc 1 )
+ endif( "+${_arg}" STREQUAL "+AUTOMOC" )
+
+ # found directive "META_INCLUDES"
+ if( "+${_arg}" STREQUAL "+META_INCLUDES" )
+ set( _skip_store 1 )
+ set( _storage "_meta_includes" )
+ endif( )
+
+ # found directive "NO_LIBTOOL_FILE"
+ if( "+${_arg}" STREQUAL "+NO_LIBTOOL_FILE" )
+ set( _skip_store 1 )
+ set( _no_libtool_file 1 )
+ endif( "+${_arg}" STREQUAL "+NO_LIBTOOL_FILE" )
+
+ # found directive "NO_EXPORT"
+ if( "+${_arg}" STREQUAL "+NO_EXPORT" )
+ set( _skip_store 1 )
+ set( _no_export 1 )
+ endif( "+${_arg}" STREQUAL "+NO_EXPORT" )
+
+ # found directive "VERSION"
+ if( "+${_arg}" STREQUAL "+VERSION" )
+ set( _skip_store 1 )
+ set( _storage "_version" )
+ endif( "+${_arg}" STREQUAL "+VERSION" )
+
+ # found directive "RELEASE"
+ if( "+${_arg}" STREQUAL "+RELEASE" )
+ set( _skip_store 1 )
+ set( _storage "_release" )
+ endif( "+${_arg}" STREQUAL "+RELEASE" )
+
+ # found directive "SOURCES"
+ if( "+${_arg}" STREQUAL "+SOURCES" )
+ set( _skip_store 1 )
+ set( _storage "_sources" )
+ endif( "+${_arg}" STREQUAL "+SOURCES" )
+
+ # found directive "CXX_FEATURES"
+ if( "+${_arg}" STREQUAL "+CXX_FEATURES" )
+ set( _skip_store 1 )
+ set( _storage "_cxx_features" )
+ endif( "+${_arg}" STREQUAL "+CXX_FEATURES" )
+
+ # found directive "CXX_FEATURES_PRIVATE"
+ if( "+${_arg}" STREQUAL "+CXX_FEATURES_PRIVATE" )
+ set( _skip_store 1 )
+ set( _storage "_cxx_features_private" )
+ endif( "+${_arg}" STREQUAL "+CXX_FEATURES_PRIVATE" )
+
+ # found directive "EMBED"
+ if( "+${_arg}" STREQUAL "+EMBED" )
+ set( _skip_store 1 )
+ set( _storage "_embed" )
+ endif( "+${_arg}" STREQUAL "+EMBED" )
+
+ # found directive "LINK"
+ if( "+${_arg}" STREQUAL "+LINK" )
+ set( _skip_store 1 )
+ set( _storage "_link" )
+ endif( "+${_arg}" STREQUAL "+LINK" )
+
+ # found directive "LINK_PRIVATE"
+ if( "+${_arg}" STREQUAL "+LINK_PRIVATE" )
+ set( _skip_store 1 )
+ set( _storage "_link_private" )
+ endif( "+${_arg}" STREQUAL "+LINK_PRIVATE" )
+
+ # found directive "DEPENDENCIES"
+ if( "+${_arg}" STREQUAL "+DEPENDENCIES" )
+ set( _skip_store 1 )
+ set( _storage "_dependencies" )
+ endif( "+${_arg}" STREQUAL "+DEPENDENCIES" )
+
+ # found directive "DESTINATION"
+ if( "+${_arg}" STREQUAL "+DESTINATION" )
+ set( _skip_store 1 )
+ set( _storage "_destination" )
+ unset( ${_storage} )
+ endif( "+${_arg}" STREQUAL "+DESTINATION" )
+
+ # found directive "EXCLUDE_FROM_ALL"
+ if( "+${_arg}" STREQUAL "+EXCLUDE_FROM_ALL" )
+ set( _skip_store 1 )
+ set( _exclude_from_all "EXCLUDE_FROM_ALL" )
+ endif( "+${_arg}" STREQUAL "+EXCLUDE_FROM_ALL" )
+
+ # metadata
+ if( "+${_arg}" STREQUAL "+DESCRIPTION" )
+ set( _skip_store 1 )
+ set( _storage "_description" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+LICENSE" )
+ set( _skip_store 1 )
+ set( _storage "_license" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+COPYRIGHT" )
+ set( _skip_store 1 )
+ set( _storage "_copyright" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+AUTHORS" )
+ set( _skip_store 1 )
+ set( _storage "_authors" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+PRODUCT" )
+ set( _skip_store 1 )
+ set( _storage "_product" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+ORGANIZATION" )
+ set( _skip_store 1 )
+ set( _storage "_organization" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+VERSION" )
+ set( _skip_store 1 )
+ set( _storage "_version" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+DATETIME" )
+ set( _skip_store 1 )
+ set( _storage "_datetime" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+NOTES" )
+ set( _skip_store 1 )
+ set( _storage "_notes" )
+ endif( )
+
+ # storing value
+ if( _storage AND NOT _skip_store )
+ list( APPEND ${_storage} ${_arg} )
+ list( REMOVE_DUPLICATES ${_storage} )
+ endif( _storage AND NOT _skip_store )
+
+ endforeach( _arg )
+
+ # if no type is set, we choose one
+ # based on BUILD_SHARED_LIBS
+ if( NOT _type )
+ if( BUILD_SHARED_LIBS )
+ set( _type "SHARED" )
+ else( BUILD_SHARED_LIBS )
+ set( _type "STATIC" )
+ endif( BUILD_SHARED_LIBS )
+ endif( NOT _type )
+
+ # change target name, based on type
+ string( TOLOWER "${_type}" _type_lower )
+ set( _target "${_arg_target}-${_type_lower}" )
+
+ # create variables like "LIB_xxx" for convenience
+ if( ${_type} STREQUAL "SHARED" )
+ string( TOUPPER "${_arg_target}" _tmp )
+ set( LIB_${_tmp} ${_target} CACHE INTERNAL LIB_${tmp} FORCE )
+ endif( ${_type} STREQUAL "SHARED" )
+
+ # disallow target without sources
+ if( NOT _sources )
+ message( FATAL_ERROR "\nTarget [$_target] have no sources." )
+ endif( NOT _sources )
+
+ # processing different types of sources
+ __tde_internal_process_sources( _sources ${_sources} )
+
+ # set automoc
+ if( _automoc )
+ tde_automoc( ${_sources} )
+ endif( _automoc )
+
+ # add target
+ add_library( ${_target} ${_type} ${_exclude_from_all} ${_sources} )
+
+ # set cxx features
+ if( _cxx_features )
+ target_compile_features( ${_target} PUBLIC ${_cxx_features} )
+ endif( )
+ if( TDE_CXX_FEATURES OR PROJECT_CXX_FEATURES OR _cxx_features_private )
+ target_compile_features( ${_target} PRIVATE
+ ${TDE_CXX_FEATURES} ${PROJECT_CXX_FEATURES} ${_cxx_features_private} )
+ endif( )
+
+ # we assume that modules have no prefix and no version
+ # also, should not link
+ if( ${_type} STREQUAL "MODULE" )
+ set_target_properties( ${_target} PROPERTIES PREFIX "" )
+ unset( _version )
+ set( _shouldnotlink yes )
+ endif( ${_type} STREQUAL "MODULE" )
+
+ # set real name of target
+ if( _release )
+ # add release number to output name
+ set_target_properties( ${_target} PROPERTIES RELEASE ${_release} )
+ set_target_properties( ${_target} PROPERTIES OUTPUT_NAME "${_arg_target}-${_release}" )
+ else( _release )
+ set_target_properties( ${_target} PROPERTIES OUTPUT_NAME ${_arg_target} )
+ endif( _release )
+
+ # set -fPIC flag for static libraries
+ if( _static_pic )
+ set_target_properties( ${_target} PROPERTIES POSITION_INDEPENDENT_CODE ON )
+ endif( _static_pic )
+
+ # set version
+ if( _version )
+ if( ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD" )
+ # OpenBSD: _soversion and _version both contains only major and minor
+ string( REGEX MATCH "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" _dummy "${_version}" )
+ set( _version "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}" )
+ set( _soversion "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}" )
+ else( ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD" )
+ # General (Linux) case: _soversion contains only the major number of version
+ string( REGEX MATCH "^[0-9]+" _soversion ${_version} )
+ endif( ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD" )
+ set_target_properties( ${_target} PROPERTIES VERSION ${_version} SOVERSION ${_soversion} )
+ endif( _version )
+
+ # set interface libraries (only for shared)
+ unset( _shared_libs )
+ if( NOT ${_type} STREQUAL "STATIC" )
+ foreach( _lib ${_link} )
+ #get_target_property( _lib_type ${_lib} TYPE )
+ #if( NOT "STATIC_LIBRARY" STREQUAL "${_lib_type}" )
+ if( NOT ${_lib} MATCHES ".+-static" )
+ list( APPEND _shared_libs ${_lib} )
+ endif( NOT ${_lib} MATCHES ".+-static" )
+ #endif( NOT "STATIC_LIBRARY" STREQUAL "${_lib_type}" )
+ endforeach( _lib )
+ endif( NOT ${_type} STREQUAL "STATIC" )
+
+ # set embedded archives
+ if( _embed )
+ if( ${CMAKE_SYSTEM_NAME} MATCHES "SunOS" )
+ list( INSERT _link_private 0 -Wl,-zallextract ${_embed} -Wl,-zdefaultextract )
+ else( )
+ list( INSERT _link_private 0 -Wl,-whole-archive ${_embed} -Wl,-no-whole-archive )
+ endif( )
+ endif( _embed )
+
+ # set private linked libraries
+ if( _link_private )
+ if( _link )
+ list( INSERT _link 0 "PUBLIC" )
+ endif()
+ list( INSERT _link_private 0 "PRIVATE" )
+ list( INSERT _link 0 ${_link_private} )
+ endif( _link_private )
+
+ # set link libraries
+ if( _link )
+ target_link_libraries( ${_target} ${_link} )
+ endif( )
+ if( _shared_libs )
+ string( TOUPPER "${CMAKE_BUILD_TYPE}" _build_type )
+ set_target_properties( ${_target} PROPERTIES
+ LINK_INTERFACE_LIBRARIES "${_shared_libs}"
+ LINK_INTERFACE_LIBRARIES_${_build_type} "${_shared_libs}"
+ INTERFACE_LINK_LIBRARIES "${_shared_libs}"
+ INTERFACE_LINK_LIBRARIES_${_build_type} "${_shared_libs}" )
+ endif( _shared_libs )
+
+ # set dependencies
+ if( _dependencies )
+ add_dependencies( ${_target} ${_dependencies} )
+ endif( _dependencies )
+
+ # if destination directory is set
+ if( _destination )
+
+ # we export only shared libs (no static, no modules);
+ # also, do not export targets marked as "NO_EXPORT" (usually for tdeinit)
+ if( "SHARED" STREQUAL ${_type} AND NOT _no_export )
+
+ # get target properties: output name, version, soversion
+ tde_get_library_filename( _output ${_target} )
+ get_target_property( _version ${_target} VERSION )
+ get_target_property( _soversion ${_target} SOVERSION )
+
+ if( _version )
+ set( _location "${_destination}/${_output}.${_version}" )
+ set( _soname "${_output}.${_soversion}" )
+ else( )
+ set( _location "${_destination}/${_output}" )
+ set( _soname "${_output}" )
+ unset( _version )
+ endif( )
+
+ configure_file( ${TDE_CMAKE_TEMPLATES}/tde_export_library.cmake "${PROJECT_BINARY_DIR}/export-${_target}.cmake" @ONLY )
+ endif( )
+
+ # install target
+ install( TARGETS ${_target} DESTINATION ${_destination} )
+
+ # install base soname
+ if( _release AND NOT "STATIC" STREQUAL ${_type} )
+ tde_get_library_filename( _soname ${_target} )
+ string( REPLACE "-${_release}" "" _soname_base "${_soname}" )
+ if( _version )
+ get_target_property( _soversion ${_target} SOVERSION )
+ set( _soname "${_soname}.${_soversion}" )
+ endif( )
+ if( NOT _exclude_from_all )
+ add_custom_command(
+ OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${_soname_base}"
+ COMMAND ln -s ${_soname} "${CMAKE_CURRENT_BINARY_DIR}/${_soname_base}"
+ DEPENDS ${_target}
+ )
+ add_custom_target(
+ ${_target}+base-so ALL
+ DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${_soname_base}"
+ )
+ else( )
+ add_custom_command(
+ TARGET ${_target} POST_BUILD
+ COMMAND ln -s ${_soname} "${CMAKE_CURRENT_BINARY_DIR}/${_soname_base}"
+ )
+ endif( )
+ install( FILES "${CMAKE_CURRENT_BINARY_DIR}/${_soname_base}" DESTINATION ${_destination} )
+ endif( )
+
+ # install .la files for dynamic libraries
+ if( NOT "STATIC" STREQUAL ${_type} AND NOT _no_libtool_file )
+ tde_install_libtool_file( ${_target} ${_destination} )
+ endif( )
+
+ endif( _destination )
+
+ # embed name and metadata
+ set( ELF_EMBEDDING_METADATA "\"${_target}\" \"${_description}\" \"${_license}\" \"${_copyright}\" \"${_authors}\" \"${_product}\" \"${_organization}\" \"${_version}\" \"${_datetime}\" \"x-sharedlib\" \"${TDE_SCM_MODULE_NAME}\" \"${TDE_SCM_MODULE_REVISION}\" \"${_notes}\"" )
+ separate_arguments( ELF_EMBEDDING_METADATA )
+ if( TDELFEDITOR_EXECUTABLE AND _soname )
+ if( _version )
+ get_filename_component( _target_lib ${CMAKE_CURRENT_BINARY_DIR}/${_soname}.${_version} ABSOLUTE )
+ else( )
+ get_filename_component( _target_lib ${CMAKE_CURRENT_BINARY_DIR}/${_soname} ABSOLUTE )
+ endif( )
+ file( RELATIVE_PATH _target_path "${CMAKE_BINARY_DIR}" "${_target_lib}" )
+
+ if( TARGET ${TDELFEDITOR_EXECUTABLE} AND NOT _exclude_from_all )
+ # create target for all metadata writes
+ if( NOT TARGET tdelfeditor-write )
+ add_custom_target( tdelfeditor-write
+ WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
+ DEPENDS ${TDELFEDITOR_EXECUTABLE}
+ COMMENT "Write metadata to binaries..."
+ )
+ endif( )
+ add_custom_target(
+ ${_target}+metadata ALL
+ COMMAND ${TDELFEDITOR_EXECUTABLE} -m ${_target_lib} ${ELF_EMBEDDING_METADATA} || true
+ COMMAND ${TDELFEDITOR_EXECUTABLE} -e ${_target_lib} || true
+ COMMENT "Storing SCM metadata in ${_target_path}"
+ DEPENDS tdelfeditor-write
+ )
+ add_dependencies( tdelfeditor-write ${_target} )
+ else( )
+ add_custom_command(
+ TARGET ${_target}
+ POST_BUILD
+ COMMAND ${TDELFEDITOR_EXECUTABLE} -m ${_target_lib} ${ELF_EMBEDDING_METADATA} || true
+ COMMAND ${TDELFEDITOR_EXECUTABLE} -e ${_target_lib} || true
+ COMMENT "Storing SCM metadata in ${_target_path}"
+ )
+ if( TARGET ${TDELFEDITOR_EXECUTABLE} )
+ add_dependencies( ${_target} ${TDELFEDITOR_EXECUTABLE} )
+ endif()
+ endif( )
+ endif( TDELFEDITOR_EXECUTABLE AND _soname )
+
+endmacro( tde_add_library )
+
+
+#################################################
+#####
+##### tde_add_kpart
+
+macro( tde_add_kpart _target )
+ tde_add_library( ${_target} ${ARGN} MODULE )
+endmacro( tde_add_kpart )
+
+
+#################################################
+#####
+##### tde_curdatetime
+
+macro( tde_curdatetime result )
+ if( TDE_PKG_DATETIME )
+ set( ${result} ${TDE_PKG_DATETIME} )
+ elseif( TDE_SCM_MODULE_DATETIME )
+ set( ${result} ${TDE_SCM_MODULE_DATETIME} )
+ else( )
+ tde_execute_process( COMMAND "date" "-u" "+%m/%d/%Y %H:%M:%S" OUTPUT_VARIABLE ${result} )
+ string( REGEX REPLACE "(..)/(..)/(....) (........).*" "\\1/\\2/\\3 \\4" ${result} ${${result}} )
+ endif( )
+endmacro( tde_curdatetime )
+
+
+#################################################
+#####
+##### tde_add_executable
+
+macro( tde_add_executable _arg_target )
+
+ unset( _target )
+ unset( _automoc )
+ unset( _meta_includes )
+ unset( _setuid )
+ unset( _sources )
+ unset( _cxx_features )
+ unset( _destination )
+ unset( _link )
+ unset( _dependencies )
+ unset( _storage )
+
+ # metadata
+ unset( _description )
+ unset( _license )
+ unset( _copyright )
+ unset( _authors )
+ unset( _product )
+ unset( _organization )
+ unset( _version )
+ unset( _datetime )
+ unset( _notes )
+
+ # default metadata
+ set( _product "Trinity Desktop Environment" )
+ set( _version "${TDE_VERSION}" )
+ if( TDE_PKG_VERSION )
+ set( _version "${_version} (${TDE_PKG_VERSION})" )
+ endif( )
+ tde_curdatetime( _datetime )
+
+ foreach( _arg ${ARGV} )
+
+ # this variable help us to skip
+ # storing unapropriate values (i.e. directives)
+ unset( _skip_store )
+
+ # found directive "AUTOMOC"
+ if( "+${_arg}" STREQUAL "+AUTOMOC" )
+ set( _skip_store 1 )
+ set( _automoc 1 )
+ endif( "+${_arg}" STREQUAL "+AUTOMOC" )
+
+ # found directive "META_INCLUDES"
+ if( "+${_arg}" STREQUAL "+META_INCLUDES" )
+ set( _skip_store 1 )
+ set( _storage "_meta_includes" )
+ endif( )
+
+ # found directive "SETUID"
+ if( "+${_arg}" STREQUAL "+SETUID" )
+ set( _skip_store 1 )
+ set( _setuid 1 )
+ endif( "+${_arg}" STREQUAL "+SETUID" )
+
+ # found directive "SOURCES"
+ if( "+${_arg}" STREQUAL "+SOURCES" )
+ set( _skip_store 1 )
+ set( _storage "_sources" )
+ endif( "+${_arg}" STREQUAL "+SOURCES" )
+
+ # found directive "CXX_FEATURES"
+ if( "+${_arg}" STREQUAL "+CXX_FEATURES" )
+ set( _skip_store 1 )
+ set( _storage "_cxx_features" )
+ endif( "+${_arg}" STREQUAL "+CXX_FEATURES" )
+
+ # found directive "LINK"
+ if( "+${_arg}" STREQUAL "+LINK" )
+ set( _skip_store 1 )
+ set( _storage "_link" )
+ endif( "+${_arg}" STREQUAL "+LINK" )
+
+ # found directive "DEPENDENCIES"
+ if( "+${_arg}" STREQUAL "+DEPENDENCIES" )
+ set( _skip_store 1 )
+ set( _storage "_dependencies" )
+ endif( "+${_arg}" STREQUAL "+DEPENDENCIES" )
+
+ # found directive "DESTINATION"
+ if( "+${_arg}" STREQUAL "+DESTINATION" )
+ set( _skip_store 1 )
+ set( _storage "_destination" )
+ unset( ${_storage} )
+ endif( "+${_arg}" STREQUAL "+DESTINATION" )
+
+ # metadata
+ if( "+${_arg}" STREQUAL "+DESCRIPTION" )
+ set( _skip_store 1 )
+ set( _storage "_description" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+LICENSE" )
+ set( _skip_store 1 )
+ set( _storage "_license" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+COPYRIGHT" )
+ set( _skip_store 1 )
+ set( _storage "_copyright" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+AUTHORS" )
+ set( _skip_store 1 )
+ set( _storage "_authors" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+PRODUCT" )
+ set( _skip_store 1 )
+ set( _storage "_product" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+ORGANIZATION" )
+ set( _skip_store 1 )
+ set( _storage "_organization" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+VERSION" )
+ set( _skip_store 1 )
+ set( _storage "_version" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+DATETIME" )
+ set( _skip_store 1 )
+ set( _storage "_datetime" )
+ endif( )
+ if( "+${_arg}" STREQUAL "+NOTES" )
+ set( _skip_store 1 )
+ set( _storage "_notes" )
+ endif( )
+
+ # storing value
+ if( _storage AND NOT _skip_store )
+ #set( ${_storage} "${${_storage}} ${_arg}" )
+ list( APPEND ${_storage} ${_arg} )
+ endif( _storage AND NOT _skip_store )
+
+ endforeach( _arg )
+
+ set( _target "${_arg_target}" )
+
+ # disallow target without sources
+ if( NOT _sources )
+ message( FATAL_ERROR "\nTarget [$_target] have no sources." )
+ endif( NOT _sources )
+
+ # processing different types of sources
+ __tde_internal_process_sources( _sources ${_sources} )
+
+ # set automoc
+ if( _automoc )
+ tde_automoc( ${_sources} )
+ endif( _automoc )
+
+ # add target
+ add_executable( ${_target} ${_sources} )
+
+ # set cxx features
+ if( TDE_CXX_FEATURES OR PROJECT_CXX_FEATURES OR _cxx_features )
+ target_compile_features( ${_target} PRIVATE
+ ${TDE_CXX_FEATURES} ${PROJECT_CXX_FEATURES} ${_cxx_features} )
+ endif( )
+
+ # set link libraries
+ if( _link )
+ target_link_libraries( ${_target} ${_link} )
+ endif( _link )
+
+ # set dependencies
+ if( _dependencies )
+ add_dependencies( ${_target} ${_dependencies} )
+ endif( _dependencies )
+
+ # set PIE flags for setuid binaries
+ if( _setuid )
+ set_target_properties( ${_target} PROPERTIES COMPILE_FLAGS "${TDE_PIE_CFLAGS}" )
+ set_target_properties( ${_target} PROPERTIES LINK_FLAGS "${TDE_PIE_LDFLAGS}" )
+ endif( _setuid )
+
+ # set destination directory
+ if( _destination )
+ if( _setuid )
+ install( TARGETS ${_target} DESTINATION ${_destination} PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_EXECUTE WORLD_EXECUTE SETUID )
+ else( _setuid )
+ install( TARGETS ${_target} DESTINATION ${_destination} )
+ endif( _setuid )
+ endif( _destination )
+
+ # embed icon, name, and metadata
+ set( ELF_EMBEDDING_METADATA "\"${_target}\" \"${_description}\" \"${_license}\" \"${_copyright}\" \"${_authors}\" \"${_product}\" \"${_organization}\" \"${_version}\" \"${_datetime}\" \"${_target}\" \"${TDE_SCM_MODULE_NAME}\" \"${TDE_SCM_MODULE_REVISION}\" \"${_notes}\"" )
+ separate_arguments( ELF_EMBEDDING_METADATA )
+ if( TDELFEDITOR_EXECUTABLE )
+ get_filename_component( _target_path ${CMAKE_CURRENT_BINARY_DIR}/${_target} ABSOLUTE )
+ file( RELATIVE_PATH _target_path "${CMAKE_BINARY_DIR}" "${_target_path}" )
+ if( TARGET ${TDELFEDITOR_EXECUTABLE} )
+ # create target for all metadata writes
+ if( NOT TARGET tdelfeditor-write )
+ add_custom_target( tdelfeditor-write
+ WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
+ DEPENDS ${TDELFEDITOR_EXECUTABLE}
+ COMMENT "Write metadata to binaries..."
+ )
+ endif( )
+ add_custom_target(
+ ${_target}+metadata ALL
+ COMMAND ${TDELFEDITOR_EXECUTABLE} -m ${CMAKE_CURRENT_BINARY_DIR}/${_target} ${ELF_EMBEDDING_METADATA} || true
+ COMMAND ${TDELFEDITOR_EXECUTABLE} -e ${CMAKE_CURRENT_BINARY_DIR}/${_target} || true
+ COMMENT "Storing SCM metadata in ${_target_path}"
+ DEPENDS tdelfeditor-write
+ )
+ add_dependencies( tdelfeditor-write ${_target} )
+ else()
+ add_custom_command(
+ TARGET ${_target}
+ POST_BUILD
+ COMMAND ${TDELFEDITOR_EXECUTABLE} -m ${CMAKE_CURRENT_BINARY_DIR}/${_target} ${ELF_EMBEDDING_METADATA} || true
+ COMMAND ${TDELFEDITOR_EXECUTABLE} -e ${CMAKE_CURRENT_BINARY_DIR}/${_target} || true
+ COMMAND ${TDELFEDITOR_EXECUTABLE} -t ${CMAKE_CURRENT_BINARY_DIR}/${_target} ${_target} || true
+ COMMENT "Storing SCM metadata in ${_target_path}"
+ )
+ endif()
+ endif( TDELFEDITOR_EXECUTABLE )
+
+endmacro( tde_add_executable )
+
+
+#################################################
+#####
+##### tde_add_check_executable
+
+macro( tde_add_check_executable _arg_target )
+
+ unset( _target )
+ unset( _automoc )
+ unset( _test )
+ unset( _test_args )
+ unset( _meta_includes )
+ unset( _sources )
+ unset( _cxx_features )
+ unset( _destination )
+ unset( _link )
+ unset( _dependencies )
+ unset( _storage )
+
+ foreach( _arg ${ARGV} )
+
+ # this variable help us to skip
+ # storing unapropriate values (i.e. directives)
+ unset( _skip_store )
+
+ # found directive "AUTOMOC"
+ if( "+${_arg}" STREQUAL "+AUTOMOC" )
+ set( _skip_store 1 )
+ set( _automoc 1 )
+ endif( "+${_arg}" STREQUAL "+AUTOMOC" )
+
+ # found directive "TEST"
+ if( "+${_arg}" STREQUAL "+TEST" )
+ set( _skip_store 1 )
+ set( _test 1 )
+ set( _storage "_test_args" )
+ endif( "+${_arg}" STREQUAL "+TEST" )
+
+ # found directive "META_INCLUDES"
+ if( "+${_arg}" STREQUAL "+META_INCLUDES" )
+ set( _skip_store 1 )
+ set( _storage "_meta_includes" )
+ endif( )
+
+ # found directive "SOURCES"
+ if( "+${_arg}" STREQUAL "+SOURCES" )
+ set( _skip_store 1 )
+ set( _storage "_sources" )
+ endif( "+${_arg}" STREQUAL "+SOURCES" )
+
+ # found directive "CXX_FEATURES"
+ if( "+${_arg}" STREQUAL "+CXX_FEATURES" )
+ set( _skip_store 1 )
+ set( _storage "_cxx_features" )
+ endif( "+${_arg}" STREQUAL "+CXX_FEATURES" )
+
+ # found directive "LINK"
+ if( "+${_arg}" STREQUAL "+LINK" )
+ set( _skip_store 1 )
+ set( _storage "_link" )
+ endif( "+${_arg}" STREQUAL "+LINK" )
+
+ # found directive "DEPENDENCIES"
+ if( "+${_arg}" STREQUAL "+DEPENDENCIES" )
+ set( _skip_store 1 )
+ set( _storage "_dependencies" )
+ endif( "+${_arg}" STREQUAL "+DEPENDENCIES" )
+
+ # storing value
+ if( _storage AND NOT _skip_store )
+ #set( ${_storage} "${${_storage}} ${_arg}" )
+ list( APPEND ${_storage} ${_arg} )
+ endif( _storage AND NOT _skip_store )
+
+ endforeach( _arg )
+
+ set( _target "${_arg_target}" )
+
+ # try to autodetect sources
+ if( NOT _sources )
+ file( GLOB _sources "${_target}.cpp" "${_target}.cxx" "${_target}.c" )
+ if( NOT _sources )
+ message( FATAL_ERROR "\nNo sources found for test executable \"${_target}\"." )
+ endif( )
+ endif( NOT _sources )
+
+ # processing different types of sources
+ __tde_internal_process_sources( _sources ${_sources} )
+
+ # set automoc
+ if( _automoc )
+ tde_automoc( ${_sources} )
+ endif( _automoc )
+
+ # add target
+ add_executable( ${_target} EXCLUDE_FROM_ALL ${_sources} )
+
+ # set cxx features
+ if( TDE_CXX_FEATURES OR PROJECT_CXX_FEATURES OR _cxx_features )
+ target_compile_features( ${_target} PRIVATE
+ ${TDE_CXX_FEATURES} ${PROJECT_CXX_FEATURES} ${_cxx_features} )
+ endif( )
+
+ # set link libraries
+ if( _link )
+ target_link_libraries( ${_target} ${_link} )
+ endif( _link )
+
+ # set dependencies
+ if( _dependencies )
+ add_dependencies( ${_target} ${_dependencies} )
+ endif( _dependencies )
+
+ # create make check target
+ if(NOT TARGET check)
+ add_custom_target( check
+ COMMAND ${CMAKE_CTEST_COMMAND}
+ WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
+ COMMENT "Running tests..." )
+ endif(NOT TARGET check)
+
+ add_dependencies( check ${_target} )
+
+ # add test target
+ if( _test )
+ # get relative path to current directory and strip end tests dir
+ file( RELATIVE_PATH _test_prefix ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR} )
+ string( REGEX REPLACE "(^\\.+/?|(^|/)tests?$|/$)" "" _test_prefix "${_test_prefix}" )
+ if( _test_prefix )
+ set( _test_prefix "${_test_prefix}/" )
+ endif( _test_prefix )
+ add_test( NAME "${_test_prefix}${_target}" COMMAND "${_target}" ${_test_args} )
+ endif( _test )
+
+endmacro( tde_add_check_executable )
+
+
+#################################################
+#####
+##### tde_add_tdeinit_executable
+
+macro( tde_add_tdeinit_executable _target )
+
+ configure_file( ${TDE_CMAKE_TEMPLATES}/tde_tdeinit_executable.cmake ${_target}_tdeinit_executable.cpp COPYONLY )
+ configure_file( ${TDE_CMAKE_TEMPLATES}/tde_tdeinit_module.cmake ${_target}_tdeinit_module.cpp COPYONLY )
+
+ unset( _sources )
+ unset( _runtime_destination )
+ unset( _library_destination )
+ unset( _plugin_destination )
+
+ # default storage is _sources
+ set( _storage _sources )
+
+ # set default export to NO_EXPORT
+ set( _export "NO_EXPORT" )
+
+ foreach( _arg ${ARGN} )
+
+ # this variable help us to skip
+ # storing unapropriate values (i.e. directives)
+ unset( _skip_store )
+
+ # found directive "EXPORT"
+ if( "+${_arg}" STREQUAL "+EXPORT" )
+ set( _skip_store 1 )
+ unset( _export )
+ endif( "+${_arg}" STREQUAL "+EXPORT" )
+
+ # found directive "RUNTIME_DESTINATION"
+ if( "+${_arg}" STREQUAL "+RUNTIME_DESTINATION" )
+ set( _skip_store 1 )
+ set( _storage "_runtime_destination" )
+ unset( ${_storage} )
+ endif( "+${_arg}" STREQUAL "+RUNTIME_DESTINATION" )
+
+ # found directive "LIBRARY_DESTINATION"
+ if( "+${_arg}" STREQUAL "+LIBRARY_DESTINATION" )
+ set( _skip_store 1 )
+ set( _storage "_library_destination" )
+ unset( ${_storage} )
+ endif( "+${_arg}" STREQUAL "+LIBRARY_DESTINATION" )
+
+ # found directive "PLUGIN_DESTINATION"
+ if( "+${_arg}" STREQUAL "+PLUGIN_DESTINATION" )
+ set( _skip_store 1 )
+ set( _storage "_plugin_destination" )
+ unset( ${_storage} )
+ endif( "+${_arg}" STREQUAL "+PLUGIN_DESTINATION" )
+
+ # storing value
+ if( _storage AND NOT _skip_store )
+ list( APPEND ${_storage} ${_arg} )
+ set( _storage "_sources" )
+ endif( _storage AND NOT _skip_store )
+
+ endforeach( _arg )
+
+ # if destinations are not set, we using some defaults
+ # we assume that tdeinit executable MUST be installed
+ # (otherwise why we build it?)
+ if( NOT _runtime_destination )
+ set( _runtime_destination ${BIN_INSTALL_DIR} )
+ endif( NOT _runtime_destination )
+ if( NOT _library_destination )
+ set( _library_destination ${LIB_INSTALL_DIR} )
+ endif( NOT _library_destination )
+ if( NOT _plugin_destination )
+ set( _plugin_destination ${PLUGIN_INSTALL_DIR} )
+ endif( NOT _plugin_destination )
+
+ # create the library
+ tde_add_library( tdeinit_${_target} ${_sources} SHARED ${_export}
+ DESTINATION ${_library_destination}
+ )
+
+ # create the executable
+ tde_add_executable( ${_target}
+ SOURCES ${CMAKE_CURRENT_BINARY_DIR}/${_target}_tdeinit_executable.cpp
+ LINK tdeinit_${_target}-shared
+ DESTINATION ${_runtime_destination}
+ )
+
+ # create the plugin
+ tde_add_kpart( ${_target}
+ SOURCES ${CMAKE_CURRENT_BINARY_DIR}/${_target}_tdeinit_module.cpp
+ LINK tdeinit_${_target}-shared
+ DESTINATION ${_plugin_destination}
+ )
+
+endmacro( tde_add_tdeinit_executable )
+
+
+#################################################
+#####
+##### tde_conditional_add_project_translations
+##### tde_add_project_translations
+#####
+##### Macro for standard processing and installation of translations.
+##### This is designed for ordinary modules - as an applications, not for core modules.
+
+function( tde_conditional_add_project_translations _cond )
+
+ if( ${_cond} )
+ tde_add_project_translations()
+ endif()
+
+endfunction()
+
+function( tde_add_project_translations )
+
+ if( ${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR} )
+ set( TRANSLATIONS_SOURCE_DIR ${PROJECT_SOURCE_DIR}/translations/messages )
+ else()
+ set( TRANSLATIONS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} )
+ endif()
+
+ file( GLOB_RECURSE po_files RELATIVE ${TRANSLATIONS_SOURCE_DIR} ${TRANSLATIONS_SOURCE_DIR}/*.po )
+ string( REGEX REPLACE "[ \r\n\t]+" ";" _linguas "$ENV{LINGUAS}" )
+
+ foreach( _po ${po_files} )
+ get_filename_component( _lang ${_po} NAME_WE )
+ if( "${_linguas}" MATCHES "^;*$" OR ";${_linguas};" MATCHES ";${_lang};" )
+ if( "${_po}" MATCHES "^([^/]*)/.*" )
+ string( REGEX REPLACE "^([^/]*)/.*" "\\1" _component "${_po}" )
+ else( )
+ set( _component "${PROJECT_NAME}" )
+ endif( )
+ tde_create_translation( FILES ${TRANSLATIONS_SOURCE_DIR}/${_po} LANG ${_lang} OUTPUT_NAME ${_component} )
+ endif( )
+ endforeach( )
+
+endfunction()
+
+
+#################################################
+#####
+##### tde_create_translation
+
+macro( tde_create_translation )
+
+ unset( _srcs )
+ unset( _lang )
+ unset( _dest )
+ unset( _out_name )
+ unset( _directive )
+ unset( _var )
+
+ foreach( _arg ${ARGN} )
+
+ # found directive "FILES"
+ if( "+${_arg}" STREQUAL "+FILES" )
+ unset( _srcs )
+ set( _var _srcs )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "LANG"
+ if( "+${_arg}" STREQUAL "+LANG" )
+ unset( _lang )
+ set( _var _lang )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "DESTINATION"
+ if( "+${_arg}" STREQUAL "+DESTINATION" )
+ unset( _dest )
+ set( _var _dest )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "OUTPUT_NAME"
+ if( "+${_arg}" STREQUAL "+OUTPUT_NAME" )
+ unset( _out_name )
+ set( _var _out_name )
+ set( _directive 1 )
+ endif( )
+
+ # collect data
+ if( _directive )
+ unset( _directive )
+ elseif( _var )
+ list( APPEND ${_var} ${_arg} )
+ endif()
+
+ endforeach( )
+
+ if( NOT MSGFMT_EXECUTABLE )
+ tde_setup_msgfmt( )
+ endif( )
+ if( NOT _lang )
+ tde_message_fatal( "missing LANG directive" )
+ endif( )
+
+ # if no file specified, include all *.po files
+ if( NOT _srcs )
+ file( GLOB _srcs RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.po )
+ endif( )
+ if( NOT _srcs )
+ tde_message_fatal( "no source files" )
+ endif( )
+
+ if( NOT _lang STREQUAL "auto")
+ set( _real_lang ${_lang} )
+
+ if( NOT _dest )
+ set( _dest "${LOCALE_INSTALL_DIR}/${_lang}/LC_MESSAGES" )
+ endif( )
+
+ # OUTPUT_NAME can only be used if we have only one file
+ list( LENGTH _srcs _srcs_num)
+ if( _out_name AND _srcs_num GREATER 1 )
+ tde_message_fatal( "OUTPUT_NAME can be supplied only with single file or LANG=auto" )
+ endif( )
+
+ elseif( NOT _out_name )
+ tde_message_fatal( "LANG=auto reqires OUTPUT_NAME directive to be set" )
+ elseif( _dest )
+ tde_message_fatal( "DESTINATION cannot be used with LANG=auto" )
+ endif( )
+
+ # generate *.mo files
+ foreach( _src ${_srcs} )
+
+ get_filename_component( _src ${_src} ABSOLUTE )
+
+ if( _out_name )
+ set( _out ${_out_name} )
+ if( _lang STREQUAL "auto" )
+ get_filename_component( _real_lang ${_src} NAME_WE )
+ set( _dest "${LOCALE_INSTALL_DIR}/${_real_lang}/LC_MESSAGES" )
+ endif( )
+ else( )
+ get_filename_component( _out ${_src} NAME_WE )
+ endif( )
+
+ string( REPLACE "@" "_" _target ${_real_lang} )
+ set( _out_filename "${_out}-${_real_lang}.mo" )
+ set( _install_filename "${_out}.mo" )
+
+ add_custom_command(
+ OUTPUT ${_out_filename}
+ COMMAND ${MSGFMT_EXECUTABLE} ${_src} -o ${_out_filename}
+ DEPENDS ${_src} )
+ add_custom_target( "${_out}-${_target}-translation" ALL DEPENDS ${_out_filename} )
+ install( FILES ${CMAKE_CURRENT_BINARY_DIR}/${_out_filename} RENAME ${_install_filename} DESTINATION ${_dest} )
+
+ endforeach( )
+
+endmacro( )
+
+
+#################################################
+#####
+##### tde_create_translated_desktop
+#####
+##### Macro is used to merge translations into desktop file
+#####
+##### Syntax:
+##### tde_create_translated_desktop(
+##### [SOURCE] file_name
+##### [KEYWORDS keyword [keyword]]
+##### [FORMAT (desktop|xml)]
+##### [PO_DIR po_directory]
+##### [DESTINATION directory]
+##### [OUTPUT_NAME file_name]
+##### )
+
+macro( tde_create_translated_desktop )
+
+ unset( _srcs )
+ unset( _arg_out_name )
+ unset( _arg_po_dir )
+ unset( _keywords_add )
+ unset( _dest )
+ unset( _directive )
+ set( _var _srcs )
+ set( _keywords_desktop_default
+ "Name" "GenericName" "Comment" "Keywords"
+ "Description" "ExtraNames" "X-TDE-Submenu" )
+ set( _format "desktop" )
+
+ foreach( _arg ${ARGN} )
+
+ # found directive "SOURCE"
+ if( "+${_arg}" STREQUAL "+SOURCE" )
+ unset( _srcs )
+ set( _var _srcs )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "KEYWORDS"
+ if( "+${_arg}" STREQUAL "+KEYWORDS" )
+ unset( _keywords_add )
+ set( _var _keywords_add )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "FORMAT"
+ if( "+${_arg}" STREQUAL "+FORMAT" )
+ unset( _format )
+ set( _var _format )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "PO_DIR"
+ if( "+${_arg}" STREQUAL "+PO_DIR" )
+ unset( _arg_po_dir )
+ set( _var _arg_po_dir )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "DESTINATION"
+ if( "+${_arg}" STREQUAL "+DESTINATION" )
+ unset( _dest )
+ set( _var _dest )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "OUTPUT_NAME"
+ if( "+${_arg}" STREQUAL "+OUTPUT_NAME" )
+ unset( _arg_out_name )
+ set( _var _arg_out_name )
+ set( _directive 1 )
+ endif( )
+
+ # collect data
+ if( _directive )
+ unset( _directive )
+ elseif( _var )
+ list( APPEND ${_var} ${_arg} )
+ endif()
+
+ endforeach( )
+
+ # no source file specified!
+ if( NOT _srcs )
+ tde_message_fatal( "no source desktop file specified" )
+ endif( )
+
+ # OUTPUT_NAME can only be used if we have only one file
+ list( LENGTH _srcs _srcs_num )
+ if( _arg_out_name AND _srcs_num GREATER 1 )
+ tde_message_fatal( "OUTPUT_NAME can be supplied only with single file" )
+ endif( )
+
+ # if no destination directory specified, install as application link
+ if( NOT _dest )
+ set( _dest ${XDG_APPS_INSTALL_DIR} )
+ endif( )
+
+ # select a tool for merging desktop file translations
+ #
+ # Because some of our desktop files contain underscores in variable
+ # names (for example eventsrc), which is not an allowed character
+ # for names of entries in desktop style files, we can't use msgfmt,
+ # so we need intltool-merge.
+ #
+ #if( NOT MSGFMT_EXECUTABLE OR NOT MSGFMT_VERSION )
+ # tde_setup_msgfmt( )
+ #endif( )
+ #if( "${MSGFMT_VERSION}" VERSION_LESS "0.19" )
+ if( 1 )
+ if( NOT PERL_EXECUTABLE )
+ include( FindPerl )
+ endif( )
+ if( NOT INTLTOOL_MERGE_EXECUTABLE )
+ find_file( INTLTOOL_MERGE_EXECUTABLE
+ NAMES tde_l10n_merge.pl
+ HINTS ${TDE_CMAKE_MODULES}
+ )
+ if( "${INTLTOOL_MERGE_EXECUTABLE}" STREQUAL "INTLTOOL_MERGE_EXECUTABLE-NOTFOUND" )
+ #tde_message_fatal( "xgettext >= 0.19 or tde_l10n_merge.pl is required but not found" )
+ tde_message_fatal( "tde_l10n_merge.pl is required but not found" )
+ endif( )
+ message( STATUS "Found intltool: ${INTLTOOL_MERGE_EXECUTABLE}" )
+ endif( )
+ set( DESKTOP_MERGE_INTLTOOL 1 )
+ else( )
+ set( DESKTOP_MERGE_MSGFMT 1 )
+ endif( )
+
+ # pick keywords
+ unset( _keywords_desktop )
+ foreach( _keyword ${_keywords_desktop_default} ${_keywords_add} )
+ if( "${_keyword}" STREQUAL "-" )
+ unset( _keywords_desktop )
+ unset( _keyword )
+ endif( )
+ if( _keyword )
+ list( APPEND _keywords_desktop "${_keyword}" )
+ endif( )
+ endforeach( )
+
+ # prepare the length of the binary path prefix
+ string( LENGTH "${CMAKE_BINARY_DIR}" CMAKE_BINARY_DIR_LEN )
+
+ # process source files
+ foreach( _src IN LISTS _srcs )
+
+ # get a base name and a directory
+ get_filename_component( _basename ${_src} ABSOLUTE )
+ get_filename_component( _basedir ${_basename} PATH )
+ file( RELATIVE_PATH _sourcename "${CMAKE_SOURCE_DIR}" "${_basename}" )
+ string( LENGTH "${_basename}" _basename_len )
+ if( ${_basename_len} LESS ${CMAKE_BINARY_DIR_LEN} )
+ set( _basedir_prefix "${CMAKE_SOURCE_DIR}" )
+ else( )
+ string( SUBSTRING "${_basename}" 0 ${CMAKE_BINARY_DIR_LEN} _basedir_prefix )
+ endif( )
+ if( ${_basedir_prefix} STREQUAL "${CMAKE_BINARY_DIR}" )
+ file( RELATIVE_PATH _basename "${CMAKE_CURRENT_BINARY_DIR}" "${_basename}" )
+ set( _binsuffix ".out" )
+ else( )
+ file( RELATIVE_PATH _basename "${CMAKE_CURRENT_SOURCE_DIR}" "${_basename}" )
+ set( _binsuffix "" )
+ endif( )
+
+ # prepare the binary directory according to source directory
+ if( ${_basedir_prefix} STREQUAL "${CMAKE_BINARY_DIR}" )
+ file( RELATIVE_PATH _binary_basedir "${CMAKE_CURRENT_BINARY_DIR}" "${_basedir}" )
+ else( )
+ file( RELATIVE_PATH _binary_basedir "${CMAKE_CURRENT_SOURCE_DIR}" "${_basedir}" )
+ endif( )
+ set( _binary_basedir "${CMAKE_CURRENT_BINARY_DIR}/${_binary_basedir}" )
+ file( MAKE_DIRECTORY "${_binary_basedir}" )
+
+ # process source file as a configuration file if necessary
+ if( "+${_src}" MATCHES "\\.cmake$" )
+ configure_file( ${_src} ${_basename} @ONLY )
+ set( _src "${CMAKE_CURRENT_BINARY_DIR}/${_basename}" )
+ string( REGEX REPLACE "\\.cmake$" "" _basename "${_basename}" )
+ endif()
+
+ # determine output name
+ if( _arg_out_name )
+ set( _out_name ${_arg_out_name} )
+ else()
+ get_filename_component( _out_name ${_basename} NAME )
+ endif( )
+
+ # determine po directory
+ if( _arg_po_dir )
+ set( _po_base ${_arg_po_dir} )
+ else()
+ get_filename_component( _po_base ${_basename} NAME )
+ endif()
+ if( IS_ABSOLUTE ${_po_base} )
+ set( _po_dir ${_po_base} )
+ else()
+ if( EXISTS ${CMAKE_SOURCE_DIR}/translations/desktop_files/${_po_base} AND
+ IS_DIRECTORY ${CMAKE_SOURCE_DIR}/translations/desktop_files/${_po_base} )
+ set( _po_dir ${CMAKE_SOURCE_DIR}/translations/desktop_files/${_po_base} )
+
+ elseif( EXISTS ${CMAKE_SOURCE_DIR}/po/desktop_files/${_po_base} AND
+ IS_DIRECTORY ${CMAKE_SOURCE_DIR}/po/desktop_files/${_po_base} )
+ set( _po_dir ${CMAKE_SOURCE_DIR}/po/desktop_files/${_po_base} )
+
+ else()
+ set( _po_dir ${CMAKE_SOURCE_DIR}/translations/desktop_files )
+ endif( )
+ endif( )
+
+ # if the translated desktop file is not installed, generate to the specified output name
+ if( "${_dest}" STREQUAL "-" )
+ set( _basename "${_out_name}" )
+ set( _binsuffix "" )
+ get_filename_component( _out_dir "${CMAKE_CURRENT_BINARY_DIR}/${_out_name}" PATH )
+ file( MAKE_DIRECTORY "${_out_dir}" )
+ endif( )
+
+ # are there any translations available?
+ unset( _translations )
+ if( EXISTS "${_po_dir}" AND IS_DIRECTORY "${_po_dir}" )
+ file( GLOB _translations RELATIVE "${_po_dir}" "${_po_dir}/*.po" )
+ endif( )
+
+ # prepare a full name for the target
+ get_filename_component( _target ${_basename} ABSOLUTE )
+ file( RELATIVE_PATH _target "${CMAKE_SOURCE_DIR}" "${_target}-translated" )
+ string( REPLACE "/" "+" _target "${_target}" )
+ string( REPLACE "@" "_" _target "${_target}" )
+ string( REPLACE " " "_" _target "${_target}" )
+
+ if( NOT TARGET ${_target} )
+
+ # use absolute path for src
+ get_filename_component( _src ${_src} ABSOLUTE )
+
+ if( _translations )
+
+ if( DESKTOP_MERGE_MSGFMT )
+
+ # Decide which translations to build; the ones selected in the
+ # LINGUAS environment variable, or all that are available.
+ if( DEFINED ENV{LINGUAS} )
+ set( _linguas "$ENV{LINGUAS}" )
+ else( )
+ string( REPLACE ".po;" " " _linguas "${_translations};" )
+ endif( )
+
+ # prepare keywords for msgfmt
+ set( _keywords_arg "--keyword=" )
+ foreach( _keyword ${_keywords_desktop} )
+ list( APPEND _keywords_arg "--keyword=\"${_keyword}\"" )
+ endforeach( )
+
+ # merge translations command
+ add_custom_command(
+ OUTPUT ${_basename}${_binsuffix}
+ COMMAND ${CMAKE_COMMAND} -E env "LINGUAS=${_linguas}" ${MSGFMT_EXECUTABLE} --desktop --template ${_src} -d ${_po_dir} -o ${_basename}${_binsuffix} ${_keywords_arg}
+ DEPENDS ${_src}
+ COMMENT "Merging translations into ${_sourcename}"
+ )
+
+ else( )
+
+ # prepare keywords for intltool
+ string( REPLACE ";" "|" _keywords_match "(${_keywords_desktop})" )
+
+ # merge translations command
+ if( _format STREQUAL "desktop" )
+ add_custom_command(
+ OUTPUT ${_basename}${_binsuffix}
+ COMMAND ${PERL_EXECUTABLE} -p -e "'s/^${_keywords_match}[ ]*=[ ]*/_\\1=/'" < ${_src} > ${_basename}.in
+ COMMAND ${PERL_EXECUTABLE} ${INTLTOOL_MERGE_EXECUTABLE} -q -d ${_po_dir} ${_basename}.in ${_basename}${_binsuffix}
+ DEPENDS ${_src}
+ COMMENT "Merging translations into ${_sourcename}"
+ )
+ elseif( _format STREQUAL "xml" )
+ add_custom_command(
+ OUTPUT ${_basename}${_binsuffix}
+ COMMAND ${PERL_EXECUTABLE} -p -e "'s/(<\\/?)${_keywords_match}([ >])/\\1_\\2\\3/g'" < ${_src} > ${_basename}.in
+ COMMAND ${PERL_EXECUTABLE} ${INTLTOOL_MERGE_EXECUTABLE} -q -x ${_po_dir} ${_basename}.in ${_basename}${_binsuffix}
+ DEPENDS ${_src}
+ COMMENT "Merging translations into ${_sourcename}"
+ )
+ else()
+ tde_message_fatal( "Unknown file format for merging translations." )
+ endif()
+
+ endif( )
+
+
+ else( )
+
+ # just copy the original file without translations
+ add_custom_command(
+ OUTPUT ${_basename}${_binsuffix}
+ COMMAND ${CMAKE_COMMAND} -E copy ${_src} ${_basename}${_binsuffix}
+ DEPENDS ${_src}
+ COMMENT "Skiping translation and copying source file to ${_sourcename}"
+ )
+
+ endif( )
+
+ # merge translations target
+ add_custom_target( "${_target}" ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${_basename}${_binsuffix} )
+
+ endif( )
+
+ # install traslated desktop file
+ if( NOT "${_dest}" STREQUAL "-" )
+ install(
+ FILES ${CMAKE_CURRENT_BINARY_DIR}/${_basename}${_binsuffix}
+ RENAME ${_out_name}
+ DESTINATION ${_dest}
+ )
+ endif()
+
+ endforeach()
+
+endmacro( )
+
+
+#################################################
+#####
+##### tde_conditional_add_project_docs
+##### tde_add_project_docs
+#####
+##### Macro for standard processing and installation of documentation and man pages.
+##### This is designed for ordinary modules - as an applications, not for core modules.
+
+function( tde_conditional_add_project_docs _cond )
+
+ if( ${_cond} )
+ tde_add_project_docs()
+ endif()
+
+endfunction()
+
+function( tde_add_project_docs )
+
+ if( ${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR} )
+ set( DOCS_SOURCE_DIR ${PROJECT_SOURCE_DIR}/doc )
+ else()
+ set( DOCS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} )
+ endif()
+
+ file( GLOB_RECURSE _doc_files RELATIVE ${DOCS_SOURCE_DIR} ${DOCS_SOURCE_DIR}/* )
+ foreach( _doc_file IN LISTS _doc_files )
+ get_filename_component( _dir ${_doc_file} PATH )
+ list( APPEND _dirs ${_dir} )
+ endforeach()
+ if( _dirs )
+ list( SORT _dirs )
+ list( REMOVE_DUPLICATES _dirs )
+ endif()
+
+ string( REGEX REPLACE "[ \r\n\t]+" ";" _linguas "$ENV{LINGUAS}" )
+
+ unset( _skip_subdir )
+ foreach( _dir IN LISTS _dirs )
+ string( REGEX REPLACE "/.*" "" _lang ${_dir} )
+ if( NOT ${_lang} MATCHES "^(html|man|misc|other)$"
+ AND ( NOT DEFINED _skip_subdir OR
+ NOT ${_dir} MATCHES "^${_skip_subdir}/" )
+ AND ( ${_lang} STREQUAL "en" OR
+ "${_linguas}" MATCHES "^;*$" OR
+ ";${_linguas};" MATCHES ";${_lang};" ))
+ if( EXISTS ${DOCS_SOURCE_DIR}/${_dir}/CMakeLists.txt )
+ set( _skip_subdir ${_dir} )
+ add_subdirectory( ${DOCS_SOURCE_DIR}/${_dir} )
+ else()
+ unset( _skip_subdir )
+ if( ${_dir} MATCHES "/[^/]*/" )
+ string( REGEX REPLACE "^[^/]*/(.*)" "\\1" _doc_dest "${_dir}" )
+ else()
+ string( REGEX REPLACE "^[^/]*/(.*)" "\\1" _doc_dest "${_dir}/${PROJECT_NAME}" )
+ endif()
+ file( GLOB _doc_files RELATIVE ${DOCS_SOURCE_DIR}/${_dir} ${DOCS_SOURCE_DIR}/${_dir}/*.docbook )
+ if( _doc_files )
+ list( FIND _doc_files "index.docbook" _find_index )
+ if( -1 EQUAL _find_index )
+ set( _noindex "NOINDEX" )
+ else()
+ unset( _noindex )
+ endif()
+ tde_create_handbook(
+ SOURCE_BASEDIR ${DOCS_SOURCE_DIR}/${_dir}
+ ${_noindex}
+ LANG ${_lang}
+ DESTINATION ${_doc_dest}
+ )
+ else()
+ file( GLOB _html_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${DOCS_SOURCE_DIR}/${_dir}/*.html )
+ if( _html_files )
+ file( GLOB _htmldoc_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+ ${DOCS_SOURCE_DIR}/${_dir}/*.css
+ ${DOCS_SOURCE_DIR}/${_dir}/*.gif
+ ${DOCS_SOURCE_DIR}/${_dir}/*.jpg
+ ${DOCS_SOURCE_DIR}/${_dir}/*.png
+ )
+ install(
+ FILES ${_html_files} ${_htmldoc_files}
+ DESTINATION ${HTML_INSTALL_DIR}/${_lang}/${_doc_dest}
+ )
+ endif()
+ endif()
+ endif()
+ endif()
+ endforeach()
+
+ if( EXISTS ${DOCS_SOURCE_DIR}/man AND
+ NOT EXISTS ${DOCS_SOURCE_DIR}/man/CMakeLists.txt )
+ file( GLOB_RECURSE _man_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${DOCS_SOURCE_DIR}/man/* )
+ foreach( _man_file IN LISTS _man_files )
+ if( ${_man_file} MATCHES "\\.[0-9]$" )
+ string( REGEX REPLACE ".*\\.([0-9])$" "\\1" _man_section "${_man_file}" )
+ list( APPEND _man_files_${_man_section} "${_man_file}" )
+ list( APPEND _man_sections "${_man_section}" )
+ endif()
+ endforeach()
+ foreach( _man_section IN LISTS _man_sections )
+ INSTALL(
+ FILES ${_man_files_${_man_section}}
+ DESTINATION ${MAN_INSTALL_DIR}/man${_man_section}
+ COMPONENT doc
+ )
+ endforeach()
+ endif()
+
+ if( EXISTS ${DOCS_SOURCE_DIR}/misc AND
+ NOT EXISTS ${DOCS_SOURCE_DIR}/misc/CMakeLists.txt )
+ install(
+ DIRECTORY ${DOCS_SOURCE_DIR}/misc/
+ DESTINATION ${SHARE_INSTALL_PREFIX}/doc/${PROJECT_NAME}
+ COMPONENT doc
+ PATTERN Makefile.am EXCLUDE
+ )
+ endif()
+
+ foreach( _dir html man misc other )
+ if( EXISTS ${DOCS_SOURCE_DIR}/${_dir}/CMakeLists.txt )
+ add_subdirectory( ${DOCS_SOURCE_DIR}/${_dir} )
+ endif()
+ endforeach()
+
+endfunction( )
+
+
+#################################################
+#####
+##### tde_create_handbook
+
+macro( tde_create_handbook )
+
+ unset( _target )
+ unset( _dest )
+ unset( _noindex )
+ unset( _srcs )
+ unset( _extra )
+ unset( _srcdir )
+
+ get_filename_component( _source_basedir "${CMAKE_CURRENT_SOURCE_DIR}" ABSOLUTE )
+ set( _lang en )
+ set( _first_arg 1 )
+ set( _var _target )
+
+ foreach( _arg ${ARGN} )
+
+ # found directive "SOURCE_BASEDIR"
+ if( "+${_arg}" STREQUAL "+SOURCE_BASEDIR" )
+ unset( _source_basedir )
+ set( _var _source_basedir )
+ set( _directive 1 )
+ endif()
+
+ # found directive "NOINDEX"
+ if( "+${_arg}" STREQUAL "+NOINDEX" )
+ set( _noindex 1 )
+ set( _directive 1 )
+ endif()
+
+ # found directive "FILES"
+ if( "+${_arg}" STREQUAL "+FILES" )
+ unset( _srcs )
+ set( _var _srcs )
+ set( _directive 1 )
+ endif()
+
+ # found directive "EXTRA"
+ if( "+${_arg}" STREQUAL "+EXTRA" )
+ unset( _extra )
+ set( _var _extra )
+ set( _directive 1 )
+ endif()
+
+ # found directive "SRCDIR"
+ if( "+${_arg}" STREQUAL "+SRCDIR" )
+ unset( _srcdir )
+ set( _var _srcdir )
+ set( _directive 1 )
+ endif()
+
+ # found directive DESTINATION
+ if( "+${_arg}" STREQUAL "+DESTINATION" )
+ unset( _dest )
+ set( _var _dest )
+ set( _directive 1 )
+ endif()
+
+ # found directive "LANG"
+ if( "+${_arg}" STREQUAL "+LANG" )
+ unset( _lang )
+ set( _var _lang )
+ set( _directive 1 )
+ endif()
+
+ # collect data
+ if( _directive )
+ unset( _directive )
+ elseif( _var )
+ if( _first_arg )
+ set( _target "${_arg}" )
+ else()
+ list( APPEND ${_var} ${_arg} )
+ endif()
+ endif()
+
+ unset( _first_arg )
+
+ endforeach()
+
+ # if source_basedir is relative, complete the path to absolute
+ if( NOT IS_ABSOLUTE ${_source_basedir} )
+ get_filename_component( _source_basedir "${_source_basedir}" ABSOLUTE )
+ endif()
+
+ # prepare the binary directory according to source_basedir
+ file( RELATIVE_PATH _binary_basedir "${CMAKE_CURRENT_SOURCE_DIR}" "${_source_basedir}" )
+ set( _binary_basedir "${CMAKE_CURRENT_BINARY_DIR}/${_binary_basedir}" )
+ file( MAKE_DIRECTORY "${_binary_basedir}" )
+
+ # if no target specified, try to guess it from DESTINATION
+ if( NOT _target )
+ if( NOT _dest )
+ tde_message_fatal( "target name cannot be determined because DESTINATION is not set" )
+ endif()
+ string( REPLACE "/" "-" _target "${_dest}" )
+ endif()
+
+ set( _target "${_target}-${_lang}-handbook" )
+
+ # if sources are listed, complete the path to absolute
+ if( _srcs )
+ foreach( _src ${_srcs} )
+ if( NOT IS_ABSOLUTE ${_src} )
+ list( REMOVE_ITEM _srcs ${_src} )
+ get_filename_component( _src "${_source_basedir}/${_src}" ABSOLUTE )
+ list( APPEND _srcs ${_src} )
+ endif()
+ endforeach()
+ endif()
+
+ # if no file specified, include all docbooks, stylesheets and images
+ if( NOT _srcs )
+ file( GLOB _srcs
+ ${_source_basedir}/*.docbook
+ ${_source_basedir}/*.css
+ ${_source_basedir}/*.gif
+ ${_source_basedir}/*.jpg
+ ${_source_basedir}/*.png
+ )
+ endif()
+
+ # if no destination specified, defaulting to HTML_INSTALL_DIR
+ if( NOT _dest )
+ set( _dest "${HTML_INSTALL_DIR}/${_lang}" )
+ # if destination is NOT absolute path,
+ # we assume that is relative to HTML_INSTALL_DIR
+ elseif( NOT IS_ABSOLUTE ${_dest} )
+ set( _dest "${HTML_INSTALL_DIR}/${_lang}/${_dest}" )
+ endif()
+
+ if( NOT _srcs )
+ tde_message_fatal( "no source files" )
+ endif()
+
+ if( NOT _noindex )
+
+ # check for index.docbook
+ list( FIND _srcs "${_source_basedir}/index.docbook" _find_index )
+ if( -1 EQUAL _find_index )
+ tde_message_fatal( "missing index.docbook file" )
+ endif()
+
+ # check for srcdir
+ if( _srcdir )
+ set( _srcdir "--srcdir=${_srcdir}" )
+ endif()
+
+ add_custom_command(
+ OUTPUT ${_binary_basedir}/index.cache.bz2
+ COMMAND ${KDE3_MEINPROC_EXECUTABLE} ${_srcdir} --check --cache index.cache.bz2 ${_source_basedir}/index.docbook
+ COMMENT "Generating ${_target}"
+ DEPENDS ${_srcs}
+ WORKING_DIRECTORY "${_binary_basedir}"
+ )
+
+ string( REPLACE "@" "_" _target "${_target}" )
+ add_custom_target( ${_target} ALL DEPENDS ${_binary_basedir}/index.cache.bz2 )
+
+ list( APPEND _srcs ${_binary_basedir}/index.cache.bz2 )
+
+ if( NOT TDE_HTML_DIR )
+ set( TDE_HTML_DIR ${HTML_INSTALL_DIR} )
+ endif( )
+
+ tde_install_empty_directory( ${_dest} )
+ file( RELATIVE_PATH _common_link_target "${_dest}" "${TDE_HTML_DIR}/${_lang}/common" )
+ tde_install_symlink( ${_common_link_target} ${_dest} )
+
+ endif()
+
+ install( FILES ${_srcs} ${_extra} DESTINATION ${_dest} )
+
+endmacro( )
+
+
+#################################################
+#####
+##### tde_create_tarball
+#####
+##### Macro is used to create tarball.
+#####
+
+macro( tde_create_tarball )
+
+ unset( _target )
+ unset( _files )
+ unset( _destination )
+ set( _sourcedir "${CMAKE_CURRENT_SOURCE_DIR}" )
+ set( _compression "gzip" )
+ set( _var _target )
+
+ foreach( _arg ${ARGN} )
+
+ # found directive "TARGET"
+ if( "+${_arg}" STREQUAL "+TARGET" )
+ unset( _target )
+ set( _var _target )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "SOURCEDIR"
+ if( "+${_arg}" STREQUAL "+SOURCEDIR" )
+ unset( _sourcedir )
+ set( _var _sourcedir )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "FILES"
+ if( "+${_arg}" STREQUAL "+FILES" )
+ unset( _files )
+ set( _var _files )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "DESTINATION"
+ if( "+${_arg}" STREQUAL "+DESTINATION" )
+ unset( _destination )
+ set( _var _destination )
+ set( _directive 1 )
+ endif( )
+
+ # found directive "COMPRESSION"
+ if( "+${_arg}" STREQUAL "+COMPRESSION" )
+ unset( _compression )
+ set( _var _compression )
+ set( _directive 1 )
+ endif( )
+
+ # collect data
+ if( _directive )
+ unset( _directive )
+ elseif( _var )
+ list( APPEND ${_var} ${_arg} )
+ endif( )
+
+ endforeach( )
+
+ if( NOT _target )
+ tde_message_fatal( "Target tarball name not specified." )
+ endif( )
+
+ if( NOT IS_ABSOLUTE ${_sourcedir} )
+ set( _sourcedir "${CMAKE_CURRENT_SOURCE_DIR}/${_sourcedir}" )
+ endif( )
+
+ if( NOT _files )
+ file( GLOB_RECURSE _files RELATIVE ${_sourcedir} "${_sourcedir}/*" )
+ list( SORT _files )
+ endif( )
+
+ unset( _files_deps )
+ foreach( _file ${_files} )
+ list( APPEND _files_deps "${_sourcedir}/${_file}" )
+ endforeach( )
+
+ if( NOT DEFINED TAR_EXECUTABLE )
+ find_program( TAR_EXECUTABLE NAMES tar )
+ if( "${TAR_EXECUTABLE}" STREQUAL "TAR_EXECUTABLE-NOTFOUND" )
+ tde_message_fatal( "tar executable is required but not found on your system" )
+ endif( )
+ endif( )
+
+ if( NOT DEFINED TAR_SETOWNER )
+ execute_process(
+ COMMAND ${TAR_EXECUTABLE} --version
+ OUTPUT_VARIABLE TAR_VERSION
+ )
+ string( REGEX REPLACE "^([^\n]*)\n.*" "\\1" TAR_VERSION "${TAR_VERSION}" )
+ if( "${TAR_VERSION}" MATCHES "GNU *tar" )
+ set( TAR_SETOWNER "--owner=root;--group=root" )
+ set( TAR_REPRODUCIBLE "--pax-option=exthdr.name=%d/PaxHeaders/%f,delete=atime,delete=ctime" )
+ list( APPEND TAR_REPRODUCIBLE "--mode=u+rw,go=rX,a-s" )
+ tde_read_src_metadata()
+ if( TDE_PKG_DATETIME )
+ list( APPEND TAR_REPRODUCIBLE --mtime "${TDE_PKG_DATETIME} UTC" )
+ elseif( TDE_SCM_MODULE_DATETIME )
+ list( APPEND TAR_REPRODUCIBLE --mtime "${TDE_SCM_MODULE_DATETIME} UTC" )
+ endif( )
+ elseif( "${TAR_VERSION}" MATCHES "bsd *tar" )
+ set( TAR_SETOWNER "--uname=root;--gname=root" )
+ else( )
+ set( TAR_SETOWNER "" )
+ endif( )
+ endif( )
+
+ if( "${_compression}" STREQUAL "-" )
+ unset( _compression )
+ endif( )
+ if( _compression )
+ if( "${_compression}" STREQUAL "gzip" )
+ set( TAR_COMPRESSION "|" ${_compression} "-n" )
+ else( )
+ set( TAR_COMPRESSION "|" ${_compression} )
+ endif( )
+ endif( )
+
+ get_filename_component( _target_path "${CMAKE_CURRENT_BINARY_DIR}/${_target}" ABSOLUTE )
+ file( RELATIVE_PATH _target_path "${CMAKE_BINARY_DIR}" "${_target_path}" )
+ string( REPLACE "/" "+" _target_name "${_target_path}" )
+ add_custom_target( "${_target_name}-tarball" ALL
+ DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${_target}" )
+
+ add_custom_command(
+ COMMAND ${TAR_EXECUTABLE} cf -
+ ${TAR_SETOWNER} ${TAR_REPRODUCIBLE} -- ${_files}
+ ${TAR_COMPRESSION} > ${CMAKE_CURRENT_BINARY_DIR}/${_target}
+ WORKING_DIRECTORY "${_sourcedir}"
+ OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${_target}"
+ DEPENDS ${_files_deps}
+ COMMENT "Create tarball ${_target_path}"
+ )
+
+ if( _destination )
+ install( FILES ${CMAKE_CURRENT_BINARY_DIR}/${_target} DESTINATION ${_destination} )
+ endif( )
+
+endmacro()
+
+
+#################################################
+#####
+##### tde_include_tqt
+
+macro( tde_include_tqt )
+ foreach( _cpp ${ARGN} )
+ set_source_files_properties( ${_cpp} PROPERTIES COMPILE_FLAGS "-include tqt.h" )
+ endforeach()
+endmacro( )
+
+
+#################################################
+#####
+##### tde_install_symlink
+
+macro( tde_install_symlink _target _link )
+
+ # if path is relative, we must to prefix it with CMAKE_INSTALL_PREFIX
+ if( IS_ABSOLUTE "${_link}" )
+ set( _destination "${_link}" )
+ else( IS_ABSOLUTE "${_link}" )
+ set( _destination "${CMAKE_INSTALL_PREFIX}/${_link}" )
+ endif( IS_ABSOLUTE "${_link}" )
+
+ get_filename_component( _path "${_destination}" PATH )
+ if( NOT IS_DIRECTORY "\$ENV{DESTDIR}${_path}" )
+ install( CODE "file( MAKE_DIRECTORY \"\$ENV{DESTDIR}${_path}\" )" )
+ endif( NOT IS_DIRECTORY "\$ENV{DESTDIR}${_path}" )
+
+ install( CODE "execute_process( COMMAND ln -s ${_target} \$ENV{DESTDIR}${_destination} )" )
+
+endmacro( tde_install_symlink )
+
+
+#################################################
+#####
+##### tde_install_empty_directory
+
+macro( tde_install_empty_directory _path )
+
+ # if path is relative, we must to prefix it with CMAKE_INSTALL_PREFIX
+ if( IS_ABSOLUTE "${_path}" )
+ set( _destination "${_path}" )
+ else( IS_ABSOLUTE "${_path}" )
+ set( _destination "${CMAKE_INSTALL_PREFIX}/${_path}" )
+ endif( IS_ABSOLUTE "${_path}" )
+
+ install( CODE "file( MAKE_DIRECTORY \"\$ENV{DESTDIR}${_destination}\" )" )
+
+endmacro( tde_install_empty_directory )
+
+
+#################################################
+#####
+##### tde_conditional_add_subdirectory
+
+macro( tde_conditional_add_subdirectory _cond _path )
+
+ if( ${_cond} )
+ add_subdirectory( "${_path}" )
+ endif( ${_cond} )
+
+endmacro( tde_conditional_add_subdirectory )
+
+
+#################################################
+#####
+##### tde_auto_add_subdirectories
+
+macro( tde_auto_add_subdirectories )
+ file( GLOB _dirs RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} * )
+ foreach( _dir ${_dirs} )
+ if( IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${_dir} )
+ if( NOT ${_dir} STREQUAL ".svn" AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${_dir}/CMakeLists.txt )
+ add_subdirectory( ${_dir} )
+ endif()
+ endif()
+ endforeach()
+endmacro()
+
+
+#################################################
+#####
+##### tde_save / tde_restore
+
+macro( tde_save )
+ foreach( _var ${ARGN} )
+ set( __bak_${_var} ${${_var}} )
+ endforeach()
+endmacro()
+
+macro( tde_save_and_set _var )
+ set( __bak_${_var} ${${_var}} )
+ set( ${_var} ${ARGN} )
+endmacro( )
+
+macro( tde_restore )
+ foreach( _var ${ARGN} )
+ set( ${_var} ${__bak_${_var}} )
+ unset( __bak_${_var} )
+ endforeach()
+endmacro()
+
+
+#################################################
+#####
+##### tde_setup_install_path
+
+macro( tde_setup_install_path _path _default )
+ if( DEFINED ${_path} )
+ set( ${_path} "${${_path}}" CACHE INTERNAL "" FORCE )
+ else( )
+ set( ${_path} "${_default}" )
+ endif( )
+endmacro( )
+
+
+##################################################
+
+if( ${CMAKE_SOURCE_DIR} MATCHES ${CMAKE_BINARY_DIR} )
+ tde_message_fatal( "Please use out-of-source building, like this:
+ \n rm ${CMAKE_SOURCE_DIR}/CMakeCache.txt
+ mkdir /tmp/${PROJECT_NAME}.build
+ cd /tmp/${PROJECT_NAME}.build
+ cmake ${CMAKE_SOURCE_DIR} [arguments...]" )
+endif( )
+
+#################################################
+#####
+##### tde_setup_architecture_flags
+
+macro( tde_setup_architecture_flags )
+ if( NOT DEFINED LINKER_IMMEDIATE_BINDING_FLAGS )
+ message( STATUS "Detected ${CMAKE_SYSTEM_PROCESSOR} CPU architecture" )
+ ## Immediate symbol binding is available only for gcc but not on ARM architectures
+ if( ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU" AND NOT ${CMAKE_SYSTEM_PROCESSOR} MATCHES arm* AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD" )
+ set( LINKER_IMMEDIATE_BINDING_FLAGS "-z\ now" CACHE INTERNAL "" FORCE )
+ else( )
+ set( LINKER_IMMEDIATE_BINDING_FLAGS "" CACHE INTERNAL "" FORCE )
+ endif( )
+
+ check_cxx_compiler_flag( -fPIE HAVE_PIE_SUPPORT )
+ if( HAVE_PIE_SUPPORT )
+ set( TDE_PIE_CFLAGS -fPIE )
+
+ if( ${CMAKE_VERSION} VERSION_LESS "3.18" )
+ execute_process(COMMAND "${CMAKE_LINKER}" --help
+ OUTPUT_VARIABLE __linker_help
+ ERROR_VARIABLE __linker_help)
+ if( "${__linker_help}" MATCHES "-pie" )
+ set( LINKER_PIE_SUPPORT 1 )
+ elseif( "${__linker_help}" MATCHES "type=type.*pie" )
+ set( LINKER_ZTYPE_PIE_SUPPORT 1 )
+ endif( )
+ unset(__linker_help)
+ else( )
+ check_linker_flag(CXX -pie LINKER_PIE_SUPPORT)
+ if( NOT LINKER_PIE_SUPPORT )
+ check_linker_flag(CXX -ztype=pie LINKER_ZTYPE_PIE_SUPPORT)
+ endif()
+ endif()
+ if( LINKER_PIE_SUPPORT )
+ set( TDE_PIE_LDFLAGS -pie )
+ endif( LINKER_PIE_SUPPORT )
+ if( LINKER_ZTYPE_PIE_SUPPORT )
+ set( TDE_PIE_LDFLAGS -ztype=pie )
+ endif( LINKER_ZTYPE_PIE_SUPPORT )
+ endif( HAVE_PIE_SUPPORT )
+
+ set( _reproducible_cxxflags
+ "-fdebug-prefix-map=${CMAKE_SOURCE_DIR}=."
+ "-fmacro-prefix-map=${CMAKE_SOURCE_DIR}=."
+ )
+ foreach( _flag ${_reproducible_cxxflags} )
+ string( REGEX REPLACE "=.*" "" _flag_name "${_flag}" )
+ string( REGEX REPLACE "[^a-zA-Z0-9]+" "_" _flag_var "CXXFLAG_${_flag_name}" )
+ if( NOT "${CMAKE_CXX_FLAGS}" MATCHES "(^| )${_flag_name}" )
+ check_cxx_compiler_flag( "${_flag}" ${_flag_var} )
+ if( ${_flag_var} )
+ set( CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS} ${_flag}" )
+ set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_flag}" )
+ endif()
+ endif()
+ endforeach()
+ endif( )
+endmacro( )
+
+
+#################################################
+#####
+##### tde_setup_gcc_visibility
+
+macro( tde_setup_gcc_visibility )
+ if( NOT DEFINED __TDE_HAVE_GCC_VISIBILITY )
+ if( NOT UNIX )
+ tde_message_fatal( "gcc visibility support was requested, but your system is not *NIX" )
+ endif( NOT UNIX )
+
+ if( TQT_FOUND AND NOT DEFINED HAVE_TQT_VISIBILITY )
+ find_library( TQT_LIBFILE tqt-mt HINTS "${TQT_LIBRARY_DIRS}" )
+ if( NOT "${TQT_LIBFILE}" STREQUAL "TQT_LIBFILE-NOTFOUND" )
+ message( STATUS "Performing Test HAVE_TQT_VISIBILITY" )
+ execute_process(
+ COMMAND readelf --syms "${TQT_LIBFILE}"
+ OUTPUT_VARIABLE HAVE_TQT_VISIBILITY
+ )
+ if( "${HAVE_TQT_VISIBILITY}" STREQUAL "" OR
+ "${HAVE_TQT_VISIBILITY}" MATCHES "GLOBAL[\t ]+DEFAULT[^\n]+QSettingsPrivate" )
+ message( STATUS "Performing Test HAVE_TQT_VISIBILITY - Failed" )
+ tde_message_fatal( "gcc visibility support was requested, but not supported in tqt library" )
+ endif( )
+ set( HAVE_TQT_VISIBILITY 1 CACHE INTERNAL "" )
+ message( STATUS "Performing Test HAVE_TQT_VISIBILITY - Success" )
+ endif( )
+ endif( TQT_FOUND AND NOT DEFINED HAVE_TQT_VISIBILITY )
+
+ if( TDE_FOUND AND NOT DEFINED HAVE_TDE_VISIBILITY )
+ find_file( TDEMACROS_H tdemacros.h HINTS "${TDE_INCLUDE_DIR}" )
+ if( NOT "${TDEMACROS_H}" STREQUAL "TDEMACROS_H-NOTFOUND" )
+ tde_save_and_set( CMAKE_REQUIRED_INCLUDES "${TDE_INCLUDE_DIR}" )
+ check_cxx_source_compiles( "
+ #include <${TDEMACROS_H}>
+ #ifndef __TDE_HAVE_GCC_VISIBILITY
+ #error gcc visibility is not enabled in tdelibs
+ #endif
+ int main() { return 0; } "
+ HAVE_TDE_VISIBILITY
+ )
+ tde_restore( CMAKE_REQUIRED_INCLUDES )
+ if( NOT HAVE_TDE_VISIBILITY )
+ tde_message_fatal( "gcc visibility support was requested, but not supported in tdelibs" )
+ endif( NOT HAVE_TDE_VISIBILITY )
+ endif( )
+ endif( TDE_FOUND AND NOT DEFINED HAVE_TDE_VISIBILITY )
+
+ set( __TDE_HAVE_GCC_VISIBILITY 1 CACHE INTERNAL "" )
+ set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
+ set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -fvisibility-inlines-hidden")
+ endif( )
+endmacro( )
+
+
+#################################################
+#####
+##### tde_setup_msgfmt
+
+macro( tde_setup_msgfmt )
+ if( NOT DEFINED MSGFMT_EXECUTABLE )
+ include( FindGettext )
+ if( GETTEXT_FOUND )
+ set( MSGFMT_EXECUTABLE ${GETTEXT_MSGFMT_EXECUTABLE}
+ CACHE FILEPATH "path to msgfmt executable" )
+ if( GETTEXT_VERSION_STRING )
+ set( MSGFMT_VERSION ${GETTEXT_VERSION_STRING}
+ CACHE STRING "version of msgfmt executable" )
+ endif( )
+ endif( GETTEXT_FOUND )
+
+ if( NOT MSGFMT_EXECUTABLE )
+ tde_message_fatal( "msgfmt is required but was not found on your system." )
+ endif( NOT MSGFMT_EXECUTABLE )
+ endif( )
+
+ if( NOT MSGFMT_VERSION )
+ execute_process(
+ COMMAND ${MSGFMT_EXECUTABLE} --version
+ OUTPUT_VARIABLE _msgfmt_version
+ ERROR_VARIABLE _msgfmt_version
+ )
+ string( REGEX REPLACE "^msgfmt[^\n]* ([^ ]*)\n.*" "\\1" _msgfmt_version ${_msgfmt_version} )
+ set( MSGFMT_VERSION ${_msgfmt_version}
+ CACHE STRING "version of msgfmt executable" )
+ endif( )
+endmacro( )
+
+
+################################################
+#####
+##### tde_setup_largefiles
+
+macro( tde_setup_largefiles )
+ if( NOT DEFINED HAVE_LARGEFILES )
+ message( STATUS "Check support for large files" )
+ unset( LARGEFILES_DEFINITIONS )
+
+ # check without special definitions
+ unset( HAVE_SIZEOF_T CACHE )
+ check_type_size( off_t SIZEOF_OFF_T )
+ if( SIZEOF_OFF_T GREATER 7 )
+ set( HAVE_LARGEFILES 1 )
+ endif( )
+
+ # check with definition _FILE_OFFSET_BITS=64
+ if( NOT HAVE_LARGEFILES )
+ unset( HAVE_SIZEOF_OFF_T CACHE )
+ tde_save_and_set( CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS} -D_FILE_OFFSET_BITS=64" )
+ check_type_size( off_t SIZEOF_OFF_T )
+ tde_restore( CMAKE_REQUIRED_DEFINITIONS )
+ if( SIZEOF_OFF_T GREATER 7 )
+ set( LARGEFILES_DEFINITIONS "-D_FILE_OFFSET_BITS=64" )
+ set( HAVE_LARGEFILES 1 )
+ endif( )
+ endif( )
+
+ # check with definition _LARGE_FILES
+ if( NOT HAVE_LARGEFILES )
+ unset( HAVE_SIZEOF_OFF_T CACHE )
+ tde_save_and_set( CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS} -D_LARGE_FILES" )
+ check_type_size( off_t SIZEOF_OFF_T )
+ tde_restore( CMAKE_REQUIRED_DEFINITIONS )
+ if( SIZEOF_OFF_T GREATER 7 )
+ set( LARGEFILES_DEFINITIONS "-D_LARGE_FILES" )
+ set( HAVE_LARGEFILES 1 )
+ endif( )
+ endif( )
+
+ # check with definition _LARGEFILE_SOURCE
+ if( NOT HAVE_LARGEFILES )
+ unset( HAVE_SIZEOF_OFF_T CACHE )
+ tde_save_and_set( CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS} -D_LARGEFILE_SOURCE" )
+ check_type_size( off_t SIZEOF_OFF_T )
+ tde_restore( CMAKE_REQUIRED_DEFINITIONS )
+ if( SIZEOF_OFF_T GREATER 7 )
+ set( LARGEFILES_DEFINITIONS "-D_LARGEFILE_SOURCE" )
+ set( HAVE_LARGEFILES 1 )
+ endif( )
+ endif( )
+
+ # check for fseeko/ftello
+ if( HAVE_LARGEFILES )
+ tde_save_and_set( CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS} ${LARGEFILES_DEFINITIONS}" )
+ check_symbol_exists( "fseeko" "stdio.h" HAVE_FSEEKO )
+ tde_restore( CMAKE_REQUIRED_DEFINITIONS )
+ if( NOT HAVE_FSEEKO )
+ tde_save_and_set( CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS} ${LARGEFILES_DEFINITIONS} -D_LARGEFILE_SOURCE" )
+ check_symbol_exists( "fseeko" "stdio.h" HAVE_FSEEKO )
+ tde_restore( CMAKE_REQUIRED_DEFINITIONS )
+ if( HAVE_FSEEKO )
+ set( LARGEFILES_DEFINITIONS "${LARGEFILES_DEFINITIONS} -D_LARGEFILE_SOURCE" )
+ else( )
+ unset( HAVE_LARGEFILES )
+ endif( )
+ endif( )
+ endif( )
+
+ # check results
+ if( HAVE_LARGEFILES )
+ if( "${LARGEFILES_DEFINITIONS}" STREQUAL "" )
+ message( STATUS "Check support for large files - Success" )
+ else( )
+ add_definitions( ${LARGEFILES_DEFINITIONS} )
+ message( STATUS "Check support for large files - Success with ${LARGEFILES_DEFINITIONS}" )
+ endif( )
+ set( HAVE_LARGEFILES 1 CACHE INTERNAL "Support for large files enabled" )
+ else( )
+ message( STATUS "Check support for large files - Failed" )
+ tde_message_fatal( "Cannot find a way to enable support for large files." )
+ endif( )
+ endif( )
+endmacro( )
+
+
+#################################################
+#####
+##### tde_setup_dbus
+
+macro( tde_setup_dbus )
+ if( NOT DBUS_FOUND )
+ pkg_search_module( DBUS dbus-1 )
+ if( NOT DBUS_FOUND )
+ tde_message_fatal( "dbus-1 is required, but not found on your system" )
+ endif( )
+ endif( )
+
+ if( NOT DEFINED DBUS_SYSTEM_CONF_DIRECTORY )
+ execute_process(
+ COMMAND ${PKG_CONFIG_EXECUTABLE}
+ dbus-1 --variable=sysconfdir
+ OUTPUT_VARIABLE DBUS_SYSTEM_CONF_BASE
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ if( DBUS_SYSTEM_CONF_BASE )
+ set( DBUS_SYSTEM_CONF_DIRECTORY "${DBUS_SYSTEM_CONF_BASE}/dbus-1/system.d"
+ CACHE PATH "Path for DBUS system configuration files" )
+ message( STATUS "Using " ${DBUS_SYSTEM_CONF_DIRECTORY} " for DBUS system configuration files" )
+ else( )
+ tde_message_fatal( "Can not find the base directory for the dbus-1 configuration" )
+ endif( )
+ endif( )
+
+ if( NOT DEFINED DBUS_SESSION_CONF_DIRECTORY )
+ execute_process(
+ COMMAND ${PKG_CONFIG_EXECUTABLE}
+ dbus-1 --variable=sysconfdir
+ OUTPUT_VARIABLE DBUS_SYSTEM_CONF_BASE
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ if( DBUS_SYSTEM_CONF_BASE )
+ set( DBUS_SESSION_CONF_DIRECTORY "${DBUS_SYSTEM_CONF_BASE}/dbus-1/session.d"
+ CACHE PATH "Path for DBUS session configuration files" )
+ message( STATUS "Using " ${DBUS_SESSION_CONF_DIRECTORY} " for DBUS session configuration files" )
+ else( )
+ tde_message_fatal( "Can not find the base directory for the dbus-1 configuration" )
+ endif( )
+ endif( )
+
+ if( NOT DEFINED DBUS_SESSION_DIRECTORY )
+ execute_process(
+ COMMAND ${PKG_CONFIG_EXECUTABLE}
+ dbus-1 --variable=session_bus_services_dir
+ OUTPUT_VARIABLE DBUS_SESSION_DIRECTORY
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ set( DBUS_SESSION_DIRECTORY "${DBUS_SESSION_DIRECTORY}"
+ CACHE PATH "Path for DBUS session service files" )
+ message( STATUS "Using " ${DBUS_SESSION_DIRECTORY} " for DBUS session service files" )
+ endif( )
+
+ if( NOT DEFINED DBUS_SERVICE_DIRECTORY )
+ execute_process(
+ COMMAND ${PKG_CONFIG_EXECUTABLE}
+ dbus-1 --variable=system_bus_services_dir
+ OUTPUT_VARIABLE DBUS_SERVICE_DIRECTORY
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ if( "${DBUS_SERVICE_DIRECTORY}" STREQUAL "" )
+ if( "${DBUS_SESSION_DIRECTORY}" MATCHES "/services$" )
+ string( REGEX REPLACE "/services$" "/system-services"
+ DBUS_SERVICE_DIRECTORY "${DBUS_SESSION_DIRECTORY}" )
+ else( )
+ tde_message_fatal( "Directory for DBUS system service files can not be determined." )
+ endif( )
+ endif( )
+ set( DBUS_SERVICE_DIRECTORY "${DBUS_SERVICE_DIRECTORY}"
+ CACHE PATH "Path for DBUS system service files" )
+ message( STATUS "Using " ${DBUS_SERVICE_DIRECTORY} " for DBUS system service files" )
+ endif( )
+
+ if( NOT "${ARGV}" STREQUAL "" AND NOT DBUS_TQT_FOUND )
+ pkg_search_module( DBUS_TQT ${ARGV} )
+ if( NOT DBUS_TQT_FOUND )
+ tde_message_fatal( "${ARGV} is required, but not found on your system" )
+ endif( )
+ endif( )
+ if( "${ARGV}" STREQUAL "dbus-1-tqt" AND NOT DEFINED DBUSXML2QT3_EXECUTABLE )
+ find_program( DBUSXML2QT3_EXECUTABLE
+ NAMES dbusxml2qt3
+ HINTS "${TDE_PREFIX}/bin" ${BIN_INSTALL_DIR}
+ )
+ endif( )
+
+endmacro( )
+
+
+#################################################
+#####
+##### tde_setup_polkit
+
+macro( tde_setup_polkit )
+ if( NOT POLKIT_GOBJECT_FOUND )
+ pkg_search_module( POLKIT_GOBJECT polkit-gobject-1 )
+ if( NOT POLKIT_GOBJECT_FOUND )
+ tde_message_fatal( "polkit-gobject-1 is required, but not found on your system" )
+ endif( )
+ endif( )
+
+ foreach( _arg ${ARGV} )
+ if( NOT "${_arg}" MATCHES "^polkit-" )
+ set( _arg "polkit-${_arg}" )
+ endif( )
+ string( TOUPPER "${_arg}" _polkit_module )
+ if( "${_polkit_module}" MATCHES "-[0-9]+$" )
+ string( REGEX REPLACE "-[0-9]+$" "" _polkit_module "${_polkit_module}" )
+ endif( )
+ string( REPLACE "-" "_" _polkit_module "${_polkit_module}" )
+ if( NOT "${_arg}" MATCHES "-[0-9]+$" )
+ set( _arg "${_arg}-1" )
+ endif( )
+ if( NOT ${_polkit_module}_FOUND )
+ pkg_search_module( ${_polkit_module} ${_arg} )
+ if( NOT ${_polkit_module}_FOUND )
+ tde_message_fatal( "${_arg} is required, but not found on your system" )
+ endif( )
+ endif( )
+ endforeach( )
+
+ if( NOT DEFINED POLKIT_ACTIONS_DIRECTORY )
+ execute_process(
+ COMMAND ${PKG_CONFIG_EXECUTABLE}
+ polkit-gobject-1 --variable=actiondir
+ OUTPUT_VARIABLE POLKIT_ACTIONS_DIRECTORY
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ set( POLKIT_ACTIONS_DIRECTORY "${POLKIT_ACTIONS_DIRECTORY}"
+ CACHE PATH "Path for PolicyKit action files" )
+ message( STATUS "Using " ${POLKIT_ACTIONS_DIRECTORY} " for PolicyKit action files" )
+ endif( )
+
+endmacro( )
+
+
+#################################################
+#####
+##### restore CMake policies
+
+cmake_policy( POP )
+
+
+#################################################
diff -Naur orig/modules/TDESetupPaths.cmake tde-cmake-trinity-14.1.3/modules/TDESetupPaths.cmake
--- orig/modules/TDESetupPaths.cmake 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/modules/TDESetupPaths.cmake 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,72 @@
+#################################################
+#
+# (C) 2010-2011 Serghei Amelian
+# serghei (DOT) amelian (AT) gmail.com
+#
+# Improvements and feedback are welcome
+#
+# This file is released under GPL >= 2
+#
+#################################################
+
+#################################################
+#####
+##### tde_internal_setup_path
+
+macro( _tde_internal_setup_path _path _default _comment )
+ if( DEFINED ${_path} )
+ if( IS_ABSOLUTE ${${_path}} )
+ set( ${_path} "${${_path}}" CACHE PATH "${_comment}" FORCE )
+ else( )
+ set( ${_path} "${CMAKE_INSTALL_PREFIX}/${${_path}}" CACHE PATH "${_comment}" FORCE )
+ endif( )
+ else( )
+ set( ${_path} "${_default}" )
+ endif( )
+endmacro( _tde_internal_setup_path )
+
+
+#################################################
+#####
+##### tde_setup_paths
+
+macro( tde_setup_paths )
+
+ # install paths
+ _tde_internal_setup_path( EXEC_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}" "Base directory for executables and libraries" )
+ _tde_internal_setup_path( SHARE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/share" "Base directory for files which go to share/" )
+ _tde_internal_setup_path( BIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/bin" "The install dir for executables (default ${EXEC_INSTALL_PREFIX}/bin)" )
+ _tde_internal_setup_path( SBIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/sbin" "The install dir for system executables (default ${EXEC_INSTALL_PREFIX}/sbin)" )
+ _tde_internal_setup_path( LIB_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}" "The subdirectory relative to the install prefix where libraries will be installed (default is ${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX})" )
+ _tde_internal_setup_path( LIBEXEC_INSTALL_DIR "${LIB_INSTALL_DIR}/trinity/libexec" "The subdirectory relative to the install prefix where libraries will be installed (default is ${LIB_INSTALL_DIR}/trinity/libexec)" )
+ _tde_internal_setup_path( PKGCONFIG_INSTALL_DIR "${LIB_INSTALL_DIR}/pkgconfig" "The install dir for pkg-config metadata files" )
+ _tde_internal_setup_path( INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" "The subdirectory to the header prefix" )
+
+ _tde_internal_setup_path( CMAKE_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/cmake" "The install dir for cmake import modules" )
+ _tde_internal_setup_path( PLUGIN_INSTALL_DIR "${LIB_INSTALL_DIR}/trinity" "The subdirectory relative to the install prefix where plugins will be installed (default is ${LIB_INSTALL_DIR}/trinity)" )
+ _tde_internal_setup_path( CONFIG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config" "The config file install dir" )
+ _tde_internal_setup_path( DATA_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/apps" "The parent directory where applications can install their data" )
+ _tde_internal_setup_path( HTML_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/doc/tde/HTML" "The HTML install dir for documentation" )
+ _tde_internal_setup_path( ICON_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/icons" "The icon install dir (default ${SHARE_INSTALL_PREFIX}/share/icons/)" )
+ _tde_internal_setup_path( KCFG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config.kcfg" "The install dir for tdeconfig files" )
+ _tde_internal_setup_path( LOCALE_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/locale" "The install dir for translations" )
+ _tde_internal_setup_path( APPS_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/applnk" "The install dir for the application desktop files" )
+ _tde_internal_setup_path( MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mimelnk" "The install dir for the mimetype desktop files" )
+ _tde_internal_setup_path( SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/services" "The install dir for service (desktop, protocol, ...) files" )
+ _tde_internal_setup_path( SERVICETYPES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/servicetypes" "The install dir for servicestypes desktop files" )
+ _tde_internal_setup_path( SOUND_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/sounds" "The install dir for sound files" )
+ _tde_internal_setup_path( TEMPLATES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/templates" "The install dir for templates (Create new file...)" )
+ _tde_internal_setup_path( WALLPAPER_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/wallpapers" "The install dir for wallpapers" )
+ _tde_internal_setup_path( KCONF_UPDATE_INSTALL_DIR "${DATA_INSTALL_DIR}/tdeconf_update" "The tdeconf_update install dir" )
+ _tde_internal_setup_path( AUTOSTART_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/autostart" "The install dir for autostart files" )
+
+ _tde_internal_setup_path( SYSCONF_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/etc" "The sysconfig install dir (default ${CMAKE_INSTALL_PREFIX}/etc)" )
+ _tde_internal_setup_path( MAN_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/man" "The man install dir (default ${SHARE_INSTALL_PREFIX}/man/)" )
+ _tde_internal_setup_path( INFO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/info" "The info install dir (default ${SHARE_INSTALL_PREFIX}/info)" )
+
+ _tde_internal_setup_path( XDG_MENU_INSTALL_DIR "${SYSCONF_INSTALL_DIR}/xdg/menus" "The XDG menus dir" )
+ _tde_internal_setup_path( XDG_APPS_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/applications/tde" "The XDG apps dir" )
+ _tde_internal_setup_path( XDG_DIRECTORY_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/desktop-directories" "The XDG directory" )
+ _tde_internal_setup_path( XDG_MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mime/packages" "The install dir for the xdg mimetypes" )
+
+endmacro( tde_setup_paths )
diff -Naur orig/modules/TDEVersion.cmake tde-cmake-trinity-14.1.3/modules/TDEVersion.cmake
--- orig/modules/TDEVersion.cmake 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/modules/TDEVersion.cmake 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,37 @@
+#################################################
+#
+# (C) 2022 Michele Calgaro
+# michele (DOT) calgaro (AT) yahoo (DOT) it
+#
+# Improvements and feedback are welcome
+#
+# This file is released under GPL >= 2
+#
+#################################################
+
+# Centralized place where to set the minimum cmake version required in TDE
+
+set( TDE_CMAKE_MINIMUM_VERSION 3.5 )
+
+
+#################################################
+#####
+##### tde_set_project_version
+
+macro( tde_set_project_version )
+
+ set( DEFAULT_VERSION "R14.1.3" )
+
+ unset( VERSION )
+
+ if( EXISTS ${CMAKE_SOURCE_DIR}/.tdescminfo )
+ file( STRINGS ${CMAKE_SOURCE_DIR}/.tdescminfo VERSION_STRING REGEX "^Version:.+$" )
+ string( REGEX REPLACE "^Version: (R[0-9]+\\.[0-9]+\\.[0-9]+.*)$" "\\1" VERSION "${VERSION_STRING}" )
+ endif()
+
+ if( NOT VERSION )
+ set( VERSION "${DEFAULT_VERSION}" )
+ endif()
+
+endmacro( )
+
diff -Naur orig/modules/tde_automoc.cmake tde-cmake-trinity-14.1.3/modules/tde_automoc.cmake
--- orig/modules/tde_automoc.cmake 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/modules/tde_automoc.cmake 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,76 @@
+#################################################
+#
+# (C) 2022 Slávek Banko
+# slavek (DOT) banko (AT) axis.cz
+#
+# Improvements and feedback are welcome
+#
+# This file is released under GPL >= 2
+#
+#################################################
+
+if( NOT ${CMAKE_CURRENT_LIST_DIR} STREQUAL ${CMAKE_ROOT}/Modules )
+ set( CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}" )
+endif()
+include( TDEMacros )
+
+
+get_filename_component( _src_file "${SRC_FILE}" ABSOLUTE )
+set( _meta_includes ${META_INCLUES} )
+unset( _moc_headers )
+
+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 header 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 )
+ set( _header_file "${_src_path}/${_src_header}.h" )
+
+ # if header doesn't exists, check in META_INCLUDES
+ if( NOT EXISTS "${_header_file}" )
+ unset( _found )
+ foreach( _src_path ${_meta_includes} )
+ set( _header_file "${_src_path}/${_src_header}.h" )
+ if( EXISTS "${_header_file}" )
+ 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_header}.h' not found." )
+ endif( )
+ endif( )
+
+ # moc-ing header
+ execute_process( COMMAND ${TMOC_EXECUTABLE} ${_header_file} -o ${_moc_file} )
+ list( APPEND _moc_headers "${_src_header}.h" )
+
+ endforeach( _moc_file )
+
+ endif( _moc_includes )
+
+else()
+ tde_message_fatal( "AUTOMOC error: '${_src_file}' not found!" )
+endif( EXISTS "${_src_file}" )
+
+get_filename_component( _automoc_file "${_src_file}+automoc" NAME )
+if( DEFINED _moc_headers )
+ string( REPLACE ";" "\n * " _moc_headers "${_moc_headers}" )
+ file( WRITE "${_automoc_file}" "/*\n * processed:\n * ${_moc_headers}\n */" )
+else()
+ file( WRITE "${_automoc_file}" "/* processed - no moc files */" )
+endif()
diff -Naur orig/modules/tde_l10n_merge.pl tde-cmake-trinity-14.1.3/modules/tde_l10n_merge.pl
--- orig/modules/tde_l10n_merge.pl 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/modules/tde_l10n_merge.pl 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,1521 @@
+#!/usr/bin/perl -w
+# -*- Mode: perl; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+
+#
+# The Intltool Message Merger
+#
+# Copyright (C) 2000, 2003 Free Software Foundation.
+# Copyright (C) 2000, 2001 Eazel, Inc
+#
+# Intltool is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# version 2 published by the Free Software Foundation.
+#
+# Intltool is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+#
+# Authors: Maciej Stachowiak <mjs@noisehavoc.org>
+# Kenneth Christiansen <kenneth@gnu.org>
+# Darin Adler <darin@bentspoon.com>
+#
+# Proper XML UTF-8'ification written by Cyrille Chepelov <chepelov@calixo.net>
+#
+
+## Release information
+my $PROGRAM = "intltool-merge";
+my $PACKAGE = "intltool";
+my $VERSION = "0.51.0";
+
+## Loaded modules
+use strict;
+use Getopt::Long;
+use Text::Wrap;
+use File::Basename;
+use Encode;
+use Fcntl qw(:flock);
+
+my $must_end_tag = -1;
+my $last_depth = -1;
+my $translation_depth = -1;
+my @tag_stack = ();
+my @entered_tag = ();
+my @translation_strings = ();
+my $leading_space = "";
+
+## Scalars used by the option stuff
+my $HELP_ARG = 0;
+my $VERSION_ARG = 0;
+my $BA_STYLE_ARG = 0;
+my $XML_STYLE_ARG = 0;
+my $KEYS_STYLE_ARG = 0;
+my $DESKTOP_STYLE_ARG = 0;
+my $SCHEMAS_STYLE_ARG = 0;
+my $RFC822DEB_STYLE_ARG = 0;
+my $QUOTED_STYLE_ARG = 0;
+my $QUOTEDXML_STYLE_ARG = 0;
+my $QUIET_ARG = 0;
+my $PASS_THROUGH_ARG = 0;
+my $UTF8_ARG = 0;
+my $MULTIPLE_OUTPUT = 0;
+my $NO_TRANSLATIONS_ARG = 0;
+my $cache_file;
+
+## Handle options
+GetOptions
+(
+ "help" => \$HELP_ARG,
+ "version" => \$VERSION_ARG,
+ "quiet|q" => \$QUIET_ARG,
+ "oaf-style|o" => \$BA_STYLE_ARG, ## for compatibility
+ "ba-style|b" => \$BA_STYLE_ARG,
+ "xml-style|x" => \$XML_STYLE_ARG,
+ "keys-style|k" => \$KEYS_STYLE_ARG,
+ "desktop-style|d" => \$DESKTOP_STYLE_ARG,
+ "schemas-style|s" => \$SCHEMAS_STYLE_ARG,
+ "rfc822deb-style|r" => \$RFC822DEB_STYLE_ARG,
+ "quoted-style" => \$QUOTED_STYLE_ARG,
+ "quotedxml-style" => \$QUOTEDXML_STYLE_ARG,
+ "pass-through|p" => \$PASS_THROUGH_ARG,
+ "utf8|u" => \$UTF8_ARG,
+ "multiple-output|m" => \$MULTIPLE_OUTPUT,
+ "no-translations" => \$NO_TRANSLATIONS_ARG,
+ "cache|c=s" => \$cache_file
+ ) or &error;
+
+my $PO_DIR;
+my $FILE;
+my $OUTFILE;
+
+my %po_files_by_lang = ();
+my %translations = ();
+
+# Use this instead of \w for XML files to handle more possible characters.
+my $w = "[-A-Za-z0-9._:]";
+
+# XML quoted string contents
+my $q = "[^\\\"]*";
+
+## Check for options.
+
+if ($VERSION_ARG)
+{
+ &print_version;
+}
+elsif ($HELP_ARG)
+{
+ &print_help;
+}
+elsif ($BA_STYLE_ARG && @ARGV > 2)
+{
+ &utf8_sanity_check;
+ &preparation;
+ &print_message;
+ &ba_merge_translations;
+ &finalize;
+}
+elsif ($XML_STYLE_ARG && (@ARGV > 2 || ($NO_TRANSLATIONS_ARG && @ARGV > 1)))
+{
+ &utf8_sanity_check;
+ &preparation;
+ &print_message;
+ &xml_merge_output;
+ &finalize;
+}
+elsif ($KEYS_STYLE_ARG && @ARGV > 2)
+{
+ &utf8_sanity_check;
+ &preparation;
+ &print_message;
+ &keys_merge_translations;
+ &finalize;
+}
+elsif ($DESKTOP_STYLE_ARG && @ARGV > 2)
+{
+ &utf8_sanity_check;
+ &preparation;
+ &print_message;
+ &desktop_merge_translations;
+ &finalize;
+}
+elsif ($SCHEMAS_STYLE_ARG && @ARGV > 2)
+{
+ &utf8_sanity_check;
+ &preparation;
+ &print_message;
+ &schemas_merge_translations;
+ &finalize;
+}
+elsif ($RFC822DEB_STYLE_ARG && @ARGV > 2)
+{
+ &preparation;
+ &print_message;
+ &rfc822deb_merge_translations;
+ &finalize;
+}
+elsif (($QUOTED_STYLE_ARG || $QUOTEDXML_STYLE_ARG) && @ARGV > 2)
+{
+ &utf8_sanity_check;
+ &preparation;
+ &print_message;
+ &quoted_merge_translations($QUOTEDXML_STYLE_ARG);
+ &finalize;
+}
+else
+{
+ &print_help;
+}
+
+exit;
+
+## Sub for printing release information
+sub print_version
+{
+ print <<_EOF_;
+${PROGRAM} (${PACKAGE}) ${VERSION}
+Written by Maciej Stachowiak, Darin Adler and Kenneth Christiansen.
+
+Copyright (C) 2000-2003 Free Software Foundation, Inc.
+Copyright (C) 2000-2001 Eazel, Inc.
+This is free software; see the source for copying conditions. There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+_EOF_
+ exit;
+}
+
+## Sub for printing usage information
+sub print_help
+{
+ print <<_EOF_;
+Usage: ${PROGRAM} [OPTION]... PO_DIRECTORY FILENAME OUTPUT_FILE
+Generates an output file that includes some localized attributes from an
+untranslated source file.
+
+Mandatory options: (exactly one must be specified)
+ -b, --ba-style includes translations in the bonobo-activation style
+ -d, --desktop-style includes translations in the desktop style
+ -k, --keys-style includes translations in the keys style
+ -s, --schemas-style includes translations in the schemas style
+ -r, --rfc822deb-style includes translations in the RFC822 style
+ --quoted-style includes translations in the quoted string style
+ --quotedxml-style includes translations in the quoted xml string style
+ -x, --xml-style includes translations in the standard xml style
+
+Other options:
+ -u, --utf8 convert all strings to UTF-8 before merging
+ (default for everything except RFC822 style)
+ -p, --pass-through deprecated, does nothing and issues a warning
+ -m, --multiple-output output one localized file per locale, instead of
+ a single file containing all localized elements
+ --no-translations do not merge any translations: only generates the
+ unlocalised (English) version -- applies only
+ to XML merging
+ -c, --cache=FILE specify cache file name
+ (usually \$top_builddir/po/.intltool-merge-cache)
+ -q, --quiet suppress most messages
+ --help display this help and exit
+ --version output version information and exit
+
+Report bugs to http://bugs.launchpad.net/intltool
+_EOF_
+ exit;
+}
+
+
+## Sub for printing error messages
+sub print_error
+{
+ print STDERR "Try `${PROGRAM} --help' for more information.\n";
+ exit;
+}
+
+
+sub print_message
+{
+ print "Merging translations into $OUTFILE.\n" unless $QUIET_ARG;
+}
+
+
+sub preparation
+{
+ if (!$XML_STYLE_ARG || !$NO_TRANSLATIONS_ARG) {
+ $PO_DIR = $ARGV[0];
+ $FILE = $ARGV[1];
+ $OUTFILE = $ARGV[2];
+
+ &gather_po_files;
+ &get_translation_database;
+ } else {
+ $FILE = $ARGV[0];
+ $OUTFILE = $ARGV[1];
+ }
+}
+
+# General-purpose code for looking up translations in .po files
+
+sub po_file2lang
+{
+ my ($tmp) = @_;
+ $tmp =~ s/^.*\/(.*)\.po$/$1/;
+ return $tmp;
+}
+
+sub gather_po_files
+{
+ if (my $linguas = $ENV{"LINGUAS"})
+ {
+ for my $lang (split / /, $linguas) {
+ my $po_file = $PO_DIR . "/" . $lang . ".po";
+ if (-e $po_file) {
+ $po_files_by_lang{$lang} = $po_file;
+ }
+ }
+ }
+ else
+ {
+ if (open LINGUAS_FILE, "$PO_DIR/LINGUAS")
+ {
+ while (<LINGUAS_FILE>)
+ {
+ next if /^#/;
+
+ for my $lang (split)
+ {
+ chomp ($lang);
+ my $po_file = $PO_DIR . "/" . $lang . ".po";
+ if (-e $po_file) {
+ $po_files_by_lang{$lang} = $po_file;
+ }
+ }
+ }
+
+ close LINGUAS_FILE;
+ }
+ else
+ {
+ for my $po_file (glob "$PO_DIR/*.po") {
+ $po_files_by_lang{po_file2lang($po_file)} = $po_file;
+ }
+ }
+ }
+}
+
+sub get_po_encoding
+{
+ my ($in_po_file) = @_;
+ my $encoding = "";
+
+ open IN_PO_FILE, $in_po_file or die;
+ while (<IN_PO_FILE>)
+ {
+ ## example: "Content-Type: text/plain; charset=ISO-8859-1\n"
+ if (/Content-Type\:.*charset=([-a-zA-Z0-9]+)\\n/)
+ {
+ $encoding = $1;
+ last;
+ }
+ }
+ close IN_PO_FILE;
+
+ if (!$encoding)
+ {
+ print STDERR "Warning: no encoding found in $in_po_file. Assuming ISO-8859-1\n" unless $QUIET_ARG;
+ $encoding = "ISO-8859-1";
+ }
+
+ return $encoding
+}
+
+sub utf8_sanity_check
+{
+ print STDERR "Warning: option --pass-through has been removed.\n" if $PASS_THROUGH_ARG;
+ $UTF8_ARG = 1;
+}
+
+sub get_translation_database
+{
+ if ($cache_file) {
+ &get_cached_translation_database;
+ } else {
+ &create_translation_database;
+ }
+}
+
+sub get_newest_po_age
+{
+ my $newest_age;
+
+ foreach my $file (values %po_files_by_lang)
+ {
+ my $file_age = -M $file;
+ $newest_age = $file_age if !$newest_age || $file_age < $newest_age;
+ }
+
+ $newest_age = 0 if !$newest_age;
+
+ return $newest_age;
+}
+
+sub create_cache
+{
+ print "Generating and caching the translation database\n" unless $QUIET_ARG;
+
+ &create_translation_database;
+
+ open CACHE, ">$cache_file" || die;
+ print CACHE join "\x01", %translations;
+ close CACHE;
+}
+
+sub load_cache
+{
+ print "Found cached translation database\n" unless $QUIET_ARG;
+
+ my $contents;
+ open CACHE, "<$cache_file" || die;
+ {
+ local $/;
+ $contents = <CACHE>;
+ }
+ close CACHE;
+ %translations = split "\x01", $contents;
+}
+
+sub get_cached_translation_database
+{
+ open(my $lockfh, ">", "$cache_file.lock") or die $!;
+ flock($lockfh, LOCK_EX) or die "Could not lock '$cache_file.lock' - $!";
+ my $cache_file_age = -M $cache_file;
+ if (defined $cache_file_age)
+ {
+ if ($cache_file_age <= &get_newest_po_age)
+ {
+ close($lockfh);
+ &load_cache;
+ return;
+ }
+ print "Found too-old cached translation database\n" unless $QUIET_ARG;
+ }
+
+ &create_cache;
+ close($lockfh);
+}
+
+sub add_translation
+{
+ my ($lang, $encoding, $msgctxt, $msgid, $msgstr) = @_;
+
+ return if !($msgid && $msgstr);
+
+ if ($msgctxt) {
+ $msgid = "$msgctxt\004$msgid";
+ }
+ if (uc $encoding ne "UTF-8") {
+ Encode::from_to ($msgid, $encoding, "UTF-8");
+ Encode::from_to ($msgstr, $encoding, "UTF-8");
+ }
+ $translations{$lang, $msgid} = $msgstr;
+}
+
+sub create_translation_database
+{
+ for my $lang (keys %po_files_by_lang)
+ {
+ my $po_file = $po_files_by_lang{$lang};
+ my $encoding = "UTF-8";
+
+ if ($UTF8_ARG)
+ {
+ $encoding = get_po_encoding ($po_file);
+ if (uc $encoding ne "UTF-8") {
+ print "NOTICE: $po_file is not in UTF-8 but $encoding, converting...\n" unless $QUIET_ARG;;
+ }
+ }
+ open PO_FILE, "<$po_file";
+
+ my $nextfuzzy = 0;
+ my $inmsgctxt = 0;
+ my $inmsgid = 0;
+ my $inmsgstr = 0;
+ my $msgctxt = "";
+ my $msgid = "";
+ my $msgstr = "";
+
+ while (<PO_FILE>)
+ {
+ $nextfuzzy = 1 if /^#, fuzzy/;
+
+ if (/^msgctxt "((\\.|[^\\]+)*)"/ )
+ {
+ if ($inmsgstr) {
+ add_translation ($lang, $encoding,
+ $msgctxt, $msgid, $msgstr);
+ $msgctxt = "";
+ $msgid = "";
+ $msgstr = "";
+ }
+
+ $msgctxt = unescape_po_string($1);
+ $inmsgctxt = 1;
+ $inmsgid = 0;
+ $inmsgstr = 0;
+ }
+
+ if (/^msgid "((\\.|[^\\]+)*)"/ )
+ {
+ if ($inmsgstr) {
+ add_translation ($lang, $encoding,
+ $msgctxt, $msgid, $msgstr);
+ $msgctxt = "";
+ $msgid = "";
+ $msgstr = "";
+ }
+
+ if ($nextfuzzy) {
+ $inmsgid = 0;
+ $nextfuzzy = 0;
+ } else {
+ $msgid = unescape_po_string($1);
+ $inmsgid = 1;
+ }
+ $inmsgctxt = 0;
+ $inmsgstr = 0;
+ }
+
+ if (/^msgstr "((\\.|[^\\]+)*)"/)
+ {
+ $msgstr = unescape_po_string($1);
+ $inmsgstr = 1;
+ $inmsgctxt = 0;
+ $inmsgid = 0;
+ }
+
+ if (/^"((\\.|[^\\]+)*)"/)
+ {
+ $msgctxt .= unescape_po_string($1) if $inmsgctxt;
+ $msgid .= unescape_po_string($1) if $inmsgid;
+ $msgstr .= unescape_po_string($1) if $inmsgstr;
+ }
+ }
+ add_translation ($lang, $encoding, $msgctxt, $msgid, $msgstr)
+ if ($inmsgstr);
+ }
+}
+
+sub finalize
+{
+}
+
+sub unescape_one_sequence
+{
+ my ($sequence) = @_;
+
+ return "\\" if $sequence eq "\\\\";
+ return "\"" if $sequence eq "\\\"";
+ return "\n" if $sequence eq "\\n";
+ return "\r" if $sequence eq "\\r";
+ return "\t" if $sequence eq "\\t";
+ return "\b" if $sequence eq "\\b";
+ return "\f" if $sequence eq "\\f";
+ return "\a" if $sequence eq "\\a";
+ return chr(11) if $sequence eq "\\v"; # vertical tab, see ascii(7)
+
+ return chr(hex($1)) if ($sequence =~ /\\x([0-9a-fA-F]{2})/);
+ return chr(oct($1)) if ($sequence =~ /\\([0-7]{3})/);
+
+ # FIXME: Is \0 supported as well? Kenneth and Rodney don't want it, see bug #48489
+
+ return $sequence;
+}
+
+sub unescape_po_string
+{
+ my ($string) = @_;
+
+ $string =~ s/(\\x[0-9a-fA-F]{2}|\\[0-7]{3}|\\.)/unescape_one_sequence($1)/eg;
+
+ return $string;
+}
+
+sub entity_decode
+{
+ local ($_) = @_;
+
+ s/&apos;/'/g; # '
+ s/&quot;/"/g; # "
+ s/&lt;/</g;
+ s/&gt;/>/g;
+ s/&amp;/&/g;
+
+ return $_;
+}
+
+# entity_encode: (string)
+#
+# Encode the given string to XML format (encode '<' etc).
+
+sub entity_encode
+{
+ my ($pre_encoded) = @_;
+
+ my @list_of_chars = unpack ('C*', $pre_encoded);
+
+ # with UTF-8 we only encode minimalistic
+ return join ('', map (&entity_encode_int_minimalist, @list_of_chars));
+}
+
+sub entity_encode_int_minimalist
+{
+ return "&quot;" if $_ == 34;
+ return "&amp;" if $_ == 38;
+ return "&apos;" if $_ == 39;
+ return "&lt;" if $_ == 60;
+ return "&gt;" if $_ == 62;
+ return chr $_;
+}
+
+sub entity_encoded_translation
+{
+ my ($lang, $string) = @_;
+
+ my $translation = $translations{$lang, $string};
+ return $string if !$translation;
+ return entity_encode ($translation);
+}
+
+## XML (bonobo-activation specific) merge code
+
+sub ba_merge_translations
+{
+ my $source;
+
+ {
+ local $/; # slurp mode
+ open INPUT, "<$FILE" or die "can't open $FILE: $!";
+ $source = <INPUT>;
+ close INPUT;
+ }
+
+ open OUTPUT, ">$OUTFILE" or die "can't open $OUTFILE: $!";
+ # Binmode so that selftest works ok if using a native Win32 Perl...
+ binmode (OUTPUT) if $^O eq 'MSWin32';
+
+ while ($source =~ s|^(.*?)([ \t]*<\s*$w+\s+($w+\s*=\s*"$q"\s*)+/?>)([ \t]*\n)?||s)
+ {
+ print OUTPUT $1;
+
+ my $node = $2 . "\n";
+
+ my @strings = ();
+ $_ = $node;
+ while (s/(\s)_($w+\s*=\s*"($q)")/$1$2/s) {
+ push @strings, entity_decode($3);
+ }
+ print OUTPUT;
+
+ my %langs;
+ for my $string (@strings)
+ {
+ for my $lang (keys %po_files_by_lang)
+ {
+ $langs{$lang} = 1 if $translations{$lang, $string};
+ }
+ }
+
+ for my $lang (sort keys %langs)
+ {
+ $_ = $node;
+ s/(\sname\s*=\s*)"($q)"/$1"$2-$lang"/s;
+ s/(\s)_($w+\s*=\s*")($q)"/$1 . $2 . entity_encoded_translation($lang, $3) . '"'/seg;
+ print OUTPUT;
+ }
+ }
+
+ print OUTPUT $source;
+
+ close OUTPUT;
+}
+
+
+## XML (non-bonobo-activation) merge code
+
+
+# Process tag attributes
+# Only parameter is a HASH containing attributes -> values mapping
+sub getAttributeString
+{
+ my $sub = shift;
+ my $do_translate = shift || 0;
+ my $language = shift || "";
+ my $result = "";
+ my $translate = shift;
+ foreach my $e (reverse(sort(keys %{ $sub }))) {
+ my $key = $e;
+ my $string = $sub->{$e};
+ my $quote = '"';
+
+ $string =~ s/^[\s]+//;
+ $string =~ s/[\s]+$//;
+
+ if ($string =~ /^'.*'$/)
+ {
+ $quote = "'";
+ }
+ $string =~ s/^['"]//g;
+ $string =~ s/['"]$//g;
+
+ if ($do_translate && $key =~ /^_/) {
+ $key =~ s|^_||g;
+ if ($language) {
+ # Handle translation
+ my $decode_string = entity_decode($string);
+ my $translation = $translations{$language, $decode_string};
+ if ($translation) {
+ $translation = entity_encode($translation);
+ $string = $translation;
+ }
+ $$translate = 2;
+ } else {
+ $$translate = 2 if ($translate && (!$$translate)); # watch not to "overwrite" $translate
+ }
+ }
+
+ $result .= " $key=$quote$string$quote";
+ }
+ return $result;
+}
+
+# Returns a translatable string from XML node, it works on contents of every node in XML::Parser tree
+sub getXMLstring
+{
+ my $ref = shift;
+ my $spacepreserve = shift || 0;
+ my @list = @{ $ref };
+ my $result = "";
+
+ my $count = scalar(@list);
+ my $attrs = $list[0];
+ my $index = 1;
+
+ $spacepreserve = 1 if ((exists $attrs->{"xml:space"}) && ($attrs->{"xml:space"} =~ /^["']?preserve["']?$/));
+ $spacepreserve = 0 if ((exists $attrs->{"xml:space"}) && ($attrs->{"xml:space"} =~ /^["']?default["']?$/));
+
+ while ($index < $count) {
+ my $type = $list[$index];
+ my $content = $list[$index+1];
+ if (! $type ) {
+ # We've got CDATA
+ if ($content) {
+ # lets strip the whitespace here, and *ONLY* here
+ $content =~ s/\s+/ /gs if (!$spacepreserve);
+ $result .= $content;
+ }
+ } elsif ( "$type" ne "1" ) {
+ # We've got another element
+ $result .= "<$type";
+ $result .= getAttributeString(@{$content}[0], 0); # no nested translatable elements
+ if ($content) {
+ my $subresult = getXMLstring($content, $spacepreserve);
+ if ($subresult) {
+ $result .= ">".$subresult . "</$type>";
+ } else {
+ $result .= "/>";
+ }
+ } else {
+ $result .= "/>";
+ }
+ }
+ $index += 2;
+ }
+ return $result;
+}
+
+# Translate list of nodes if necessary
+sub translate_subnodes
+{
+ my $fh = shift;
+ my $content = shift;
+ my $language = shift || "";
+ my $singlelang = shift || 0;
+ my $spacepreserve = shift || 0;
+
+ my @nodes = @{ $content };
+
+ my $count = scalar(@nodes);
+ my $index = 0;
+ while ($index < $count) {
+ my $type = $nodes[$index];
+ my $rest = $nodes[$index+1];
+ if ($singlelang) {
+ my $oldMO = $MULTIPLE_OUTPUT;
+ $MULTIPLE_OUTPUT = 1;
+ traverse($fh, $type, $rest, $language, $spacepreserve);
+ $MULTIPLE_OUTPUT = $oldMO;
+ } else {
+ traverse($fh, $type, $rest, $language, $spacepreserve);
+ }
+ $index += 2;
+ }
+}
+
+sub isWellFormedXmlFragment
+{
+ my $ret = eval 'require XML::Parser';
+ if(!$ret) {
+ die "You must have XML::Parser installed to run $0\n\n";
+ }
+
+ my $fragment = shift;
+ return 0 if (!$fragment);
+
+ $fragment = "<root>$fragment</root>";
+ my $xp = new XML::Parser(Style => 'Tree');
+ my $tree = 0;
+ eval { $tree = $xp->parse($fragment); };
+ return $tree;
+}
+
+sub traverse
+{
+ my $fh = shift;
+ my $nodename = shift;
+ my $content = shift;
+ my $language = shift || "";
+ my $spacepreserve = shift || 0;
+
+ if (!$nodename) {
+ if ($content =~ /^[\s]*$/) {
+ $leading_space .= $content;
+ }
+ print $fh $content;
+ } else {
+ # element
+ my @all = @{ $content };
+ my $attrs = shift @all;
+ my $translate = 0;
+ my $outattr = getAttributeString($attrs, 1, $language, \$translate);
+
+ if ($nodename =~ /^_/) {
+ $translate = 1;
+ $nodename =~ s/^_//;
+ }
+ my $lookup = '';
+
+ $spacepreserve = 0 if ((exists $attrs->{"xml:space"}) && ($attrs->{"xml:space"} =~ /^["']?default["']?$/));
+ $spacepreserve = 1 if ((exists $attrs->{"xml:space"}) && ($attrs->{"xml:space"} =~ /^["']?preserve["']?$/));
+
+ print $fh "<$nodename", $outattr;
+ if ($translate) {
+ $content = getXMLstring($content, $spacepreserve);
+ if (!$spacepreserve) {
+ $content =~ s/^\s+//s;
+ $content =~ s/\s+$//s;
+ }
+ if (exists $attrs->{"msgctxt"}) {
+ my $context = entity_decode ($attrs->{"msgctxt"});
+ $context =~ s/^["'](.*)["']/$1/;
+ $lookup = "$context\004$content";
+ } else {
+ $lookup = $content;
+ }
+
+ if ($lookup || $translate == 2) {
+ my $translation = $translations{$language, $lookup} if isWellFormedXmlFragment($translations{$language, $lookup});
+ if ($MULTIPLE_OUTPUT && ($translation || $translate == 2)) {
+ $translation = $content if (!$translation);
+ print $fh " xml:lang=\"", $language, "\"" if $language;
+ print $fh ">";
+ if ($translate == 2) {
+ translate_subnodes($fh, \@all, $language, 1, $spacepreserve);
+ } else {
+ print $fh $translation;
+ }
+ print $fh "</$nodename>";
+
+ return; # this means there will be no same translation with xml:lang="$language"...
+ # if we want them both, just remove this "return"
+ } else {
+ print $fh ">";
+ if ($translate == 2) {
+ translate_subnodes($fh, \@all, $language, 1, $spacepreserve);
+ } else {
+ print $fh $content;
+ }
+ print $fh "</$nodename>";
+ }
+ } else {
+ print $fh "/>";
+ }
+
+ for my $lang (sort keys %po_files_by_lang) {
+ if ($MULTIPLE_OUTPUT && $lang ne "$language") {
+ next;
+ }
+ if ($lang) {
+ # Handle translation
+ #
+ my $translate = 0;
+ my $localattrs = getAttributeString($attrs, 1, $lang, \$translate);
+ my $translation = $translations{$lang, $lookup} if isWellFormedXmlFragment($translations{$lang, $lookup});
+ if ($translate && !$translation) {
+ $translation = $content;
+ }
+
+ if ($translation || $translate) {
+ print $fh "\n";
+ $leading_space =~ s/.*\n//g;
+ print $fh $leading_space;
+ print $fh "<", $nodename, " xml:lang=\"", $lang, "\"", $localattrs, ">";
+ if ($translate == 2) {
+ translate_subnodes($fh, \@all, $lang, 1, $spacepreserve);
+ } else {
+ print $fh $translation;
+ }
+ print $fh "</$nodename>";
+ }
+ }
+ }
+
+ } else {
+ my $count = scalar(@all);
+ if ($count > 0) {
+ print $fh ">";
+ my $index = 0;
+ while ($index < $count) {
+ my $type = $all[$index];
+ my $rest = $all[$index+1];
+ traverse($fh, $type, $rest, $language, $spacepreserve);
+ $index += 2;
+ }
+ print $fh "</$nodename>";
+ } else {
+ print $fh "/>";
+ }
+ }
+ }
+}
+
+sub intltool_tree_comment
+{
+ my $expat = shift;
+ my $data = shift;
+ my $clist = $expat->{Curlist};
+ my $pos = $#$clist;
+
+ push @$clist, 1 => $data;
+}
+
+sub intltool_tree_cdatastart
+{
+ my $expat = shift;
+ my $clist = $expat->{Curlist};
+ my $pos = $#$clist;
+
+ push @$clist, 0 => $expat->original_string();
+}
+
+sub intltool_tree_cdataend
+{
+ my $expat = shift;
+ my $clist = $expat->{Curlist};
+ my $pos = $#$clist;
+
+ $clist->[$pos] .= $expat->original_string();
+}
+
+sub intltool_tree_char
+{
+ my $expat = shift;
+ my $text = shift;
+ my $clist = $expat->{Curlist};
+ my $pos = $#$clist;
+
+ # Use original_string so that we retain escaped entities
+ # in CDATA sections.
+ #
+ if ($pos > 0 and $clist->[$pos - 1] eq '0') {
+ $clist->[$pos] .= $expat->original_string();
+ } else {
+ push @$clist, 0 => $expat->original_string();
+ }
+}
+
+sub intltool_tree_start
+{
+ my $expat = shift;
+ my $tag = shift;
+ my @origlist = ();
+
+ # Use original_string so that we retain escaped entities
+ # in attribute values. We must convert the string to an
+ # @origlist array to conform to the structure of the Tree
+ # Style.
+ #
+ my @original_array = split /\x/, $expat->original_string();
+ my $source = $expat->original_string();
+
+ # Remove leading tag.
+ #
+ $source =~ s|^\s*<\s*(\S+)||s;
+
+ # Grab attribute key/value pairs and push onto @origlist array.
+ #
+ while ($source)
+ {
+ if ($source =~ /^\s*([\w:-]+)\s*[=]\s*["]/)
+ {
+ $source =~ s|^\s*([\w:-]+)\s*[=]\s*["]([^"]*)["]||s;
+ push @origlist, $1;
+ push @origlist, '"' . $2 . '"';
+ }
+ elsif ($source =~ /^\s*([\w:-]+)\s*[=]\s*[']/)
+ {
+ $source =~ s|^\s*([\w:-]+)\s*[=]\s*[']([^']*)[']||s;
+ push @origlist, $1;
+ push @origlist, "'" . $2 . "'";
+ }
+ else
+ {
+ last;
+ }
+ }
+
+ my $ol = [ { @origlist } ];
+
+ push @{ $expat->{Lists} }, $expat->{Curlist};
+ push @{ $expat->{Curlist} }, $tag => $ol;
+ $expat->{Curlist} = $ol;
+}
+
+sub readXml
+{
+ my $filename = shift || return;
+ if(!-f $filename) {
+ die "ERROR Cannot find filename: $filename\n";
+ }
+
+ my $ret = eval 'require XML::Parser';
+ if(!$ret) {
+ die "You must have XML::Parser installed to run $0\n\n";
+ }
+ my $xp = new XML::Parser(Style => 'Tree');
+ $xp->setHandlers(Char => \&intltool_tree_char);
+ $xp->setHandlers(Start => \&intltool_tree_start);
+ $xp->setHandlers(CdataStart => \&intltool_tree_cdatastart);
+ $xp->setHandlers(CdataEnd => \&intltool_tree_cdataend);
+ my $tree = $xp->parsefile($filename);
+
+# <foo><head id="a">Hello <em>there</em></head><bar>Howdy<ref/></bar>do</foo>
+# would be:
+# [foo, [{}, head, [{id => "a"}, 0, "Hello ", em, [{}, 0, "there"]], bar, [{},
+# 0, "Howdy", ref, [{}]], 0, "do" ] ]
+
+ return $tree;
+}
+
+sub print_header
+{
+ my $infile = shift;
+ my $fh = shift;
+ my $source;
+
+ if(!-f $infile) {
+ die "ERROR Cannot find filename: $infile\n";
+ }
+
+ print $fh qq{<?xml version="1.0" encoding="UTF-8"?>\n};
+ {
+ local $/;
+ open DOCINPUT, "<${FILE}" or die;
+ $source = <DOCINPUT>;
+ close DOCINPUT;
+ }
+ if ($source =~ /(<!DOCTYPE.*\[.*\]\s*>)/s)
+ {
+ print $fh "$1\n";
+ }
+ elsif ($source =~ /(<!DOCTYPE[^>]*>)/s)
+ {
+ print $fh "$1\n";
+ }
+}
+
+sub parseTree
+{
+ my $fh = shift;
+ my $ref = shift;
+ my $language = shift || "";
+
+ my $name = shift @{ $ref };
+ my $cont = shift @{ $ref };
+
+ while (!$name || "$name" eq "1") {
+ $name = shift @{ $ref };
+ $cont = shift @{ $ref };
+ }
+
+ my $spacepreserve = 0;
+ my $attrs = @{$cont}[0];
+ $spacepreserve = 1 if ((exists $attrs->{"xml:space"}) && ($attrs->{"xml:space"} =~ /^["']?preserve["']?$/));
+
+ traverse($fh, $name, $cont, $language, $spacepreserve);
+}
+
+sub xml_merge_output
+{
+ my $source;
+
+ if ($MULTIPLE_OUTPUT) {
+ for my $lang (sort keys %po_files_by_lang) {
+ if ( ! -d $lang ) {
+ mkdir $lang or -d $lang or die "Cannot create subdirectory $lang: $!\n";
+ }
+ open OUTPUT, ">$lang/$OUTFILE" or die "Cannot open $lang/$OUTFILE: $!\n";
+ binmode (OUTPUT) if $^O eq 'MSWin32';
+ my $tree = readXml($FILE);
+ print_header($FILE, \*OUTPUT);
+ parseTree(\*OUTPUT, $tree, $lang);
+ close OUTPUT;
+ print "CREATED $lang/$OUTFILE\n" unless $QUIET_ARG;
+ }
+ if ( ! -d "C" ) {
+ mkdir "C" or -d "C" or die "Cannot create subdirectory C: $!\n";
+ }
+ open OUTPUT, ">C/$OUTFILE" or die "Cannot open C/$OUTFILE: $!\n";
+ binmode (OUTPUT) if $^O eq 'MSWin32';
+ my $tree = readXml($FILE);
+ print_header($FILE, \*OUTPUT);
+ parseTree(\*OUTPUT, $tree);
+ close OUTPUT;
+ print "CREATED C/$OUTFILE\n" unless $QUIET_ARG;
+ } else {
+ open OUTPUT, ">$OUTFILE" or die "Cannot open $OUTFILE: $!\n";
+ binmode (OUTPUT) if $^O eq 'MSWin32';
+ my $tree = readXml($FILE);
+ print_header($FILE, \*OUTPUT);
+ parseTree(\*OUTPUT, $tree);
+ close OUTPUT;
+ print "CREATED $OUTFILE\n" unless $QUIET_ARG;
+ }
+}
+
+sub keys_merge_translation
+{
+ my ($lang) = @_;
+
+ if ( ! -d $lang && $MULTIPLE_OUTPUT)
+ {
+ mkdir $lang or -d $lang or die "Cannot create subdirectory $lang: $!\n";
+ }
+
+ open INPUT, "<${FILE}" or die "Cannot open ${FILE}: $!\n";
+ open OUTPUT, ">$lang/$OUTFILE" or die "Cannot open $lang/$OUTFILE: $!\n";
+ binmode (OUTPUT) if $^O eq 'MSWin32';
+
+ while (<INPUT>)
+ {
+ if (s/^(\s*)_(\w+=(.*))/$1$2/)
+ {
+ my $string = $3;
+
+ if (!$MULTIPLE_OUTPUT)
+ {
+ print OUTPUT;
+
+ my $non_translated_line = $_;
+
+ for my $lang (sort keys %po_files_by_lang)
+ {
+ my $translation = $translations{$lang, $string};
+ next if !$translation;
+
+ $_ = $non_translated_line;
+ s/(\w+)=.*/[$lang]$1=$translation/;
+ print OUTPUT;
+ }
+ }
+ else
+ {
+ my $non_translated_line = $_;
+ my $translation = $translations{$lang, $string};
+ $translation = $string if !$translation;
+
+ $_ = $non_translated_line;
+ s/(\w+)=.*/$1=$translation/;
+ print OUTPUT;
+ }
+ }
+ else
+ {
+ print OUTPUT;
+ }
+ }
+
+ close OUTPUT;
+ close INPUT;
+
+ print "CREATED $lang/$OUTFILE\n" unless $QUIET_ARG;
+}
+
+sub keys_merge_translations
+{
+ if ($MULTIPLE_OUTPUT)
+ {
+ for my $lang (sort keys %po_files_by_lang)
+ {
+ keys_merge_translation ($lang);
+ }
+ keys_merge_translation ("C");
+ }
+ else
+ {
+ keys_merge_translation (".");
+ }
+}
+
+sub desktop_merge_translations
+{
+ open INPUT, "<${FILE}" or die;
+ open OUTPUT, ">${OUTFILE}" or die;
+ binmode (OUTPUT) if $^O eq 'MSWin32';
+
+ while (<INPUT>)
+ {
+ if (s/^(\s*)_([A-Za-z0-9\-]+\s*=\s*(.*))/$1$2/)
+ {
+ my $string = $3;
+
+ print OUTPUT;
+
+ my $non_translated_line = $_;
+
+ for my $lang (sort keys %po_files_by_lang)
+ {
+ my $translation = $translations{$lang, unescape_po_string($string)};
+ next if !$translation;
+
+ # escape new lines
+ $translation =~ s/\n/\\n/g;
+
+ # skip unchanged strings
+ next if $translation eq $string;
+
+ $_ = $non_translated_line;
+ s/(\w+)\s*=\s*.*/${1}[$lang]=$translation/;
+ print OUTPUT;
+ }
+ }
+ else
+ {
+ print OUTPUT;
+ }
+ }
+
+ close OUTPUT;
+ close INPUT;
+}
+
+sub schemas_merge_translations
+{
+ my $source;
+
+ {
+ local $/; # slurp mode
+ open INPUT, "<$FILE" or die "can't open $FILE: $!";
+ $source = <INPUT>;
+ close INPUT;
+ }
+
+ open OUTPUT, ">$OUTFILE" or die;
+ binmode (OUTPUT) if $^O eq 'MSWin32';
+
+ # FIXME: support attribute translations
+
+ # Empty nodes never need translation, so unmark all of them.
+ # For example, <_foo/> is just replaced by <foo/>.
+ $source =~ s|<\s*_($w+)\s*/>|<$1/>|g;
+
+ while ($source =~ s/
+ (.*?)
+ (\s+)(<locale\ name="C">(\s*)
+ (<default>\s*(?:<!--[^>]*?-->\s*)?(.*?)\s*<\/default>)?(\s*)
+ (<short>\s*(?:<!--[^>]*?-->\s*)?(.*?)\s*<\/short>)?(\s*)
+ (<long>\s*(?:<!--[^>]*?-->\s*)?(.*?)\s*<\/long>)?(\s*)
+ <\/locale>)
+ //sx)
+ {
+ print OUTPUT $1;
+
+ my $locale_start_spaces = $2 ? $2 : '';
+ my $default_spaces = $4 ? $4 : '';
+ my $short_spaces = $7 ? $7 : '';
+ my $long_spaces = $10 ? $10 : '';
+ my $locale_end_spaces = $13 ? $13 : '';
+ my $c_default_block = $3 ? $3 : '';
+ my $default_string = $6 ? $6 : '';
+ my $short_string = $9 ? $9 : '';
+ my $long_string = $12 ? $12 : '';
+
+ print OUTPUT "$locale_start_spaces$c_default_block";
+
+ $default_string =~ s/\s+/ /g;
+ $default_string = entity_decode($default_string);
+ $short_string =~ s/\s+/ /g;
+ $short_string = entity_decode($short_string);
+ $long_string =~ s/\s+/ /g;
+ $long_string = entity_decode($long_string);
+
+ for my $lang (sort keys %po_files_by_lang)
+ {
+ my $default_translation = $translations{$lang, $default_string};
+ my $short_translation = $translations{$lang, $short_string};
+ my $long_translation = $translations{$lang, $long_string};
+
+ next if (!$default_translation && !$short_translation &&
+ !$long_translation);
+
+ print OUTPUT "\n$locale_start_spaces<locale name=\"$lang\">";
+
+ print OUTPUT "$default_spaces";
+
+ if ($default_translation)
+ {
+ $default_translation = entity_encode($default_translation);
+ print OUTPUT "<default>$default_translation</default>";
+ }
+
+ print OUTPUT "$short_spaces";
+
+ if ($short_translation)
+ {
+ $short_translation = entity_encode($short_translation);
+ print OUTPUT "<short>$short_translation</short>";
+ }
+
+ print OUTPUT "$long_spaces";
+
+ if ($long_translation)
+ {
+ $long_translation = entity_encode($long_translation);
+ print OUTPUT "<long>$long_translation</long>";
+ }
+
+ print OUTPUT "$locale_end_spaces</locale>";
+ }
+ }
+
+ print OUTPUT $source;
+
+ close OUTPUT;
+}
+
+sub rfc822deb_merge_translations
+{
+ my %encodings = ();
+ for my $lang (keys %po_files_by_lang) {
+ $encodings{$lang} = ($UTF8_ARG ? 'UTF-8' : get_po_encoding($po_files_by_lang{$lang}));
+ }
+
+ my $source;
+
+ $Text::Wrap::huge = 'overflow';
+ $Text::Wrap::break = qr/\n|\s(?=\S)/;
+
+ {
+ local $/; # slurp mode
+ open INPUT, "<$FILE" or die "can't open $FILE: $!";
+ $source = <INPUT>;
+ close INPUT;
+ }
+
+ open OUTPUT, ">${OUTFILE}" or die;
+ binmode (OUTPUT) if $^O eq 'MSWin32';
+
+ while ($source =~ /(^|\n+)(_*)([^:\s]+)(:[ \t]*)(.*?)(?=\n[\S\n]|$)/sg)
+ {
+ my $sep = $1;
+ my $non_translated_line = $3.$4;
+ my $string = $5;
+ my $underscore = length($2);
+ next if $underscore eq 0 && $non_translated_line =~ /^#/;
+ # Remove [] dummy strings
+ my $stripped = $string;
+ $stripped =~ s/\[\s[^\[\]]*\],/,/g if $underscore eq 2;
+ $stripped =~ s/\[\s[^\[\]]*\]$//;
+ $non_translated_line .= $stripped;
+
+ print OUTPUT $sep.$non_translated_line;
+
+ if ($underscore)
+ {
+ my @str_list = rfc822deb_split($underscore, $string);
+
+ for my $lang (sort keys %po_files_by_lang)
+ {
+ my $is_translated = 1;
+ my $str_translated = '';
+ my $first = 1;
+
+ for my $str (@str_list)
+ {
+ my $translation = $translations{$lang, $str};
+
+ if (!$translation)
+ {
+ $is_translated = 0;
+ last;
+ }
+
+ # $translation may also contain [] dummy
+ # strings, mostly to indicate an empty string
+ $translation =~ s/\[\s[^\[\]]*\]$//;
+
+ if ($first)
+ {
+ if ($underscore eq 2)
+ {
+ $str_translated .= $translation;
+ }
+ else
+ {
+ $str_translated .=
+ Text::Tabs::expand($translation) .
+ "\n";
+ }
+ }
+ else
+ {
+ if ($underscore eq 2)
+ {
+ $str_translated .= ', ' . $translation;
+ }
+ else
+ {
+ $str_translated .= Text::Tabs::expand(
+ Text::Wrap::wrap(' ', ' ', $translation)) .
+ "\n .\n";
+ }
+ }
+ $first = 0;
+
+ # To fix some problems with Text::Wrap::wrap
+ $str_translated =~ s/(\n )+\n/\n .\n/g;
+ }
+ next unless $is_translated;
+
+ $str_translated =~ s/\n \.\n$//;
+ $str_translated =~ s/\s+$//;
+
+ $_ = $non_translated_line;
+ s/^(\w+):\s*.*/$sep${1}-$lang.$encodings{$lang}: $str_translated/s;
+ print OUTPUT;
+ }
+ }
+ }
+ print OUTPUT "\n";
+
+ close OUTPUT;
+ close INPUT;
+}
+
+sub rfc822deb_split
+{
+ # Debian defines a special way to deal with rfc822-style files:
+ # when a value contain newlines, it consists of
+ # 1. a short form (first line)
+ # 2. a long description, all lines begin with a space,
+ # and paragraphs are separated by a single dot on a line
+ # This routine returns an array of all paragraphs, and reformat
+ # them.
+ # When first argument is 2, the string is a comma separated list of
+ # values.
+ my $type = shift;
+ my $text = shift;
+ $text =~ s/^[ \t]//mg;
+ return (split(/, */, $text, 0)) if $type ne 1;
+ return ($text) if $text !~ /\n/;
+
+ $text =~ s/([^\n]*)\n//;
+ my @list = ($1);
+ my $str = '';
+
+ for my $line (split (/\n/, $text))
+ {
+ chomp $line;
+ if ($line =~ /^\.\s*$/)
+ {
+ # New paragraph
+ $str =~ s/\s*$//;
+ push(@list, $str);
+ $str = '';
+ }
+ elsif ($line =~ /^\s/)
+ {
+ # Line which must not be reformatted
+ $str .= "\n" if length ($str) && $str !~ /\n$/;
+ $line =~ s/\s+$//;
+ $str .= $line."\n";
+ }
+ else
+ {
+ # Continuation line, remove newline
+ $str .= " " if length ($str) && $str !~ /\n$/;
+ $str .= $line;
+ }
+ }
+
+ $str =~ s/\s*$//;
+ push(@list, $str) if length ($str);
+
+ return @list;
+}
+
+sub quoted_translation
+{
+ my ($xml_mode, $lang, $string) = @_;
+
+ $string = entity_decode($string) if $xml_mode;
+ $string =~ s/\\\"/\"/g;
+
+ my $translation = $translations{$lang, $string};
+ $translation = $string if !$translation;
+ $translation = entity_encode($translation) if $xml_mode;
+ $translation =~ s/\"/\\\"/g;
+ return $translation
+}
+
+sub quoted_merge_translations
+{
+ my ($xml_mode) = @_;
+
+ if (!$MULTIPLE_OUTPUT) {
+ print "Quoted only supports Multiple Output.\n";
+ exit(1);
+ }
+
+ for my $lang (sort keys %po_files_by_lang) {
+ if ( ! -d $lang ) {
+ mkdir $lang or -d $lang or die "Cannot create subdirectory $lang: $!\n";
+ }
+ open INPUT, "<${FILE}" or die;
+ open OUTPUT, ">$lang/$OUTFILE" or die "Cannot open $lang/$OUTFILE: $!\n";
+ binmode (OUTPUT) if $^O eq 'MSWin32';
+ while (<INPUT>)
+ {
+ s/\"(([^\"]|\\\")*[^\\\"])\"/"\"" . &quoted_translation($xml_mode, $lang, $1) . "\""/ge;
+ print OUTPUT;
+ }
+ close OUTPUT;
+ close INPUT;
+ }
+}
diff -Naur orig/modules/tde_uic.cmake tde-cmake-trinity-14.1.3/modules/tde_uic.cmake
--- orig/modules/tde_uic.cmake 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/modules/tde_uic.cmake 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,79 @@
+#################################################
+#
+# (C) 2010-2011 Serghei Amelian
+# serghei (DOT) amelian (AT) gmail.com
+#
+# Improvements and feedback are welcome
+#
+# This file is released under GPL >= 2
+#
+#################################################
+
+if( NOT ${CMAKE_CURRENT_LIST_DIR} STREQUAL ${CMAKE_ROOT}/Modules )
+ set( CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}" )
+endif()
+include( TDEMacros )
+
+get_filename_component( _ui_basename ${UI_FILE} NAME_WE )
+
+# FIXME this will working only on out-of-source mode
+set( local_ui_file ${_ui_basename}.ui )
+configure_file( ${UI_FILE} ${local_ui_file} COPYONLY )
+tde_execute_process( COMMAND ${TQT_REPLACE_SCRIPT} ${local_ui_file} )
+
+# ui.h extension file, if exists
+if( EXISTS "${UI_FILE}.h" )
+ configure_file( ${UI_FILE}.h ${local_ui_file}.h COPYONLY )
+ tde_execute_process( COMMAND ${TQT_REPLACE_SCRIPT} ${local_ui_file}.h )
+endif( )
+
+if( TDE_TQTPLUGINS_DIR )
+ set( L -L ${TDE_TQTPLUGINS_DIR} )
+endif( )
+
+# Choose translation function, different for TQt and TDE
+if ( TDE_FOUND AND NOT TQT_ONLY )
+ set( TR_FUNC "tr2i18n" )
+else( TDE_FOUND AND NOT TQT_ONLY )
+ set( TR_FUNC "tr" )
+endif( TDE_FOUND AND NOT TQT_ONLY )
+
+# Generate ui .h file
+tde_execute_process( COMMAND ${UIC_EXECUTABLE}
+ -nounload -tr ${TR_FUNC}
+ ${L}
+ ${local_ui_file}
+ OUTPUT_VARIABLE _ui_h_content )
+
+if( _ui_h_content )
+ string( REGEX REPLACE "#ifndef " "#ifndef UI_" _ui_h_content "${_ui_h_content}" )
+ string( REGEX REPLACE "#define " "#define UI_" _ui_h_content "${_ui_h_content}" )
+ if ( TDE_FOUND AND NOT TQT_ONLY )
+ string( REGEX REPLACE "public T?QWizard" "public KWizard" _ui_h_content "${_ui_h_content}" )
+ string( REGEX REPLACE "#include <(n?t)?qwizard.h>" "#include <kwizard.h>" _ui_h_content "${_ui_h_content}" )
+ endif( TDE_FOUND AND NOT TQT_ONLY )
+ file( WRITE ${_ui_basename}.h "${_ui_h_content}" )
+endif( )
+
+# Generate ui .cpp file
+tde_execute_process( COMMAND ${UIC_EXECUTABLE}
+ -nounload -tr ${TR_FUNC}
+ ${L}
+ -impl ${_ui_basename}.h
+ ${local_ui_file}
+ OUTPUT_VARIABLE _ui_cpp_content )
+
+if( _ui_cpp_content )
+ string( REGEX REPLACE "${TR_FUNC}\\(\"\"\\)" "TQString::null" _ui_cpp_content "${_ui_cpp_content}" )
+ string( REGEX REPLACE "${TR_FUNC}\\(\"\", \"\"\\)" "TQString::null" _ui_cpp_content "${_ui_cpp_content}" )
+ if ( TDE_FOUND AND NOT TQT_ONLY )
+ string( REGEX REPLACE ": T?QWizard\\(" ": KWizard(" _ui_cpp_content "${_ui_cpp_content}" )
+ set( _ui_cpp_content "#include <kdialog.h>\n#include <tdelocale.h>\n\n${_ui_cpp_content}" )
+ endif( TDE_FOUND AND NOT TQT_ONLY )
+ file( WRITE ${_ui_basename}.cpp "${_ui_cpp_content}" )
+
+ tde_execute_process( COMMAND ${MOC_EXECUTABLE}
+ ${_ui_basename}.h
+ OUTPUT_VARIABLE _ui_h_moc_content )
+ file( APPEND ${_ui_basename}.cpp "${_ui_h_moc_content}" )
+endif( _ui_cpp_content )
diff -Naur orig/templates/tde_dummy_cpp.cmake tde-cmake-trinity-14.1.3/templates/tde_dummy_cpp.cmake
--- orig/templates/tde_dummy_cpp.cmake 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/templates/tde_dummy_cpp.cmake 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,5 @@
+#ifdef _AIX
+ namespace {
+ void *not_empty_file;
+ }
+#endif
diff -Naur orig/templates/tde_export_library.cmake tde-cmake-trinity-14.1.3/templates/tde_export_library.cmake
--- orig/templates/tde_export_library.cmake 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/templates/tde_export_library.cmake 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,8 @@
+add_library( @_target@ @_type@ IMPORTED )
+
+set_target_properties( @_target@ PROPERTIES
+ INTERFACE_COMPILE_FEATURES "@_cxx_features@"
+ IMPORTED_LINK_INTERFACE_LIBRARIES "@_shared_libs@"
+ IMPORTED_LOCATION "@_location@"
+ IMPORTED_SONAME "@_soname@" )
+
diff -Naur orig/templates/tde_libtool_file.cmake tde-cmake-trinity-14.1.3/templates/tde_libtool_file.cmake
--- orig/templates/tde_libtool_file.cmake 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/templates/tde_libtool_file.cmake 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,35 @@
+# @_laname@ - a libtool library file
+# Generated by CMake - GNU libtool
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname='@_library_name_2@'
+
+# Names of this library.
+library_names='@_library_name_1@ @_library_name_2@ @_library_name_3@'
+
+# The name of the static archive.
+old_library=''
+
+# Libraries that this one depends upon.
+dependency_libs=''
+
+# Version information for @_name@.
+current=@_version_current@
+age=@_version_age@
+revision=@_version_revision@
+
+# Is this an already installed library?
+installed=yes
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=@_shouldnotlink@
+
+# Files to dlopen/dlpreopen
+dlopen=''
+dlpreopen=''
+
+# Directory that this library needs to be installed in:
+libdir='@_libdir@'
diff -Naur orig/templates/tde_tdeinit_executable.cmake tde-cmake-trinity-14.1.3/templates/tde_tdeinit_executable.cmake
--- orig/templates/tde_tdeinit_executable.cmake 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/templates/tde_tdeinit_executable.cmake 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,2 @@
+extern "C" int kdemain(int argc, char* argv[]);
+int main(int argc, char* argv[]) { return kdemain(argc,argv); }
diff -Naur orig/templates/tde_tdeinit_module.cmake tde-cmake-trinity-14.1.3/templates/tde_tdeinit_module.cmake
--- orig/templates/tde_tdeinit_module.cmake 1970-01-01 08:00:00.000000000 +0800
+++ tde-cmake-trinity-14.1.3/templates/tde_tdeinit_module.cmake 2024-10-15 00:00:02.000000000 +0800
@@ -0,0 +1,3 @@
+#include <tdemacros.h>
+extern "C" int kdemain(int argc, char* argv[]);
+extern "C" TDE_EXPORT int tdeinitmain(int argc, char* argv[]) { return kdemain(argc,argv); }
Reference in New Issue View Git Blame Copy Permalink