Merge branch 'plugin-support-for-third-party-projects'

* plugin-support-for-third-party-projects:
  Cached resource files in plug-ins can now be specified with absolute path.
  Always add the plugin root dir to the list of include dirs.
  Fix an issue with long relative include paths in moc generated files.
  Added quotes in case the variable is empty.
  Added missing variable for external projects to start DGraph on Windows.
  On plug-in activation, the dependencies must also be started (no lazy start).
  Converted tab to space.
  Improved the usage of the plug-in build system for external projects.
  Support for customizing the output dir for plug-ins.
  Added support for exporting additional include dirs in plug-ins.
  Renamed macros and made them usable for external projects.

Conflicts:
	CMake/ctkMacroBuildPlugin.cmake
	CMake/ctkMacroTargetLibraries.cmake

CMake/ctkFunctionGenerateDGraphInput.cmake

@@ -84,7 +84,7 @@ FUNCTION(ctkFunctionGenerateDGraphInput dir target_directories)
         SET(ctk_dependencies ${dependencies})
       ELSE()
         # filter dependencies starting with CTK org org_commontk_
-        ctkMacroGetAllCTKTargetLibraries("${dependencies}" ctk_dependencies)
+        ctkMacroGetAllProjectTargetLibraries("${dependencies}" ctk_dependencies)
       ENDIF()
 
       IF(ctk_dependencies)

CMake/ctkFunctionGeneratePluginUseFile.cmake

@@ -30,8 +30,23 @@ FUNCTION(ctkFunctionGeneratePluginUseFile filename)
 
   SET(CTK_PLUGIN_INCLUDE_DIRS_CONFIG)
   FOREACH(plugin ${my_ctk_plugin_libraries})
-    SET(${plugin}_INCLUDE_DIRS ${${plugin}_SOURCE_DIR} ${${plugin}_BINARY_DIR})
+    SET(${plugin}_INCLUDE_DIRS )
+
+    # The call to ctkFunctionGetIncludeDirs returns all include dirs
+    # the plugin itself needs. This does not include the plugin's
+    # source dir, so we add it explicitly.
+    IF(${plugin}_INCLUDE_SUFFIXES)
+      FOREACH(_suffix ${${plugin}_INCLUDE_SUFFIXES})
+        LIST(APPEND ${plugin}_INCLUDE_DIRS ${${plugin}_SOURCE_DIR}/${_suffix})
+      ENDFOREACH()
+    ELSE()
+      LIST(APPEND ${plugin}_INCLUDE_DIRS ${${plugin}_SOURCE_DIR})
+    ENDIF()
+
+    LIST(APPEND ${plugin}_INCLUDE_DIRS ${${plugin}_BINARY_DIR})
+
     ctkFunctionGetIncludeDirs(${plugin}_INCLUDE_DIRS ${plugin})
+
     SET(CTK_PLUGIN_INCLUDE_DIRS_CONFIG "${CTK_PLUGIN_INCLUDE_DIRS_CONFIG}
 SET(${plugin}_INCLUDE_DIRS \"${${plugin}_INCLUDE_DIRS}\")")
 

CMake/ctkFunctionGenerateProjectXml.cmake

@@ -79,7 +79,7 @@ FUNCTION(ctkFunctionGenerateProjectXml dir name target_directories is_superbuild
       SET(ctk_dependencies)
 
       # filter dependencies starting with CTK
-      ctkMacroGetAllCTKTargetLibraries("${dependencies}" ctk_dependencies)
+      ctkMacroGetAllProjectTargetLibraries("${dependencies}" ctk_dependencies)
 
       IF(${is_superbuild})
         SET(xml_subprojects ${xml_subprojects} "    <Dependency name=\"SuperBuild\"/>\n")

CMake/ctkFunctionGetIncludeDirs.cmake

@@ -36,14 +36,22 @@ FUNCTION(ctkFunctionGetIncludeDirs var_include_dirs)
     SET(ctk_deps )
     SET(ext_deps )
 
-    ctkMacroGetAllCTKTargetLibraries("${${_target}_DEPENDENCIES}" ctk_deps)
-    ctkMacroGetAllNonCTKTargetLibraries("${${_target}_DEPENDENCIES}" ext_deps)
+    ctkMacroGetAllProjectTargetLibraries("${${_target}_DEPENDENCIES}" ctk_deps)
+    ctkMacroGetAllNonProjectTargetLibraries("${${_target}_DEPENDENCIES}" ext_deps)
 
     FOREACH(dep ${ctk_deps})
-      LIST(APPEND _include_dirs
-           ${${dep}_SOURCE_DIR}
-           ${${dep}_BINARY_DIR}
-           )
+
+      IF(${dep}_INCLUDE_SUFFIXES)
+        FOREACH(_suffix ${${dep}_INCLUDE_SUFFIXES})
+          LIST(APPEND _include_dirs ${${dep}_SOURCE_DIR}/${_suffix})
+        ENDFOREACH()
+        LIST(APPEND _include_dirs ${${dep}_BINARY_DIR})
+      ELSE()
+        LIST(APPEND _include_dirs
+             ${${dep}_SOURCE_DIR}
+             ${${dep}_BINARY_DIR}
+             )
+      ENDIF()
 
       # For external projects, CTKConfig.cmake contains variables
       # listening the include dirs for CTK libraries and plugins
@@ -61,7 +69,12 @@ FUNCTION(ctkFunctionGetIncludeDirs var_include_dirs)
 
       # This is for resolving include dependencies between
       # libraries / plugins from external projects using CTK
-      IF(${dep}_SOURCE_DIR)
+      IF(${dep}_SOURCE_DIR AND ${dep}_INCLUDE_SUFFIXES)
+        FOREACH(_suffix ${${dep}_INCLUDE_SUFFIXES})
+          LIST(APPEND _include_dirs ${${dep}_SOURCE_DIR}/${_suffix})
+        ENDFOREACH()
+        LIST(APPEND _include_dirs ${${dep}_BINARY_DIR})
+      ELSEIF(${dep}_SOURCE_DIR)
         LIST(APPEND _include_dirs ${${dep}_SOURCE_DIR})
       ENDIF()
 

CMake/ctkFunctionGetLibraryDirs.cmake

@@ -35,7 +35,7 @@ FUNCTION(ctkFunctionGetLibraryDirs var_library_dirs)
 
     SET(ext_deps )
 
-    ctkMacroGetAllNonCTKTargetLibraries("${${_target}_DEPENDENCIES}" ext_deps)
+    ctkMacroGetAllNonProjectTargetLibraries("${${_target}_DEPENDENCIES}" ext_deps)
     
     FOREACH(dep ${ext_deps})
 

CMake/ctkMacroBuildApp.cmake

@@ -75,7 +75,13 @@ MACRO(ctkMacroBuildApp)
   SET(MY_QRC_SRCS)
 
   # Wrap
-  QT4_WRAP_CPP(MY_MOC_CPP ${MY_MOC_SRCS})
+  IF(MY_MOC_SRCS)
+    # this is a workaround for Visual Studio. The relative include paths in the generated
+    # moc files can get very long and can't be resolved by the MSVC compiler.
+    FOREACH(moc_src ${MY_MOC_SRCS})
+      QT4_WRAP_CPP(MY_MOC_CPP ${moc_src} OPTIONS -f${moc_src})
+    ENDFOREACH()
+  ENDIF()
   QT4_WRAP_UI(MY_UI_CPP ${MY_UI_FORMS})
   IF(DEFINED MY_RESOURCES)
     QT4_ADD_RESOURCES(MY_QRC_SRCS ${MY_RESOURCES})

CMake/ctkMacroBuildLib.cmake

@@ -92,7 +92,13 @@ MACRO(ctkMacroBuildLib)
   SET(MY_QRC_SRCS)
 
   # Wrap
-  QT4_WRAP_CPP(MY_MOC_CPP ${MY_MOC_SRCS})
+  IF(MY_MOC_SRCS)
+    # this is a workaround for Visual Studio. The relative include paths in the generated
+    # moc files can get very long and can't be resolved by the MSVC compiler.
+    FOREACH(moc_src ${MY_MOC_SRCS})
+      QT4_WRAP_CPP(MY_MOC_CPP ${moc_src} OPTIONS -f${moc_src})
+    ENDFOREACH()
+  ENDIF()
   QT4_WRAP_UI(MY_UI_CPP ${MY_UI_FORMS})
   IF(DEFINED MY_RESOURCES)
     QT4_ADD_RESOURCES(MY_QRC_SRCS ${MY_RESOURCES})

CMake/ctkMacroBuildPlugin.cmake

@@ -48,7 +48,7 @@
 #! \ingroup CMakeAPI
 MACRO(ctkMacroBuildPlugin)
   CtkMacroParseArguments(MY
-    "EXPORT_DIRECTIVE;SRCS;MOC_SRCS;UI_FORMS;INCLUDE_DIRECTORIES;TARGET_LIBRARIES;RESOURCES;CACHED_RESOURCEFILES;TRANSLATIONS"
+    "EXPORT_DIRECTIVE;SRCS;MOC_SRCS;UI_FORMS;INCLUDE_DIRECTORIES;EXPORTED_INCLUDE_SUFFIXES;TARGET_LIBRARIES;RESOURCES;CACHED_RESOURCEFILES;TRANSLATIONS;OUTPUT_DIR"
     "TEST_PLUGIN"
     ${ARGN}
     )
@@ -100,11 +100,26 @@ MACRO(ctkMacroBuildPlugin)
 
   # --------------------------------------------------------------------------
   # Include dirs
-  SET(my_includes
-    ${CMAKE_CURRENT_SOURCE_DIR}
-    ${CMAKE_CURRENT_BINARY_DIR}
-    ${MY_INCLUDE_DIRECTORIES}
-    )
+  IF(MY_EXPORTED_INCLUDE_SUFFIXES)
+    SET(${lib_name}_INCLUDE_SUFFIXES ${MY_EXPORTED_INCLUDE_SUFFIXES}
+        CACHE INTERNAL "List of exported plugin include dirs")
+
+    SET(my_includes )
+    FOREACH(_suffix ${MY_EXPORTED_INCLUDE_SUFFIXES})
+      LIST(APPEND my_includes ${CMAKE_CURRENT_SOURCE_DIR}/${_suffix})
+    ENDFOREACH()
+  ELSE()
+    SET(${lib_name}_INCLUDE_SUFFIXES ""
+        CACHE INTERNAL "List of exported plugin include dirs")
+
+    SET(my_includes )
+  ENDIF()
+  
+  LIST(APPEND my_includes
+      ${CMAKE_CURRENT_SOURCE_DIR}
+      ${CMAKE_CURRENT_BINARY_DIR}
+      ${MY_INCLUDE_DIRECTORIES}
+      )
 
   # Add the include directories from the plugin dependencies
   # and external dependencies
@@ -113,6 +128,9 @@ MACRO(ctkMacroBuildPlugin)
   INCLUDE_DIRECTORIES(
     ${my_includes}
     )
+
+  # Add Qt include dirs and defines
+  INCLUDE(${QT_USE_FILE})
     
   # Add the library directories from the external project
   ctkFunctionGetLibraryDirs(my_library_dirs ${lib_name})
@@ -138,7 +156,13 @@ MACRO(ctkMacroBuildPlugin)
   SET(MY_QRC_SRCS)
 
   # Wrap
-  QT4_WRAP_CPP(MY_MOC_CPP ${MY_MOC_SRCS})
+  IF(MY_MOC_SRCS)
+    # this is a workaround for Visual Studio. The relative include paths in the generated
+    # moc files can get very long and can't be resolved by the MSVC compiler.
+    FOREACH(moc_src ${MY_MOC_SRCS})
+      QT4_WRAP_CPP(MY_MOC_CPP ${moc_src} OPTIONS -f${moc_src})
+    ENDFOREACH()
+  ENDIF()
   QT4_WRAP_UI(MY_UI_CPP ${MY_UI_FORMS})
   IF(DEFINED MY_RESOURCES)
     QT4_ADD_RESOURCES(MY_QRC_SRCS ${MY_RESOURCES})
@@ -171,7 +195,7 @@ MACRO(ctkMacroBuildPlugin)
 
   # Create translation files (.ts and .qm)
   SET(_plugin_qm_files )
-  SET(_plugin_relative_qm_files )
+  SET(_plugin_cached_resources_in_binary_tree )
   SET(_translations_dir "${CMAKE_CURRENT_BINARY_DIR}/CTK-INF/l10n")
   IF(MY_TRANSLATIONS)
     SET_SOURCE_FILES_PROPERTIES(${MY_TRANSLATIONS}
@@ -182,18 +206,31 @@ MACRO(ctkMacroBuildPlugin)
   IF(_plugin_qm_files)
     FOREACH(_qm_file ${_plugin_qm_files})
       FILE(RELATIVE_PATH _relative_qm_file ${CMAKE_CURRENT_BINARY_DIR} ${_qm_file})
-      LIST(APPEND _plugin_relative_qm_files ${_relative_qm_file})
+      LIST(APPEND _plugin_cached_resources_in_binary_tree ${_relative_qm_file})
+    ENDFOREACH()
+  ENDIF()
+
+  SET(_plugin_cached_resources_in_source_tree )
+  IF(MY_CACHED_RESOURCEFILES)
+    FOREACH(_cached_resource ${MY_CACHED_RESOURCEFILES})
+      IF(IS_ABSOLUTE "${_cached_resource}")
+        # create a path relative to the current binary dir
+        FILE(RELATIVE_PATH _relative_cached_resource ${CMAKE_CURRENT_BINARY_DIR} ${_cached_resource})
+        LIST(APPEND _plugin_cached_resources_in_binary_tree ${_relative_cached_resource})
+      ELSE()
+        LIST(APPEND _plugin_cached_resources_in_source_tree ${_cached_resource})
+      ENDIF()
     ENDFOREACH()
   ENDIF()
 
   # Add any other additional resource files
-  IF(MY_CACHED_RESOURCEFILES OR _plugin_relative_qm_files)
+  IF(_plugin_cached_resources_in_source_tree OR _plugin_cached_resources_in_binary_tree)
     STRING(REPLACE "." "_" _plugin_symbolicname ${Plugin-SymbolicName})
     ctkMacroGeneratePluginResourceFile(MY_QRC_SRCS
       NAME ${_plugin_symbolicname}_cached.qrc
       PREFIX ${Plugin-SymbolicName}
-      RESOURCES ${MY_CACHED_RESOURCEFILES}
-      BINARY_RESOURCES ${_plugin_relative_qm_files})
+      RESOURCES ${_plugin_cached_resources_in_source_tree}
+      BINARY_RESOURCES ${_plugin_cached_resources_in_binary_tree})
   ENDIF()
 
   SOURCE_GROUP("Resources" FILES
@@ -218,10 +255,16 @@ MACRO(ctkMacroBuildPlugin)
     )
 
   # Set the output directory for the plugin
-  SET(output_dir_suffix "plugins")
+  IF(MY_OUTPUT_DIR)
+    SET(output_dir_suffix ${MY_OUTPUT_DIR})
+  ELSE()
+    SET(output_dir_suffix "plugins")
+  ENDIF()
+
   IF(MY_TEST_PLUGIN)
-    SET(output_dir_suffix "test_plugins")
+    SET(output_dir_suffix "test_${output_dir_suffix}")
   ENDIF()
+
   IF(CMAKE_RUNTIME_OUTPUT_DIRECTORY)
     SET(runtime_output_dir "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${output_dir_suffix}")
   ELSE()

CMake/ctkMacroSetupExternalPlugins.cmake

@@ -22,7 +22,7 @@
 #! \ingroup CMakeAPI
 MACRO(ctkMacroSetupExternalPlugins )
 
-  ctkMacroParseArguments(MY "BUILD_OPTION_PREFIX" "" ${ARGN})
+  ctkMacroParseArguments(MY "BUILD_OPTION_PREFIX;BUILD_ALL" "COMPACT_OPTIONS" ${ARGN})
 
   IF(NOT MY_DEFAULT_ARGS)
     MESSAGE(FATAL_ERROR "Empty plugin list")
@@ -34,12 +34,45 @@ MACRO(ctkMacroSetupExternalPlugins )
     SET(MY_BUILD_OPTION_PREFIX "BUILD_")
   ENDIF()
 
+  IF(NOT MY_BUILD_ALL)
+    SET(MY_BUILD_ALL 0)
+  ENDIF()
+
+  # Set up Qt, if not already done
+  IF(NOT QT4_FOUND)
+    SET(minimum_required_qt_version "4.6")
+    FIND_PACKAGE(Qt4 REQUIRED)
+
+    IF("${QT_VERSION_MAJOR}.${QT_VERSION_MINOR}" VERSION_LESS "${minimum_required_qt_version}")
+      MESSAGE(FATAL_ERROR "error: CTK requires Qt >= ${minimum_required_qt_version} -- you cannot use Qt ${QT_VERSION_MAJOR}.${QT_VERSION_MINOR}.${QT_VERSION_PATCH}.")
+    ENDIF()
+  ENDIF()
+  
+  # Set variable QT_INSTALLED_LIBRARY_DIR that will contains
+  # Qt shared library
+  SET(QT_INSTALLED_LIBRARY_DIR ${QT_LIBRARY_DIR})
+  IF(WIN32)
+    GET_FILENAME_COMPONENT(QT_INSTALLED_LIBRARY_DIR ${QT_QMAKE_EXECUTABLE} PATH)
+  ENDIF()
+
   SET(plugin_dirswithoption )
   SET(plugin_subdirs )
   FOREACH(plugin ${plugin_list})
     ctkFunctionExtractOptionNameAndValue(${plugin} plugin_name plugin_value)
-    SET(option_name ${MY_BUILD_OPTION_PREFIX}${plugin_name})
+    IF(MY_COMPACT_OPTIONS)
+      STRING(REPLACE "/" ";" _tokens ${plugin_name})
+      LIST(GET _tokens -1 option_name)
+      SET(option_name ${MY_BUILD_OPTION_PREFIX}${option_name})
+    ELSE()
+      SET(option_name ${MY_BUILD_OPTION_PREFIX}${plugin_name})
+    ENDIF()
+    SET(${plugin_name}_option_name ${option_name})
+
     OPTION(${option_name} "Build ${plugin_name} Plugin." ${plugin_value})
+    IF(MY_BUILD_ALL)
+      SET(${option_name} 1)
+    ENDIF()
+
     LIST(APPEND plugin_subdirs "${plugin_name}")
     LIST(APPEND plugin_dirswithoption "${CMAKE_CURRENT_SOURCE_DIR}/${plugin_name}^^${option_name}")
   ENDFOREACH()
@@ -48,7 +81,7 @@ MACRO(ctkMacroSetupExternalPlugins )
   ctkMacroValidateBuildOptions("${CMAKE_CURRENT_BINARY_DIR}" "${CTK_DGRAPH_EXECUTABLE}" "${plugin_dirswithoption}")
 
   FOREACH(plugin ${plugin_subdirs})
-    IF(${MY_BUILD_OPTION_PREFIX}${plugin})
+    IF(${${plugin}_option_name})
       ADD_SUBDIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/${plugin})
     ENDIF()
   ENDFOREACH()

CMake/ctkMacroTargetLibraries.cmake

@@ -192,29 +192,33 @@ MACRO(ctkMacroCollectAllTargetLibraries targets subdir varname)
 ENDMACRO()
 
 #!
-#! Extract all library names starting with CTK uppercase or org_commontk_
+#! Extract all library names which are build within this project
 #!
 #! \ingroup CMakeUtilities
-MACRO(ctkMacroGetAllCTKTargetLibraries all_target_libraries varname)
-  SET(re_ctklib "^(c|C)(t|T)(k|K)[a-zA-Z0-9]+$")
-  SET(re_ctkplugin "^org_commontk_[a-zA-Z0-9_]+$")
-  SET(_tmp_list)
-  LIST(APPEND _tmp_list ${all_target_libraries})
-  #MESSAGE("calling ctkMacroListFilter with varname:${varname}")
-  ctkMacroListFilter(_tmp_list re_ctklib re_ctkplugin OUTPUT_VARIABLE ${varname})
-  #MESSAGE(STATUS "getallctklibs from ${all_target_libraries}")
-  #MESSAGE(STATUS varname:${varname}:${${varname}})
+MACRO(ctkMacroGetAllProjectTargetLibraries all_target_libraries varname)
+  # Allow external projects to override the set of internal targets
+  IF(COMMAND GetMyTargetLibraries)
+    GetMyTargetLibraries("${all_target_libraries}" ${varname})
+  ELSE()
+    SET(re_ctklib "^(c|C)(t|T)(k|K)[a-zA-Z0-9]+$")
+    SET(re_ctkplugin "^org_commontk_[a-zA-Z0-9_]+$")
+    SET(_tmp_list)
+    LIST(APPEND _tmp_list ${all_target_libraries})
+    #MESSAGE("calling ctkMacroListFilter with varname:${varname}")
+    ctkMacroListFilter(_tmp_list re_ctklib re_ctkplugin OUTPUT_VARIABLE ${varname})
+    #MESSAGE(STATUS "getallctklibs from ${all_target_libraries}")
+    #MESSAGE(STATUS varname:${varname}:${${varname}})
+  ENDIF()
 ENDMACRO()
 
-#!
-#! Extract all library names *NOT* starting with CTK uppercase or org_commontk_
-#!
-#! \ingroup CMakeUtilities
-MACRO(ctkMacroGetAllNonCTKTargetLibraries all_target_libraries varname)
-  ctkMacroGetAllCTKTargetLibraries("${all_target_libraries}" all_ctk_libraries)
+#
+# Extract all library names *NOT* being build within this project
+#
+MACRO(ctkMacroGetAllNonProjectTargetLibraries all_target_libraries varname)
+  ctkMacroGetAllProjectTargetLibraries("${all_target_libraries}" all_project_libraries)
   SET(_tmp_list ${all_target_libraries})
-  IF(all_ctk_libraries)
-    LIST(REMOVE_ITEM _tmp_list ${all_ctk_libraries})
+  IF(all_project_libraries)
+    LIST(REMOVE_ITEM _tmp_list ${all_project_libraries})
   ENDIF()
   SET(${varname} ${_tmp_list})
   #MESSAGE(STATUS varname:${varname}:${${varname}})

CMake/ctkMacroValidateBuildOptions.cmake

@@ -153,12 +153,7 @@ MACRO(ctkMacroValidateBuildOptions dir executable target_directories)
       # Check if all internal CTK targets included in the dependency path are enabled
       SET(int_dep_path_list )
       SET(ext_dep_path_list ${dep_path_list})
-      # Allow external projects to override the set of internal targets
-      IF(COMMAND GetMyTargetLibraries)
-        GetMyTargetLibraries("${dep_path_list}" int_dep_path_list)
-      ELSE()
-        ctkMacroGetAllCTKTargetLibraries("${dep_path_list}" int_dep_path_list)
-      ENDIF()
+      ctkMacroGetAllProjectTargetLibraries("${dep_path_list}" int_dep_path_list)
       IF(int_dep_path_list)
         LIST(REMOVE_ITEM ext_dep_path_list ${int_dep_path_list})
       ENDIF()

CTKPluginUseFile.cmake.in

@@ -1,5 +1,5 @@
 # List all plugins
-SET(CTK_PLUGIN_LIBRARIES @CTK_PLUGIN_LIBRARIES@)
+SET(CTK_PLUGIN_LIBRARIES "@CTK_PLUGIN_LIBRARIES@")
 
 # Plugin specific include directories
 @CTK_PLUGIN_INCLUDE_DIRS_CONFIG@

Libs/PluginFramework/ctkPluginConstants.h

@@ -102,7 +102,7 @@ struct CTK_PLUGINFW_EXPORT ctkPluginConstants {
    * The attribute value may be retrieved from the <code>QHash</code>
    * object returned by the <code>Plugin::getHeaders()</code> method.
    */
-  static const QString	PLUGIN_SYMBOLICNAME; // = "Plugin-SymbolicName"
+  static const QString PLUGIN_SYMBOLICNAME; // = "Plugin-SymbolicName"
 
   /**
    * Manifest header identifying the plugin's copyright information.

Libs/PluginFramework/ctkPluginPrivate.cpp

@@ -369,7 +369,8 @@ void ctkPluginPrivate::startDependencies()
     }
 
     // We take the first plugin in the list (highest version number)
-    pl.front()->start();
+    // Immediately start the dependencies (no lazy activation)
+    pl.front()->start(0);
   }
 }
 

SuperBuild.cmake

@@ -112,7 +112,7 @@ ctkMacroCollectAllTargetLibraries("${CTK_APPLICATIONS_SUBDIRS}" "Applications" A
 # Using the variable ALL_TARGET_LIBRARIES initialized above with the help
 # of the macro ctkMacroCollectAllTargetLibraries, let's get the list of all Non-CTK dependencies.
 # NON_CTK_DEPENDENCIES is expected by the macro ctkMacroShouldAddExternalProject
-ctkMacroGetAllNonCTKTargetLibraries("${ALL_TARGET_LIBRARIES}" NON_CTK_DEPENDENCIES)
+ctkMacroGetAllNonProjectTargetLibraries("${ALL_TARGET_LIBRARIES}" NON_CTK_DEPENDENCIES)
 #MESSAGE(STATUS NON_CTK_DEPENDENCIES:${NON_CTK_DEPENDENCIES})
 
 #-----------------------------------------------------------------------------