Add only needed include dirs.

CMake/ctkFunctionGenerateDGraphInput.cmake

@@ -78,8 +78,12 @@ FUNCTION(ctkFunctionGenerateDGraphInput dir target_directories)
       # Make sure the variable is cleared
       SET(ctk_dependencies)
 
-      # filter dependencies starting with CTK
-      ctkMacroGetAllCTKTargetLibraries("${dependencies}" ctk_dependencies)
+      IF(MY_WITH_EXTERNALS)
+        SET(ctk_dependencies ${dependencies})
+      ELSE()
+        # filter dependencies starting with CTK org org_commontk_
+        ctkMacroGetAllCTKTargetLibraries("${dependencies}" ctk_dependencies)
+      ENDIF()
 
       IF(ctk_dependencies)
         LIST(APPEND vertices ${target_project_name})
@@ -104,8 +108,10 @@ FUNCTION(ctkFunctionGenerateDGraphInput dir target_directories)
 
   SET(dgraph_list "${numberOfVertices} ${numberOfEdges}\n" ${dgraph_list})
 
-  IF(${with_option})
+  IF(MY_WITH_OPTION)
     SET(filename "${dir}/DGraphInput.txt")
+  ELSEIF(MY_WITH_EXTERNALS)
+    SET(filename "${dir}/DGraphInput-alldep-withext.txt")
   ELSE()
     SET(filename "${dir}/DGraphInput-alldep.txt")
   ENDIF()

CMake/ctkMacroBuildApp.cmake

@@ -57,13 +57,33 @@ MACRO(ctkMacroBuildApp)
   # --------------------------------------------------------------------------
   # Include dirs
   SET(my_includes
-    ${CTK_BASE_INCLUDE_DIRS}
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
     ${MY_INCLUDE_DIRECTORIES}
     )  
-  SET(CTK_BASE_INCLUDE_DIRS ${my_includes} CACHE INTERNAL "CTK includes" FORCE)
-  INCLUDE_DIRECTORIES(${CTK_BASE_INCLUDE_DIRS}) 
+
+  # Add the include directories from the library dependencies
+  # The variable ${lib_name}_DEPENDENCIES is set in the
+  # macro ctkMacroValidateBuildOptions
+  SET(ctk_deps )
+  SET(ext_deps )
+  ctkMacroGetAllCTKTargetLibraries("${${proj_name}_DEPENDENCIES}" ctk_deps)
+  ctkMacroGetAllNonCTKTargetLibraries("${${proj_name}_DEPENDENCIES}" ext_deps)
+
+  FOREACH(dep ${ctk_deps})
+    LIST(APPEND my_includes
+         ${${dep}_SOURCE_DIR}
+         ${${dep}_BINARY_DIR}
+         )
+  ENDFOREACH()
+
+  FOREACH(dep ${ext_deps})
+    LIST(APPEND my_includes ${${dep}_INCLUDE_DIRS})
+  ENDFOREACH()
+
+  LIST(REMOVE_DUPLICATES my_includes)
+
+  INCLUDE_DIRECTORIES(${my_includes})
 
 #   SET(MY_LIBRARY_EXPORT_DIRECTIVE ${MY_EXPORT_DIRECTIVE})
 #   SET(MY_EXPORT_HEADER_PREFIX ${MY_NAME})

CMake/ctkMacroBuildLib.cmake

@@ -47,15 +47,40 @@ MACRO(ctkMacroBuildLib)
   # --------------------------------------------------------------------------
   # Include dirs
   SET(my_includes
-    ${CTK_BASE_INCLUDE_DIRS}
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
     # with CMake >2.9, use QT4_MAKE_OUTPUT_FILE instead ?
     ${CMAKE_CURRENT_BINARY_DIR}/Resources/UI
     ${MY_INCLUDE_DIRECTORIES}
     )  
-  SET(CTK_BASE_INCLUDE_DIRS ${my_includes} CACHE INTERNAL "CTK includes" FORCE)
-  INCLUDE_DIRECTORIES(${CTK_BASE_INCLUDE_DIRS})
+
+  MESSAGE("setting up include dirs for ${lib_name}")
+
+  # Add the include directories from the library dependencies
+  # The variable ${lib_name}_DEPENDENCIES is set in the
+  # macro ctkMacroValidateBuildOptions
+  SET(ctk_deps )
+  SET(ext_deps )
+  ctkMacroGetAllCTKTargetLibraries("${${lib_name}_DEPENDENCIES}" ctk_deps)
+  ctkMacroGetAllNonCTKTargetLibraries("${${lib_name}_DEPENDENCIES}" ext_deps)
+
+  FOREACH(dep ${ctk_deps})
+    LIST(APPEND my_includes
+         ${${dep}_SOURCE_DIR}
+         ${${dep}_BINARY_DIR}
+         )
+  ENDFOREACH()
+
+  FOREACH(dep ${ext_deps})
+    LIST(APPEND my_includes ${${dep}_INCLUDE_DIRS})
+  ENDFOREACH()
+
+  LIST(REMOVE_DUPLICATES my_includes)
+
+  INCLUDE_DIRECTORIES(
+    ${my_includes}
+    )
+
 
   SET(MY_LIBRARY_EXPORT_DIRECTIVE ${MY_EXPORT_DIRECTIVE})
   SET(MY_EXPORT_HEADER_PREFIX ${MY_NAME})

CMake/ctkMacroBuildPlugin.cmake

@@ -90,7 +90,6 @@ MACRO(ctkMacroBuildPlugin)
   # --------------------------------------------------------------------------
   # Include dirs
   SET(my_includes
-    ${CTK_BASE_INCLUDE_DIRS}
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
     ${MY_INCLUDE_DIRECTORIES}
@@ -99,13 +98,24 @@ MACRO(ctkMacroBuildPlugin)
   # Add the include directories from the plugin dependencies
   # The variable ${lib_name}_DEPENDENCIES is set in the
   # macro ctkMacroValidateBuildOptions
-  FOREACH(dep ${${lib_name}_DEPENDENCIES})
+  SET(ctk_deps )
+  SET(ext_deps )
+  ctkMacroGetAllCTKTargetLibraries("${${lib_name}_DEPENDENCIES}" ctk_deps)
+  ctkMacroGetAllNonCTKTargetLibraries("${${lib_name}_DEPENDENCIES}" ext_deps)
+
+  FOREACH(dep ${ctk_deps})
+    MESSAGE("Adding ctk include path for ${dep}")
     LIST(APPEND my_includes
          ${${dep}_SOURCE_DIR}
          ${${dep}_BINARY_DIR}
          )
   ENDFOREACH()
 
+  FOREACH(dep ${ext_deps})
+MESSAGE("Adding ext include path for ${dep}: ${${dep}_INCLUDE_DIRS}")
+    LIST(APPEND my_includes ${${dep}_INCLUDE_DIRS})
+  ENDFOREACH()
+
   LIST(REMOVE_DUPLICATES my_includes)
 
   INCLUDE_DIRECTORIES(

CMake/ctkMacroTargetLibraries.cmake

@@ -183,9 +183,9 @@ MACRO(ctkMacroGetAllCTKTargetLibraries all_target_libraries varname)
   SET(re_ctkplugin "^org_commontk_[a-zA-Z0-9_]+$")
   SET(_tmp_list)
   LIST(APPEND _tmp_list ${all_target_libraries})
-  ctkMacroListFilter(_tmp_list re_ctklib OUTPUT_VARIABLE ${varname})
-  ctkMacroListFilter(_tmp_list re_ctkplugin)
-  LIST(APPEND ${varname} ${_tmp_list})
+  #MESSAGE("calling ctkMacroListFilter with varname:${varname}")
+  ctkMacroListFilter(_tmp_list re_ctklib re_ctkplugin OUTPUT_VARIABLE ${varname})
+  #MESSAGE(STATUS "getallctklibs from ${all_target_libraries}")
   #MESSAGE(STATUS varname:${varname}:${${varname}})
 ENDMACRO()
 
@@ -195,7 +195,7 @@ ENDMACRO()
 MACRO(ctkMacroGetAllNonCTKTargetLibraries all_target_libraries varname)
   ctkMacroGetAllCTKTargetLibraries("${all_target_libraries}" all_ctk_libraries)
   SET(_tmp_list ${all_target_libraries})
-  IF("${all_ctk_libraries}")
+  IF(all_ctk_libraries)
     LIST(REMOVE_ITEM _tmp_list ${all_ctk_libraries})
   ENDIF()
   SET(${varname} ${_tmp_list})

CMake/ctkMacroValidateBuildOptions.cmake

@@ -115,7 +115,7 @@ MACRO(ctkMacroValidateBuildOptions dir executable target_directories)
       # Obtain dependency path
       ctkMacroSetPaths("${QT_INSTALLED_LIBRARY_DIR}")
       EXECUTE_PROCESS(
-        COMMAND "${executable}" "${CTK_BINARY_DIR}/DGraphInput-alldep.txt" -sort ${target_project_name}
+        COMMAND "${executable}" "${CTK_BINARY_DIR}/DGraphInput-alldep-withext.txt" -sort ${target_project_name}
         WORKING_DIRECTORY ${CTK_BINARY_DIR}
         RESULT_VARIABLE RESULT_VAR
         OUTPUT_VARIABLE dep_path
@@ -139,8 +139,10 @@ MACRO(ctkMacroValidateBuildOptions dir executable target_directories)
 
       #MESSAGE("path for ${target_project_name} is: ${dep_path_list}")
         
-      # Check if all target included in the dependency path are enabled
-      FOREACH(dep ${dep_path_list})
+      # Check if all CTK targets included in the dependency path are enabled
+      SET(ctk_dep_path_list )
+      ctkMacroGetAllCTKTargetLibraries("${dep_path_list}" ctk_dep_path_list)
+      FOREACH(dep ${ctk_dep_path_list})
         ctkMacroGetOptionName("${target_directories_with_target_name}" ${dep} dep_option)
         IF(NOT ${${dep_option}})
           # Enable option

CMakeExternals/Log4Qt.cmake

@@ -2,7 +2,8 @@
 # Log4Qt
 #
 SET(Log4Qt_DEPENDS)
-ctkMacroShouldAddExternalProject(Log4Qt_LIBRARIES add_project)
+SET(Log4Qt_enabling_variable Log4Qt_LIBRARIES)
+ctkMacroShouldAddExternalProject(${Log4Qt_enabling_variable} add_project)
 IF(${add_project})
 
   # Sanity checks
@@ -29,6 +30,7 @@ IF(${add_project})
         ${proj_DEPENDENCIES}
       )
     SET(Log4Qt_DIR ${ep_install_dir})
+    SET(Log4Qt_FOUND 1)
     
     # Since Log4Qt is statically build, there is not need to add its corresponding 
     # library output directory to CTK_EXTERNAL_LIBRARY_DIRS
@@ -36,4 +38,12 @@ IF(${add_project})
   ELSE()
     ctkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
   ENDIF()
+
+  FIND_PACKAGE(Log4Qt)
+  IF(NOT Log4Qt_FOUND)
+    MESSAGE(FATAL_ERROR "error: Log4Qt package is required" )
+  ELSE()
+    SET(${Log4Qt_enabling_variable}_INCLUDE_DIRS ${Log4Qt_INCLUDE_DIR})
+  ENDIF()
+
 ENDIF()

CMakeExternals/QtMobility.cmake

@@ -2,7 +2,8 @@
 # QtMobility
 #
 SET(QtMobility_DEPENDS)
-ctkMacroShouldAddExternalProject(QTMOBILITY_QTSERVICEFW_LIBRARIES add_project)
+SET(QtMobility_enabling_variable QTMOBILITY_QTSERVICEFW_LIBRARIES)
+ctkMacroShouldAddExternalProject(${QtMobility_enabling_variable} add_project)
 IF(${add_project})
   SET(proj QtMobility)
 #   MESSAGE(STATUS "Adding project:${proj}")
@@ -74,10 +75,10 @@ IF(${add_project})
   # its corresponding library output directory to CTK_EXTERNAL_LIBRARY_DIRS
 
   IF(UNIX)
-    SET(QTMOBILITY_QTSERVICEFW_LIBRARIES_INCLUDE_DIRS 
-        "${CTK_BINARY_DIR}/../CMakeExternals/Source/QtMobility/install/include")
+    SET(${QtMobility_enabling_variable}_INCLUDE_DIRS 
+        "${CTK_BINARY_DIR}/CMakeExternals/Source/QtMobility/install/include")
   ELSE()
-    SET(QTMOBILITY_QTSERVICEFW_LIBRARIES_INCLUDE_DIRS
+    SET(${QtMobility_enabling_variable}_INCLUDE_DIRS
         "${qtmobility_win32_install_prefix}/include")
   ENDIF()
 	

CMakeLists.txt

@@ -423,7 +423,8 @@ MARK_AS_ADVANCED(DGraph_EXECUTABLE)
 #-----------------------------------------------------------------------------
 # Let's make sure the enabled/disabled libraries, plugins or applications are coherent
 #
-ctkFunctionGenerateDGraphInput(${CTK_BINARY_DIR} "${target_directories}" FALSE)
+ctkFunctionGenerateDGraphInput(${CTK_BINARY_DIR} "${target_directories}")
+ctkFunctionGenerateDGraphInput(${CTK_BINARY_DIR} "${target_directories}" WITH_EXTERNALS)
 ctkMacroValidateBuildOptions("${CTK_BINARY_DIR}" "${DGraph_EXECUTABLE}" "${target_directories}")
 
 #-----------------------------------------------------------------------------
@@ -449,7 +450,7 @@ ENDIF()
 #
 
 # Generate DGraph input file expected by DGraph
-ctkFunctionGenerateDGraphInput(${CTK_BINARY_DIR} "${target_directories}" TRUE)
+ctkFunctionGenerateDGraphInput(${CTK_BINARY_DIR} "${target_directories}" WITH_OPTION)
 
 # Obtain list of target ordered topologically
 ctkMacroSetPaths("${QT_INSTALLED_LIBRARY_DIR}")

Libs/Core/CMakeLists.txt

@@ -18,7 +18,6 @@ SET(KIT_export_directive "CTK_CORE_EXPORT")
 
 # Additional directories to include
 SET(KIT_include_directories
-  ${Log4Qt_INCLUDE_DIR}
   )
 
 # Source files
@@ -88,6 +87,8 @@ SET(KIT_resources
 
 # Target libraries - See CMake/ctkMacroGetTargetLibraries.cmake
 # The following macro will read the target libraries from the file 'target_libraries.cmake'
+SET(KIT_target_libraries)
+
 ctkMacroGetTargetLibraries(KIT_target_libraries)
 
 ctkMacroBuildLib(

Libs/PluginFramework/CMakeLists.txt

@@ -39,7 +39,6 @@ SET(KIT_export_directive "CTK_PLUGINFW_EXPORT")
 
 # Additional directories to include
 SET(KIT_include_directories
-  ${QTMOBILITY_INCLUDE_DIRS}
   )
   
 # Source files

SuperBuild.cmake

@@ -125,9 +125,16 @@ SET(external_projects
   )
 
 # Include external projects
+SET(dependency_args )
 FOREACH(p ${external_projects})
   INCLUDE(CMakeExternals/${p}.cmake)
+  IF(${p}_enabling_variable)
+    LIST(APPEND dependency_args 
+      "-D${${p}_enabling_variable}_INCLUDE_DIRS:STRING=${${${p}_enabling_variable}_INCLUDE_DIRS}")
+  ENDIF()
 ENDFOREACH()
+
+MESSAGE("Superbuild args: ${dependency_args}")
    
 #-----------------------------------------------------------------------------
 # CTK Utilities
@@ -235,6 +242,7 @@ ExternalProject_Add(${proj}
     -DPYTHONQT_INSTALL_DIR:PATH=${PYTHONQT_INSTALL_DIR} # FindPythonQt expects PYTHONQT_INSTALL_DIR variable to be defined
     -DPYTHONQTGENERATOR_EXECUTABLE:FILEPATH=${PYTHONQTGENERATOR_EXECUTABLE} #FindPythonQtGenerator expects PYTHONQTGENERATOR_EXECUTABLE to be defined
     -DLog4Qt_DIR:PATH=${Log4Qt_DIR} # FindLog4Qt expects Log4Qt_DIR variable to be defined
+    ${dependency_args}
   SOURCE_DIR ${CTK_SOURCE_DIR}
   BINARY_DIR ${CTK_BINARY_DIR}/CTK-build
   BUILD_COMMAND ""