Merge branch '76-support-non-superbuild-build'. Closes #76 and #71

* 76-support-non-superbuild-build:
  Re-factor build system to support "non-superbuild" builds. See #76

Conflicts:
	CMakeExternals/QtMobility.cmake
	SuperBuild.cmake

CMake/ctkBlockCheckDependencies.cmake

@@ -0,0 +1,87 @@
+
+#
+# Independently of the value of CTK_SUPERBUILD, each external project definition will
+# provides either the include and library directories or a variable name
+# used by the corresponding Find<package>.cmake files.
+#
+# Within top-level CMakeLists.txt file, the variable names will be expanded if not in
+# superbuild mode. The include and library dirs are then used in
+# ctkMacroBuildApp, ctkMacroBuildLib, and ctkMacroBuildPlugin
+#
+
+#-----------------------------------------------------------------------------
+# Collect CTK library target dependencies
+#
+
+ctkMacroCollectAllTargetLibraries("${CTK_LIBS_SUBDIRS}" "Libs" ALL_TARGET_LIBRARIES)
+ctkMacroCollectAllTargetLibraries("${CTK_PLUGINS_SUBDIRS}" "Plugins" ALL_TARGET_LIBRARIES)
+ctkMacroCollectAllTargetLibraries("${CTK_APPLICATIONS_SUBDIRS}" "Applications" ALL_TARGET_LIBRARIES)
+#MESSAGE(STATUS ALL_TARGET_LIBRARIES:${ALL_TARGET_LIBRARIES})
+
+#-----------------------------------------------------------------------------
+# Initialize NON_CTK_DEPENDENCIES variable
+#
+# 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
+ctkMacroGetAllNonProjectTargetLibraries("${ALL_TARGET_LIBRARIES}" NON_CTK_DEPENDENCIES)
+#MESSAGE(STATUS NON_CTK_DEPENDENCIES:${NON_CTK_DEPENDENCIES})
+
+#-----------------------------------------------------------------------------
+# Include external projects
+#
+#-----------------------------------------------------------------------------
+# Git protocole option
+#
+option(CTK_USE_GIT_PROTOCOL "If behind a firewall turn this OFF to use http instead." ON)
+set(git_protocol "git")
+if(NOT CTK_USE_GIT_PROTOCOL)
+  set(git_protocol "http")
+endif()
+
+#-----------------------------------------------------------------------------
+# Enable and setup External project global properties
+#
+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")
+
+  set(ep_common_c_flags "${CMAKE_C_FLAGS_INIT} ${ADDITIONAL_C_FLAGS}")
+  set(ep_common_cxx_flags "${CMAKE_CXX_FLAGS_INIT} ${ADDITIONAL_CXX_FLAGS}")
+
+  # 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_POSSIBLE_DEPENDENCIES)
+  MESSAGE(FATAL_ERROR "error: CTK_POSSIBLE_DEPENDENCIES variable is not defined !")
+ENDIF()
+FOREACH(p ${CTK_POSSIBLE_DEPENDENCIES})
+  INCLUDE(CMakeExternals/${p}.cmake)
+ENDFOREACH()
+
+#MESSAGE("CTK_POSSIBLE_DEPENDENCIES:")
+#FOREACH(dep ${CTK_POSSIBLE_DEPENDENCIES})
+#  MESSAGE("  ${dep}")
+#ENDFOREACH()

CMakeExternals/CTKData.cmake

@@ -1,9 +1,8 @@
 #
 # CTKData
 #
-SET(CTKData_DEPENDS)
-IF(BUILD_TESTING)
 
+IF(BUILD_TESTING)
   # Sanity checks
   IF(DEFINED CTKData_DIR AND NOT EXISTS ${CTKData_DIR})
     MESSAGE(FATAL_ERROR "CTKData_DIR variable is defined but corresponds to non-existing directory")
@@ -12,33 +11,38 @@ IF(BUILD_TESTING)
   SET(proj CTKData)
   set(proj_DEPENDENCIES)
 
-  SET(CTKData_DEPENDS ${proj})
+  LIST(APPEND CTK_DEPENDENCIES ${proj})
+
+  IF(CTK_SUPERBUILD)
 
-  IF(NOT DEFINED CTKData_DIR)
+    IF(NOT DEFINED CTKData_DIR)
 
-    SET(revision_tag cc07f1ff391b7828459c)
-    IF(${proj}_REVISION_TAG)
-      SET(revision_tag ${${proj}_REVISION_TAG})
+      SET(revision_tag cc07f1ff391b7828459c)
+      IF(${proj}_REVISION_TAG)
+        SET(revision_tag ${${proj}_REVISION_TAG})
+      ENDIF()
+
+  #    MESSAGE(STATUS "Adding project:${proj}")
+      ExternalProject_Add(${proj}
+        SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
+        BINARY_DIR ${proj}-build
+        PREFIX ${proj}${ep_suffix}
+        GIT_REPOSITORY ${git_protocol}://github.com/commontk/CTKData.git
+        GIT_TAG ${revision_tag}
+        UPDATE_COMMAND ""
+        CONFIGURE_COMMAND ""
+        BUILD_COMMAND ""
+        INSTALL_COMMAND ""
+        DEPENDS
+          ${proj_DEPENDENCIES}
+        )
+      SET(CTKData_DIR ${CMAKE_BINARY_DIR}/${proj})
+    ELSE()
+      ctkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
     ENDIF()
 
-#    MESSAGE(STATUS "Adding project:${proj}")
-    ExternalProject_Add(${proj}
-      SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
-      BINARY_DIR ${proj}-build
-      PREFIX ${proj}${ep_suffix}
-      GIT_REPOSITORY ${git_protocol}://github.com/commontk/CTKData.git
-      GIT_TAG ${revision_tag}
-      UPDATE_COMMAND ""
-      CONFIGURE_COMMAND ""
-      BUILD_COMMAND ""
-      INSTALL_COMMAND ""
-      DEPENDS
-        ${proj_DEPENDENCIES}
-      )
-    SET(CTKData_DIR ${CMAKE_BINARY_DIR}/${proj})
-  ELSE()
-    ctkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
+    LIST(APPEND CTK_SUPERBUILD_EP_VARS CTKData_DIR:PATH)
+
   ENDIF()
 
-  LIST(APPEND CTK_SUPERBUILD_EP_VARS CTKData_DIR:PATH)
 ENDIF()

CMakeExternals/DCMTK.cmake

@@ -2,7 +2,6 @@
 # DCMTK
 #
 
-SET(DCMTK_DEPENDS)
 ctkMacroShouldAddExternalProject(DCMTK_LIBRARIES add_project)
 IF(${add_project})
 
@@ -16,71 +15,76 @@ IF(${add_project})
   SET(proj DCMTK)
   SET(proj_DEPENDENCIES)
 
-  SET(DCMTK_DEPENDS ${proj})
+  LIST(APPEND CTK_DEPENDENCIES ${proj})
 
-  IF(NOT DEFINED DCMTK_DIR)
-    SET(revision_tag 085525e643cab5ac82)
-    IF(${proj}_REVISION_TAG)
-      SET(revision_tag ${${proj}_REVISION_TAG})
-    ENDIF()
+  SET(${DCMTK_enabling_variable}_INCLUDE_DIRS DCMTK_INCLUDE_DIR)
+  SET(${DCMTK_enabling_variable}_FIND_PACKAGE_CMD DCMTK)
 
-#     MESSAGE(STATUS "Adding project:${proj}")
-    # Set CMake OSX variable to pass down the external project
-    set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
-    if(APPLE)
-      list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
-        -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
-        -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
-        -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
-    endif()
-    ExternalProject_Add(${proj}
-      SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
-      BINARY_DIR ${proj}-build
-      PREFIX ${proj}${ep_suffix}
-      GIT_REPOSITORY "${git_protocol}://git.dcmtk.org/dcmtk.git"
-      GIT_TAG ${revision_tag}
-      CMAKE_GENERATOR ${gen}
-      UPDATE_COMMAND ""
-      BUILD_COMMAND ""
-      CMAKE_CACHE_ARGS
-        -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-        -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
-        -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
-        -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
-        -DDCMTK_WITH_ZLIB:BOOL=OFF # see github issue #25
-        -DDCMTK_WITH_OPENSSL:BOOL=OFF # see github issue #25
-        -DDCMTK_WITH_PNG:BOOL=OFF # see github issue #25
-        -DDCMTK_WITH_TIFF:BOOL=OFF  # see github issue #25
-        -DDCMTK_WITH_XML:BOOL=OFF  # see github issue #25
-        -DDCMTK_FORCE_FPIC_ON_UNIX:BOOL=ON
-        ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
-        #-DBUILD_TESTING:BOOL=OFF # Not used
-        -DDCMTK_OVERWRITE_WIN32_COMPILER_FLAGS:BOOL=OFF
-      )
-    SET(DCMTK_DIR ${ep_install_dir})
+  IF(CTK_SUPERBUILD)
 
-# 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}
-#      )
+    IF(NOT DEFINED DCMTK_DIR)
+      SET(revision_tag 085525e643cab5ac82)
+      IF(${proj}_REVISION_TAG)
+        SET(revision_tag ${${proj}_REVISION_TAG})
+      ENDIF()
 
-    # Since DCMTK is statically build, there is not need to add its corresponding
-    # library output directory to CTK_EXTERNAL_LIBRARY_DIRS
+  #     MESSAGE(STATUS "Adding project:${proj}")
+      # Set CMake OSX variable to pass down the external project
+      set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
+      if(APPLE)
+        list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
+          -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
+          -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
+          -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
+      endif()
+      ExternalProject_Add(${proj}
+        SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
+        BINARY_DIR ${proj}-build
+        PREFIX ${proj}${ep_suffix}
+        GIT_REPOSITORY "${git_protocol}://git.dcmtk.org/dcmtk.git"
+        GIT_TAG ${revision_tag}
+        CMAKE_GENERATOR ${gen}
+        UPDATE_COMMAND ""
+        BUILD_COMMAND ""
+        CMAKE_CACHE_ARGS
+          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+          -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
+          -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
+          -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
+          -DDCMTK_WITH_ZLIB:BOOL=OFF # see github issue #25
+          -DDCMTK_WITH_OPENSSL:BOOL=OFF # see github issue #25
+          -DDCMTK_WITH_PNG:BOOL=OFF # see github issue #25
+          -DDCMTK_WITH_TIFF:BOOL=OFF  # see github issue #25
+          -DDCMTK_WITH_XML:BOOL=OFF  # see github issue #25
+          -DDCMTK_FORCE_FPIC_ON_UNIX:BOOL=ON
+          ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
+          #-DBUILD_TESTING:BOOL=OFF # Not used
+          -DDCMTK_OVERWRITE_WIN32_COMPILER_FLAGS:BOOL=OFF
+        )
+      SET(DCMTK_DIR ${ep_install_dir})
 
-  ELSE()
-    ctkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
-  ENDIF()
+  # 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}
+  #      )
 
-  LIST(APPEND CTK_SUPERBUILD_EP_VARS DCMTK_DIR:PATH)
+      # 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}")
+    ENDIF()
+
+    LIST(APPEND CTK_SUPERBUILD_EP_VARS DCMTK_DIR:PATH)
+
+  ENDIF()
 
-  SET(${DCMTK_enabling_variable}_INCLUDE_DIRS DCMTK_INCLUDE_DIR)
-  SET(${DCMTK_enabling_variable}_FIND_PACKAGE_CMD DCMTK)
 ENDIF()

CMakeExternals/ITK.cmake

@@ -1,7 +1,6 @@
 #
 # ITK
 #
-SET (ITK_DEPENDS)
 ctkMacroShouldAddExternalProject(ITK_LIBRARIES add_project)
 IF(${add_project})
   # Sanity checks
@@ -14,67 +13,72 @@ IF(${add_project})
   SET(proj ITK)
   SET(proj_DEPENDENCIES)
 
-  SET(ITK_DEPENDS ${proj})
+  LIST(APPEND CTK_DEPENDENCIES ${proj})
 
-  IF(NOT DEFINED ITK_DIR)
+  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(revision_tag "v3.20.0")
-    IF(${proj}_REVISION_TAG)
-      SET(revision_tag ${${proj}_REVISION_TAG})
-    ENDIF()
+  IF(CTK_SUPERBUILD)
 
-    # Set CMake OSX variable to pass down the external project
-    set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
-    if(APPLE)
-      list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
-        -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
-        -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
-        -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
-    endif()
+    IF(NOT DEFINED ITK_DIR)
 
-#     MESSAGE(STATUS "Adding project:${proj}")
-    ExternalProject_Add(${proj}
-      SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
-      BINARY_DIR ${proj}-build
-      PREFIX ${proj}${ep_suffix}
-      GIT_REPOSITORY "${git_protocol}://itk.org/ITK.git"
-      GIT_TAG ${revision_tag}
-      UPDATE_COMMAND ""
-      INSTALL_COMMAND ""
-      CMAKE_GENERATOR ${gen}
-      CMAKE_CACHE_ARGS
-        -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-        -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
-        -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
-        -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
-        ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
-        -DBUILD_TESTING:BOOL=OFF
-        -DBUILD_EXAMPLES:BOOL=OFF
-        -DBUILD_SHARED_LIBS:BOOL=ON
-        -DITK_USE_REVIEW:BOOL=ON
-        -DITK_USE_REVIEW_STATISTICS:BOOL=ON
-        -DITK_USE_OPTIMIZED_REGISTRATION_METHODS:BOOL=ON
-        -DITK_USE_PORTABLE_ROUND:BOOL=ON
-        -DITK_USE_CENTERED_PIXEL_COORDINATES_CONSISTENTLY:BOOL=ON
-        -DITK_USE_TRANSFORM_IO_FACTORIES:BOOL=ON
-        -DITK_LEGACY_REMOVE:BOOL=ON
-      DEPENDS
-        ${proj_DEPENDENCIES}
-      )
-    SET(ITK_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
+      SET(revision_tag "v3.20.0")
+      IF(${proj}_REVISION_TAG)
+        SET(revision_tag ${${proj}_REVISION_TAG})
+      ENDIF()
 
-    # 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)
+      # Set CMake OSX variable to pass down the external project
+      set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
+      if(APPLE)
+        list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
+          -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
+          -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
+          -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
+      endif()
 
-  ELSE()
-    ctkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
-  ENDIF()
+  #     MESSAGE(STATUS "Adding project:${proj}")
+      ExternalProject_Add(${proj}
+        SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
+        BINARY_DIR ${proj}-build
+        PREFIX ${proj}${ep_suffix}
+        GIT_REPOSITORY "${git_protocol}://itk.org/ITK.git"
+        GIT_TAG ${revision_tag}
+        UPDATE_COMMAND ""
+        INSTALL_COMMAND ""
+        CMAKE_GENERATOR ${gen}
+        CMAKE_CACHE_ARGS
+          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+          -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
+          -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
+          -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
+          ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
+          -DBUILD_TESTING:BOOL=OFF
+          -DBUILD_EXAMPLES:BOOL=OFF
+          -DBUILD_SHARED_LIBS:BOOL=ON
+          -DITK_USE_REVIEW:BOOL=ON
+          -DITK_USE_REVIEW_STATISTICS:BOOL=ON
+          -DITK_USE_OPTIMIZED_REGISTRATION_METHODS:BOOL=ON
+          -DITK_USE_PORTABLE_ROUND:BOOL=ON
+          -DITK_USE_CENTERED_PIXEL_COORDINATES_CONSISTENTLY:BOOL=ON
+          -DITK_USE_TRANSFORM_IO_FACTORIES:BOOL=ON
+          -DITK_LEGACY_REMOVE:BOOL=ON
+        DEPENDS
+          ${proj_DEPENDENCIES}
+        )
+      SET(ITK_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
 
-  LIST(APPEND CTK_SUPERBUILD_EP_VARS ITK_DIR:PATH)
+      # 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}")
+    ENDIF()
+
+    LIST(APPEND CTK_SUPERBUILD_EP_VARS ITK_DIR:PATH)
+
+  ENDIF()
 
-  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)
 ENDIF()
 

CMakeExternals/KWStyle.cmake

@@ -1,7 +1,7 @@
 #
 # KWStyle
 #
-SET(kwstyle_DEPENDS)
+
 IF(CTK_USE_KWSTYLE)
 
   # Sanity checks
@@ -12,44 +12,48 @@ IF(CTK_USE_KWSTYLE)
   SET(proj KWStyle-CVSHEAD)
   SET(proj_DEPENDENCIES)
 
-  SET(kwstyle_DEPENDS ${proj})
-
-  IF(NOT DEFINED CTK_KWSTYLE_EXECUTABLE)
-    # Set CMake OSX variable to pass down the external project
-    set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
-    if(APPLE)
-      list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
-        -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
-        -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
-        -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
-    endif()
-
-    ExternalProject_Add(${proj}
-      SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
-      BINARY_DIR ${proj}-build
-      PREFIX ${proj}${ep_suffix}
-      LIST_SEPARATOR ${sep}
-      CVS_REPOSITORY ":pserver:anoncvs:@public.kitware.com:/cvsroot/KWStyle"
-      CVS_MODULE "KWStyle"
-      CMAKE_GENERATOR ${gen}
-      CMAKE_CACHE_ARGS
-        -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-        -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
-        -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
-        -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
-        ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
-        -DBUILD_TESTING:BOOL=OFF
-      DEPENDS
-        ${proj_DEPENDENCIES}
-      )
-    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}")
-  ENDIF()
+  LIST(APPEND CTK_DEPENDENCIES ${proj})
+
+  IF(CTK_SUPERBUILD)
+
+    IF(NOT DEFINED CTK_KWSTYLE_EXECUTABLE)
+      # Set CMake OSX variable to pass down the external project
+      set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
+      if(APPLE)
+        list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
+          -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
+          -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
+          -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
+      endif()
+
+      ExternalProject_Add(${proj}
+        SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
+        BINARY_DIR ${proj}-build
+        PREFIX ${proj}${ep_suffix}
+        LIST_SEPARATOR ${sep}
+        CVS_REPOSITORY ":pserver:anoncvs:@public.kitware.com:/cvsroot/KWStyle"
+        CVS_MODULE "KWStyle"
+        CMAKE_GENERATOR ${gen}
+        CMAKE_CACHE_ARGS
+          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+          -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
+          -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
+          -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
+          ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
+          -DBUILD_TESTING:BOOL=OFF
+        DEPENDS
+          ${proj_DEPENDENCIES}
+        )
+      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}")
+    ENDIF()
+
+    LIST(APPEND CTK_SUPERBUILD_EP_VARS KWSTYLE_EXECUTABLE:PATH)
 
-  LIST(APPEND CTK_SUPERBUILD_EP_VARS KWSTYLE_EXECUTABLE:PATH)
+  ENDIF()
 
 ENDIF()

CMakeExternals/Log4Qt.cmake

@@ -1,7 +1,7 @@
 #
 # Log4Qt
 #
-SET(Log4Qt_DEPENDS)
+
 ctkMacroShouldAddExternalProject(Log4Qt_LIBRARIES add_project)
 IF(${add_project})
 
@@ -15,56 +15,60 @@ IF(${add_project})
   SET(proj Log4Qt)
   SET(proj_DEPENDENCIES)
 
-  SET(Log4Qt_DEPENDS ${proj})
+  LIST(APPEND CTK_DEPENDENCIES ${proj})
 
-  IF(NOT DEFINED Log4Qt_DIR)
+  SET(${Log4Qt_enabling_variable}_INCLUDE_DIRS Log4Qt_INCLUDE_DIRS)
+  SET(${Log4Qt_enabling_variable}_FIND_PACKAGE_CMD Log4Qt)
 
-    SET(revision_tag 8d3558b0f636cbf8ff83)
-    IF(${proj}_REVISION_TAG)
-      SET(revision_tag ${${proj}_REVISION_TAG})
-    ENDIF()
+  IF(CTK_SUPERBUILD)
 
-    # Set CMake OSX variable to pass down the external project
-    set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
-    if(APPLE)
-      list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
-        -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
-        -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
-        -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
-    endif()
-
-#     MESSAGE(STATUS "Adding project:${proj}")
-    ExternalProject_Add(${proj}
-      SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
-      BINARY_DIR ${proj}-build
-      PREFIX ${proj}${ep_suffix}
-      GIT_REPOSITORY "${git_protocol}://github.com/commontk/Log4Qt.git"
-      GIT_TAG ${revision_tag}
-      CMAKE_GENERATOR ${gen}
-      INSTALL_COMMAND ""
-      UPDATE_COMMAND ""
-      CMAKE_CACHE_ARGS
-        -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-        -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
-        #-DCMAKE_C_FLAGS:STRING=${ep_common_c_flags} # Not used
-        -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
-        ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
-        -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
-      DEPENDS
-        ${proj_DEPENDENCIES}
-      )
-    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}")
-  ENDIF()
+    IF(NOT DEFINED Log4Qt_DIR)
 
-  LIST(APPEND CTK_SUPERBUILD_EP_VARS Log4Qt_DIR:PATH)
+      SET(revision_tag 8d3558b0f636cbf8ff83)
+      IF(${proj}_REVISION_TAG)
+        SET(revision_tag ${${proj}_REVISION_TAG})
+      ENDIF()
 
-  SET(${Log4Qt_enabling_variable}_INCLUDE_DIRS Log4Qt_INCLUDE_DIRS)
-  SET(${Log4Qt_enabling_variable}_FIND_PACKAGE_CMD Log4Qt)
+      # Set CMake OSX variable to pass down the external project
+      set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
+      if(APPLE)
+        list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
+          -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
+          -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
+          -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
+      endif()
+
+  #     MESSAGE(STATUS "Adding project:${proj}")
+      ExternalProject_Add(${proj}
+        SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
+        BINARY_DIR ${proj}-build
+        PREFIX ${proj}${ep_suffix}
+        GIT_REPOSITORY "${git_protocol}://github.com/commontk/Log4Qt.git"
+        GIT_TAG ${revision_tag}
+        CMAKE_GENERATOR ${gen}
+        INSTALL_COMMAND ""
+        UPDATE_COMMAND ""
+        CMAKE_CACHE_ARGS
+          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+          -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
+          #-DCMAKE_C_FLAGS:STRING=${ep_common_c_flags} # Not used
+          -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
+          ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
+          -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
+        DEPENDS
+          ${proj_DEPENDENCIES}
+        )
+      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}")
+    ENDIF()
+
+    LIST(APPEND CTK_SUPERBUILD_EP_VARS Log4Qt_DIR:PATH)
+
+  ENDIF()
 
 ENDIF()

CMakeExternals/OpenIGTLink.cmake

@@ -1,7 +1,7 @@
 #
 # OpenIGTLink
 #
-SET (OpenIGTLink_DEPENDS)
+
 ctkMacroShouldAddExternalProject(OpenIGTLink_LIBRARIES add_project)
 IF(${add_project})
 
@@ -15,45 +15,49 @@ IF(${add_project})
   SET(proj OpenIGTLink)
   SET(proj_DEPENDENCIES)
 
-  SET(OpenIGTLink_DEPENDS ${proj})
-
-  IF(NOT DEFINED OpenIGTLink_DIR)
-    # Set CMake OSX variable to pass down the external project
-    set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
-    if(APPLE)
-      list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
-        -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
-        -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
-        -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
-    endif()
-
-  #   MESSAGE(STATUS "Adding project:${proj}")
-    ExternalProject_Add(${proj}
-      SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
-      BINARY_DIR ${proj}-build
-      PREFIX ${proj}${ep_suffix}
-      SVN_REPOSITORY "http://svn.na-mic.org/NAMICSandBox/trunk/OpenIGTLink"
-      INSTALL_COMMAND ""
-      CMAKE_GENERATOR ${gen}
-      CMAKE_CACHE_ARGS
-        -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-        -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
-        -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
-        -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
-        ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
-      DEPENDS
-        ${proj_DEPENDENCIES}
-      )
-    SET(OpenIGTLink_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
-
-  ELSE()
-    ctkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
-  ENDIF()
-
-  LIST(APPEND CTK_SUPERBUILD_EP_VARS OpenIGTLink_DIR:PATH)
+  LIST(APPEND CTK_DEPENDENCIES ${proj})
 
   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)
 
+  IF(CTK_SUPERBUILD)
+
+    IF(NOT DEFINED OpenIGTLink_DIR)
+      # Set CMake OSX variable to pass down the external project
+      set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
+      if(APPLE)
+        list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
+          -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
+          -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
+          -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
+      endif()
+
+    #   MESSAGE(STATUS "Adding project:${proj}")
+      ExternalProject_Add(${proj}
+        SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
+        BINARY_DIR ${proj}-build
+        PREFIX ${proj}${ep_suffix}
+        SVN_REPOSITORY "http://svn.na-mic.org/NAMICSandBox/trunk/OpenIGTLink"
+        INSTALL_COMMAND ""
+        CMAKE_GENERATOR ${gen}
+        CMAKE_CACHE_ARGS
+          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+          -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
+          -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
+          -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
+          ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
+        DEPENDS
+          ${proj_DEPENDENCIES}
+        )
+      SET(OpenIGTLink_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
+
+    ELSE()
+      ctkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
+    ENDIF()
+
+    LIST(APPEND CTK_SUPERBUILD_EP_VARS OpenIGTLink_DIR:PATH)
+
+  ENDIF()
+
 ENDIF()

CMakeExternals/PythonQt.cmake

@@ -1,7 +1,7 @@
 #
 # PythonQt
 #
-SET(PythonQt_DEPENDS)
+
 ctkMacroShouldAddExternalProject(PYTHONQT_LIBRARIES add_project)
 IF(${add_project})
 
@@ -15,84 +15,89 @@ IF(${add_project})
   SET(proj PythonQt)
   SET(proj_DEPENDENCIES)
 
-  SET(PythonQt_DEPENDS ${proj})
-
-  IF(NOT DEFINED PYTHONQT_INSTALL_DIR)
-  #   MESSAGE(STATUS "Adding project:${proj}")
-
-    SET(ep_PythonQt_args)
+  LIST(APPEND CTK_DEPENDENCIES ${proj})
 
-    # Should PythonQt use VTK
-    IF(CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK)
-      LIST(APPEND proj_DEPENDENCIES VTK)
-      LIST(APPEND ep_PythonQt_args -DVTK_DIR:PATH=${VTK_DIR})
-    ENDIF()
-    LIST(APPEND ep_PythonQt_args -DPythonQt_USE_VTK:BOOL=${CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK})
-
-    # Enable Qt libraries PythonQt wrapping if required
-    foreach(qtlib core gui network opengl sql svg uitools webkit xml xmlpatterns)
-      STRING(TOUPPER ${qtlib} qtlib_uppercase)
-      LIST(APPEND ep_PythonQt_args -DPythonQt_Wrap_Qt${qtlib}:BOOL=${CTK_LIB_Scripting/Python/Core_PYTHONQT_WRAP_QT${qtlib_uppercase}})
-    endforeach()
-
-    # Python is required
-    FIND_PACKAGE(PythonLibs)
-    IF(NOT PYTHONLIBS_FOUND)
-      MESSAGE(FATAL_ERROR "error: Python is required to build ${PROJECT_NAME}")
-    ENDIF()
+  SET(${PythonQt_enabling_variable}_INCLUDE_DIRS PYTHONQT_INCLUDE_DIR PYTHON_INCLUDE_DIRS)
+  SET(${PythonQt_enabling_variable}_FIND_PACKAGE_CMD PythonQt)
 
-    # Set CMake OSX variable to pass down the external project
-    set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
-    if(APPLE)
-      list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
-        -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
-        -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
-        -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
-    endif()
-
-    SET(revision_tag 3171a94e16ba9bfee137)
-    IF(${proj}_REVISION_TAG)
-      SET(revision_tag ${${proj}_REVISION_TAG})
+  IF(CTK_SUPERBUILD)
+
+    IF(NOT DEFINED PYTHONQT_INSTALL_DIR)
+    #   MESSAGE(STATUS "Adding project:${proj}")
+
+      SET(ep_PythonQt_args)
+
+      # Should PythonQt use VTK
+      IF(CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK)
+        LIST(APPEND proj_DEPENDENCIES VTK)
+        LIST(APPEND ep_PythonQt_args -DVTK_DIR:PATH=${VTK_DIR})
+      ENDIF()
+      LIST(APPEND ep_PythonQt_args -DPythonQt_USE_VTK:BOOL=${CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK})
+
+      # Enable Qt libraries PythonQt wrapping if required
+      foreach(qtlib core gui network opengl sql svg uitools webkit xml xmlpatterns)
+        STRING(TOUPPER ${qtlib} qtlib_uppercase)
+        LIST(APPEND ep_PythonQt_args -DPythonQt_Wrap_Qt${qtlib}:BOOL=${CTK_LIB_Scripting/Python/Core_PYTHONQT_WRAP_QT${qtlib_uppercase}})
+      endforeach()
+
+      # Python is required
+      FIND_PACKAGE(PythonLibs)
+      IF(NOT PYTHONLIBS_FOUND)
+        MESSAGE(FATAL_ERROR "error: Python is required to build ${PROJECT_NAME}")
+      ENDIF()
+
+      # Set CMake OSX variable to pass down the external project
+      set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
+      if(APPLE)
+        list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
+          -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
+          -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
+          -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
+      endif()
+
+      SET(revision_tag 3171a94e16ba9bfee137)
+      IF(${proj}_REVISION_TAG)
+        SET(revision_tag ${${proj}_REVISION_TAG})
+      ENDIF()
+
+      ExternalProject_Add(${proj}
+        SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
+        BINARY_DIR ${proj}-build
+        PREFIX ${proj}${ep_suffix}
+        GIT_REPOSITORY "${git_protocol}://github.com/commontk/PythonQt.git"
+        GIT_TAG ${revision_tag}
+        CMAKE_GENERATOR ${gen}
+        UPDATE_COMMAND ""
+        BUILD_COMMAND ""
+        CMAKE_CACHE_ARGS
+          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+          -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
+          #-DCMAKE_C_FLAGS:STRING=${ep_common_c_flags} # Not used
+          -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
+          ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
+          -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
+          -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
+          -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
+          ${ep_PythonQt_args}
+        DEPENDS
+          ${proj_DEPENDENCIES}
+        )
+      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}")
     ENDIF()
 
-    ExternalProject_Add(${proj}
-      SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
-      BINARY_DIR ${proj}-build
-      PREFIX ${proj}${ep_suffix}
-      GIT_REPOSITORY "${git_protocol}://github.com/commontk/PythonQt.git"
-      GIT_TAG ${revision_tag}
-      CMAKE_GENERATOR ${gen}
-      UPDATE_COMMAND ""
-      BUILD_COMMAND ""
-      CMAKE_CACHE_ARGS
-        -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-        -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
-        #-DCMAKE_C_FLAGS:STRING=${ep_common_c_flags} # Not used
-        -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
-        ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
-        -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
-        -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
-        -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
-        ${ep_PythonQt_args}
-      DEPENDS
-        ${proj_DEPENDENCIES}
+    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
       )
-    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}")
   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
-    )
-
-  SET(${PythonQt_enabling_variable}_INCLUDE_DIRS PYTHONQT_INCLUDE_DIR PYTHON_INCLUDE_DIRS)
-  SET(${PythonQt_enabling_variable}_FIND_PACKAGE_CMD PythonQt)
 ENDIF()

CMakeExternals/PythonQtGenerator.cmake

@@ -2,7 +2,6 @@
 # PythonQtGenerator
 #
 
-SET(PythonQtGenerator_DEPENDS)
 IF(CTK_WRAP_PYTHONQT_FULL)
 
   # Sanity checks
@@ -10,87 +9,95 @@ IF(CTK_WRAP_PYTHONQT_FULL)
     MESSAGE(FATAL_ERROR "PYTHONQTGENERATOR_EXECUTABLE variable is defined but corresponds to non-existing executable")
   ENDIF()
 
-  IF(NOT DEFINED PYTHONQTGENERATOR_EXECUTABLE)
-    # Set CMake OSX variable to pass down the external project
-    set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
-    if(APPLE)
-      list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
-        -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
-        -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
-        -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
-    endif()
-
-    #
-    # PythonQtGenerator is the tool allowing to generate the PythonQt decorators using
-    # typesystem xml files. If called without any option, it will generate the bindings for Qt.
-    #
-    # See http://www.pyside.org/docs/apiextractor/typesystem.html
-    # See http://doc.trolltech.com/qtjambi-4.5.2_01/com/trolltech/qt/qtjambi-typesystem.html
-    # See http://qt.gitorious.org/qt-labs/qtscriptgenerator
-    #
-    SET(proj PythonQtGenerator)
-  #   MESSAGE(STATUS "Adding project:${proj}")
-    SET(PythonQtGenerator_DEPENDS ${proj})
-
-    #
-    # If directory PythonQt already exists, the corresponding project will
-    # be cloned. Since PythonQt and PythonQtGenerator source code are hosted
-    # on the same repository, we will assume that if the directory PythonQt
-    # exists, the generator code will also be available.
-    #
-    IF(EXISTS ${CMAKE_BINARY_DIR}/PythonQt)
-      #MESSAGE(STATUS "ExternalProject/PythonQtGenerator: PythonQt already added as ExternalProject")
-      ExternalProject_Add(${proj}
-        SOURCE_DIR ${CMAKE_BINARY_DIR}/PythonQt/generator
-        BINARY_DIR ${proj}-build
-        PREFIX ${proj}${ep_suffix}
-        DOWNLOAD_COMMAND ""
-        CMAKE_GENERATOR ${gen}
-        INSTALL_COMMAND ""
-        CMAKE_CACHE_ARGS
-          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-          -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
-          -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
-          -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
-          ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
-          -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
-        DEPENDS
-          "PythonQt" # To make sure the generator code is checked out, let's depend on PythonQt
-        )
-    ELSE()
-
-      SET(revision_tag 3171a94e16ba9bfee137)
-      IF(${proj}_REVISION_TAG)
-        SET(revision_tag ${${proj}_REVISION_TAG})
+  SET(proj PythonQtGenerator)
+  SET(proj_DEPENDENCIES)
+
+  LIST(APPEND CTK_DEPENDENCIES ${proj})
+
+  IF(CTK_SUPERBUILD)
+
+    IF(NOT DEFINED PYTHONQTGENERATOR_EXECUTABLE)
+      # Set CMake OSX variable to pass down the external project
+      set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
+      if(APPLE)
+        list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
+          -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
+          -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
+          -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
+      endif()
+
+      #
+      # PythonQtGenerator is the tool allowing to generate the PythonQt decorators using
+      # typesystem xml files. If called without any option, it will generate the bindings for Qt.
+      #
+      # See http://www.pyside.org/docs/apiextractor/typesystem.html
+      # See http://doc.trolltech.com/qtjambi-4.5.2_01/com/trolltech/qt/qtjambi-typesystem.html
+      # See http://qt.gitorious.org/qt-labs/qtscriptgenerator
+      #
+
+    #   MESSAGE(STATUS "Adding project:${proj}")
+
+      #
+      # If directory PythonQt already exists, the corresponding project will
+      # be cloned. Since PythonQt and PythonQtGenerator source code are hosted
+      # on the same repository, we will assume that if the directory PythonQt
+      # exists, the generator code will also be available.
+      #
+      IF(EXISTS ${CMAKE_BINARY_DIR}/PythonQt)
+        #MESSAGE(STATUS "ExternalProject/PythonQtGenerator: PythonQt already added as ExternalProject")
+        ExternalProject_Add(${proj}
+          SOURCE_DIR ${CMAKE_BINARY_DIR}/PythonQt/generator
+          BINARY_DIR ${proj}-build
+          PREFIX ${proj}${ep_suffix}
+          DOWNLOAD_COMMAND ""
+          CMAKE_GENERATOR ${gen}
+          INSTALL_COMMAND ""
+          CMAKE_CACHE_ARGS
+            -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+            -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
+            -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
+            -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
+            ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
+            -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
+          DEPENDS
+            "PythonQt" # To make sure the generator code is checked out, let's depend on PythonQt
+          )
+      ELSE()
+
+        SET(revision_tag 3171a94e16ba9bfee137)
+        IF(${proj}_REVISION_TAG)
+          SET(revision_tag ${${proj}_REVISION_TAG})
+        ENDIF()
+
+        #MESSAGE(STATUS "ExternalProject/PythonQtGenerator: PythonQt is NOT an ExternalProject")
+        ExternalProject_Add(${proj}
+          SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
+          BINARY_DIR ${proj}-build
+          PREFIX ${proj}${ep_suffix}
+          GIT_REPOSITORY "${git_protocol}://github.com/commontk/PythonQt.git"
+          GIT_TAG 3171a94e16ba9bfee137
+          CMAKE_GENERATOR ${gen}
+          UPDATE_COMMAND ""
+          INSTALL_COMMAND ""
+          CMAKE_CACHE_ARGS
+            -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+            -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
+            -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
+            -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
+            ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
+            -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
+          )
       ENDIF()
 
-      #MESSAGE(STATUS "ExternalProject/PythonQtGenerator: PythonQt is NOT an ExternalProject")
-      ExternalProject_Add(${proj}
-        SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
-        BINARY_DIR ${proj}-build
-        PREFIX ${proj}${ep_suffix}
-        GIT_REPOSITORY "${git_protocol}://github.com/commontk/PythonQt.git"
-        GIT_TAG 3171a94e16ba9bfee137
-        CMAKE_GENERATOR ${gen}
-        UPDATE_COMMAND ""
-        INSTALL_COMMAND ""
-        CMAKE_CACHE_ARGS
-          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-          -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
-          -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
-          -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
-          ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
-          -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
-        )
-    ENDIF()
+      SET(PYTHONQTGENERATOR_EXECUTABLE ${CMAKE_BINARY_DIR}/PythonQtGenerator-build/PythonQtGenerator)
 
-    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
 
-    # Since PythonQtGenerator is an executable, there is no need to add its corresponding
-    # library output directory to CTK_EXTERNAL_LIBRARY_DIRS
+    ENDIF()
 
-  ENDIF()
+    LIST(APPEND CTK_SUPERBUILD_EP_VARS PYTHONQTGENERATOR_EXECUTABLE:FILEPATH)
 
-  LIST(APPEND CTK_SUPERBUILD_EP_VARS PYTHONQTGENERATOR_EXECUTABLE:FILEPATH)
+  ENDIF()
 
 ENDIF()

CMakeExternals/QtSOAP.cmake

@@ -2,7 +2,6 @@
 # QtSOAP
 #
 
-SET(QtSOAP_DEPENDS)
 ctkMacroShouldAddExternalProject(QtSOAP_LIBRARIES add_project)
 IF(${add_project})
 
@@ -16,58 +15,62 @@ IF(${add_project})
   SET(proj QtSOAP)
   SET(proj_DEPENDENCIES)
 
-  SET(QtSOAP_DEPENDS ${proj})
+  LIST(APPEND CTK_DEPENDENCIES ${proj})
 
-  IF(NOT DEFINED QtSOAP_DIR)
+  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(revision_tag 6bf1b8c8)
-    IF(${proj}_REVISION_TAG)
-      SET(revision_tag ${${proj}_REVISION_TAG})
-    ENDIF()
+  IF(CTK_SUPERBUILD)
 
-    # Set CMake OSX variable to pass down the external project
-    set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
-    if(APPLE)
-      list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
-        -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
-        -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
-        -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
-    endif()
-
-    #     MESSAGE(STATUS "Adding project:${proj}")
-    ExternalProject_Add(${proj}
-      SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
-      BINARY_DIR ${proj}-build
-      PREFIX ${proj}${ep_suffix}
-      GIT_REPOSITORY "${git_protocol}://github.com/commontk/QtSOAP.git"
-      GIT_TAG ${revision_tag}
-      CMAKE_GENERATOR ${gen}
-      UPDATE_COMMAND ""
-      INSTALL_COMMAND ""
-      CMAKE_CACHE_ARGS
-        -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-        -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
-        -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
-        -DCMAKE_RUNTIME_OUTPUT_DIRECTORY:STRING=${CTK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}
-        -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
-        ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
-        -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
-      DEPENDS
-        ${proj_DEPENDENCIES}
-      )
-    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}")
-  ENDIF()
+    IF(NOT DEFINED QtSOAP_DIR)
 
-  LIST(APPEND CTK_SUPERBUILD_EP_VARS QtSOAP_DIR:PATH)
+      SET(revision_tag 6bf1b8c8)
+      IF(${proj}_REVISION_TAG)
+        SET(revision_tag ${${proj}_REVISION_TAG})
+      ENDIF()
 
-  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 CMake OSX variable to pass down the external project
+      set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
+      if(APPLE)
+        list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
+          -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
+          -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
+          -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
+      endif()
+
+      #     MESSAGE(STATUS "Adding project:${proj}")
+      ExternalProject_Add(${proj}
+        SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
+        BINARY_DIR ${proj}-build
+        PREFIX ${proj}${ep_suffix}
+        GIT_REPOSITORY "${git_protocol}://github.com/commontk/QtSOAP.git"
+        GIT_TAG ${revision_tag}
+        CMAKE_GENERATOR ${gen}
+        UPDATE_COMMAND ""
+        INSTALL_COMMAND ""
+        CMAKE_CACHE_ARGS
+          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+          -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
+          -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
+          -DCMAKE_RUNTIME_OUTPUT_DIRECTORY:STRING=${CTK_CMAKE_RUNTIME_OUTPUT_DIRECTORY}
+          -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
+          ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
+          -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
+        DEPENDS
+          ${proj_DEPENDENCIES}
+        )
+      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}")
+    ENDIF()
+
+    LIST(APPEND CTK_SUPERBUILD_EP_VARS QtSOAP_DIR:PATH)
+
+  ENDIF()
 
 ENDIF()

CMakeExternals/VTK.cmake

@@ -1,7 +1,7 @@
 #
 # VTK
 #
-SET (VTK_DEPENDS)
+
 ctkMacroShouldAddExternalProject(VTK_LIBRARIES add_project)
 IF(${add_project} OR CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK)
   # Sanity checks
@@ -11,85 +11,90 @@ IF(${add_project} OR CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK)
 
   SET(VTK_enabling_variable VTK_LIBRARIES)
 
-  SET(additional_vtk_cmakevars )
-  IF(MINGW)
-    LIST(APPEND additional_vtk_cmakevars -DCMAKE_USE_PTHREADS:BOOL=OFF)
-  ENDIF()
-
-  IF(CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK)
-    LIST(APPEND additional_vtk_cmakevars
-      -DPYTHON_EXECUTABLE:PATH=${PYTHON_EXECUTABLE}
-      -DPYTHON_LIBRARIES:FILEPATH=${PYTHON_LIBRARIES}
-      -DPYTHON_DEBUG_LIBRARIES:FILEPATH=${PYTHON_DEBUG_LIBRARIES}
-      )
-  ENDIF()
-
   SET(proj VTK)
   SET(proj_DEPENDENCIES)
 
-  SET(VTK_DEPENDS ${proj})
+  LIST(APPEND CTK_DEPENDENCIES ${proj})
+
+  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)
 
-  IF(NOT DEFINED VTK_DIR)
+  IF(CTK_SUPERBUILD)
 
-    SET(revision_tag 4b419e67427e974b51ea0812bae25b174426a2ff)
-    IF(${proj}_REVISION_TAG)
-      SET(revision_tag ${${proj}_REVISION_TAG})
+    SET(additional_vtk_cmakevars )
+    IF(MINGW)
+      LIST(APPEND additional_vtk_cmakevars -DCMAKE_USE_PTHREADS:BOOL=OFF)
     ENDIF()
 
-    # Set CMake OSX variable to pass down the external project
-    set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
-    if(APPLE)
-      list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
-        -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
-        -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
-        -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
-    endif()
-
-#     MESSAGE(STATUS "Adding project:${proj}")
-    ExternalProject_Add(${proj}
-      SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
-      BINARY_DIR ${proj}-build
-      PREFIX ${proj}${ep_suffix}
-      GIT_REPOSITORY ${git_protocol}://vtk.org/VTK.git
-      GIT_TAG ${revision_tag}
-      UPDATE_COMMAND ""
-      INSTALL_COMMAND ""
-      CMAKE_GENERATOR ${gen}
-      CMAKE_CACHE_ARGS
-        -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-        -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
-        -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
-        -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
-        ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
-        -DBUILD_TESTING:BOOL=OFF
-        ${additional_vtk_cmakevars}
-        -DVTK_WRAP_TCL:BOOL=OFF
-        -DVTK_USE_TK:BOOL=OFF
-        -DVTK_WRAP_PYTHON:BOOL=${CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK}
-        -DVTK_WRAP_JAVA:BOOL=OFF
-        -DBUILD_SHARED_LIBS:BOOL=ON
-        -DDESIRED_QT_VERSION:STRING=4
-        -DVTK_USE_GUISUPPORT:BOOL=ON
-        -DVTK_USE_QVTK_QTOPENGL:BOOL=ON
-        -DVTK_USE_QT:BOOL=ON
-        -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
-      DEPENDS
-        ${proj_DEPENDENCIES}
-      )
-    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}")
-  ENDIF()
+    IF(CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK)
+      LIST(APPEND additional_vtk_cmakevars
+        -DPYTHON_EXECUTABLE:PATH=${PYTHON_EXECUTABLE}
+        -DPYTHON_LIBRARIES:FILEPATH=${PYTHON_LIBRARIES}
+        -DPYTHON_DEBUG_LIBRARIES:FILEPATH=${PYTHON_DEBUG_LIBRARIES}
+        )
+    ENDIF()
 
-  LIST(APPEND CTK_SUPERBUILD_EP_VARS VTK_DIR:PATH)
+    IF(NOT DEFINED VTK_DIR)
+
+      SET(revision_tag 4b419e67427e974b51ea0812bae25b174426a2ff)
+      IF(${proj}_REVISION_TAG)
+        SET(revision_tag ${${proj}_REVISION_TAG})
+      ENDIF()
+
+      # Set CMake OSX variable to pass down the external project
+      set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
+      if(APPLE)
+        list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
+          -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
+          -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
+          -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
+      endif()
+
+  #     MESSAGE(STATUS "Adding project:${proj}")
+      ExternalProject_Add(${proj}
+        SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
+        BINARY_DIR ${proj}-build
+        PREFIX ${proj}${ep_suffix}
+        GIT_REPOSITORY ${git_protocol}://vtk.org/VTK.git
+        GIT_TAG ${revision_tag}
+        UPDATE_COMMAND ""
+        INSTALL_COMMAND ""
+        CMAKE_GENERATOR ${gen}
+        CMAKE_CACHE_ARGS
+          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+          -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
+          -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
+          -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
+          ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
+          -DBUILD_TESTING:BOOL=OFF
+          ${additional_vtk_cmakevars}
+          -DVTK_WRAP_TCL:BOOL=OFF
+          -DVTK_USE_TK:BOOL=OFF
+          -DVTK_WRAP_PYTHON:BOOL=${CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK}
+          -DVTK_WRAP_JAVA:BOOL=OFF
+          -DBUILD_SHARED_LIBS:BOOL=ON
+          -DDESIRED_QT_VERSION:STRING=4
+          -DVTK_USE_GUISUPPORT:BOOL=ON
+          -DVTK_USE_QVTK_QTOPENGL:BOOL=ON
+          -DVTK_USE_QT:BOOL=ON
+          -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
+        DEPENDS
+          ${proj_DEPENDENCIES}
+        )
+      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}")
+    ENDIF()
+
+    LIST(APPEND CTK_SUPERBUILD_EP_VARS VTK_DIR:PATH)
+
+  ENDIF()
 
-  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)
 ENDIF()
 

CMakeExternals/XIP.cmake

@@ -1,7 +1,7 @@
 #
 # XIP
 #
-SET (XIP_DEPENDS)
+
 ctkMacroShouldAddExternalProject(XIP_LIBRARIES add_project)
 IF(${add_project})
   # Sanity checks
@@ -14,47 +14,51 @@ IF(${add_project})
   SET(proj XIP)
   SET(proj_DEPENDENCIES)
 
-  SET(XIP_DEPENDS ${proj})
-
-  IF(NOT DEFINED XIP_DIR)
-    # Set CMake OSX variable to pass down the external project
-    set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
-    if(APPLE)
-      list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
-        -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
-        -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
-        -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
-    endif()
-
-    #   MESSAGE(STATUS "Adding project:${proj}")
-    ExternalProject_Add(${proj}
-      SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
-      BINARY_DIR ${proj}-build
-      PREFIX ${proj}${ep_suffix}
-      SVN_REPOSITORY "https://collab01a.scr.siemens.com/svn/xip/releases/latest"
-      SVN_USERNAME "anonymous"
-      INSTALL_COMMAND ""
-      CMAKE_GENERATOR ${gen}
-      CMAKE_CACHE_ARGS
-        -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-        -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
-        -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
-        -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
-        ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
-        -DBUILD_TESTING:BOOL=OFF
-        -DHAS_VTK:BOOL=OFF
-        -DHAS_ITK:BOOL=OFF
-      )
-    SET(XIP_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
-
-  ELSE()
-    ctkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
-  ENDIF()
-
-  LIST(APPEND CTK_SUPERBUILD_EP_VARS XIP_DIR:PATH)
+  LIST(APPEND CTK_DEPENDENCIES ${proj})
 
   SET(${XIP_enabling_variable}_INCLUDE_DIRS XIP_LIBRARY_DIRS)
   SET(${XIP_enabling_variable}_INCLUDE_DIRS XIP_INCLUDE_DIRS)
   SET(${XIP_enabling_variable}_FIND_PACKAGE_CMD XIP)
 
+  IF(CTK_SUPERBUILD)
+
+    IF(NOT DEFINED XIP_DIR)
+      # Set CMake OSX variable to pass down the external project
+      set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
+      if(APPLE)
+        list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
+          -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
+          -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
+          -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
+      endif()
+
+      #   MESSAGE(STATUS "Adding project:${proj}")
+      ExternalProject_Add(${proj}
+        SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
+        BINARY_DIR ${proj}-build
+        PREFIX ${proj}${ep_suffix}
+        SVN_REPOSITORY "https://collab01a.scr.siemens.com/svn/xip/releases/latest"
+        SVN_USERNAME "anonymous"
+        INSTALL_COMMAND ""
+        CMAKE_GENERATOR ${gen}
+        CMAKE_CACHE_ARGS
+          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+          -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
+          -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
+          -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
+          ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
+          -DBUILD_TESTING:BOOL=OFF
+          -DHAS_VTK:BOOL=OFF
+          -DHAS_ITK:BOOL=OFF
+        )
+      SET(XIP_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
+
+    ELSE()
+      ctkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
+    ENDIF()
+
+    LIST(APPEND CTK_SUPERBUILD_EP_VARS XIP_DIR:PATH)
+
+  ENDIF()
+
 ENDIF()

CMakeExternals/ZMQ.cmake

@@ -1,7 +1,7 @@
 #
 # ZMQ
 #
-SET(ZMQ_DEPENDS)
+
 ctkMacroShouldAddExternalProject(ZMQ_LIBRARIES add_project)
 IF(${add_project})
 
@@ -15,56 +15,61 @@ IF(${add_project})
   SET(proj ZMQ)
   SET(proj_DEPENDENCIES)
 
-  SET(ZMQ_DEPENDS ${proj})
+  LIST(APPEND CTK_DEPENDENCIES ${proj})
 
-  IF(NOT DEFINED ZMQ_DIR)
+  SET(${ZMQ_enabling_variable}_INCLUDE_DIRS ZMQ_LIBRARY_DIRS)
+  SET(${ZMQ_enabling_variable}_INCLUDE_DIRS ZMQ_INCLUDE_DIRS)
+  SET(${ZMQ_enabling_variable}_FIND_PACKAGE_CMD ZMQ)
 
-    SET(revision_tag d2c2f96b49ed3835a47e)
-    IF(${proj}_REVISION_TAG)
-      SET(revision_tag ${${proj}_REVISION_TAG})
-    ENDIF()
+  IF(CTK_SUPERBUILD)
 
-    # Set CMake OSX variable to pass down the external project
-    set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
-    if(APPLE)
-      list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
-        -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
-        -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
-        -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
-    endif()
+    IF(NOT DEFINED ZMQ_DIR)
 
-  #   MESSAGE(STATUS "Adding project:${proj}")
-    ExternalProject_Add(${proj}
-      SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
-      BINARY_DIR ${proj}-build
-      PREFIX ${proj}${ep_suffix}
-      GIT_REPOSITORY ${git_protocol}://github.com/PatrickCheng/zeromq2.git
-      GIT_TAG ${revision_tag}
-      UPDATE_COMMAND ""
-      INSTALL_COMMAND ""
-      CMAKE_GENERATOR ${gen}
-      CMAKE_CACHE_ARGS
-        -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-        -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
-        -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
-        -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
-        ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
-        -DBUILD_TESTING:BOOL=OFF
-        -DBUILD_SHARED_LIBS:BOOL=ON
-        -DZMQ_BUILD_DEVICES:BOOL=ON
-        -DZMQ_BUILD_PERFORMANCE_TESTS:BOOL=ON
-       DEPENDS
-        ${proj_DEPENDENCIES}
-      )
-    SET(ZMQ_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
+      SET(revision_tag d2c2f96b49ed3835a47e)
+      IF(${proj}_REVISION_TAG)
+        SET(revision_tag ${${proj}_REVISION_TAG})
+      ENDIF()
 
-  ELSE()
-    ctkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
-  ENDIF()
+      # Set CMake OSX variable to pass down the external project
+      set(CMAKE_OSX_EXTERNAL_PROJECT_ARGS)
+      if(APPLE)
+        list(APPEND CMAKE_OSX_EXTERNAL_PROJECT_ARGS
+          -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
+          -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
+          -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET})
+      endif()
 
-  LIST(APPEND CTK_SUPERBUILD_EP_VARS ZMQ_DIR:PATH)
+    #   MESSAGE(STATUS "Adding project:${proj}")
+      ExternalProject_Add(${proj}
+        SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
+        BINARY_DIR ${proj}-build
+        PREFIX ${proj}${ep_suffix}
+        GIT_REPOSITORY ${git_protocol}://github.com/PatrickCheng/zeromq2.git
+        GIT_TAG ${revision_tag}
+        UPDATE_COMMAND ""
+        INSTALL_COMMAND ""
+        CMAKE_GENERATOR ${gen}
+        CMAKE_CACHE_ARGS
+          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+          -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
+          -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
+          -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
+          ${CMAKE_OSX_EXTERNAL_PROJECT_ARGS}
+          -DBUILD_TESTING:BOOL=OFF
+          -DBUILD_SHARED_LIBS:BOOL=ON
+          -DZMQ_BUILD_DEVICES:BOOL=ON
+          -DZMQ_BUILD_PERFORMANCE_TESTS:BOOL=ON
+         DEPENDS
+          ${proj_DEPENDENCIES}
+        )
+      SET(ZMQ_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
+
+    ELSE()
+      ctkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
+    ENDIF()
+
+    LIST(APPEND CTK_SUPERBUILD_EP_VARS ZMQ_DIR:PATH)
+
+  ENDIF()
 
-  SET(${ZMQ_enabling_variable}_INCLUDE_DIRS ZMQ_LIBRARY_DIRS)
-  SET(${ZMQ_enabling_variable}_INCLUDE_DIRS ZMQ_INCLUDE_DIRS)
-  SET(${ZMQ_enabling_variable}_FIND_PACKAGE_CMD ZMQ)
 ENDIF()

CMakeLists.txt

@@ -589,6 +589,26 @@ CONFIGURE_FILE(${CTK_SOURCE_DIR}/CTestConfigSubProject.cmake.in
 ctkFunctionGenerateProjectXml(${CTK_BINARY_DIR} ${PROJECT_NAME} "${target_directories}" ${CTK_SUPERBUILD})
 
 #-----------------------------------------------------------------------------
+# CTK dependencies - Projects should be TOPOLOGICALLY ordered
+#-----------------------------------------------------------------------------
+SET(CTK_POSSIBLE_DEPENDENCIES
+  CTKData
+  Log4Qt
+  KWStyle
+  VTK
+  PythonQt
+  PythonQtGenerator # Should be added after PythonQt - See comment in CMakeExternals/PythonQtGenerator.cmake
+  DCMTK
+  ZMQ
+  QtSOAP
+  OpenIGTLink
+  XIP
+  ITK
+  )
+SET(CTK_DEPENDENCIES) # This variable will contain the list of required CTK dependencies
+INCLUDE(CMake/ctkBlockCheckDependencies.cmake)
+
+#-----------------------------------------------------------------------------
 # Superbuild script
 #
 
@@ -597,12 +617,6 @@ IF(CTK_SUPERBUILD)
   RETURN()
 ENDIF()
 
-
-#=============================================================================
-# End of Superbuild
-#=============================================================================
-
-
 #-----------------------------------------------------------------------------
 # Expand variables containing include and library directories for external projects
 # This relies on the variable EXTERNAL_TARGETS set in ctkMacroValidateBuildOptions
@@ -615,38 +629,30 @@ ENDFOREACH()
 
 FOREACH(_external_target ${EXTERNAL_TARGETS})
   IF(${_external_target}_INCLUDE_DIRS)
-    STRING(REPLACE "^" ";" _include_variable_list "${${_external_target}_INCLUDE_DIRS}")
-    IF(_include_variable_list)
-      #MESSAGE("[${_external_target}] Resolving include variables: ${${_external_target}_INCLUDE_DIRS}")
-      SET(${_external_target}_INCLUDE_DIRS "")
-      FOREACH(_include_variable ${_include_variable_list})
-        #MESSAGE("[${_external_target}] Appending ${${_include_variable}}")
-        IF(${_include_variable})
-          LIST(APPEND ${_external_target}_INCLUDE_DIRS ${${_include_variable}})
-        ELSE()
-          LIST(APPEND ${_external_target}_INCLUDE_DIRS ${_include_variable})
-        ENDIF()
-        #MESSAGE("[${_external_target}] New dirs: ${${_external_target}_INCLUDE_DIRS}")
-      ENDFOREACH()
-      #MESSAGE("[${_external_target}] Appended dirs: ${${_external_target}_INCLUDE_DIRS}")
-    ENDIF()
+    #MESSAGE("[${_external_target}] Resolving include variables: ${${_external_target}_INCLUDE_DIRS}")
+    FOREACH(_include_variable ${${_external_target}_INCLUDE_DIRS})
+      #MESSAGE("[${_external_target}] Appending ${${_include_variable}}")
+      IF(${_include_variable})
+        LIST(APPEND ${_external_target}_INCLUDE_DIRS ${${_include_variable}})
+      ELSE()
+        LIST(APPEND ${_external_target}_INCLUDE_DIRS ${_include_variable})
+      ENDIF()
+      #MESSAGE("[${_external_target}] New dirs: ${${_external_target}_INCLUDE_DIRS}")
+    ENDFOREACH()
+    #MESSAGE("[${_external_target}] Appended dirs: ${${_external_target}_INCLUDE_DIRS}")
   ENDIF()
   IF(${_external_target}_LIBRARY_DIRS)
-    STRING(REPLACE "^" ";" _library_variable_list "${${_external_target}_LIBRARY_DIRS}")
-    IF(_library_variable_list)
-      #MESSAGE("[${_external_target}] Resolving library variables: ${${_external_target}_LIBRARY_DIRS}")
-      SET(${_external_target}_LIBRARY_DIRS "")
-      FOREACH(_library_variable ${_library_variable_list})
-        #MESSAGE("[${_external_target}] Appending ${${_library_variable}}")
-        IF(${_library_variable})
-          LIST(APPEND ${_external_target}_LIBRARY_DIRS ${${_library_variable}})
-        ELSE()
-          LIST(APPEND ${_external_target}_LIBRARY_DIRS ${_library_variable})
-        ENDIF()
-        #MESSAGE("[${_external_target}] New dirs: ${${_external_target}_LIBRARY_DIRS}")
-      ENDFOREACH()
-      #MESSAGE("[${_external_target}] Appended dirs: ${${_external_target}_LIBRARY_DIRS}")
-    ENDIF()
+    #MESSAGE("[${_external_target}] Resolving library variables: ${${_external_target}_LIBRARY_DIRS}")
+    FOREACH(_library_variable ${${_external_target}_LIBRARY_DIRS})
+      #MESSAGE("[${_external_target}] Appending ${${_library_variable}}")
+      IF(${_library_variable})
+        LIST(APPEND ${_external_target}_LIBRARY_DIRS ${${_library_variable}})
+      ELSE()
+        LIST(APPEND ${_external_target}_LIBRARY_DIRS ${_library_variable})
+      ENDIF()
+      #MESSAGE("[${_external_target}] New dirs: ${${_external_target}_LIBRARY_DIRS}")
+    ENDFOREACH()
+    #MESSAGE("[${_external_target}] Appended dirs: ${${_external_target}_LIBRARY_DIRS}")
   ENDIF()
 ENDFOREACH()
 

SuperBuild.cmake

@@ -18,24 +18,6 @@
 #
 ###########################################################################
 
-#-----------------------------------------------------------------------------
-# ExternalProjects - Project should be topologically ordered
-#-----------------------------------------------------------------------------
-SET(external_projects
-  CTKData
-  Log4Qt
-  KWStyle
-  VTK
-  PythonQt
-  PythonQtGenerator # Should be added after PythonQt - See comment in CMakeExternals/PythonQtGenerator.cmake
-  DCMTK
-  ZMQ
-  QtSOAP
-  qxmlrpc
-  OpenIGTLink
-  XIP
-  ITK
-  )
 
 #-----------------------------------------------------------------------------
 # WARNING - No change should be required after this comment
@@ -58,59 +40,6 @@ IF(NOT EXISTS ${CTK_BINARY_DIR}/CTK-build/bin)
 ENDIF()
 
 #-----------------------------------------------------------------------------
-# Git protocole option
-#
-option(CTK_USE_GIT_PROTOCOL "If behind a firewall turn this OFF to use http instead." ON)
-
-set(git_protocol "git")
-if(NOT CTK_USE_GIT_PROTOCOL)
-  set(git_protocol "http")
-endif()
-
-#-----------------------------------------------------------------------------
-# Enable and setup External project global properties
-#
-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")
-
-set(ep_common_c_flags "${CMAKE_C_FLAGS_INIT} ${ADDITIONAL_C_FLAGS}")
-set(ep_common_cxx_flags "${CMAKE_CXX_FLAGS_INIT} ${ADDITIONAL_CXX_FLAGS}")
-
-# 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 "^^")
-
-#-----------------------------------------------------------------------------
-# Collect CTK library target dependencies
-#
-
-ctkMacroCollectAllTargetLibraries("${CTK_LIBS_SUBDIRS}" "Libs" ALL_TARGET_LIBRARIES)
-ctkMacroCollectAllTargetLibraries("${CTK_PLUGINS_SUBDIRS}" "Plugins" ALL_TARGET_LIBRARIES)
-ctkMacroCollectAllTargetLibraries("${CTK_APPLICATIONS_SUBDIRS}" "Applications" ALL_TARGET_LIBRARIES)
-#MESSAGE(STATUS ALL_TARGET_LIBRARIES:${ALL_TARGET_LIBRARIES})
-
-#-----------------------------------------------------------------------------
-# Initialize NON_CTK_DEPENDENCIES variable
-#
-# 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
-ctkMacroGetAllNonProjectTargetLibraries("${ALL_TARGET_LIBRARIES}" NON_CTK_DEPENDENCIES)
-#MESSAGE(STATUS NON_CTK_DEPENDENCIES:${NON_CTK_DEPENDENCIES})
-
-#-----------------------------------------------------------------------------
 # Qt is expected to be setup by CTK/CMakeLists.txt just before it includes the SuperBuild script
 #
 
@@ -120,53 +49,6 @@ ctkMacroGetAllNonProjectTargetLibraries("${ALL_TARGET_LIBRARIES}" NON_CTK_DEPEND
 FIND_PACKAGE(Doxygen QUIET)
 
 #-----------------------------------------------------------------------------
-# Include external projects
-#
-
-SET(CTK_SUPERBUILD_EP_ARGS)
-
-# 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)
-
-# This variable will contain the list of external project that CTK depends on.
-SET(CTK_DEPENDS)
-
-SET(dependency_args )
-FOREACH(p ${external_projects})
-  INCLUDE(CMakeExternals/${p}.cmake)
-  IF(${p}_enabling_variable)
-    # Provides the include and library directories either directly or provides the variable name
-    # used by the corresponding Find<package>.cmake files.
-    # The top-level CMakeLists.txt file will expand the variable names if not in
-    # superbuild mode. The include and library dirs are then used in
-    # ctkMacroBuildApp, ctkMacroBuildLib, and ctkMacroBuildPlugin
-    STRING(REPLACE ";" "^" _include_dirs "${${${p}_enabling_variable}_INCLUDE_DIRS}")
-    LIST(APPEND dependency_args
-         -D${${p}_enabling_variable}_INCLUDE_DIRS:STRING=${_include_dirs})
-    STRING(REPLACE ";" "^" _library_dirs "${${${p}_enabling_variable}_LIBRARY_DIRS}")
-    LIST(APPEND dependency_args
-         -D${${p}_enabling_variable}_LIBRARY_DIRS:STRING=${_library_dirs})
-    IF(${${p}_enabling_variable}_FIND_PACKAGE_CMD)
-      LIST(APPEND dependency_args
-           -D${${p}_enabling_variable}_FIND_PACKAGE_CMD:STRING=${${${p}_enabling_variable}_FIND_PACKAGE_CMD})
-    ENDIF()
-  ENDIF()
-  LIST(APPEND CTK_DEPENDS ${${p}_DEPENDS})
-ENDFOREACH()
-
-#MESSAGE("Superbuild args: ${dependency_args}")
-
-# MESSAGE("CTK_DEPENDS:")
-# FOREACH(dep ${CTK_DEPENDS})
-#   MESSAGE("  ${dep}")
-# ENDFOREACH()
-
-#-----------------------------------------------------------------------------
 # Generate cmake variable name corresponding to Libs, Plugins and Applications
 #
 SET(ctk_libs_bool_vars)
@@ -216,6 +98,7 @@ 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})
@@ -273,13 +156,12 @@ ExternalProject_Add(${proj}
     -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
     ${CTK_SUPERBUILD_EP_ARGS}
     -DCTK_SUPERBUILD_EP_VARNAMES:STRING=${CTK_SUPERBUILD_EP_VARNAMES}
-    ${dependency_args}
   SOURCE_DIR ${CTK_SOURCE_DIR}
   BINARY_DIR ${CTK_BINARY_DIR}/CTK-build
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
   DEPENDS
-    ${CTK_DEPENDS}
+    ${CTK_DEPENDENCIES}
   )
 
 IF(CMAKE_GENERATOR MATCHES ".*Makefiles.*")