Merge branch '418-support-use-system-option'

* 418-support-use-system-option:
  Remove code related to CTK_EXTERNAL_LIBRARY_DIRS
  Automatically add CMAKE_GENERATOR external project argument
  Automatically add LIST_SEPARATOR external project argument
  Generalize the logic allowing to decide if an external project is optional.
  Update indent variable based on external project stack size
  Teach 'superbuild_include_dependencies' how to update <proj> variable.
  SuperBuild - Improve management of "proj" variable adding stack support
  Generalize how superbuild CMake variables can be passed to inner project.
  Add "superbuild_cmakevar_to_cmakearg" convenience function
  Introduce "SUPERBUILD_TOPLEVEL_PROJECT" project variable
  Simplify CTK external project specifying 'STEP_TARGETS'
  Fix test of ctk_list_to_string CMake function

Conflicts:
	CMake/LastConfigureStep/CTKGenerateCTKConfig.cmake

CMake/LastConfigureStep/CTKGenerateCTKConfig.cmake

@@ -73,9 +73,8 @@ else()
 endif()
 
 # CTK external projects variables
-string(REPLACE "^" ";" CTK_SUPERBUILD_EP_VARNAMES "${CTK_SUPERBUILD_EP_VARNAMES}")
 set(CTK_SUPERBUILD_EP_VARS_CONFIG)
-foreach(varname ${CTK_SUPERBUILD_EP_VARNAMES})
+foreach(varname ${CTK_EP_LABEL_FIND_PACKAGE})
   set(CTK_SUPERBUILD_EP_VARS_CONFIG
    "${CTK_SUPERBUILD_EP_VARS_CONFIG}
 set(CTK_${varname} \"${${varname}}\")")
@@ -160,8 +159,12 @@ foreach(lib ${CTK_LIBRARIES})
 endforeach()
 set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}# External project libraries\n")
 set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}set(CTK_EXTERNAL_LIBRARIES \"${CTK_EXTERNAL_LIBRARIES}\")\n")
-set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}# External project library directories\n")
-set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}set(CTK_EXTERNAL_LIBRARY_DIRS \"${CTK_EXTERNAL_LIBRARY_DIRS}\")\n")
+if(DEFINED DCMTK_HAVE_CONFIG_H_OPTIONAL AND NOT DCMTK_HAVE_CONFIG_H_OPTIONAL AND TARGET CTKDICOMCore)
+  set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}# Definition required to build DCMTK dependent libraries\n")
+  set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}if(\"\${CMAKE_VERSION}\" VERSION_GREATER 2.8.10)\n")
+  set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}  set_target_properties(CTKDICOMCore PROPERTIES INTERFACE_COMPILE_DEFINITIONS ${DCMTK_DEFINITIONS})\n")
+  set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}endif()\n")
+endif()
 set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}##################################################")
 
 set(ctk_config ${CTK_SUPERBUILD_BINARY_DIR}/CTKConfig.cmake)
@@ -200,6 +203,12 @@ set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}# CTK library directories that could be u
 foreach(lib ${CTK_LIBRARIES})
   set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}set(${lib}_LIBRARY_DIRS \"\")\n")
 endforeach()
+if(DEFINED DCMTK_HAVE_CONFIG_H_OPTIONAL AND NOT DCMTK_HAVE_CONFIG_H_OPTIONAL AND TARGET CTKDICOMCore)
+  set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}# Definition required to build DCMTK dependent libraries\n")
+  set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}if(\"\${CMAKE_VERSION}\" VERSION_GREATER 2.8.10)\n")
+  set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}  set_target_properties(CTKDICOMCore PROPERTIES INTERFACE_COMPILE_DEFINITIONS ${DCMTK_DEFINITIONS})\n")
+  set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}endif()\n")
+endif()
 
 set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}##################################################")
 

CMake/Testing/CMakeLists.txt

@@ -10,7 +10,35 @@ macro(add_cmakescript_test testname script)
     PASS_REGULAR_EXPRESSION "SUCCESS")
 endmacro()
 
+set(CMAKE_TEST_GENERATOR "${CMAKE_GENERATOR}")
+set(CMAKE_TEST_GENERATOR_TOOLSET "${CMAKE_GENERATOR_TOOLSET}")
+set(CMAKE_TEST_MAKEPROGRAM "${CMAKE_MAKE_PROGRAM}")
+
+set(build_generator_args
+  --build-generator ${CMAKE_TEST_GENERATOR}
+  --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
+  )
+if(CMAKE_TEST_GENERATOR_TOOLSET)
+  list(APPEND build_generator_args
+    --build-generator-toolset ${CMAKE_TEST_GENERATOR_TOOLSET}
+    )
+endif()
+
 #
 # Add 'CMake script' Tests
 #
-add_cmakescript_test(list_to_string_test ctkListToString)
+add_cmakescript_test(ctk_list_to_string_test ctkListToString)
+add_cmakescript_test(_sb_cmakevar_to_cmakearg_test ctkMacroCheckExternalProjectDependencyTest)
+add_cmakescript_test(_sb_extract_varname_and_vartype_test ctkMacroCheckExternalProjectDependencyTest)
+
+add_test(cmake_superbuild_test ${CMAKE_CTEST_COMMAND}
+    --build-and-test
+    "${CMAKE_SOURCE_DIR}/CMake/Testing/SuperBuildTest"
+    "${CMAKE_BINARY_DIR}/CMake/Testing/SuperBuildTest"
+    ${build_generator_args}
+    --build-project SuperBuildTest
+    --build-exe-dir "${CMAKE_BINARY_DIR}/CMake/Testing/SuperBuildTest"
+    --force-new-ctest-process
+    --test-command ${CMAKE_CTEST_COMMAND} -V
+    )
+set_tests_properties(cmake_superbuild_test PROPERTIES LABELS CMake)

CMake/Testing/SuperBuildTest/CMakeLists.txt

@@ -0,0 +1,90 @@
+cmake_minimum_required(VERSION 2.8.7)
+
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../" ${CMAKE_MODULE_PATH})
+set(EXTERNAL_PROJECT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/TheExternals)
+set(EXTERNAL_PROJECT_FILE_PREFIX "TheExternal_")
+include(ExternalProject)
+include(ctkMacroCheckExternalProjectDependency)
+
+project(SuperBuildTest NONE)
+
+option(${PROJECT_NAME}_SUPERBUILD "Build ${PROJECT_NAME} and the projects it depends" ON)
+mark_as_advanced(${PROJECT_NAME}_SUPERBUILD)
+
+if(${PROJECT_NAME}_SUPERBUILD)
+  option(FOO_OPTION "Option mark_as_superbuild" ON)
+  mark_as_superbuild(FOO_OPTION)
+
+  set(FOO_VAR "FooVar")
+  mark_as_superbuild(FOO_VAR)
+
+  set(FOO_LIST Item1 Item2)
+  mark_as_superbuild(FOO_LIST)
+
+  set(FOO_LIST_FOR_CMAKE_CMD "Item1${EP_LIST_SEPARATOR}Item2")
+  mark_as_superbuild(FOO_LIST_FOR_CMAKE_CMD CMAKE_CMD)
+
+  set(FOO_VAR_WITH_LABELS "FooVarWithLabels")
+  mark_as_superbuild(VARS FOO_VAR_WITH_LABELS LABELS "LABEL_A" "LABEL_B")
+
+  set(BAR_VAR_WITH_LABELS "BarVarWithLabels")
+  mark_as_superbuild(VARS BAR_VAR_WITH_LABELS LABELS "LABEL_B")
+
+  set(LibA_VAR "LibA")
+  mark_as_superbuild(VARS LibA_VAR PROJECT LibA)
+
+  set(LibA_VAR_WITH_LABELS "LibAWithLabels")
+  mark_as_superbuild(VARS LibA_VAR_WITH_LABELS PROJECT LibA LABELS "LABEL_A")
+
+  # Since LibC depends on LibD, LibD will also be expected to be found on the system
+  set(${CMAKE_PROJECT_NAME}_USE_SYSTEM_LibC 1)
+endif()
+
+set(${PROJECT_NAME}_DEPENDENCIES LibA LibB LibC)
+
+superbuild_include_dependencies(${PROJECT_NAME})
+
+if(${PROJECT_NAME}_SUPERBUILD)
+  ExternalProject_Add(${PROJECT_NAME}
+    ${${PROJECT_NAME}_EXTERNAL_PROJECT_ARGS}
+    DOWNLOAD_COMMAND ""
+    CMAKE_CACHE_ARGS
+      -D${PROJECT_NAME}_SUPERBUILD:BOOL=OFF
+    SOURCE_DIR ${${PROJECT_NAME}_SOURCE_DIR}
+    BINARY_DIR ${${PROJECT_NAME}_BINARY_DIR}/${PROJECT_NAME}-build
+    BUILD_COMMAND ""
+    INSTALL_COMMAND ""
+    DEPENDS
+      ${${PROJECT_NAME}_DEPENDENCIES}
+    )
+  return()
+endif()
+
+function(check_variable var_name expected_value)
+  if(NOT "x${${var_name}}" STREQUAL "x${expected_value}")
+    message(FATAL_ERROR "Problem with mark_as_superbuild() - CMake variable [${var_name}] is incorrectly set !\n"
+                        "current:${${var_name}}\n"
+                        "expected:${expected_value}")
+  endif()
+endfunction()
+
+check_variable(FOO_OPTION "ON")
+check_variable(FOO_VAR "FooVar")
+check_variable(FOO_LIST "Item1;Item2")
+check_variable(FOO_LIST_FOR_CMAKE_CMD "Item1;Item2")
+check_variable(FOO_VAR_WITH_LABELS "FooVarWithLabels")
+check_variable(BAR_VAR_WITH_LABELS "BarVarWithLabels")
+
+check_variable(SuperBuildTest_EP_LABEL_LABEL_A "FOO_VAR_WITH_LABELS")
+check_variable(SuperBuildTest_EP_LABEL_LABEL_B "FOO_VAR_WITH_LABELS;BAR_VAR_WITH_LABELS")
+
+check_variable(SuperBuildTest_EP_LABEL_FIND_PACKAGE "LibA_DIR")
+get_filename_component(expected_LibA_DIR "${CMAKE_CURRENT_BINARY_DIR}/../LibA-build" REALPATH)
+check_variable(LibA_DIR ${expected_LibA_DIR})
+
+check_variable(SuperBuildTest_EP_LABEL_USE_SYSTEM
+  "${CMAKE_PROJECT_NAME}_USE_SYSTEM_LibA;${CMAKE_PROJECT_NAME}_USE_SYSTEM_LibB;${CMAKE_PROJECT_NAME}_USE_SYSTEM_LibC;${CMAKE_PROJECT_NAME}_USE_SYSTEM_LibD")
+check_variable(${CMAKE_PROJECT_NAME}_USE_SYSTEM_LibA "")
+check_variable(${CMAKE_PROJECT_NAME}_USE_SYSTEM_LibB "")
+check_variable(${CMAKE_PROJECT_NAME}_USE_SYSTEM_LibC 1)
+check_variable(${CMAKE_PROJECT_NAME}_USE_SYSTEM_LibD 1)

CMake/Testing/SuperBuildTest/LibA/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 2.8.7)
+
+project(LibA NONE)
+
+function(check_variable var_name expected_value)
+  if(NOT "x${${var_name}}" STREQUAL "x${expected_value}")
+    message(FATAL_ERROR "Problem with mark_as_superbuild() - CMake variable [${var_name}] is incorrectly set !\n"
+                        "current:${${var_name}}\n"
+                        "expected:${expected_value}")
+  endif()
+endfunction()
+
+check_variable(LibA_VAR "LibA")
+
+check_variable(LibA_EP_LABEL_LABEL_A "LibA_VAR_WITH_LABELS")

CMake/Testing/SuperBuildTest/TheExternals/TheExternal_LibA.cmake

@@ -0,0 +1,48 @@
+#
+# LibA
+#
+
+superbuild_include_once()
+
+set(proj LibA)
+
+set(${proj}_DEPENDENCIES "")
+
+superbuild_include_dependencies(PROJECT_VAR proj)
+
+if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
+  message(FATAL_ERROR "Enabling ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj} is not supported !")
+endif()
+
+mark_as_superbuild(
+  VARS ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj}:BOOL
+  LABELS "USE_SYSTEM"
+  )
+
+# Sanity checks
+if(DEFINED LibA_DIR AND NOT EXISTS ${LibA_DIR})
+  message(FATAL_ERROR "LibA_DIR variable is defined but corresponds to non-existing directory")
+endif()
+
+if(NOT DEFINED LibA_DIR AND NOT ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
+
+  ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
+    SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/${proj}
+    BINARY_DIR ${proj}-build
+    DOWNLOAD_COMMAND ""
+    BUILD_COMMAND ""
+    INSTALL_COMMAND ""
+    DEPENDS
+      ${${proj}_DEPENDENCIES}
+    )
+  set(LibA_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
+
+else()
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
+endif()
+
+mark_as_superbuild(
+  VARS LibA_DIR:PATH
+  LABELS "FIND_PACKAGE"
+  )

CMake/Testing/SuperBuildTest/TheExternals/TheExternal_LibB.cmake

@@ -0,0 +1,44 @@
+#
+# LibB
+#
+
+superbuild_include_once()
+
+set(proj LibB)
+
+set(${proj}_DEPENDENCIES LibA)
+
+superbuild_include_dependencies(PROJECT_VAR proj)
+
+if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
+   message(FATAL_ERROR "Enabling ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj} is not supported !")
+endif()
+
+mark_as_superbuild(
+  VARS ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj}:BOOL
+  LABELS "USE_SYSTEM"
+  )
+
+# Sanity checks
+if(DEFINED LibB_DIR AND NOT EXISTS ${LibB_DIR})
+  message(FATAL_ERROR "LibB_DIR variable is defined but corresponds to non-existing directory")
+endif()
+
+if(NOT DEFINED LibB_DIR AND NOT ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
+
+  ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
+    BINARY_DIR ${proj}-build
+    DOWNLOAD_COMMAND ""
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND ""
+    INSTALL_COMMAND ""
+    DEPENDS
+      ${${proj}_DEPENDENCIES}
+    )
+  set(LibB_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
+
+else()
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
+endif()
+

CMake/Testing/SuperBuildTest/TheExternals/TheExternal_LibC.cmake

@@ -0,0 +1,34 @@
+#
+# LibC
+#
+
+superbuild_include_once()
+
+set(proj LibC)
+
+set(${proj}_DEPENDENCIES LibD)
+
+superbuild_include_dependencies(PROJECT_VAR proj)
+
+if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
+  unset(LibC_DIR CACHE)
+endif()
+
+mark_as_superbuild(
+  VARS ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj}:BOOL
+  LABELS "USE_SYSTEM"
+  )
+
+# Sanity checks
+if(DEFINED LibC_DIR AND NOT EXISTS ${LibC_DIR})
+  message(FATAL_ERROR "LibC_DIR variable is defined but corresponds to non-existing directory")
+endif()
+
+if(NOT DEFINED LibC_DIR AND NOT ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
+
+   message(FATAL_ERROR "Disabling ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj} is not supported !")
+
+else()
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
+endif()
+

CMake/Testing/SuperBuildTest/TheExternals/TheExternal_LibD.cmake

@@ -0,0 +1,34 @@
+#
+# LibD
+#
+
+superbuild_include_once()
+
+set(proj_libd LibD)
+
+set(${proj_libd}_DEPENDENCIES "")
+
+superbuild_include_dependencies(PROJECT_VAR proj_libd)
+
+if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj_libd})
+  unset(LibD_DIR CACHE)
+endif()
+
+mark_as_superbuild(
+  VARS ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj_libd}:BOOL
+  LABELS "USE_SYSTEM"
+  )
+
+# Sanity checks
+if(DEFINED LibD_DIR AND NOT EXISTS ${LibD_DIR})
+  message(FATAL_ERROR "LibD_DIR variable is defined but corresponds to non-existing directory")
+endif()
+
+if(NOT DEFINED LibD_DIR AND NOT ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj_libd})
+
+  message(FATAL_ERROR "Disabling ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj_libd} is not supported !")
+
+else()
+  superbuild_add_empty_external_project(${proj_libd} "${${proj_libd}_DEPENDENCIES}")
+endif()
+

CMake/UseCTK.cmake.in

@@ -30,9 +30,6 @@ IF(NOT CTK_USE_FILE_INCLUDED)
   # Add include directories needed to use CTK.
   INCLUDE_DIRECTORIES(${CTK_INCLUDE_DIRS})
 
-  # Add link directories needed to use CTK.
-  # LINK_DIRECTORIES(${CTK_LIBRARY_DIRS} ${CTK_EXTERNAL_LIBRARY_DIRS})
-
   if (NOT DEFINED QT_QMAKE_EXECUTABLE)
     set(QT_QMAKE_EXECUTABLE ${CTK_QT_QMAKE_EXECUTABLE})
   endif()

CMake/ctkBlockCheckDependencies.cmake

@@ -32,12 +32,6 @@ ctkMacroGetAllNonProjectTargetLibraries("${ALL_TARGET_LIBRARIES}" NON_CTK_DEPEND
 #
 
 if(CTK_SUPERBUILD)
-  include(ExternalProject)
-  include(ctkMacroEmptyExternalProject)
-
-  #set(ep_base "${CMAKE_BINARY_DIR}/CMakeExternals")
-  #set_property(DIRECTORY PROPERTY EP_BASE ${ep_base})
-
   set(ep_install_dir ${CMAKE_BINARY_DIR}/CMakeExternals/Install)
   set(ep_suffix      "-cmake")
 
@@ -53,46 +47,78 @@ if(CTK_SUPERBUILD)
       -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
       -DBUILD_TESTING:BOOL=OFF
      )
-
-  # Set CMake OSX variable to pass down the external projects
-  set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
-  if(APPLE)
-    list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
-         -DCMAKE_OSX_ARCHITECTURES:STRING=${CMAKE_OSX_ARCHITECTURES}
-         -DCMAKE_OSX_SYSROOT:STRING=${CMAKE_OSX_SYSROOT}
-         -DCMAKE_OSX_DEPLOYMENT_TARGET:STRING=${CMAKE_OSX_DEPLOYMENT_TARGET}
-        )
-    list(APPEND ep_common_cache_args ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS})
-  endif()
-
-  # Compute -G arg for configuring external projects with the same CMake generator:
-  if(CMAKE_EXTRA_GENERATOR)
-    set(gen "${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}")
-  else()
-    set(gen "${CMAKE_GENERATOR}")
-  endif()
-
-  # Use this value where semi-colons are needed in ep_add args:
-  set(sep "^^")
-
-  # This variable will contain the list of CMake variable specific to each external project
-  # that should passed to CTK.
-  # The item of this list should have the following form: <EP_VAR>:<TYPE>
-  # where '<EP_VAR>' is an external project variable and TYPE is either BOOL, PATH or FILEPATH.
-  # Variable appended to this list will be automatically exported in CTKConfig.cmake, prefix 'CTK_'
-  # will be prepended if it applied.
-  set(CTK_SUPERBUILD_EP_VARS)
 endif()
 
 if(NOT DEFINED CTK_DEPENDENCIES)
   message(FATAL_ERROR "error: CTK_DEPENDENCIES variable is not defined !")
 endif()
 
-set(EXTERNAL_PROJECT_DIR ${${CMAKE_PROJECT_NAME}_SOURCE_DIR}/CMakeExternals)
-set(EXTERNAL_PROJECT_FILE_PREFIX "")
-include(ctkMacroCheckExternalProjectDependency)
+set(DCMTK_enabling_variable DCMTK_LIBRARIES)
+set(${DCMTK_enabling_variable}_INCLUDE_DIRS DCMTK_INCLUDE_DIR)
+set(${DCMTK_enabling_variable}_FIND_PACKAGE_CMD DCMTK)
+
+set(ITK_enabling_variable ITK_LIBRARIES)
+set(${ITK_enabling_variable}_LIBRARY_DIRS ITK_LIBRARY_DIRS)
+set(${ITK_enabling_variable}_INCLUDE_DIRS ITK_INCLUDE_DIRS)
+set(${ITK_enabling_variable}_FIND_PACKAGE_CMD ITK)
+
+set(Log4Qt_enabling_variable Log4Qt_LIBRARIES)
+set(${Log4Qt_enabling_variable}_INCLUDE_DIRS Log4Qt_INCLUDE_DIRS)
+set(${Log4Qt_enabling_variable}_FIND_PACKAGE_CMD Log4Qt)
+
+set(OpenIGTLink_enabling_variable OpenIGTLink_LIBRARIES)
+set(${OpenIGTLink_enabling_variable}_LIBRARY_DIRS OpenIGTLink_LIBRARY_DIRS)
+set(${OpenIGTLink_enabling_variable}_INCLUDE_DIRS OpenIGTLink_INCLUDE_DIRS)
+set(${OpenIGTLink_enabling_variable}_FIND_PACKAGE_CMD OpenIGTLink)
+
+set(PythonQt_enabling_variable PYTHONQT_LIBRARIES)
+set(${PythonQt_enabling_variable}_INCLUDE_DIRS PYTHONQT_INCLUDE_DIR PYTHON_INCLUDE_DIRS)
+set(${PythonQt_enabling_variable}_FIND_PACKAGE_CMD PythonQt)
+
+set(QtSOAP_enabling_variable QtSOAP_LIBRARIES)
+set(${QtSOAP_enabling_variable}_LIBRARY_DIRS QtSOAP_LIBRARY_DIRS)
+set(${QtSOAP_enabling_variable}_INCLUDE_DIRS QtSOAP_INCLUDE_DIRS)
+set(${QtSOAP_enabling_variable}_FIND_PACKAGE_CMD QtSOAP)
+
+set(qxmlrpc_enabling_variable qxmlrpc_LIBRARY)
+set(${qxmlrpc_enabling_variable}_LIBRARY_DIRS qxmlrpc_LIBRARY_DIRS)
+set(${qxmlrpc_enabling_variable}_INCLUDE_DIRS qxmlrpc_INCLUDE_DIRS)
+set(${qxmlrpc_enabling_variable}_FIND_PACKAGE_CMD qxmlrpc)
+
+set(VTK_enabling_variable VTK_LIBRARIES)
+set(${VTK_enabling_variable}_LIBRARY_DIRS VTK_LIBRARY_DIRS)
+set(${VTK_enabling_variable}_INCLUDE_DIRS VTK_INCLUDE_DIRS)
+set(${VTK_enabling_variable}_FIND_PACKAGE_CMD VTK)
+
+set(XIP_enabling_variable XIP_LIBRARIES)
+set(${XIP_enabling_variable}_LIBRARY_DIRS XIP_LIBRARY_DIRS)
+set(${XIP_enabling_variable}_INCLUDE_DIRS XIP_INCLUDE_DIRS)
+set(${XIP_enabling_variable}_FIND_PACKAGE_CMD XIP)
+
+set(ZMQ_enabling_variable ZMQ_LIBRARIES)
+set(${ZMQ_enabling_variable}_LIBRARY_DIRS ZMQ_LIBRARY_DIRS)
+set(${ZMQ_enabling_variable}_INCLUDE_DIRS ZMQ_INCLUDE_DIRS)
+set(${ZMQ_enabling_variable}_FIND_PACKAGE_CMD ZMQ)
+
+macro(superbuild_is_external_project_includable possible_proj output_var)
+  if(DEFINED ${possible_proj}_enabling_variable)
+    ctkMacroShouldAddExternalProject(${${possible_proj}_enabling_variable} ${output_var})
+    if(NOT ${${output_var}})
+      if(${possible_proj} STREQUAL "VTK"
+         AND CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK)
+        set(${output_var} 1)
+      else()
+        unset(${${possible_proj}_enabling_variable}_INCLUDE_DIRS)
+        unset(${${possible_proj}_enabling_variable}_LIBRARY_DIRS)
+        unset(${${possible_proj}_enabling_variable}_FIND_PACKAGE_CMD)
+      endif()
+    endif()
+  else()
+    set(${output_var} 1)
+  endif()
+endmacro()
 
-ctkMacroCheckExternalProjectDependency(CTK)
+superbuild_include_dependencies(CTK)
 
 #message("Updated CTK_DEPENDENCIES:")
 #foreach(dep ${CTK_DEPENDENCIES})

CMake/ctkDashboardDriverScript.cmake

@@ -129,7 +129,6 @@ macro(run_ctest)
     # Write initial cache.
     file(WRITE "${CTEST_BINARY_DIRECTORY}/CMakeCache.txt" "
 QT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
-SUPERBUILD_EXCLUDE_CTKBUILD_TARGET:BOOL=TRUE
 WITH_COVERAGE:BOOL=${WITH_COVERAGE}
 #DOCUMENTATION_TARGET_IN_ALL:BOOL=${WITH_DOCUMENTATION}
 DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY:PATH=${DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY}
@@ -153,7 +152,7 @@ ${ADDITIONNAL_CMAKECACHE_OPTION}
 
     # Build top level
     message("----------- [ Build SuperBuild ] -----------")
-    ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}" APPEND)
+    ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}" TARGET "CTK-configure" APPEND)
     ctest_submit(PARTS Build)
     
     ctest_test(

CMake/ctkMacroAddCtkLibraryOptions.cmake

@@ -35,7 +35,7 @@ macro(ctkMacroAddCtkLibraryOptions lib)
       ctkFunctionExtractOptionNameAndValue(${option} option_name option_value)
       option(CTK_LIB_${lib}_${option_name} "Enable ${lib} Library ${option_name} option." ${option_value})
       mark_as_advanced(CTK_LIB_${lib}_${option_name})
-      list(APPEND ctk_lib_options_list CTK_LIB_${lib}_${option_name})
+      mark_as_superbuild(CTK_LIB_${lib}_${option_name})
     endforeach()
     
   endif()

CMake/ctkMacroCheckExternalProjectDependency.cmake

@@ -18,6 +18,13 @@
 #
 ###########################################################################
 
+include(CMakeParseArguments)
+include(ctkListToString)
+
+if(NOT DEFINED EP_LIST_SEPARATOR)
+  set(EP_LIST_SEPARATOR "^^")
+endif()
+
 if(NOT EXISTS "${EXTERNAL_PROJECT_DIR}")
   set(EXTERNAL_PROJECT_DIR ${${CMAKE_PROJECT_NAME}_SOURCE_DIR}/SuperBuild)
 endif()
@@ -26,6 +33,13 @@ if(NOT DEFINED EXTERNAL_PROJECT_FILE_PREFIX)
   set(EXTERNAL_PROJECT_FILE_PREFIX "External_")
 endif()
 
+# Compute -G arg for configuring external projects with the same CMake generator:
+if(CMAKE_EXTRA_GENERATOR)
+  set(EP_CMAKE_GENERATOR "${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}")
+else()
+  set(EP_CMAKE_GENERATOR "${CMAKE_GENERATOR}")
+endif()
+
 #
 # superbuild_include_once()
 #
@@ -49,45 +63,364 @@ macro(superbuild_include_once)
   set_property(GLOBAL PROPERTY ${_property_name} 1)
 endmacro()
 
-macro(_epd_status txt)
-  if(NOT __epd_first_pass)
-    message(STATUS ${txt})
+#!
+#! mark_as_superbuild(<varname1>[:<vartype1>] [<varname2>[:<vartype2>] [...]])
+#!
+#! mark_as_superbuild(
+#!     VARS <varname1>[:<vartype1>] [<varname2>[:<vartype2>] [...]]
+#!     [PROJECT <projectname>]
+#!     [LABELS <label1> [<label2> [...]]]
+#!     [CMAKE_CMD]
+#!   )
+#!
+#! PROJECT corresponds to a <projectname> that will be added using 'ExternalProject_Add' function.
+#!         If not specified and called within a project file, it defaults to the value of 'SUPERBUILD_TOPLEVEL_PROJECT'
+#!         Otherwise, it defaults to 'CMAKE_PROJECT_NAME'.
+#!
+#! VARS is an expected list of variables specified as <varname>:<vartype> to pass to <projectname>
+#!
+#!
+#! LABELS is an optional list of label to associate with the variable names specified using 'VARS' and passed to
+#!        the <projectname> as CMake CACHE args of the form:
+#!          -D<projectname>_EP_LABEL_<label1>=<varname1>;<varname2>[...]
+#!          -D<projectname>_EP_LABEL_<label2>=<varname1>;<varname2>[...]
+#!
+function(mark_as_superbuild)
+  set(options CMAKE_CMD)
+  set(oneValueArgs PROJECT)
+  set(multiValueArgs VARS LABELS)
+  cmake_parse_arguments(_sb "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  set(_vars ${_sb_UNPARSED_ARGUMENTS})
+
+  set(_named_parameters_expected 0)
+  if(_sb_PROJECT OR _sb_LABELS OR _sb_VARS)
+    set(_named_parameters_expected 1)
+    set(_vars ${_sb_VARS})
   endif()
-endmacro()
 
-macro(ctkMacroCheckExternalProjectDependency proj)
+  if(_named_parameters_expected AND _sb_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Arguments '${_sb_UNPARSED_ARGUMENTS}' should be associated with VARS parameter !")
+  endif()
+
+  foreach(var ${_vars})
+    set(_type_specified 0)
+    if(${var} MATCHES ":")
+      set(_type_specified 1)
+    endif()
+    # XXX Display warning with variable type is also specified for cache variable.
+    set(_var ${var})
+    if(NOT _type_specified)
+      get_property(_type_set_in_cache CACHE ${_var} PROPERTY TYPE SET)
+      set(_var_name ${_var})
+      set(_var_type "STRING")
+      if(_type_set_in_cache)
+        get_property(_var_type CACHE ${_var_name} PROPERTY TYPE)
+      endif()
+      set(_var ${_var_name}:${_var_type})
+    endif()
+    list(APPEND _vars_with_type ${_var})
+  endforeach()
+
+  if(_sb_CMAKE_CMD)
+    set(optional_arg_CMAKE_CMD "CMAKE_CMD")
+  endif()
+
+  _sb_append_to_cmake_args(VARS ${_vars_with_type} PROJECT ${_sb_PROJECT} LABELS ${_sb_LABELS} ${optional_arg_CMAKE_CMD})
+endfunction()
+
+#!
+#! _sb_extract_varname_and_vartype(<cmake_varname_and_type> <varname_var> [<vartype_var>])
+#!
+#! <cmake_varname_and_type> corresponds to variable name and variable type passed as "<varname>:<vartype>"
+#!
+#! <varname_var> will be set to "<varname>"
+#!
+#! <vartype_var> is an optional variable name that will be set to "<vartype>"
+function(_sb_extract_varname_and_vartype cmake_varname_and_type varname_var)
+  set(_vartype_var ${ARGV2})
+  string(REPLACE ":" ";" varname_and_vartype ${cmake_varname_and_type})
+  list(GET varname_and_vartype 0 _varname)
+  list(GET varname_and_vartype 1 _vartype)
+  set(${varname_var} ${_varname} PARENT_SCOPE)
+  if(_vartype_var MATCHES ".+")
+    set(${_vartype_var} ${_vartype} PARENT_SCOPE)
+  endif()
+endfunction()
+
+#!
+#! _sb_cmakevar_to_cmakearg(<cmake_varname_and_type> <cmake_arg_var> <cmake_arg_type> [<varname_var> [<vartype_var>]])
+#!
+#! <cmake_varname_and_type> corresponds to variable name and variable type passed as "<varname>:<vartype>"
+#!
+#! <cmake_arg_var> is a variable name that will be set to "-D<varname>:<vartype>=${<varname>}"
+#!
+#! <cmake_arg_type> is set to either CMAKE_CACHE or CMAKE_CMD.
+#!                  CMAKE_CACHE means that the generated cmake argument will be passed to
+#!                  ExternalProject_Add as CMAKE_CACHE_ARGS.
+#!                  CMAKE_CMD means that the generated cmake argument will be passed to
+#!                  ExternalProject_Add as CMAKE_ARGS.
+#!
+#! <varname_var> is an optional variable name that will be set to "<varname>"
+#!
+#! <vartype_var> is an optional variable name that will be set to "<vartype>"
+function(_sb_cmakevar_to_cmakearg cmake_varname_and_type cmake_arg_var cmake_arg_type)
+  set(_varname_var ${ARGV3})
+  set(_vartype_var ${ARGV4})
+
+  # XXX Add check for <cmake_arg_type> value
+
+  _sb_extract_varname_and_vartype(${cmake_varname_and_type} _varname _vartype)
+
+  set(_var_value "${${_varname}}")
+  get_property(_value_set_in_cache CACHE ${_varname} PROPERTY VALUE SET)
+  if(_value_set_in_cache)
+    get_property(_var_value CACHE ${_varname} PROPERTY VALUE)
+  endif()
+
+  if(cmake_arg_type STREQUAL "CMAKE_CMD")
+    # Separate list item with <EP_LIST_SEPARATOR>
+    set(ep_arg_as_string "")
+    ctk_list_to_string(${EP_LIST_SEPARATOR} "${_var_value}" _var_value)
+  endif()
+
+  set(${cmake_arg_var} -D${_varname}:${_vartype}=${_var_value} PARENT_SCOPE)
+
+  if(_varname_var MATCHES ".+")
+    set(${_varname_var} ${_varname} PARENT_SCOPE)
+  endif()
+  if(_vartype_var MATCHES ".+")
+    set(${_vartype_var} ${_vartype} PARENT_SCOPE)
+  endif()
+endfunction()
+
+#!
+#! _sb_append_to_cmake_args(
+#!     VARS <varname1>:<vartype1> [<varname2>:<vartype2> [...]]
+#!     [PROJECT <projectname>]
+#!     [LABELS <label1> [<label2> [...]]]
+#!     [CMAKE_CMD]
+#!   )
+#!
+#! PROJECT corresponds to a <projectname> that will be added using 'ExternalProject_Add' function.
+#!         If not specified and called within a project file, it defaults to the value of 'SUPERBUILD_TOPLEVEL_PROJECT'
+#!         Otherwise, it defaults to 'CMAKE_PROJECT_NAME'.
+#!
+#! VARS is an expected list of variables specified as <varname>:<vartype> to pass to <projectname>
+#!
+#!
+#! LABELS is an optional list of label to associate with the variable names specified using 'VARS' and passed to
+#!        the <projectname> as CMake CACHE args of the form:
+#!          -D<projectname>_EP_LABEL_<label1>=<varname1>;<varname2>[...]
+#!          -D<projectname>_EP_LABEL_<label2>=<varname1>;<varname2>[...]
+#!
+function(_sb_append_to_cmake_args)
+  set(options CMAKE_CMD)
+  set(oneValueArgs PROJECT)
+  set(multiValueArgs VARS LABELS)
+  cmake_parse_arguments(_sb "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  if(NOT _sb_PROJECT)
+    if(SUPERBUILD_TOPLEVEL_PROJECT)
+      set(_sb_PROJECT ${SUPERBUILD_TOPLEVEL_PROJECT})
+    else()
+      set(_sb_PROJECT ${CMAKE_PROJECT_NAME})
+    endif()
+  endif()
+
+  set(_cmake_arg_type "CMAKE_CACHE")
+  if(_sb_CMAKE_CMD)
+    set(_cmake_arg_type "CMAKE")
+    set(optional_arg_CMAKE_CMD "CMAKE_CMD")
+  endif()
+  set(_ep_property "${_cmake_arg_type}_ARGS")
+  set(_ep_varnames "")
+  foreach(varname_and_vartype ${_sb_VARS})
+    if(NOT TARGET ${_sb_PROJECT})
+      set_property(GLOBAL APPEND PROPERTY ${_sb_PROJECT}_EP_${_ep_property} ${varname_and_vartype})
+      _sb_extract_varname_and_vartype(${varname_and_vartype} _varname)
+      set_property(GLOBAL APPEND PROPERTY ${_sb_PROJECT}_EP_PROPERTIES ${_ep_property})
+    else()
+      message(FATAL_ERROR "Function _sb_append_to_cmake_args not allowed is project already added !")
+    endif()
+    list(APPEND _ep_varnames ${_varname})
+  endforeach()
+
+  if(_sb_LABELS)
+    set_property(GLOBAL APPEND PROPERTY ${_sb_PROJECT}_EP_LABELS ${_sb_LABELS})
+    foreach(label ${_sb_LABELS})
+      set_property(GLOBAL APPEND PROPERTY ${_sb_PROJECT}_EP_LABEL_${label} ${_ep_varnames})
+    endforeach()
+  endif()
+endfunction()
+
+function(_sb_get_external_project_arguments proj varname)
+
+  mark_as_superbuild(${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${proj}:BOOL)
+
+  # Set list of CMake args associated with each label
+  get_property(_labels GLOBAL PROPERTY ${proj}_EP_LABELS)
+  if(_labels)
+    list(REMOVE_DUPLICATES _labels)
+    foreach(label ${_labels})
+      get_property(${proj}_EP_LABEL_${label} GLOBAL PROPERTY ${proj}_EP_LABEL_${label})
+      list(REMOVE_DUPLICATES ${proj}_EP_LABEL_${label})
+      _sb_append_to_cmake_args(PROJECT ${proj}
+        VARS ${proj}_EP_LABEL_${label}:STRING)
+    endforeach()
+  endif()
+
+  foreach(cmake_arg_type CMAKE_CMD CMAKE_CACHE)
+
+    set(_ep_property "CMAKE_CACHE_ARGS")
+    if(cmake_arg_type STREQUAL "CMAKE_CMD")
+      set(_ep_property "CMAKE_ARGS")
+    endif()
+
+    get_property(_args GLOBAL PROPERTY ${proj}_EP_${_ep_property})
+    foreach(var ${_args})
+      _sb_cmakevar_to_cmakearg(${var} cmake_arg ${cmake_arg_type})
+      set_property(GLOBAL APPEND PROPERTY ${proj}_EP_PROPERTY_${_ep_property} ${cmake_arg})
+    endforeach()
+
+  endforeach()
+
+  set(_ep_arguments "")
+  get_property(_properties GLOBAL PROPERTY ${proj}_EP_PROPERTIES)
+  if(_properties)
+    list(REMOVE_DUPLICATES _properties)
+    foreach(property ${_properties})
+      get_property(${proj}_EP_PROPERTY_${property} GLOBAL PROPERTY ${proj}_EP_PROPERTY_${property})
+      list(APPEND _ep_arguments ${property} ${${proj}_EP_PROPERTY_${property}})
+    endforeach()
+  endif()
+
+  list(APPEND _ep_arguments LIST_SEPARATOR ${EP_LIST_SEPARATOR})
 
-  # Set indent variable if needed
-  if(NOT DEFINED __indent)
-    set(__indent "")
+  list(APPEND _ep_arguments CMAKE_GENERATOR ${EP_CMAKE_GENERATOR})
+
+  set(${varname} ${_ep_arguments} PARENT_SCOPE)
+endfunction()
+
+function(_sb_update_indent proj)
+  superbuild_stack_size(SUPERBUILD_PROJECT_STACK _stack_size)
+  set(_indent "")
+  if(_stack_size GREATER 0)
+    foreach(not_used RANGE 1 ${_stack_size})
+      set(_indent "  ${_indent}")
+    endforeach()
+  endif()
+  set_property(GLOBAL PROPERTY SUPERBUILD_${proj}_INDENT ${_indent})
+endfunction()
+
+function(superbuild_message proj msg)
+  if(NOT SUPERBUILD_FIRST_PASS)
+    get_property(_indent GLOBAL PROPERTY SUPERBUILD_${proj}_INDENT)
+    message(STATUS "SuperBuild - ${_indent}${msg}")
+  endif()
+endfunction()
+
+#!
+#! superbuild_stack_content(<stack_name> <output_var>)
+#!
+#! <stack_name> corresponds to the name of stack.
+#!
+#! <output_var> is the name of CMake variable that will be set with the content
+#! of the stack identified by <stack_name>.
+function(superbuild_stack_content stack_name output_var)
+  get_property(_stack GLOBAL PROPERTY ${stack_name})
+  set(${output_var} ${_stack} PARENT_SCOPE)
+endfunction()
+
+#!
+#! superbuild_stack_size(<stack_name> <output_var>)
+#!
+#! <stack_name> corresponds to the name of stack.
+#!
+#! <output_var> is the name of CMake variable that will be set with the size
+#! of the stack identified by <stack_name>.
+function(superbuild_stack_size stack_name output_var)
+  get_property(_stack GLOBAL PROPERTY ${stack_name})
+  list(LENGTH _stack _stack_size)
+  set(${output_var} ${_stack_size} PARENT_SCOPE)
+endfunction()
+
+#!
+#! superbuild_stack_push(<stack_name> <value>)
+#!
+#! <stack_name> corresponds to the name of stack.
+#!
+#! <value> is appended to the stack identified by <stack_name>.
+function(superbuild_stack_push stack_name value)
+  set_property(GLOBAL APPEND PROPERTY ${stack_name} ${value})
+endfunction()
+
+#!
+#! superbuild_stack_pop(<stack_name> <item_var>)
+#!
+#! <stack_name> corresponds to the name of stack.
+#!
+#! <item_var> names a CMake variable that will be set with the item
+#! removed from the stack identified by <stack_name>.
+function(superbuild_stack_pop stack_name item_var)
+  get_property(_stack GLOBAL PROPERTY ${stack_name})
+  list(LENGTH _stack _stack_size)
+  if(_stack_size GREATER 0)
+    math(EXPR _index_to_remove "${_stack_size} - 1")
+    list(GET _stack ${_index_to_remove} _item)
+    list(REMOVE_AT _stack ${_index_to_remove})
+    set_property(GLOBAL PROPERTY ${stack_name} ${_stack})
+    set(${item_var} ${_item} PARENT_SCOPE)
+  endif()
+endfunction()
+
+#
+# superbuild_include_dependencies(<project>)
+#
+# superbuild_include_dependencies(PROJECT_VAR <project_var>)
+#
+macro(superbuild_include_dependencies)
+  set(options)
+  set(oneValueArgs PROJECT_VAR)
+  set(multiValueArgs)
+  cmake_parse_arguments(_sb "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  # XXX Implement invalid parameter checking
+
+  if(NOT "x" STREQUAL "x${_sb_PROJECT_VAR}")
+    set(proj ${${_sb_PROJECT_VAR}})
   else()
-    set(__indent "${__indent}  ")
+    set(proj ${_sb_UNPARSED_ARGUMENTS})
   endif()
 
   # Sanity checks
   if(NOT DEFINED ${proj}_DEPENDENCIES)
-    message(FATAL_ERROR "${__indent}${proj}_DEPENDENCIES variable is NOT defined !")
+    message(FATAL_ERROR "${proj}_DEPENDENCIES variable is NOT defined !")
+  endif()
+
+  superbuild_stack_size(SUPERBUILD_PROJECT_STACK _stack_size)
+  if(_stack_size EQUAL 0)
+    set(SUPERBUILD_TOPLEVEL_PROJECT ${proj})
   endif()
 
+  _sb_update_indent(${proj})
+
   # Keep track of the projects
-  list(APPEND __epd_${CMAKE_PROJECT_NAME}_projects ${proj})
+  list(APPEND __epd_${SUPERBUILD_TOPLEVEL_PROJECT}_projects ${proj})
 
-  # Is this the first run ? (used to set the <CMAKE_PROJECT_NAME>_USE_SYSTEM_* variables)
-  if(${proj} STREQUAL ${CMAKE_PROJECT_NAME} AND NOT DEFINED __epd_first_pass)
+  # Is this the first run ? (used to set the <SUPERBUILD_TOPLEVEL_PROJECT>_USE_SYSTEM_* variables)
+  if(${proj} STREQUAL ${SUPERBUILD_TOPLEVEL_PROJECT} AND NOT DEFINED SUPERBUILD_FIRST_PASS)
     message(STATUS "SuperBuild - First pass")
-    set(__epd_first_pass TRUE)
-  endif()
-
-  # Set message strings
-  set(__${proj}_indent ${__indent})
-  set(__${proj}_superbuild_message "SuperBuild - ${__indent}${proj}[OK]")
-  if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
-    set(__${proj}_superbuild_message "${__${proj}_superbuild_message} (SYSTEM)")
+    set(SUPERBUILD_FIRST_PASS TRUE)
   endif()
 
   # Display dependency of project being processed
   if("${${proj}_DEPENDENCIES}" STREQUAL "")
-    _epd_status(${__${proj}_superbuild_message})
+    set(_msg "${proj}[OK]")
+    if(${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${proj})
+      set(_msg "${_msg} (SYSTEM)")
+    endif()
+    superbuild_message(${proj} ${_msg})
   else()
     set(dependency_str " ")
     foreach(dep ${${proj}_DEPENDENCIES})
@@ -98,18 +431,20 @@ macro(ctkMacroCheckExternalProjectDependency proj)
         set(dependency_str "${dependency_str}${dep}, ")
       endif()
     endforeach()
-    _epd_status("SuperBuild - ${__indent}${proj} => Requires${dependency_str}")
+    superbuild_message(${proj} "${proj} => Requires${dependency_str}")
   endif()
 
   foreach(dep ${${proj}_DEPENDENCIES})
-    if(${${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj}})
-      set(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${dep} ${${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj}})
+    if(${${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${proj}})
+      set(${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${dep} ${${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${proj}})
     endif()
-    #if(__epd_first_pass)
-    #  message("${CMAKE_PROJECT_NAME}_USE_SYSTEM_${dep} set to [${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj}:${${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj}}]")
+    #if(SUPERBUILD_FIRST_PASS)
+    #  message("${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${dep} set to [${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${proj}:${${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${proj}}]")
     #endif()
   endforeach()
 
+  superbuild_stack_push(SUPERBUILD_PROJECT_STACK ${proj})
+
   # Include dependencies
   foreach(dep ${${proj}_DEPENDENCIES})
     get_property(_is_included GLOBAL PROPERTY External_${dep}_FILE_INCLUDED)
@@ -127,70 +462,79 @@ macro(ctkMacroCheckExternalProjectDependency proj)
     endif()
   endforeach()
 
+  superbuild_stack_pop(SUPERBUILD_PROJECT_STACK proj)
+
   # If project being process has dependencies, indicates it has also been added.
   if(NOT "${${proj}_DEPENDENCIES}" STREQUAL "")
-    _epd_status(${__${proj}_superbuild_message})
-  endif()
-
-  # Update indent variable
-  string(LENGTH "${__indent}" __indent_length)
-  math(EXPR __indent_length "${__indent_length}-2")
-  if(NOT ${__indent_length} LESS 0)
-    string(SUBSTRING "${__indent}" 0 ${__indent_length} __indent)
+    set(_msg "${proj}[OK]")
+    if(${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${proj})
+      set(_msg "${_ok_message} (SYSTEM)")
+    endif()
+    superbuild_message(${proj} ${_msg})
   endif()
 
-  if(${proj} STREQUAL ${CMAKE_PROJECT_NAME} AND __epd_first_pass)
+  if(${proj} STREQUAL ${SUPERBUILD_TOPLEVEL_PROJECT} AND SUPERBUILD_FIRST_PASS)
     message(STATUS "SuperBuild - First pass - done")
-    unset(__indent)
-    if(${CMAKE_PROJECT_NAME}_SUPERBUILD)
-      set(__epd_first_pass FALSE)
-    endif()
 
-    unset(${CMAKE_PROJECT_NAME}_DEPENDENCIES) # XXX - Refactor
-
-    foreach(possible_proj ${__epd_${CMAKE_PROJECT_NAME}_projects})
-      if(NOT ${possible_proj} STREQUAL ${CMAKE_PROJECT_NAME})
-
-        set_property(GLOBAL PROPERTY ${EXTERNAL_PROJECT_FILE_PREFIX}${possible_proj}_FILE_INCLUDED 0)
-
-        # XXX - Refactor - The following code should be re-organized
-        if(DEFINED ${possible_proj}_enabling_variable)
-          ctkMacroShouldAddExternalproject(${${possible_proj}_enabling_variable} add_project)
-          if(${add_project})
-            list(APPEND ${CMAKE_PROJECT_NAME}_DEPENDENCIES ${possible_proj})
-          else()
-            # XXX HACK
-            if(${possible_proj} STREQUAL "VTK"
-               AND CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK)
-              list(APPEND ${CMAKE_PROJECT_NAME}_DEPENDENCIES VTK)
-            else()
-              unset(${${possible_proj}_enabling_variable}_INCLUDE_DIRS)
-              unset(${${possible_proj}_enabling_variable}_LIBRARY_DIRS)
-              unset(${${possible_proj}_enabling_variable}_FIND_PACKAGE_CMD)
-              if(${CMAKE_PROJECT_NAME}_SUPERBUILD)
-                message(STATUS "SuperBuild - ${possible_proj}[OPTIONAL]")
-              endif()
-            endif()
-          endif()
-        else()
-          list(APPEND ${CMAKE_PROJECT_NAME}_DEPENDENCIES ${possible_proj})
-        endif()
-        # XXX
+    unset(${SUPERBUILD_TOPLEVEL_PROJECT}_DEPENDENCIES) # XXX - Refactor
 
-      else()
+    set(SUPERBUILD_FIRST_PASS FALSE)
+
+    foreach(possible_proj ${__epd_${SUPERBUILD_TOPLEVEL_PROJECT}_projects})
+
+      set_property(GLOBAL PROPERTY ${EXTERNAL_PROJECT_FILE_PREFIX}${possible_proj}_FILE_INCLUDED 0)
 
+      if(NOT ${possible_proj} STREQUAL ${SUPERBUILD_TOPLEVEL_PROJECT})
+        set(_include_project 1)
+        if(COMMAND superbuild_is_external_project_includable)
+          superbuild_is_external_project_includable("${possible_proj}" _include_project)
+        endif()
+        if(_include_project)
+          list(APPEND ${SUPERBUILD_TOPLEVEL_PROJECT}_DEPENDENCIES ${possible_proj})
+        else()
+          superbuild_message(STATUS "${possible_proj}[OPTIONAL]")
+        endif()
       endif()
     endforeach()
 
-    list(REMOVE_DUPLICATES ${CMAKE_PROJECT_NAME}_DEPENDENCIES)
+    list(REMOVE_DUPLICATES ${SUPERBUILD_TOPLEVEL_PROJECT}_DEPENDENCIES)
 
-    if(${CMAKE_PROJECT_NAME}_SUPERBUILD)
-      ctkMacroCheckExternalProjectDependency(${CMAKE_PROJECT_NAME})
+    if(${SUPERBUILD_TOPLEVEL_PROJECT}_SUPERBUILD)
+      superbuild_include_dependencies(${SUPERBUILD_TOPLEVEL_PROJECT})
     endif()
 
+    set(SUPERBUILD_FIRST_PASS TRUE)
   endif()
 
-  if(__epd_first_pass)
+  if(_sb_PROJECT_VAR)
+    set(${_sb_PROJECT_VAR} ${proj})
+  endif()
+
+  if(SUPERBUILD_FIRST_PASS)
     return()
+  else()
+    unset(${proj}_EXTERNAL_PROJECT_ARGS)
+    _sb_get_external_project_arguments(${proj} ${proj}_EXTERNAL_PROJECT_ARGS)
+    #message("${proj}_EXTERNAL_PROJECT_ARGS:${${proj}_EXTERNAL_PROJECT_ARGS}")
   endif()
 endmacro()
+
+#!
+#! Convenient macro allowing to define a "empty" project in case an external one is provided
+#! using for example <proj>_DIR.
+#! Doing so allows to keep the external project dependency system happy.
+#!
+#! \ingroup CMakeUtilities
+macro(superbuild_add_empty_external_project proj dependencies)
+
+  ExternalProject_Add(${proj}
+    SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
+    BINARY_DIR ${proj}-build
+    DOWNLOAD_COMMAND ""
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND ""
+    INSTALL_COMMAND ""
+    DEPENDS
+      ${dependencies}
+    )
+endmacro()

CMake/ctkMacroCheckExternalProjectDependencyTest.cmake

@@ -0,0 +1,129 @@
+
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR} ${CMAKE_MODULE_PATH})
+include(ctkMacroCheckExternalProjectDependency)
+
+#
+# cmake -DTEST__sb_cmakevar_to_cmakearg_test:BOOL=ON -P ctkMacroCheckExternalProjectDependencyTest.cmake
+#
+function(_sb_cmakevar_to_cmakearg_test)
+  function(check_test_result id current_output expected_output
+      current_varname expected_varname
+      current_vartype expected_vartype)
+    if(NOT "${current_output}" STREQUAL "${expected_output}")
+      message(FATAL_ERROR "Problem with _sb_cmakevar_to_cmakearg() - See testcase: ${id}\n"
+                          "current_output:${current_output}\n"
+                          "expected_output:${expected_output}")
+    endif()
+    if(NOT "${current_varname}" STREQUAL "${expected_varname}")
+      message(FATAL_ERROR "Problem with _sb_cmakevar_to_cmakearg() - See testcase: ${id}\n"
+                          "current_varname:${current_varname}\n"
+                          "expected_varname:${expected_varname}")
+    endif()
+    if(NOT "${current_vartype}" STREQUAL "${expected_vartype}")
+      message(FATAL_ERROR "Problem with _sb_cmakevar_to_cmakearg() - See testcase: ${id}\n"
+                          "current_vartype:${current_vartype}\n"
+                          "expected_vartype:${expected_vartype}")
+    endif()
+  endfunction()
+
+  set(id 1)
+  set(case${id}_input "Hello")
+  set(case${id}_expected_varname "")
+  set(case${id}_expected_vartype "")
+  set(case${id}_expected_cmake_arg_var "-Dcase${id}_input:STRING=${case${id}_input}")
+  _sb_cmakevar_to_cmakearg("case${id}_input:STRING"
+      case${id}_cmake_arg_var CMAKE_CACHE
+      )
+  check_test_result(${id}
+      "${case${id}_cmake_arg_var}" "${case${id}_expected_cmake_arg_var}"
+      "${case${id}_varname}" "${case${id}_expected_varname}"
+      "${case${id}_vartype}" "${case${id}_expected_vartype}")
+
+  set(id 2)
+  set(case${id}_input "Hello")
+  set(case${id}_expected_varname "case${id}_input")
+  set(case${id}_expected_vartype "STRING")
+  set(case${id}_expected_cmake_arg_var "-Dcase${id}_input:STRING=${case${id}_input}")
+  _sb_cmakevar_to_cmakearg("case${id}_input:STRING"
+      case${id}_cmake_arg_var CMAKE_CACHE
+      case${id}_varname case${id}_vartype)
+  check_test_result(${id}
+      "${case${id}_cmake_arg_var}" "${case${id}_expected_cmake_arg_var}"
+      "${case${id}_varname}" "${case${id}_expected_varname}"
+      "${case${id}_vartype}" "${case${id}_expected_vartype}")
+
+  set(id 3)
+  set(case${id}_input Hello World)
+  set(case${id}_expected_varname "case${id}_input")
+  set(case${id}_expected_vartype "STRING")
+  set(case${id}_expected_cmake_arg_var "-Dcase${id}_input:STRING=${case${id}_input}")
+  _sb_cmakevar_to_cmakearg("case${id}_input:STRING"
+      case${id}_cmake_arg_var CMAKE_CACHE
+      case${id}_varname case${id}_vartype)
+  check_test_result(${id}
+      "${case${id}_cmake_arg_var}" "${case${id}_expected_cmake_arg_var}"
+      "${case${id}_varname}" "${case${id}_expected_varname}"
+      "${case${id}_vartype}" "${case${id}_expected_vartype}")
+
+  set(id 4)
+  set(case${id}_input Hello World)
+  set(case${id}_expected_varname "case${id}_input")
+  set(case${id}_expected_vartype "STRING")
+  set(case${id}_expected_cmake_arg_var "-Dcase${id}_input:STRING=Hello^^World")
+  _sb_cmakevar_to_cmakearg("case${id}_input:STRING"
+      case${id}_cmake_arg_var CMAKE_CMD
+      case${id}_varname case${id}_vartype)
+  check_test_result(${id}
+      "${case${id}_cmake_arg_var}" "${case${id}_expected_cmake_arg_var}"
+      "${case${id}_varname}" "${case${id}_expected_varname}"
+      "${case${id}_vartype}" "${case${id}_expected_vartype}")
+
+  message("SUCCESS")
+endfunction()
+if(TEST__sb_cmakevar_to_cmakearg_test)
+  _sb_cmakevar_to_cmakearg_test()
+endif()
+
+#
+# cmake -DTEST__sb_extract_varname_and_vartype_test:BOOL=ON -P ctkMacroCheckExternalProjectDependencyTest.cmake
+#
+function(_sb_extract_varname_and_vartype_test)
+  function(check_test_result id current_varname expected_varname
+      current_vartype expected_vartype)
+    if(NOT "${current_varname}" STREQUAL "${expected_varname}")
+      message(FATAL_ERROR "Problem with _sb_extract_varname_and_vartype() - See testcase: ${id}\n"
+                          "current_varname:${current_varname}\n"
+                          "expected_varname:${expected_varname}")
+    endif()
+    if(NOT "${current_vartype}" STREQUAL "${expected_vartype}")
+      message(FATAL_ERROR "Problem with _sb_extract_varname_and_vartype() - See testcase: ${id}\n"
+                          "current_vartype:${current_vartype}\n"
+                          "expected_vartype:${expected_vartype}")
+    endif()
+  endfunction()
+
+  set(id 1)
+  set(case${id}_input "VAR:STRING")
+  set(case${id}_expected_varname "VAR")
+  set(case${id}_expected_vartype "STRING")
+  _sb_extract_varname_and_vartype("${case${id}_input}"
+      case${id}_varname case${id}_vartype)
+  check_test_result(${id}
+      "${case${id}_varname}" "${case${id}_expected_varname}"
+      "${case${id}_vartype}" "${case${id}_expected_vartype}")
+
+  set(id 2)
+  set(case${id}_input "VAR:STRING")
+  set(case${id}_expected_varname "VAR")
+  set(case${id}_expected_vartype "")
+  _sb_extract_varname_and_vartype("${case${id}_input}"
+      case${id}_varname)
+  check_test_result(${id}
+      "${case${id}_varname}" "${case${id}_expected_varname}"
+      "${case${id}_vartype}" "${case${id}_expected_vartype}")
+
+  message("SUCCESS")
+endfunction()
+if(TEST__sb_extract_varname_and_vartype_test)
+  _sb_extract_varname_and_vartype_test()
+endif()

CMake/ctkMacroEmptyExternalProject.cmake

@@ -1,39 +0,0 @@
-###########################################################################
-#
-#  Library:   CTK
-#
-#  Copyright (c) Kitware Inc.
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0.txt
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-#
-###########################################################################
-
-#!
-#! Convenient macro allowing to define a "empty" project in case an external one is provided
-#! using for example <proj>_DIR.
-#! Doing so allows to keep the external project dependency system happy.
-#!
-#! \ingroup CMakeUtilities
-macro(ctkMacroEmptyExternalProject proj dependencies)
-
-  ExternalProject_Add(${proj}
-    SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
-    BINARY_DIR ${proj}-build
-    DOWNLOAD_COMMAND ""
-    CONFIGURE_COMMAND ""
-    BUILD_COMMAND ""
-    INSTALL_COMMAND ""
-    DEPENDS 
-      ${dependencies}
-    )
-endmacro()

CMake/ctkMacroOptionUtils.cmake

@@ -18,6 +18,7 @@ endfunction()
 macro(ctk_option option_prefix name doc default)
   option(${option_prefix}_${name} ${doc} ${default})
   mark_as_advanced(${option_prefix}_${name})
+  mark_as_superbuild(${option_prefix}_${name})
   list(APPEND ${option_prefix}S ${name})
   set(_logical_expr ${ARGN})
   if(_logical_expr AND NOT ${option_prefix}_${name})

CMake/ctkMacroSetupQt.cmake

@@ -46,6 +46,8 @@ macro(ctkMacroSetupQt)
       get_filename_component(QT_INSTALLED_LIBRARY_DIR ${QT_QMAKE_EXECUTABLE} PATH)
     endif()
 
+    mark_as_superbuild(QT_QMAKE_EXECUTABLE)
+
   else()
     message(FATAL_ERROR "error: Qt4 was not found on your system. You probably need to set the QT_QMAKE_EXECUTABLE variable")
   endif()

CMakeExternals/CTKData.cmake

@@ -4,11 +4,12 @@
 
 superbuild_include_once()
 
-set(CTKData_DEPENDENCIES "")
-
-ctkMacroCheckExternalProjectDependency(CTKData)
 set(proj CTKData)
 
+set(${proj}_DEPENDENCIES "")
+
+superbuild_include_dependencies(PROJECT_VAR proj)
+
 if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   message(FATAL_ERROR "Enabling ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj} is not supported !")
 endif()
@@ -37,10 +38,10 @@ if(NOT DEFINED CTKData_DIR)
   endif()
 
   ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
     BINARY_DIR ${proj}-build
     PREFIX ${proj}${ep_suffix}
-    LIST_SEPARATOR ${sep}
     ${location_args}
     UPDATE_COMMAND ""
     CONFIGURE_COMMAND ""
@@ -51,7 +52,10 @@ if(NOT DEFINED CTKData_DIR)
     )
   set(CTKData_DIR ${CMAKE_BINARY_DIR}/${proj})
 else()
-  ctkMacroEmptyExternalproject(${proj} "${${proj}_DEPENDENCIES}")
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
 endif()
 
-list(APPEND CTK_SUPERBUILD_EP_VARS CTKData_DIR:PATH)
+mark_as_superbuild(
+  VARS CTKData_DIR:PATH
+  LABELS "FIND_PACKAGE"
+  )

CMakeExternals/DCMTK.cmake

@@ -4,14 +4,11 @@
 
 superbuild_include_once()
 
-set(DCMTK_enabling_variable DCMTK_LIBRARIES)
-set(${DCMTK_enabling_variable}_INCLUDE_DIRS DCMTK_INCLUDE_DIR)
-set(${DCMTK_enabling_variable}_FIND_PACKAGE_CMD DCMTK)
+set(proj DCMTK)
 
-set(DCMTK_DEPENDENCIES "")
+set(${proj}_DEPENDENCIES "")
 
-ctkMacroCheckExternalProjectDependency(DCMTK)
-set(proj DCMTK)
+superbuild_include_dependencies(PROJECT_VAR proj)
 
 if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   unset(DCMTK_DIR CACHE)
@@ -47,14 +44,13 @@ if(NOT DEFINED DCMTK_DIR AND NOT ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   endif()
 
   ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
     BINARY_DIR ${proj}-build
     PREFIX ${proj}${ep_suffix}
     ${location_args}
-    CMAKE_GENERATOR ${gen}
     UPDATE_COMMAND ""
     BUILD_COMMAND ""
-    LIST_SEPARATOR ${sep}
     CMAKE_ARGS
       -DDCMTK_INSTALL_BINDIR:STRING=bin/${CMAKE_CFG_INTDIR}
       -DDCMTK_INSTALL_LIBDIR:STRING=lib/${CMAKE_CFG_INTDIR}
@@ -76,27 +72,12 @@ if(NOT DEFINED DCMTK_DIR AND NOT ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
     )
   set(DCMTK_DIR ${ep_install_dir})
 
-# This was used during heavy development on DCMTK itself.
-# Disabling it for now. (It also leads to to build errors
-# with the XCode CMake generator on Mac).
-#
-#    ExternalProject_Add_Step(${proj} force_rebuild
-#      COMMENT "Force ${proj} re-build"
-#      DEPENDERS build    # Steps that depend on this step
-#      ALWAYS 1
-#      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${proj}-build
-#      DEPENDS
-#        ${proj_DEPENDENCIES}
-#      )
-
-  # Since DCMTK is statically build, there is not need to add its corresponding
-  # library output directory to CTK_EXTERNAL_LIBRARY_DIRS
-
 else()
-  ctkMacroEmptyExternalproject(${proj} "${${proj}_DEPENDENCIES}")
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
 endif()
 
-list(APPEND CTK_SUPERBUILD_EP_VARS
-  DCMTK_DIR:PATH
+mark_as_superbuild(
+  VARS DCMTK_DIR:PATH
+  LABELS "FIND_PACKAGE"
   )
 

CMakeExternals/ITK.cmake

@@ -4,15 +4,11 @@
 
 superbuild_include_once()
 
-set(ITK_enabling_variable ITK_LIBRARIES)
-set(${ITK_enabling_variable}_LIBRARY_DIRS ITK_LIBRARY_DIRS)
-set(${ITK_enabling_variable}_INCLUDE_DIRS ITK_INCLUDE_DIRS)
-set(${ITK_enabling_variable}_FIND_PACKAGE_CMD ITK)
+set(proj ITK)
 
-set(ITK_DEPENDENCIES "")
+set(${proj}_DEPENDENCIES "")
 
-ctkMacroCheckExternalProjectDependency(ITK)
-set(proj ITK)
+superbuild_include_dependencies(PROJECT_VAR proj)
 
 if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   unset(ITK_DIR CACHE)
@@ -49,14 +45,13 @@ if(NOT DEFINED ITK_DIR AND NOT ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   endif()
 
   ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
     BINARY_DIR ${proj}-build
     PREFIX ${proj}${ep_suffix}
     ${location_args}
     UPDATE_COMMAND ""
     INSTALL_COMMAND ""
-    CMAKE_GENERATOR ${gen}
-    LIST_SEPARATOR ${sep}
     CMAKE_CACHE_ARGS
       ${ep_common_cache_args}
       ${ep_project_include_arg}
@@ -74,12 +69,11 @@ if(NOT DEFINED ITK_DIR AND NOT ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
     )
   set(ITK_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
 
-  # Since the link directories associated with ITK is used, it makes sens to
-  # update CTK_EXTERNAL_LIBRARY_DIRS with its associated library output directory
-  list(APPEND CTK_EXTERNAL_LIBRARY_DIRS ${ITK_DIR}/bin)
-
 else()
-  ctkMacroEmptyExternalproject(${proj} "${${proj}_DEPENDENCIES}")
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
 endif()
 
-list(APPEND CTK_SUPERBUILD_EP_VARS ITK_DIR:PATH)
+mark_as_superbuild(
+  VARS ITK_DIR:PATH
+  LABELS "FIND_PACKAGE"
+  )

CMakeExternals/KWStyle.cmake

@@ -4,11 +4,12 @@
 
 superbuild_include_once()
 
-set(KWStyle_DEPENDENCIES "")
-
-ctkMacroCheckExternalProjectDependency(KWStyle)
 set(proj KWStyle)
 
+set(${proj}_DEPENDENCIES "")
+
+superbuild_include_dependencies(PROJECT_VAR proj)
+
 if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   unset(KWSTYLE_EXECUTABLE CACHE)
   find_program(KWSTYLE_EXECUTABLE kwstyle)
@@ -33,12 +34,11 @@ if(NOT DEFINED KWSTYLE_EXECUTABLE)
   endif()
 
   ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
     BINARY_DIR ${proj}-build
     PREFIX ${proj}${ep_suffix}
     ${location_args}
-    CMAKE_GENERATOR ${gen}
-    LIST_SEPARATOR ${sep}
     CMAKE_CACHE_ARGS
       ${ep_common_cache_args}
     DEPENDS
@@ -46,10 +46,11 @@ if(NOT DEFINED KWSTYLE_EXECUTABLE)
     )
   set(KWSTYLE_EXECUTABLE ${ep_install_dir}/bin/KWStyle)
 
-  # Since KWStyle is an executable, there is not need to add its corresponding
-  # library output directory to CTK_EXTERNAL_LIBRARY_DIRS
 else()
-  ctkMacroEmptyExternalproject(${proj} "${${proj}_DEPENDENCIES}")
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
 endif()
 
-list(APPEND CTK_SUPERBUILD_EP_VARS KWSTYLE_EXECUTABLE:PATH)
+mark_as_superbuild(
+  VARS KWSTYLE_EXECUTABLE:FILEPATH
+  LABELS "FIND_PACKAGE"
+  )

CMakeExternals/Log4Qt.cmake

@@ -4,14 +4,11 @@
 
 superbuild_include_once()
 
-set(Log4Qt_enabling_variable Log4Qt_LIBRARIES)
-set(${Log4Qt_enabling_variable}_INCLUDE_DIRS Log4Qt_INCLUDE_DIRS)
-set(${Log4Qt_enabling_variable}_FIND_PACKAGE_CMD Log4Qt)
+set(proj Log4Qt)
 
-set(Log4Qt_DEPENDENCIES "")
+set(${proj}_DEPENDENCIES "")
 
-ctkMacroCheckExternalProjectDependency(Log4Qt)
-set(proj Log4Qt)
+superbuild_include_dependencies(PROJECT_VAR proj)
 
 if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   message(FATAL_ERROR "Enabling ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj} is not supported !")
@@ -41,14 +38,13 @@ if(NOT DEFINED Log4Qt_DIR)
   endif()
 
   ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
     BINARY_DIR ${proj}-build
     PREFIX ${proj}${ep_suffix}
     ${location_args}
-    CMAKE_GENERATOR ${gen}
     INSTALL_COMMAND ""
     UPDATE_COMMAND ""
-    LIST_SEPARATOR ${sep}
     CMAKE_CACHE_ARGS
       ${ep_common_cache_args}
       -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
@@ -57,11 +53,11 @@ if(NOT DEFINED Log4Qt_DIR)
     )
   set(Log4Qt_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
 
-  # Since Log4Qt is statically build, there is not need to add its corresponding
-  # library output directory to CTK_EXTERNAL_LIBRARY_DIRS
-
 else()
-  ctkMacroEmptyExternalproject(${proj} "${${proj}_DEPENDENCIES}")
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
 endif()
 
-list(APPEND CTK_SUPERBUILD_EP_VARS Log4Qt_DIR:PATH)
+mark_as_superbuild(
+  VARS Log4Qt_DIR:PATH
+  LABELS "FIND_PACKAGE"
+  )

CMakeExternals/OpenIGTLink.cmake

@@ -4,15 +4,11 @@
 
 superbuild_include_once()
 
-set(OpenIGTLink_enabling_variable OpenIGTLink_LIBRARIES)
-set(${OpenIGTLink_enabling_variable}_LIBRARY_DIRS OpenIGTLink_LIBRARY_DIRS)
-set(${OpenIGTLink_enabling_variable}_INCLUDE_DIRS OpenIGTLink_INCLUDE_DIRS)
-set(${OpenIGTLink_enabling_variable}_FIND_PACKAGE_CMD OpenIGTLink)
+set(proj OpenIGTLink)
 
-set(OpenIGTLink_DEPENDENCIES "")
+set(${proj}_DEPENDENCIES "")
 
-ctkMacroCheckExternalProjectDependency(OpenIGTLink)
-set(proj OpenIGTLink)
+superbuild_include_dependencies(PROJECT_VAR proj)
 
 if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   unset(OpenIGTLink_DIR CACHE)
@@ -40,13 +36,12 @@ if(NOT DEFINED OpenIGTLink_DIR AND NOT ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   endif()
 
   ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
     BINARY_DIR ${proj}-build
     PREFIX ${proj}${ep_suffix}
     ${location_args}
     INSTALL_COMMAND ""
-    CMAKE_GENERATOR ${gen}
-    LIST_SEPARATOR ${sep}
     CMAKE_CACHE_ARGS
       ${ep_common_cache_args}
       ${ep_project_include_arg}
@@ -56,7 +51,10 @@ if(NOT DEFINED OpenIGTLink_DIR AND NOT ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   set(OpenIGTLink_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
 
 else()
-  ctkMacroEmptyExternalproject(${proj} "${${proj}_DEPENDENCIES}")
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
 endif()
 
-list(APPEND CTK_SUPERBUILD_EP_VARS OpenIGTLink_DIR:PATH)
+mark_as_superbuild(
+  VARS OpenIGTLink_DIR:PATH
+  LABELS "FIND_PACKAGE"
+  )

CMakeExternals/PythonQt.cmake

@@ -4,14 +4,11 @@
 
 superbuild_include_once()
 
-set(PythonQt_enabling_variable PYTHONQT_LIBRARIES)
-set(${PythonQt_enabling_variable}_INCLUDE_DIRS PYTHONQT_INCLUDE_DIR PYTHON_INCLUDE_DIRS)
-set(${PythonQt_enabling_variable}_FIND_PACKAGE_CMD PythonQt)
+set(proj PythonQt)
 
-set(PythonQt_DEPENDENCIES "")
+set(${proj}_DEPENDENCIES "")
 
-ctkMacroCheckExternalProjectDependency(PythonQt)
-set(proj PythonQt)
+superbuild_include_dependencies(PROJECT_VAR proj)
 
 if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   message(FATAL_ERROR "Enabling ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj} is not supported !")
@@ -69,14 +66,13 @@ if(NOT DEFINED PYTHONQT_INSTALL_DIR)
   endif()
 
   ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
     BINARY_DIR ${proj}-build
     PREFIX ${proj}${ep_suffix}
     ${location_args}
-    CMAKE_GENERATOR ${gen}
     UPDATE_COMMAND ""
     BUILD_COMMAND ""
-    LIST_SEPARATOR ${sep}
     CMAKE_CACHE_ARGS
       ${ep_common_cache_args}
       -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
@@ -88,16 +84,15 @@ if(NOT DEFINED PYTHONQT_INSTALL_DIR)
     )
   set(PYTHONQT_INSTALL_DIR ${ep_install_dir})
 
-  # Since the full path of PythonQt library is used, there is not need to add
-  # its corresponding library output directory to CTK_EXTERNAL_LIBRARY_DIRS
-
 else()
-  ctkMacroEmptyExternalproject(${proj} "${${proj}_DEPENDENCIES}")
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
 endif()
 
-list(APPEND CTK_SUPERBUILD_EP_VARS
-  PYTHONQT_INSTALL_DIR:PATH
-  PYTHON_EXECUTABLE:FILEPATH # FindPythonInterp expects PYTHON_EXECUTABLE variable to be defined
-  PYTHON_INCLUDE_DIR:PATH # FindPythonQt expects PYTHON_INCLUDE_DIR variable to be defined
-  PYTHON_LIBRARY:FILEPATH # FindPythonQt expects PYTHON_LIBRARY variable to be defined
+mark_as_superbuild(
+  VARS
+    PYTHONQT_INSTALL_DIR:PATH
+    PYTHON_EXECUTABLE:FILEPATH # FindPythonInterp expects PYTHON_EXECUTABLE variable to be defined
+    PYTHON_INCLUDE_DIR:PATH # FindPythonQt expects PYTHON_INCLUDE_DIR variable to be defined
+    PYTHON_LIBRARY:FILEPATH # FindPythonQt expects PYTHON_LIBRARY variable to be defined
+  LABELS "FIND_PACKAGE"
   )

CMakeExternals/PythonQtGenerator.cmake

@@ -4,15 +4,16 @@
 
 superbuild_include_once()
 
+set(proj PythonQtGenerator)
+
 # Sanity checks
 if(DEFINED PYTHONQTGENERATOR_EXECUTABLE AND NOT EXISTS ${PYTHONQTGENERATOR_EXECUTABLE})
   message(FATAL_ERROR "PYTHONQTGENERATOR_EXECUTABLE variable is defined but corresponds to non-existing executable")
 endif()
 
-set(PythonQtGenerator_DEPENDENCIES PythonQt)
+set(${proj}_DEPENDENCIES PythonQt)
 
-ctkMacroCheckExternalProjectDependency(PythonQtGenerator)
-set(proj PythonQtGenerator)
+superbuild_include_dependencies(PROJECT_VAR proj)
 
 if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   message(FATAL_ERROR "Enabling ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj} is not supported !")
@@ -30,13 +31,12 @@ if(NOT DEFINED PYTHONQTGENERATOR_EXECUTABLE)
   #
 
   ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/PythonQt/generator
     BINARY_DIR ${proj}-build
     PREFIX ${proj}${ep_suffix}
     DOWNLOAD_COMMAND ""
-    CMAKE_GENERATOR ${gen}
     INSTALL_COMMAND ""
-    LIST_SEPARATOR ${sep}
     CMAKE_CACHE_ARGS
       ${ep_common_cache_args}
       -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
@@ -46,11 +46,11 @@ if(NOT DEFINED PYTHONQTGENERATOR_EXECUTABLE)
 
   set(PYTHONQTGENERATOR_EXECUTABLE ${CMAKE_BINARY_DIR}/PythonQtGenerator-build/PythonQtGenerator)
 
-  # Since PythonQtGenerator is an executable, there is no need to add its corresponding
-  # library output directory to CTK_EXTERNAL_LIBRARY_DIRS
-
 else()
-  ctkMacroEmptyExternalproject(${proj} "${${proj}_DEPENDENCIES}")
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
 endif()
 
-list(APPEND CTK_SUPERBUILD_EP_VARS PYTHONQTGENERATOR_EXECUTABLE:FILEPATH)
+mark_as_superbuild(
+  VARS PYTHONQTGENERATOR_EXECUTABLE:FILEPATH
+  LABELS "FIND_PACKAGE"
+  )

CMakeExternals/QtSOAP.cmake

@@ -4,15 +4,11 @@
 
 superbuild_include_once()
 
-set(QtSOAP_enabling_variable QtSOAP_LIBRARIES)
-set(${QtSOAP_enabling_variable}_LIBRARY_DIRS QtSOAP_LIBRARY_DIRS)
-set(${QtSOAP_enabling_variable}_INCLUDE_DIRS QtSOAP_INCLUDE_DIRS)
-set(${QtSOAP_enabling_variable}_FIND_PACKAGE_CMD QtSOAP)
+set(proj QtSOAP)
 
-set(QtSOAP_DEPENDENCIES "")
+set(${proj}_DEPENDENCIES "")
 
-ctkMacroCheckExternalProjectDependency(QtSOAP)
-set(proj QtSOAP)
+superbuild_include_dependencies(PROJECT_VAR proj)
 
 if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   message(FATAL_ERROR "Enabling ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj} is not supported !")
@@ -42,14 +38,13 @@ if(NOT DEFINED QtSOAP_DIR)
   endif()
 
   ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
     BINARY_DIR ${proj}-build
     PREFIX ${proj}${ep_suffix}
     ${location_args}
-    CMAKE_GENERATOR ${gen}
     UPDATE_COMMAND ""
     INSTALL_COMMAND ""
-    LIST_SEPARATOR ${sep}
     CMAKE_CACHE_ARGS
       ${ep_common_cache_args}
       -DCMAKE_RUNTIME_OUTPUT_DIRECTORY:STRING=${CTK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}
@@ -59,11 +54,11 @@ if(NOT DEFINED QtSOAP_DIR)
     )
   set(QtSOAP_DIR "${CMAKE_BINARY_DIR}/${proj}-build")
 
-  # Since the QtSOAP dll is created directly in CTK-build/bin, there is not need to add a
-  # library output directory to CTK_EXTERNAL_LIBRARY_DIRS
-
 else()
-  ctkMacroEmptyExternalproject(${proj} "${${proj}_DEPENDENCIES}")
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
 endif()
 
-list(APPEND CTK_SUPERBUILD_EP_VARS QtSOAP_DIR:PATH)
+mark_as_superbuild(
+  VARS QtSOAP_DIR:PATH
+  LABELS "FIND_PACKAGE"
+  )

CMakeExternals/QtTesting.cmake

@@ -4,12 +4,13 @@
 
 superbuild_include_once()
 
-set(QtTesting_DEPENDS)
+set(proj QtTesting)
 
-set(QtTesting_DEPENDENCIES "")
+set(${proj}_DEPENDS)
 
-ctkMacroCheckExternalProjectDependency(QtTesting)
-set(proj QtTesting)
+set(${proj}_DEPENDENCIES "")
+
+superbuild_include_dependencies(PROJECT_VAR proj)
 
 if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   message(FATAL_ERROR "Enabling ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj} is not supported !")
@@ -49,13 +50,12 @@ if(NOT DEFINED QtTesting_DIR)
 
   message(STATUS "Adding project:${proj}")
   ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
     BINARY_DIR ${proj}-build
     PREFIX ${proj}${ep_suffix}
     ${location_args}
-    CMAKE_GENERATOR ${gen}
     UPDATE_COMMAND ""
-    LIST_SEPARATOR ${sep}
     CMAKE_CACHE_ARGS
       ${ep_common_cache_args}
       -DBUILD_SHARED_LIBS:BOOL=ON
@@ -66,14 +66,13 @@ if(NOT DEFINED QtTesting_DIR)
   set(QtTesting_INSTALL_DIR ${ep_install_dir})
   set(QtTesting_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
 
-  # Since QtTesting is statically build, there is not need to add its corresponding
-  # library output directory to CTK_EXTERNAL_LIBRARY_DIRS
-
 else()
-  ctkMacroEmptyExternalproject(${proj} "${${proj}_DEPENDENCIES}")
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
 endif()
 
-list(APPEND CTK_SUPERBUILD_EP_VARS
-  QtTesting_INSTALL_DIR:PATH
-  QtTesting_DIR:PATH
+mark_as_superbuild(
+  VARS
+    QtTesting_INSTALL_DIR:PATH
+    QtTesting_DIR:PATH
+  LABELS "FIND_PACKAGE"
   )

CMakeExternals/VTK.cmake

@@ -4,15 +4,11 @@
 
 superbuild_include_once()
 
-set(VTK_enabling_variable VTK_LIBRARIES)
-set(${VTK_enabling_variable}_LIBRARY_DIRS VTK_LIBRARY_DIRS)
-set(${VTK_enabling_variable}_INCLUDE_DIRS VTK_INCLUDE_DIRS)
-set(${VTK_enabling_variable}_FIND_PACKAGE_CMD VTK)
+set(proj VTK)
 
-set(VTK_DEPENDENCIES "")
+set(${proj}_DEPENDENCIES "")
 
-ctkMacroCheckExternalProjectDependency(VTK)
-set(proj VTK)
+superbuild_include_dependencies(PROJECT_VAR proj)
 
 if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   unset(VTK_DIR CACHE)
@@ -56,14 +52,13 @@ if(NOT DEFINED VTK_DIR AND NOT ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   endif()
 
   ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
     BINARY_DIR ${proj}-build
     PREFIX ${proj}${ep_suffix}
     ${location_args}
     UPDATE_COMMAND ""
     INSTALL_COMMAND ""
-    CMAKE_GENERATOR ${gen}
-    LIST_SEPARATOR ${sep}
     CMAKE_CACHE_ARGS
       ${ep_common_cache_args}
       ${additional_vtk_cmakevars}
@@ -83,12 +78,11 @@ if(NOT DEFINED VTK_DIR AND NOT ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
     )
   set(VTK_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
 
-  # Since the link directories associated with VTK is used, it makes sens to
-  # update CTK_EXTERNAL_LIBRARY_DIRS with its associated library output directory
-  list(APPEND CTK_EXTERNAL_LIBRARY_DIRS ${VTK_DIR}/bin)
-
 else()
-  ctkMacroEmptyExternalproject(${proj} "${${proj}_DEPENDENCIES}")
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
 endif()
 
-list(APPEND CTK_SUPERBUILD_EP_VARS VTK_DIR:PATH)
+mark_as_superbuild(
+  VARS VTK_DIR:PATH
+  LABELS "FIND_PACKAGE"
+  )

CMakeExternals/XIP.cmake

@@ -4,15 +4,11 @@
 
 superbuild_include_once()
 
-set(XIP_enabling_variable XIP_LIBRARIES)
-set(${XIP_enabling_variable}_LIBRARY_DIRS XIP_LIBRARY_DIRS)
-set(${XIP_enabling_variable}_INCLUDE_DIRS XIP_INCLUDE_DIRS)
-set(${XIP_enabling_variable}_FIND_PACKAGE_CMD XIP)
+set(proj XIP)
 
-set(XIP_DEPENDENCIES "")
+set(${proj}_DEPENDENCIES "")
 
-ctkMacroCheckExternalProjectDependency(XIP)
-set(proj XIP)
+superbuild_include_dependencies(PROJECT_VAR proj)
 
 if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   message(FATAL_ERROR "Enabling ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj} is not supported !")
@@ -35,13 +31,12 @@ if(NOT DEFINED XIP_DIR)
   endif()
 
   ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
     BINARY_DIR ${proj}-build
     PREFIX ${proj}${ep_suffix}
     ${location_args}
     INSTALL_COMMAND ""
-    CMAKE_GENERATOR ${gen}
-    LIST_SEPARATOR ${sep}
     CMAKE_CACHE_ARGS
       ${ep_common_cache_args}
       -DHAS_VTK:BOOL=OFF
@@ -52,7 +47,10 @@ if(NOT DEFINED XIP_DIR)
   set(XIP_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
 
 else()
-  ctkMacroEmptyExternalproject(${proj} "${${proj}_DEPENDENCIES}")
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
 endif()
 
-list(APPEND CTK_SUPERBUILD_EP_VARS XIP_DIR:PATH)
+mark_as_superbuild(
+  VARS XIP_DIR:PATH
+  LABELS "FIND_PACKAGE"
+  )

CMakeExternals/ZMQ.cmake

@@ -4,15 +4,11 @@
 
 superbuild_include_once()
 
-set(ZMQ_enabling_variable ZMQ_LIBRARIES)
-set(${ZMQ_enabling_variable}_LIBRARY_DIRS ZMQ_LIBRARY_DIRS)
-set(${ZMQ_enabling_variable}_INCLUDE_DIRS ZMQ_INCLUDE_DIRS)
-set(${ZMQ_enabling_variable}_FIND_PACKAGE_CMD ZMQ)
+set(proj ZMQ)
 
-set(ZMQ_DEPENDENCIES "")
+set(${proj}_DEPENDENCIES "")
 
-ctkMacroCheckExternalProjectDependency(ZMQ)
-set(proj ZMQ)
+superbuild_include_dependencies(PROJECT_VAR proj)
 
 if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   message(FATAL_ERROR "Enabling ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj} is not supported !")
@@ -42,14 +38,13 @@ if(NOT DEFINED ZMQ_DIR)
   endif()
 
   ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
     BINARY_DIR ${proj}-build
     PREFIX ${proj}${ep_suffix}
     ${location_args}
     UPDATE_COMMAND ""
     INSTALL_COMMAND ""
-    CMAKE_GENERATOR ${gen}
-    LIST_SEPARATOR ${sep}
     CMAKE_CACHE_ARGS
       ${ep_common_cache_args}
       -DBUILD_SHARED_LIBS:BOOL=ON
@@ -61,7 +56,10 @@ if(NOT DEFINED ZMQ_DIR)
   set(ZMQ_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
 
 else()
-  ctkMacroEmptyExternalproject(${proj} "${${proj}_DEPENDENCIES}")
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
 endif()
 
-list(APPEND CTK_SUPERBUILD_EP_VARS ZMQ_DIR:PATH)
+mark_as_superbuild(
+  VARS ZMQ_DIR:PATH
+  LABELS "FIND_PACKAGE"
+  )

CMakeExternals/qxmlrpc.cmake

@@ -4,15 +4,11 @@
 
 superbuild_include_once()
 
-set(qxmlrpc_enabling_variable qxmlrpc_LIBRARY)
-set(${qxmlrpc_enabling_variable}_LIBRARY_DIRS qxmlrpc_LIBRARY_DIRS)
-set(${qxmlrpc_enabling_variable}_INCLUDE_DIRS qxmlrpc_INCLUDE_DIRS)
-set(${qxmlrpc_enabling_variable}_FIND_PACKAGE_CMD qxmlrpc)
+set(proj qxmlrpc)
 
-set(qxmlrpc_DEPENDENCIES "")
+set(${proj}_DEPENDENCIES "")
 
-ctkMacroCheckExternalProjectDependency(qxmlrpc)
-set(proj qxmlrpc)
+superbuild_include_dependencies(PROJECT_VAR proj)
 
 if(${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj})
   message(FATAL_ERROR "Enabling ${CMAKE_PROJECT_NAME}_USE_SYSTEM_${proj} is not supported !")
@@ -42,14 +38,13 @@ if(NOT DEFINED qxmlrpc_DIR)
   endif()
 
   ExternalProject_Add(${proj}
+    ${${proj}_EXTERNAL_PROJECT_ARGS}
     SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
     BINARY_DIR ${proj}-build
     PREFIX ${proj}${ep_suffix}
     ${location_args}
-    CMAKE_GENERATOR ${gen}
     INSTALL_COMMAND ""
-    LIST_SEPARATOR ${sep}
-    CMAKE_ARGS
+    CMAKE_CACHE_ARGS
       ${ep_common_cache_args}
       -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
     DEPENDS
@@ -57,11 +52,11 @@ if(NOT DEFINED qxmlrpc_DIR)
     )
   set(qxmlrpc_DIR "${CMAKE_BINARY_DIR}/${proj}-build")
 
-  # Since qxmlrpc is statically build, there is not need to add its corresponding
-  # library output directory to CTK_EXTERNAL_LIBRARY_DIRS
-
 else()
-  ctkMacroEmptyExternalproject(${proj} "${${proj}_DEPENDENCIES}")
+  superbuild_add_empty_external_project(${proj} "${${proj}_DEPENDENCIES}")
 endif()
 
-list(APPEND CTK_SUPERBUILD_EP_VARS qxmlrpc_DIR:PATH)
+mark_as_superbuild(
+  VARS qxmlrpc_DIR:PATH
+  LABELS "FIND_PACKAGE"
+  )

CMakeLists.txt

@@ -21,10 +21,23 @@
 cmake_minimum_required(VERSION 2.8.4)
 
 #-----------------------------------------------------------------------------
+# Superbuild
+#
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake" ${CMAKE_MODULE_PATH})
+set(EXTERNAL_PROJECT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/CMakeExternals)
+set(EXTERNAL_PROJECT_FILE_PREFIX "")
+include(ExternalProject)
+include(ctkMacroCheckExternalProjectDependency)
+
+#-----------------------------------------------------------------------------
 if(APPLE)
   # Note: By setting CMAKE_OSX_* variables before any enable_language() or project() calls,
   #       we ensure that the bitness will be properly detected.
   include(${CMAKE_SOURCE_DIR}/CMake/ctkBlockSetCMakeOSXVariables.cmake)
+  mark_as_superbuild(
+    VARS CMAKE_OSX_ARCHITECTURES:STRING CMAKE_OSX_SYSROOT:PATH CMAKE_OSX_DEPLOYMENT_TARGET:STRING
+    PROJECT CTK
+    )
 endif()
 
 #-----------------------------------------------------------------------------
@@ -38,6 +51,7 @@ set(CTK_LIBRARY_MODE "SHARED")
 
 option(CTK_BUILD_SHARED_LIBS "Build CTK libraries as shared module." ON)
 mark_as_advanced(CTK_BUILD_SHARED_LIBS)
+mark_as_superbuild(CTK_BUILD_SHARED_LIBS)
 if(NOT CTK_BUILD_SHARED_LIBS)
   set(CTK_LIBRARY_MODE "STATIC")
 endif()
@@ -75,6 +89,7 @@ foreach(type LIBRARY RUNTIME ARCHIVE)
     if(NOT DEFINED CTK_CMAKE_${type}_OUTPUT_DIRECTORY)
       set(CTK_CMAKE_${type}_OUTPUT_DIRECTORY ${CTK_BINARY_DIR}/CTK-build/bin)
     endif()
+    mark_as_superbuild(CTK_CMAKE_${type}_OUTPUT_DIRECTORY:PATH)
   else()
     if(NOT DEFINED CTK_CMAKE_${type}_OUTPUT_DIRECTORY)
       set(output_dir ${CTK_BINARY_DIR}/bin)
@@ -135,13 +150,23 @@ if(NOT CTK_INSTALL_DOC_DIR)
   set(CTK_INSTALL_DOC_DIR "doc")
 endif()
 
+mark_as_superbuild(
+  CTK_INSTALL_BIN_DIR:STRING
+  CTK_INSTALL_LIB_DIR:STRING
+  CTK_INSTALL_PLUGIN_DIR:STRING
+  CTK_INSTALL_CMAKE_DIR:STRING
+  CTK_INSTALL_INCLUDE_DIR:STRING
+  CTK_INSTALL_PLUGIN_INCLUDE_DIR:STRING
+  CTK_INSTALL_QTPLUGIN_DIR:STRING
+  CTK_INSTALL_DOC_DIR:STRING
+  )
+
 #-----------------------------------------------------------------------------
 # Update CMake module path
 # Note: FindXXX.cmake script specific to utility should be copied into Utilities/CMake
 #
 set(CMAKE_MODULE_PATH
   "${CMAKE_CURRENT_SOURCE_DIR}/Utilities/CMake"
-  "${CMAKE_CURRENT_SOURCE_DIR}/CMake"
   ${CMAKE_MODULE_PATH})
 
 #-----------------------------------------------------------------------------
@@ -219,6 +244,7 @@ install(FILES
 #
 include(CTest)
 mark_as_advanced(BUILD_TESTING)
+mark_as_superbuild(BUILD_TESTING)
 
 if(BUILD_TESTING)
   set(CPP_TEST_PATH ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
@@ -258,30 +284,41 @@ endif()
 #
 option(CTK_USE_QTTESTING "Enable/Disable QtTesting" OFF)
 mark_as_advanced(CTK_USE_QTTESTING)
+mark_as_superbuild(CTK_USE_QTTESTING)
 
 #-----------------------------------------------------------------------------
 # Coverage
 #
 option(WITH_COVERAGE "Enable/Disable coverage" OFF)
 mark_as_advanced(WITH_COVERAGE)
+mark_as_superbuild(WITH_COVERAGE)
 
 #-----------------------------------------------------------------------------
 # Documentation
 #
 option(DOCUMENTATION_TARGET_IN_ALL "Include the custom target for building documentation in 'all'" OFF)
 mark_as_advanced(DOCUMENTATION_TARGET_IN_ALL)
+mark_as_superbuild(DOCUMENTATION_TARGET_IN_ALL)
 
 set(DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  CACHE PATH "Where documentation archives should be stored")
 mark_as_advanced(DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY)
+mark_as_superbuild(DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY)
+
+# Attempt to discover Doxygen so that DOXYGEN_EXECUTABLE is set to an appropriate default value
+find_package(Doxygen QUIET)
+mark_as_superbuild(DOXYGEN_EXECUTABLE)
 
 #-----------------------------------------------------------------------------
 # Additional CXX/C Flags
 #
 set(ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags")
 mark_as_advanced(ADDITIONAL_C_FLAGS)
+mark_as_superbuild(ADDITIONAL_C_FLAGS)
+
 set(ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags")
 mark_as_advanced(ADDITIONAL_CXX_FLAGS)
+mark_as_superbuild(ADDITIONAL_CXX_FLAGS)
 
 #-----------------------------------------------------------------------------
 # Set symbol visibility Flags
@@ -400,15 +437,19 @@ ctk_enable_option(PluginFramework "Enable Plugin Framework" OFF
 
 # Build all CTK plug-ins
 option(CTK_BUILD_ALL_PLUGINS "Build all CTK plug-ins" OFF)
+mark_as_superbuild(CTK_BUILD_ALL_PLUGINS)
 
 # Build all CTK libraries
 option(CTK_BUILD_ALL_LIBRARIES "Build all CTK libraries" OFF)
+mark_as_superbuild(CTK_BUILD_ALL_LIBRARIES)
 
 # Build all CTK applications
 option(CTK_BUILD_ALL_APPS "Build all CTK applications" OFF)
+mark_as_superbuild(CTK_BUILD_ALL_APPS)
 
 # Build everything
 option(CTK_BUILD_ALL "Build everything in CTK" OFF)
+mark_as_superbuild(CTK_BUILD_ALL)
 if(CTK_BUILD_ALL)
   set(CTK_BUILD_ALL_PLUGINS 1)
   set(CTK_BUILD_ALL_LIBRARIES 1)
@@ -421,6 +462,7 @@ endif()
 # The CTK Python Wrapping
 ctk_enable_option(Python_Wrapping "Wrap CTK classes using Qt meta-object system into Python language" OFF
                   CTK_LIB_Scripting/Python/Core)
+mark_as_superbuild(CTK_ENABLE_Python_Wrapping)
 
 # Build examples
 # Create the logical expression containing the minium set of required options
@@ -451,10 +493,12 @@ mark_as_advanced(DART_TESTING_TIMEOUT)
 # KWStyle
 option(CTK_USE_KWSTYLE     "Enable sourcecode-based style tests." OFF)
 mark_as_advanced(CTK_USE_KWSTYLE)
+mark_as_superbuild(CTK_USE_KWSTYLE)
 
 # Qt Designer Plugins
 option(CTK_BUILD_QTDESIGNER_PLUGINS "Build Qt Designer plugins" ON)
 mark_as_advanced(CTK_BUILD_QTDESIGNER_PLUGINS)
+mark_as_superbuild(CTK_BUILD_QTDESIGNER_PLUGINS)
 
 #-----------------------------------------------------------------------------
 # CTK Libraries
@@ -674,11 +718,13 @@ ctk_plugin_option(org.commontk.eventbus
 # Add the PluginsContrib repo to the build system
 option(CTK_USE_CONTRIBUTED_PLUGINS OFF "Use CTK plug-ins from the PluginsContrib repository")
 mark_as_advanced(CTK_USE_CONTRIBUTED_PLUGINS)
+mark_as_superbuild(CTK_USE_CONTRIBUTED_PLUGINS)
 if(CTK_USE_CONTRIBUTED_PLUGINS)
   ctkFunctionAddPluginRepo(NAME PluginsContrib
                            GIT_URL github.com/commontk/PluginsContrib.git
                            GIT_TAG 7fc37f400c
                           )
+  mark_as_superbuild(PluginsContrib_DIR:PATH)
 endif()
 
 #-----------------------------------------------------------------------------
@@ -705,7 +751,6 @@ endif()
 # Create list of directories corresponding to the enabled targets
 set(target_directories)
 
-set(ctk_lib_options_list) # This list will be updated in ctkMacroAddCtkLibraryOptions
 foreach(lib ${CTK_LIBS})
   if(CTK_LIB_${lib})
     ctkMacroAddCtkLibraryOptions(${lib})
@@ -762,6 +807,7 @@ ctkMacroValidateBuildOptions("${CTK_BINARY_DIR}" "${DGraph_EXECUTABLE}" "${targe
 set(CTK_WRAP_PYTHONQT_LIGHT ${CTK_ENABLE_Python_Wrapping})
 option(CTK_WRAP_PYTHONQT_FULL "Experimental - Wrap CTK classes using Qt meta-object system into Python language" OFF)
 mark_as_advanced(CTK_WRAP_PYTHONQT_FULL)
+mark_as_superbuild(CTK_WRAP_PYTHONQT_FULL)
 if(CTK_WRAP_PYTHONQT_FULL AND CTK_WRAP_PYTHONQT_LIGHT)
   message(FATAL_ERROR "CTK_ENABLE_Python_Wrapping AND CTK_WRAP_PYTHONQT_FULL options are mutually exclusive. Please enable only one !")
 endif()
@@ -875,8 +921,9 @@ if(CTK_USE_CONTRIBUTED_PLUGINS)
     ctkFunctionCheckoutRepo(
       NAME ExternalProjectsContrib
       GIT_URL github.com/commontk/ExternalProjectsContrib.git
-      GIT_TAG 80ce3d5
+      GIT_TAG 8cea706
       )
+    mark_as_superbuild(ExternalProjectsContrib_DIR:PATH)
   endif()
 
   file(GLOB _contrib_scripts ${ExternalProjectsContrib_DIR}/*.cmake)

SuperBuild.cmake

@@ -25,14 +25,6 @@
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
-# Declare CTK_EXTERNAL_LIBRARY_DIRS variable - This variable stores
-# the library output directory associated with the different external project
-# It's then used in CMake/LastConfigureStep/CTKGenerateCTKConfig.cmake to
-# configure CTKConfig.cmake.in
-# This variable would then be exposed to project building against CTK
-set(CTK_EXTERNAL_LIBRARY_DIRS)
-
-#-----------------------------------------------------------------------------
 # Make sure ${CTK_BINARY_DIR}/CTK-build/bin exists
 # May be used by some external project to install libs 
 if(NOT EXISTS ${CTK_BINARY_DIR}/CTK-build/bin)
@@ -40,174 +32,25 @@ if(NOT EXISTS ${CTK_BINARY_DIR}/CTK-build/bin)
 endif()
 
 #-----------------------------------------------------------------------------
-# Qt is expected to be setup by CTK/CMakeLists.txt just before it includes the SuperBuild script
-#
-
-#-----------------------------------------------------------------------------
-# Attempt to discover Doxygen so that DOXYGEN_EXECUTABLE is set to an appropriate default value
-#
-find_package(Doxygen QUIET)
-
-#-----------------------------------------------------------------------------
-# Generate cmake variable name corresponding to Libs, Plugins and Applications
-#
-set(ctk_libs_bool_vars)
-foreach(lib ${CTK_LIBS})
-  list(APPEND ctk_libs_bool_vars CTK_LIB_${lib})
-endforeach()
-
-set(ctk_plugins_bool_vars)
-foreach(plugin ${CTK_PLUGINS})
-  list(APPEND ctk_plugins_bool_vars CTK_PLUGIN_${plugin})
-endforeach()
-
-set(ctk_applications_bool_vars)
-foreach(app ${CTK_APPS})
-  list(APPEND ctk_applications_bool_vars CTK_APP_${app})
-endforeach()
-
-#-----------------------------------------------------------------------------
-# Set superbuild boolean args
-#
-
-set(ctk_cmake_boolean_args
-  BUILD_TESTING
-  CTK_BUILD_ALL
-  CTK_BUILD_ALL_APPS
-  CTK_BUILD_ALL_LIBRARIES
-  CTK_BUILD_ALL_PLUGINS
-  CTK_BUILD_QTDESIGNER_PLUGINS
-  CTK_USE_QTTESTING
-  CTK_USE_KWSTYLE
-  CTK_USE_CONTRIBUTED_PLUGINS
-  WITH_COVERAGE
-  DOCUMENTATION_TARGET_IN_ALL
-  CTK_WRAP_PYTHONQT_FULL
-  CTK_ENABLE_Python_Wrapping
-  ${ctk_lib_options_list}
-  )
-
-set(ctk_superbuild_boolean_args)
-foreach(ctk_cmake_arg ${ctk_cmake_boolean_args})
-  list(APPEND ctk_superbuild_boolean_args -D${ctk_cmake_arg}:BOOL=${${ctk_cmake_arg}})
-endforeach()
-
-foreach(ctk_cmake_arg ${ctk_libs_bool_vars} ${ctk_plugins_bool_vars} ${ctk_applications_bool_vars})
-  # Use the cached value of the option in case the current value has been
-  # overridden by a "CTK_BUILD_ALL" option.
-  get_property(arg_value CACHE ${ctk_cmake_arg} PROPERTY VALUE)
-  list(APPEND ctk_superbuild_boolean_args -D${ctk_cmake_arg}:BOOL=${arg_value})
-endforeach()
-
-# message("CMake boolean args:")
-# foreach(arg ${ctk_superbuild_boolean_args})
-#   message("  ${arg}")
-# endforeach()
-
-#-----------------------------------------------------------------------------
-# Expand superbuild external project args
-#
-set(CTK_SUPERBUILD_EP_ARGS)
-set(CTK_SUPERBUILD_EP_VARNAMES)
-foreach(arg ${CTK_SUPERBUILD_EP_VARS})
-  string(REPLACE ":" ";" varname_and_vartype ${arg})
-  set(target_info_list ${target_info_list})
-  list(GET varname_and_vartype 0 _varname)
-  list(GET varname_and_vartype 1 _vartype)
-  # Separate list item with <sep>
-  set(ep_arg_as_string "")
-  ctk_list_to_string(${sep} "${${_varname}}" ep_arg_as_string)
-  list(APPEND CTK_SUPERBUILD_EP_ARGS -D${_varname}:${_vartype}=${ep_arg_as_string})
-  list(APPEND CTK_SUPERBUILD_EP_VARNAMES ${_varname})
-endforeach()
-string(REPLACE ";" "^" CTK_SUPERBUILD_EP_VARNAMES "${CTK_SUPERBUILD_EP_VARNAMES}")
-
-# message("CMake external project args:")
-# foreach(arg ${CTK_SUPERBUILD_EP_ARGS})
-#   message("  ${arg}")
-# endforeach()
-
-#-----------------------------------------------------------------------------
-if(CTK_USE_CONTRIBUTED_PLUGINS)
-  list(APPEND CTK_SUPERBUILD_EP_ARGS
-    -DExternalProjectsContrib_DIR:STRING=${ExternalProjectsContrib_DIR}
-    -DPluginsContrib_DIR:STRING=${PluginsContrib_DIR}
-    )
-endif()
-
-#-----------------------------------------------------------------------------
-# CTK Configure
-#
-set(proj CTK-Configure)
+set(proj CTK)
 
 ExternalProject_Add(${proj}
+  ${CTK_EXTERNAL_PROJECT_ARGS}
   DOWNLOAD_COMMAND ""
-  CMAKE_GENERATOR ${gen}
-  LIST_SEPARATOR ${sep}
-  CMAKE_ARGS
+  CMAKE_GENERATOR ${EP_CMAKE_GENERATOR}
+  CMAKE_CACHE_ARGS
     -DCTK_SUPERBUILD:BOOL=OFF
     -DCTK_SUPERBUILD_BINARY_DIR:PATH=${CTK_BINARY_DIR}
-    ${ctk_superbuild_boolean_args}
     -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
     -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
     -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
     -DCMAKE_CXX_FLAGS_INIT:STRING=${CMAKE_CXX_FLAGS_INIT}
     -DCMAKE_C_FLAGS_INIT:STRING=${CMAKE_C_FLAGS_INIT}
-    -DADDITIONAL_C_FLAGS:STRING=${ADDITIONAL_C_FLAGS}
-    -DADDITIONAL_CXX_FLAGS:STRING=${ADDITIONAL_CXX_FLAGS}
     -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_INSTALL_PREFIX}
-    -DCTK_BUILD_SHARED_LIBS:BOOL=${CTK_BUILD_SHARED_LIBS}
-    ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
-    -DDOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY:PATH=${DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY}
-    -DDOXYGEN_EXECUTABLE:FILEPATH=${DOXYGEN_EXECUTABLE}
-    -DCTK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${CTK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY}
-    -DCTK_CMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${CTK_CMAKE_LIBRARY_OUTPUT_DIRECTORY}
-    -DCTK_CMAKE_RUNTIME_OUTPUT_DIRECTORY:PATH=${CTK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}
-    -DCTK_INSTALL_BIN_DIR:STRING=${CTK_INSTALL_BIN_DIR}
-    -DCTK_INSTALL_LIB_DIR:STRING=${CTK_INSTALL_LIB_DIR}
-    -DCTK_INSTALL_PLUGIN_DIR:STRING=${CTK_INSTALL_PLUGIN_DIR}
-    -DCTK_INSTALL_INCLUDE_DIR:STRING=${CTK_INSTALL_INCLUDE_DIR}
-    -DCTK_INSTALL_PLUGIN_INCLUDE_DIR:STRING=${CTK_INSTALL_PLUGIN_INCLUDE_DIR}
-    -DCTK_INSTALL_QTPLUGIN_DIR:STRING=${CTK_INSTALL_QTPLUGIN_DIR}
-    -DCTK_INSTALL_DOC_DIR:STRING=${CTK_INSTALL_DOC_DIR}
-    -DCTK_EXTERNAL_LIBRARY_DIRS:STRING=${CTK_EXTERNAL_LIBRARY_DIRS}
-    -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
-    ${CTK_SUPERBUILD_EP_ARGS}
-    -DCTK_SUPERBUILD_EP_VARNAMES:STRING=${CTK_SUPERBUILD_EP_VARNAMES}
   SOURCE_DIR ${CTK_SOURCE_DIR}
   BINARY_DIR ${CTK_BINARY_DIR}/CTK-build
-  BUILD_COMMAND ""
   INSTALL_COMMAND ""
   DEPENDS
     ${CTK_DEPENDENCIES}
-  )
-
-if(CMAKE_GENERATOR MATCHES ".*Makefiles.*")
-  set(ctk_build_cmd "$(MAKE)")
-else()
-  set(ctk_build_cmd ${CMAKE_COMMAND} --build ${CTK_BINARY_DIR}/CTK-build --config ${CMAKE_CFG_INTDIR})
-endif()
-
-#-----------------------------------------------------------------------------
-# CTK
-#
-#message(STATUS SUPERBUILD_EXCLUDE_CTKBUILD_TARGET:${SUPERBUILD_EXCLUDE_CTKBUILD_TARGET})
-if(NOT DEFINED SUPERBUILD_EXCLUDE_CTKBUILD_TARGET OR NOT SUPERBUILD_EXCLUDE_CTKBUILD_TARGET)
-  set(CTKBUILD_TARGET_ALL_OPTION "ALL")
-else()
-  set(CTKBUILD_TARGET_ALL_OPTION "")
-endif()
-
-add_custom_target(CTK-build ${CTKBUILD_TARGET_ALL_OPTION}
-  COMMAND ${ctk_build_cmd}
-  WORKING_DIRECTORY ${CTK_BINARY_DIR}/CTK-build
-  )
-add_dependencies(CTK-build CTK-Configure)
-
-#-----------------------------------------------------------------------------
-# Custom target allowing to drive the build of CTK project itself
-#
-add_custom_target(CTK
-  COMMAND ${ctk_build_cmd}
-  WORKING_DIRECTORY ${CTK_BINARY_DIR}/CTK-build
+  STEP_TARGETS configure
   )