Added functions for checking out repos at configure time for issue commontk#266.

For now, the repositories ExternalProjectsContrib and PluginsContrib
are checked out during the super build if CTK_USE_CONTRIBUTED_PLUGINS
is ON. Providing a _DIR variable disables the checkout and makes the
build system use the repositories pointed to by the _DIR variable.

Things to do:

 - Use a VCS agnostic way of providing checkout information
 - Use some kind of configuration file (CMake initial cache file?) to
   add a configurable amount of external repositories to the CTK build
   system.

Author: saschazelzer

CMake/ctkBlockCheckDependencies.cmake

@@ -87,7 +87,11 @@ 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)
+  if(${p}_FILEPATH)
+    include(${${p}_FILEPATH})
+  else()
+    include(CMakeExternals/${p}.cmake)
+  endif()
 endforeach()
 
 #message("CTK_POSSIBLE_DEPENDENCIES:")

CMake/ctkCheckoutRepo.cmake.in

@@ -0,0 +1,19 @@
+
+project(${_NAME})
+
+cmake_minimum_required(VERSION 2.8.4)
+
+include(ExternalProject)
+
+ExternalProject_Add(${_NAME}
+        SOURCE_DIR ${_CHECKOUT_DIR}/${_NAME}
+        BINARY_DIR bin
+        PREFIX ep
+        GIT_REPOSITORY ${_GIT_PROTOCOL}://${_GIT_URL}
+        GIT_TAG ${_GIT_TAG}
+        UPDATE_COMMAND ""
+        CONFIGURE_COMMAND ""
+        BUILD_COMMAND ""
+        INSTALL_COMMAND ""
+        )
+  

CMake/ctkFunctionAddPluginRepo.cmake

@@ -0,0 +1,52 @@
+function(ctkFunctionAddPluginRepo)
+
+  ctkMacroParseArguments("" "NAME;GIT_URL;GIT_TAG;GIT_PROTOCOL" "" ${ARGN})
+  
+  foreach(_required_arg NAME GIT_URL)
+    if(NOT _${_required_arg})
+      message(FATAL_ERROR "${_required_arg} is empty")
+    endif()
+  endforeach()
+  
+  ctkFunctionCheckoutRepo(
+    NAME ${_NAME}
+    GIT_URL ${_GIT_URL}
+    GIT_TAG ${_GIT_TAG}
+    GIT_PROTOCOL ${_GIT_PROTOCOL}
+    )
+  
+  set(_gitmodules_files ${${_NAME}_DIR}/.gitmodules)
+  if(NOT EXISTS ${_gitmodules_files})
+    message(FATAL_ERROR "The repository at ${${_NAME}_DIR} does not contain a .gitmodules file")
+  endif()
+  
+  # Parse the .gitmodules file and add the submodules as contributed plugins
+  file(STRINGS "${_gitmodules_files}" _plugin_paths REGEX "path =.*")
+  foreach(_plugin_path ${_plugin_paths})
+    string(REPLACE " = " ";" _plugin_path_list ${_plugin_path})
+    list(GET _plugin_path_list 1 _plugin_name)
+    ctk_plugin_option(${_plugin_name} "Build the ${_plugin_name} plugin." OFF)
+    
+    # Push the value which might have been changed in ctk_plugin_option to the parent scope
+    set(CTK_PLUGIN_${_plugin_name} ${CTK_PLUGIN_${_plugin_name}} PARENT_SCOPE)
+    
+    set(${_plugin_name}_SOURCE_DIR ${${_NAME}_DIR}/${_plugin_name})
+    set(${_plugin_name}_SOURCE_DIR ${${_plugin_name}_SOURCE_DIR} PARENT_SCOPE)
+    
+    if(CTK_PLUGIN_${_plugin_name} AND NOT EXISTS ${${_plugin_name}_SOURCE_DIR})
+      execute_process(
+        COMMAND ${GIT_EXECUTABLE} submodule update ${_plugin_name}
+        WORKING_DIRECTORY ${${_NAME}_DIR}
+        RESULT_VARIABLE return_code
+        ERROR_VARIABLE error_msg
+      )
+      if(return_code)
+        message(FATAL_ERROR "Could not invoke git submodule update for ${${_plugin_name}_SOURCE_DIR}")
+      endif()
+    endif()
+  endforeach()
+  
+  set(CTK_PLUGINS ${CTK_PLUGINS} PARENT_SCOPE)
+  set(${_NAME}_DIR ${${_NAME}_DIR} PARENT_SCOPE)
+
+endfunction()

CMake/ctkFunctionCheckoutRepo.cmake

@@ -0,0 +1,55 @@
+function(ctkFunctionCheckoutRepo)
+
+  ctkMacroParseArguments("" "NAME;GIT_URL;GIT_TAG;GIT_PROTOCOL;CHECKOUT_DIR" "" ${ARGN})
+
+  if(${_NAME}_DIR)
+    # if a *_DIR variable is supplied, the repository is not cloned.
+    return()
+  endif()
+
+  foreach(_required_arg NAME GIT_URL)
+    if(NOT _${_required_arg})
+      message(FATAL_ERROR "${_required_arg} is empty")
+    endif()
+  endforeach()
+  
+  if(NOT _GIT_PROTOCOL)
+    set(_GIT_PROTOCOL ${git_protocol})
+  endif()
+  if(NOT _CHECKOUT_DIR)
+    set(_CHECKOUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
+  endif()
+  if(NOT IS_ABSOLUTE "${_CHECKOUT_DIR}")
+    message(FATAL_ERROR "The value of the CHECKOUT_DIR argument must be an absolute path.")
+  endif()
+  
+  if(NOT _GIT_TAG)
+    set(_GIT_TAG origin/master)
+  endif()
+  
+  set(_repo_build_dir ${CMAKE_CURRENT_BINARY_DIR}/${_NAME}-proj)
+  configure_file(${CTK_CMAKE_DIR}/ctkCheckoutRepo.cmake.in
+                 ${_repo_build_dir}/CMakeLists.txt)
+
+  execute_process(
+    COMMAND ${CMAKE_COMMAND} .
+    WORKING_DIRECTORY ${_repo_build_dir}
+    RESULT_VARIABLE _result_code
+    ERROR_VARIABLE _err_msg
+    )
+  if(_result_code)
+    message(FATAL_ERROR "Configuring directory ${_repo_build_dir} failed: ${_err_msg}")
+  endif()
+  
+  execute_process(
+    COMMAND ${CMAKE_COMMAND} --build ${_repo_build_dir}
+    RESULT_VARIABLE _result_code
+    ERROR_VARIABLE _err_msg
+    )
+  if(_result_code)
+    message(FATAL_ERROR "Building directory ${_repo_build_dir} failed: ${_err_msg}")
+  endif()
+  
+  set(${_NAME}_DIR ${_CHECKOUT_DIR}/${_NAME} PARENT_SCOPE)
+
+endfunction()

CMake/ctkMacroTargetLibraries.cmake

@@ -173,7 +173,11 @@ macro(ctkMacroCollectAllTargetLibraries targets subdir varname)
     set(option_name ${option_prefix}${target})
     #message(STATUS option_name:${option_name})
 
-    set(target_dir "${CTK_SOURCE_DIR}/${subdir}/${target}")
+    if(${target}_SOURCE_DIR)
+      set(target_dir "${${target}_SOURCE_DIR}")
+    else()
+      set(target_dir "${CTK_SOURCE_DIR}/${subdir}/${target}")
+    endif()
     #message(STATUS target_dir:${target_dir})
 
     set(target_libraries)

CMakeLists.txt

@@ -197,7 +197,9 @@ include(CMake/ctkFunctionGenerateDGraphInput.cmake)
 include(CMake/ctkFunctionGenerateProjectXml.cmake)
 include(CMake/ctkFunctionGeneratePluginManifest.cmake)
 include(CMake/ctkMacroGeneratePluginResourceFile.cmake)
+include(CMake/ctkFunctionAddPluginRepo.cmake)
 include(CMake/ctkFunctionCheckCompilerFlags.cmake)
+include(CMake/ctkFunctionCheckoutRepo.cmake)
 include(CMake/ctkFunctionGetIncludeDirs.cmake)
 include(CMake/ctkFunctionGetLibraryDirs.cmake)
 include(CMake/ctkFunctionGetGccVersion.cmake)
@@ -630,6 +632,13 @@ ctk_plugin_option(org.commontk.eventbus
                   "Build the org.commontk.eventbus plugin." OFF
                   CTK_APP_ctkEventBusDemo)
 
+# 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)
+if(CTK_USE_CONTRIBUTED_PLUGINS)
+  ctkFunctionAddPluginRepo(NAME PluginsContrib GIT_URL github.com/commontk/PluginsContrib.git)
+endif()
+
 #-----------------------------------------------------------------------------
 # Generate target_directories list - List of directory corresponding to the different
 # libraries, plugins and applications associated with the corresponding option name.
@@ -663,7 +672,11 @@ foreach(lib ${CTK_LIBS})
 endforeach()
 
 foreach(plugin ${CTK_PLUGINS})
-  list(APPEND target_directories "${CMAKE_CURRENT_SOURCE_DIR}/Plugins/${plugin}^^CTK_PLUGIN_${plugin}")
+  if(${plugin}_SOURCE_DIR)
+    list(APPEND target_directories "${${plugin}_SOURCE_DIR}^^CTK_PLUGIN_${plugin}")
+  else()
+    list(APPEND target_directories "${CMAKE_CURRENT_SOURCE_DIR}/Plugins/${plugin}^^CTK_PLUGIN_${plugin}")
+  endif()
 endforeach()
 
 foreach(app ${CTK_APPS})
@@ -800,6 +813,25 @@ set(CTK_POSSIBLE_DEPENDENCIES
   XIP
   ITK
   )
+
+#-----------------------------------------------------------------------------
+# Check out the ExternalProjectsContrib repository
+if(CTK_USE_CONTRIBUTED_PLUGINS)
+  if(CTK_SUPERBUILD)
+    ctkFunctionCheckoutRepo(
+      NAME ExternalProjectsContrib
+      GIT_URL github.com/commontk/ExternalProjectsContrib.git
+      )
+  endif()
+
+  file(GLOB _contrib_scripts ${ExternalProjectsContrib_DIR}/*.cmake)
+  foreach(_contrib_script ${_contrib_scripts})
+    get_filename_component(_script_name ${_contrib_script} NAME_WE)
+    list(APPEND CTK_POSSIBLE_DEPENDENCIES ${_script_name})
+    set(${_script_name}_FILEPATH ${_contrib_script})
+  endforeach()
+endif()
+
 set(CTK_DEPENDENCIES) # This variable will contain the list of required CTK dependencies
 include(CMake/ctkBlockCheckDependencies.cmake)
 
@@ -914,7 +946,11 @@ endif()
 #
 foreach(plugin ${CTK_PLUGINS})
   if(CTK_PLUGIN_${plugin})
-    add_subdirectory(Plugins/${plugin})
+    if(${plugin}_SOURCE_DIR)
+      add_subdirectory(${${plugin}_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/Plugins/${plugin})
+    else()
+      add_subdirectory(Plugins/${plugin})
+    endif()
   endif()
 endforeach()
 

SuperBuild.cmake

@@ -79,6 +79,7 @@ set(ctk_cmake_boolean_args
   CTK_BUILD_QTDESIGNER_PLUGINS
   CTK_USE_QTTESTING
   CTK_USE_KWSTYLE
+  CTK_USE_CONTRIBUTED_PLUGINS
   WITH_COVERAGE
   DOCUMENTATION_TARGET_IN_ALL
   CTK_WRAP_PYTHONQT_FULL
@@ -156,6 +157,8 @@ ExternalProject_Add(${proj}
     -DCTK_INSTALL_INCLUDE_DIR:STRING=${CTK_INSTALL_INCLUDE_DIR}
     -DCTK_INSTALL_DOC_DIR:STRING=${CTK_INSTALL_DOC_DIR}
     -DCTK_EXTERNAL_LIBRARY_DIRS:STRING=${CTK_EXTERNAL_LIBRARY_DIRS}
+    -DExternalProjectsContrib_DIR:STRING=${ExternalProjectsContrib_DIR}
+    -DPluginsContrib_DIR:STRING=${PluginsContrib_DIR}
     -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
     ${CTK_SUPERBUILD_EP_ARGS}
     -DCTK_SUPERBUILD_EP_VARNAMES:STRING=${CTK_SUPERBUILD_EP_VARNAMES}