Merge branch 'simplify-build-system-and-remove-base-include-dirs'

* simplify-build-system-and-remove-base-include-dirs:
  Fix build of ctkQtTesting application and  CTKConfig include directory export.
  Fix export of CTKTesting include directories
  Fix ctkSimplePythonShell build error supporting optional dependencies
  Do not set unused CMake build function parameter INCLUDE_DIRECTORIES
  Simplify system and remove variable CTK_BASE_INCLUDE_DIRS

Applications/ctkEventBusDemo/CMakeLists.txt

@@ -29,10 +29,6 @@ set(KIT_resources
 # The following macro will read the target libraries from the file 'target_libraries.cmake'
 ctkFunctionGetTargetLibraries(KIT_target_libraries)
 
-# Additional directories to include - Note that CTK_INCLUDE_LIBRARIES is already included
-set(KIT_include_directories
-)
-
 # Fix this after having discussed include dependencies with Jc
 foreach(_dep ${${PROJECT_NAME}_DEPENDENCIES})
   include_directories(${${_dep}_SOURCE_DIR} ${${_dep}_BINARY_DIR})
@@ -40,7 +36,6 @@ endforeach()
 
 ctkMacroBuildApp(
   NAME ${PROJECT_NAME}
-  INCLUDE_DIRECTORIES ${KIT_include_directories}
   SRCS ${KIT_SRCS}
   MOC_SRCS ${KIT_MOC_SRCS}
   UI_FORMS ${KIT_UI_FORMS}

Applications/ctkQtTesting/CMakeLists.txt

@@ -1,16 +1,6 @@
 project(ctkQtTesting)
 
 #
-# 3rd party dependencies
-#
-find_package(QtTesting REQUIRED)
-include_directories(
-  ${QtTesting_INCLUDE_DIRS}
-  ${CTKQtTesting_INCLUDE_DIRS}
-  ${CTK_BASE_INCLUDE_DIRS}
-  )
-
-#
 # See CTK/CMake/ctkMacroBuildApp.cmake for details
 #
 
@@ -37,7 +27,6 @@ set(KIT_resources
 # Target libraries - See CMake/ctkFunctionGetTargetLibraries.cmake
 # The following macro will read the target libraries from the file 'target_libraries.cmake'
 ctkFunctionGetTargetLibraries(KIT_target_libraries)
-list(APPEND KIT_target_libraries CTKQtTesting)
 
 ctkMacroBuildApp(
   NAME ${PROJECT_NAME}

Applications/ctkQtTesting/target_libraries.cmake

@@ -5,5 +5,5 @@
 # 
 
 set(target_libraries
-  CTKVisualizationVTKWidgets
+  CTKQtTesting
   )

Applications/ctkSimplePythonShell/CMakeLists.txt

@@ -1,14 +1,6 @@
 project(ctkSimplePythonShell)
 
 #
-# 3rd party dependencies
-#
-if(CTK_LIB_Scripting/Python/Core AND CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK)
-  find_package(VTK REQUIRED)
-  include(${VTK_USE_FILE})
-endif()
-
-#
 # See CTK/CMake/ctkMacroBuildApp.cmake for details
 #
 
@@ -57,30 +49,13 @@ set(KIT_UI_FORMS
 set(KIT_resources
   )
 
-set(KIT_INCLUDE_DIRECTORIES
-  )
-
 set(VTK_LIBRARIES
   )
 
-if(CTK_LIB_Scripting/Python/Core AND CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK)
-  list(APPEND KIT_INCLUDE_DIRECTORIES
-    ${CTKVisualizationVTKCore_BINARY_DIR}
-    ${CTKVisualizationVTKCore_SOURCE_DIR}
-    )
-endif()
-
 # Target libraries - See CMake/ctkFunctionGetTargetLibraries.cmake
 # The following macro will read the target libraries from the file 'target_libraries.cmake'
 ctkFunctionGetTargetLibraries(KIT_target_libraries)
 
-if(CTK_LIB_Scripting/Python/Core AND CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK)
-  list(APPEND KIT_target_libraries
-    CTKVisualizationVTKCore
-    vtkFiltering
-    )
-endif()
-
 # Configure file will be configured using CTK_WRAP_PYTHONQT_LIGHT and
 # CTK_BUILD_SHARED_LIBS variables
 configure_file(
@@ -139,7 +114,6 @@ ctkMacroBuildApp(
   SRCS ${KIT_SRCS}
   MOC_SRCS ${KIT_MOC_SRCS}
   UI_FORMS ${KIT_UI_FORMS}
-  INCLUDE_DIRECTORIES ${KIT_INCLUDE_DIRECTORIES}
   TARGET_LIBRARIES ${KIT_target_libraries}
   RESOURCES ${KIT_resources}
   )

CMake/LastConfigureStep/CMakeLists.txt

@@ -79,9 +79,6 @@ foreach(ctk_target_dependency ${ctk_target_dependencies})
   endif()
 endforeach()
 
-# Clean variable
-list(REMOVE_DUPLICATES CTK_BASE_INCLUDE_DIRS)
-
 #-----------------------------------------------------------------------------
 # Create the CTKConfig.cmake file containing the CTK configuration.
 # Since it might generate configuration file depending

CMake/LastConfigureStep/CTKGenerateCTKConfig.cmake

@@ -144,12 +144,15 @@ set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}set(CTK_QT_QMAKE_EXECUTABLE \"${QT_QMAKE_
 set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}# The CTK Qt designer plugins directory\n")
 set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}set(CTK_QTDESIGNERPLUGINS_DIR \"${CMAKE_LIBRARY_OUTPUT_DIRECTORY}\")\n")
 set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}# CTK library include dirctories\n")
-foreach(lib ${CTK_LIBRARIES} CTKTesting)
+set(_include_dirs)
+foreach(lib ${CTK_LIBRARIES})
   set(${lib}_INCLUDE_DIRS ${${lib}_SOURCE_DIR} ${${lib}_BINARY_DIR})
   ctkFunctionGetIncludeDirs(${lib}_INCLUDE_DIRS ${lib})
+  list(APPEND _include_dirs ${${lib}_INCLUDE_DIRS})
   set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}set(${lib}_INCLUDE_DIRS \"${${lib}_INCLUDE_DIRS}\")\n")
 endforeach()
-set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}set(CTK_INCLUDE_DIRS \"${CTK_BASE_INCLUDE_DIRS}\")\n")
+list(REMOVE_DUPLICATES _include_dirs)
+set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}set(CTK_INCLUDE_DIRS \"${_include_dirs}\")\n")
 set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}list(APPEND CTK_INCLUDE_DIRS \"${CTKTesting_INCLUDE_DIRS}\")\n")
 set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}# CTK library directories that could be used for linking\n")
 foreach(lib ${CTK_LIBRARIES})
@@ -195,7 +198,7 @@ set(CTK_LIBRARY_DIR_CONFIG ${CTK_INSTALL_LIB_DIR})
 
 set(CTK_CONFIG_CODE "####### Expanded from \@CTK_CONFIG_CODE\@ #######\n")
 set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}# CTK library include dirctories\n")
-foreach(libname ${CTK_LIBRARIES} CTKTesting)
+foreach(libname ${CTK_LIBRARIES})
   set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}set(${libname}_INCLUDE_DIRS \"\${PACKAGE_PREFIX_DIR}/${CTK_INSTALL_INCLUDE_DIR}\")\n")
 endforeach()
 set(CTK_CONFIG_CODE "${CTK_CONFIG_CODE}set(CTK_INCLUDE_DIRS \"\${PACKAGE_PREFIX_DIR}/${CTK_INSTALL_INCLUDE_DIR}\")\n")

CMake/ctkBlockCheckDependencies.cmake

@@ -80,6 +80,10 @@ 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(QtTesting_enabling_variable QtTesting_LIBRARIES)
+set(${QtTesting_enabling_variable}_INCLUDE_DIRS QtTesting_INCLUDE_DIRS)
+set(${QtTesting_enabling_variable}_FIND_PACKAGE_CMD QtTesting)
+
 set(qxmlrpc_enabling_variable qxmlrpc_LIBRARY)
 set(${qxmlrpc_enabling_variable}_LIBRARY_DIRS qxmlrpc_LIBRARY_DIRS)
 set(${qxmlrpc_enabling_variable}_INCLUDE_DIRS qxmlrpc_INCLUDE_DIRS)

CMake/ctkFunctionGenerateDGraphInput.cmake

@@ -76,6 +76,9 @@ function(ctkFunctionGenerateDGraphInput dir target_directories)
 
       # get dependencies
       ctkFunctionCollectTargetLibraryNames(${target_dir} dependencies)
+      if(${target_project_name}_OPTIONAL_DEPENDENCIES)
+        list(APPEND dependencies ${${target_project_name}_OPTIONAL_DEPENDENCIES})
+      endif()
 
       # Make sure the variable is cleared
       set(ctk_dependencies)

CMake/ctkMacroBuildApp.cmake

@@ -31,6 +31,8 @@ macro(ctkMacroBuildApp)
     ${ARGN}
     )
 
+  # Keep parameter 'INCLUDE_DIRECTORIES' for backward compatiblity
+
   # Sanity checks
   if(NOT DEFINED MY_NAME)
     message(FATAL_ERROR "NAME is mandatory")
@@ -54,7 +56,6 @@ macro(ctkMacroBuildApp)
   set(my_includes
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
-    ${MY_INCLUDE_DIRECTORIES}
     )
 
   # Add the include directories from the library dependencies

CMake/ctkMacroBuildLib.cmake

@@ -33,6 +33,8 @@ macro(ctkMacroBuildLib)
     ${ARGN}
     )
 
+  # Keep parameter 'INCLUDE_DIRECTORIES' for backward compatiblity
+
   # Sanity checks
   if(NOT DEFINED MY_NAME)
     message(FATAL_ERROR "NAME is mandatory")
@@ -63,7 +65,6 @@ macro(ctkMacroBuildLib)
     ${CMAKE_CURRENT_BINARY_DIR}
     # with CMake >2.9, use QT4_MAKE_OUTPUT_FILE instead ?
     ${CMAKE_CURRENT_BINARY_DIR}/Resources/UI
-    ${MY_INCLUDE_DIRECTORIES}
     )
 
   # Add the include directories from the library dependencies
@@ -72,10 +73,6 @@ macro(ctkMacroBuildLib)
   include_directories(
     ${my_includes}
     )
-  #message(lib_name:${lib_name})
-  #foreach(i ${my_includes})
-  #  message(i:${i})
-  #endforeach()
 
   # Add Qt include dirs and defines
   include(${QT_USE_FILE})
@@ -170,15 +167,8 @@ macro(ctkMacroBuildLib)
   target_link_libraries(${lib_name} ${my_libs})
 
   # Update CTK_BASE_LIBRARIES
-  set(new_ctk_base_libraries ${my_libs} ${lib_name})
-  list(REMOVE_DUPLICATES new_ctk_base_libraries)
-  set(CTK_BASE_LIBRARIES ${new_ctk_base_libraries} CACHE INTERNAL "CTK base libraries" FORCE)
-  set(new_ctk_libraries ${CTK_LIBRARIES} ${lib_name})
-  list(REMOVE_DUPLICATES new_ctk_libraries)
-  set(CTK_LIBRARIES ${new_ctk_libraries} CACHE INTERNAL "CTK libraries" FORCE)
-  set(new_ctk_base_include_dirs ${CTK_BASE_INCLUDE_DIRS} ${my_includes})
-  list(REMOVE_DUPLICATES new_ctk_base_include_dirs)
-  set(CTK_BASE_INCLUDE_DIRS ${new_ctk_base_include_dirs} CACHE INTERNAL "CTK includes" FORCE)
+  set(CTK_BASE_LIBRARIES ${my_libs} ${lib_name} CACHE INTERNAL "CTK base libraries" FORCE)
+  set(CTK_LIBRARIES ${CTK_LIBRARIES} ${lib_name} CACHE INTERNAL "CTK libraries" FORCE)
 
   # Install headers
   file(GLOB headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h" "${CMAKE_CURRENT_SOURCE_DIR}/*.tpp")

CMake/ctkMacroBuildPlugin.cmake

@@ -55,6 +55,8 @@ macro(ctkMacroBuildPlugin)
     ${ARGN}
     )
 
+  # Keep parameter 'INCLUDE_DIRECTORIES' for backward compatiblity
+
   # Sanity checks
   if(NOT DEFINED MY_EXPORT_DIRECTIVE)
     message(FATAL_ERROR "EXPORT_DIRECTIVE is mandatory")
@@ -132,7 +134,6 @@ macro(ctkMacroBuildPlugin)
   list(APPEND my_includes
       ${CMAKE_CURRENT_SOURCE_DIR}
       ${CMAKE_CURRENT_BINARY_DIR}
-      ${MY_INCLUDE_DIRECTORIES}
       )
 
   # Add the include directories from the plugin dependencies

CMake/ctkMacroBuildQtPlugin.cmake

@@ -50,12 +50,15 @@ macro(ctkMacroBuildQtPlugin)
   # --------------------------------------------------------------------------
   # Include dirs
   set(my_includes
-    ${CTK_BASE_INCLUDE_DIRS}
     ${QT_QTDESIGNER_INCLUDE_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
     ${MY_INCLUDE_DIRECTORIES}
     )
+  if(CTK_SOURCE_DIR)
+    # Add the include directories from the library dependencies
+    ctkFunctionGetIncludeDirs(my_includes ${MY_TARGET_LIBRARIES})
+  endif()
   include_directories(
     ${my_includes}
     )

CMake/ctkMacroTargetLibraries.cmake

@@ -32,8 +32,10 @@ function(ctkFunctionGetTargetLibraries varname)
   set(expanded_target_library_list)
 
   set(TARGET_DIRECTORY ${ARGV1})
+  set(_target_name )
   if("${TARGET_DIRECTORY}" STREQUAL "")
     set(TARGET_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+    set(_target_name ${PROJECT_NAME})
   endif()
 
   set(filepath ${TARGET_DIRECTORY}/target_libraries.cmake)
@@ -59,6 +61,10 @@ function(ctkFunctionGetTargetLibraries varname)
 
     include(${filepath})
 
+    if(_target_name)
+      list(APPEND target_libraries "${${_target_name}_OPTIONAL_DEPENDENCIES}")
+    endif()
+
     # Loop over all target library, if it does *NOT* start with "CTK",
     # let's resolve the variable to access its content
     foreach(target_library ${target_libraries})
@@ -145,7 +151,9 @@ function(ctkFunctionCollectTargetLibraryNames target_dir varname)
     endforeach()
   endif()
 
-  list(REMOVE_DUPLICATES target_library_list)
+  if(target_library_list)
+    list(REMOVE_DUPLICATES target_library_list)
+  endif()
   
   # Pass the list of target libraries to the caller
   set(${varname} ${target_library_list} PARENT_SCOPE)

CMakeLists.txt

@@ -173,10 +173,9 @@ set(CMAKE_MODULE_PATH
   ${CMAKE_MODULE_PATH})
 
 #-----------------------------------------------------------------------------
-# Clear CTK_BASE_INCLUDE_DIRS, CTK_BASE_LIBRARIES and CTK_WRAPPED_LIBRARIES_PYTHONQT
+# Clear CTK_BASE_LIBRARIES and CTK_WRAPPED_LIBRARIES_PYTHONQT
 #
 set(CTK_BASE_LIBRARIES CACHE INTERNAL "CTK base libraries" FORCE)
-set(CTK_BASE_INCLUDE_DIRS CACHE INTERNAL "CTK includes" FORCE)
 set(CTK_WRAPPED_LIBRARIES_PYTHONQT CACHE INTERNAL "CTK libraries wrapped using PythonQt" FORCE)
 
 # Variable use in CTKConfig.cmake.in
@@ -764,6 +763,12 @@ ctk_enable_option_raw(CTK_BUILD_EXAMPLES "Build examples for CTK components" OFF
 # Create list of directories corresponding to the enabled targets
 set(target_directories)
 
+# Setup testing environment before Libs are added by simulating
+# the use of 'ctk_lib_option' for CTKTesting library
+set(CTK_LIB_Testing TRUE)
+list(APPEND CTK_LIBS Testing)
+list(APPEND target_directories "${CMAKE_CURRENT_SOURCE_DIR}/Libs/Testing^^CTK_LIB_Testing")
+
 foreach(lib ${CTK_LIBS})
   if(CTK_LIB_${lib})
     ctkMacroAddCtkLibraryOptions(${lib})
@@ -783,6 +788,13 @@ foreach(app ${CTK_APPS})
   list(APPEND target_directories "${CMAKE_CURRENT_SOURCE_DIR}/Applications/${app}^^CTK_APP_${app}")
 endforeach()
 
+# Emulate the use of 'ctk_lib_option' for CTKQtTesting library
+set(CTK_LIB_QtTesting ${CTK_USE_QTTESTING})
+if(CTK_USE_QTTESTING)
+  list(APPEND CTK_LIBS QtTesting)
+  list(APPEND target_directories "${CMAKE_CURRENT_SOURCE_DIR}/Libs/QtTesting^^CTK_LIB_QtTesting")
+endif()
+
 #message(STATUS target_directories:${target_directories})
 
 #-----------------------------------------------------------------------------
@@ -806,6 +818,19 @@ find_program(DGraph_EXECUTABLE DGraph
   "${CTK_BINARY_DIR}/Utilities/DGraph/Release/")
 mark_as_advanced(DGraph_EXECUTABLE)
 
+# Set optional dependencies not captured in 'target_libraries.cmake' files.
+if(CTK_LIB_Scripting/Python/Core AND CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK)
+  set(ctkSimplePythonShell_OPTIONAL_DEPENDENCIES CTKVisualizationVTKCore VTK_LIBRARIES)
+endif()
+
+set(CTKQtTesting_OPTIONAL_DEPENDENCIES)
+if(CTK_LIB_Widgets)
+  list(APPEND CTKQtTesting_OPTIONAL_DEPENDENCIES CTKWidgets)
+endif()
+if(CTK_LIB_Visualization/VTK/Widgets)
+  list(APPEND CTKQtTesting_OPTIONAL_DEPENDENCIES CTKVisualizationVTKWidgets)
+endif()
+
 #-----------------------------------------------------------------------------
 # Let's make sure the enabled/disabled libraries, plugins or applications are coherent
 #
@@ -893,6 +918,7 @@ set(CTK_DEPENDENCIES
   OpenIGTLink
   XIP
   ITK
+  QtTesting
   )
 
 if(BUILD_TESTING)
@@ -903,10 +929,6 @@ if(CTK_USE_KWSTYLE)
   list(APPEND CTK_DEPENDENCIES KWStyle)
 endif()
 
-if(CTK_USE_QTTESTING)
-  list(APPEND CTK_DEPENDENCIES QtTesting)
-endif()
-
 #-----------------------------------------------------------------------------
 # Check out the ExternalProjectsContrib repository
 if(CTK_USE_CONTRIBUTED_PLUGINS)
@@ -1044,11 +1066,6 @@ set(CMAKE_C_FLAGS ${CTK_C_FLAGS} CACHE STRING "CMake CXX Flags" FORCE)
 set(CTK_EXPORT_HEADER_TEMPLATE "${CTK_SOURCE_DIR}/Libs/ctkExport.h.in")
 
 #-----------------------------------------------------------------------------
-# Setup testing environment before Libs are added
-#
-add_subdirectory(Libs/Testing)
-
-#-----------------------------------------------------------------------------
 # Add CTK library subdirectories
 #
 foreach(lib ${CTK_LIBS})
@@ -1065,11 +1082,6 @@ endforeach()
 add_subdirectory(Libs/CommandLineModules)
 
 #-----------------------------------------------------------------------------
-if(CTK_USE_QTTESTING)
-  add_subdirectory(Libs/QtTesting)
-endif()
-
-#-----------------------------------------------------------------------------
 # Add CTK plugin subdirectories
 #
 foreach(plugin ${CTK_PLUGINS})

Libs/CommandLineModules/Backend/FunctionPointer/CMakeLists.txt

@@ -42,7 +42,6 @@ ctkFunctionGetTargetLibraries(KIT_target_libraries)
 ctkMacroBuildLib(
   NAME ${PROJECT_NAME}
   EXPORT_DIRECTIVE ${KIT_export_directive}
-  INCLUDE_DIRECTORIES ${KIT_include_directories}
   SRCS ${KIT_SRCS}
   MOC_SRCS ${KIT_MOC_SRCS}
   UI_FORMS ${KIT_UI_FORMS}

Libs/CommandLineModules/Backend/LocalProcess/CMakeLists.txt

@@ -41,7 +41,6 @@ ctkFunctionGetTargetLibraries(KIT_target_libraries)
 ctkMacroBuildLib(
   NAME ${PROJECT_NAME}
   EXPORT_DIRECTIVE ${KIT_export_directive}
-  INCLUDE_DIRECTORIES ${KIT_include_directories}
   SRCS ${KIT_SRCS}
   MOC_SRCS ${KIT_MOC_SRCS}
   UI_FORMS ${KIT_UI_FORMS}

Libs/CommandLineModules/Backend/XMLChecker/CMakeLists.txt

@@ -37,7 +37,6 @@ ctkFunctionGetTargetLibraries(KIT_target_libraries)
 ctkMacroBuildLib(
   NAME ${PROJECT_NAME}
   EXPORT_DIRECTIVE ${KIT_export_directive}
-  INCLUDE_DIRECTORIES ${KIT_include_directories}
   SRCS ${KIT_SRCS}
   MOC_SRCS ${KIT_MOC_SRCS}
   UI_FORMS ${KIT_UI_FORMS}

Libs/CommandLineModules/Core/CMakeLists.txt

@@ -87,7 +87,6 @@ ctkFunctionGetTargetLibraries(KIT_target_libraries)
 ctkMacroBuildLib(
   NAME ${PROJECT_NAME}
   EXPORT_DIRECTIVE ${KIT_export_directive}
-  INCLUDE_DIRECTORIES ${KIT_include_directories}
   SRCS ${KIT_SRCS}
   MOC_SRCS ${KIT_MOC_SRCS}
   UI_FORMS ${KIT_UI_FORMS}

Libs/CommandLineModules/Frontend/QtGui/CMakeLists.txt

@@ -49,7 +49,6 @@ ctkFunctionGetTargetLibraries(KIT_target_libraries)
 ctkMacroBuildLib(
   NAME ${PROJECT_NAME}
   EXPORT_DIRECTIVE ${KIT_export_directive}
-  INCLUDE_DIRECTORIES ${KIT_include_directories}
   SRCS ${KIT_SRCS}
   MOC_SRCS ${KIT_MOC_SRCS}
   UI_FORMS ${KIT_UI_FORMS}

Libs/CommandLineModules/Frontend/QtWebKit/CMakeLists.txt

@@ -42,7 +42,6 @@ ctkFunctionGetTargetLibraries(KIT_target_libraries)
 ctkMacroBuildLib(
   NAME ${PROJECT_NAME}
   EXPORT_DIRECTIVE ${KIT_export_directive}
-  INCLUDE_DIRECTORIES ${KIT_include_directories}
   SRCS ${KIT_SRCS}
   MOC_SRCS ${KIT_MOC_SRCS}
   UI_FORMS ${KIT_UI_FORMS}

Libs/QtTesting/CMakeLists.txt

@@ -4,6 +4,7 @@ project(CTKQtTesting)
 # 3rd party dependencies
 #
 find_package(QtTesting REQUIRED)
+set(QtTesting_LIBRARIES QtTesting)
 
 #
 # See CTK/CMake/ctkMacroBuildLib.cmake for details
@@ -107,18 +108,6 @@ if (CTK_LIB_Widgets)
   set(CTK_ADD_WIDGET_EVENT_TRANSLATORS "${CTK_ADD_WIDGET_EVENT_TRANSLATORS}  this->eventTranslator()->addWidgetEventTranslator(new ctkFileDialogEventTranslator(util));\n")
 endif()
 
-set(KIT_INCLUDE_DIRECTORIES
-  ${QtTesting_INCLUDE_DIRS}
-  ${CTK_SUPERBUILD_BINARY_DIR} # For ctkConfig.h
-  )
-
-foreach(libname ${CTK_ENABLED_LIBNAMES})
-  list(APPEND KIT_INCLUDE_DIRECTORIES
-    ${${libname}_SOURCE_DIR}
-    ${${libname}_BINARY_DIR}
-    )
-endforeach()
-
 configure_file(
   ctkQtTestingUtility.cpp.in
   ${CMAKE_CURRENT_BINARY_DIR}/ctkQtTestingUtility.cpp
@@ -154,16 +143,12 @@ set(KIT_resources
   Resources/ctkQtTesting.qrc
 )
 
-# dependencie dynamic from all the libraries with Widgets + QtTesting
-set(KIT_target_libraries QtTesting)
-
-foreach(libname ${CTK_ENABLED_LIBNAMES})
-  if(${libname} MATCHES "Widgets$")
-    list(APPEND KIT_target_libraries ${libname})
-  endif()
-endforeach()
+# Set QtTesting_LIBRARIES variable
+set(QtTesting_LIBRARIES QtTesting)
 
-#message("${KIT_target_libraries}")
+# Target libraries - See CMake/ctkFunctionGetTargetLibraries.cmake
+# The following macro will read the target libraries from the file 'target_libraries.cmake'
+ctkFunctionGetTargetLibraries(KIT_target_libraries)
 
 ctkMacroBuildLib(
   NAME ${PROJECT_NAME}
@@ -171,7 +156,6 @@ ctkMacroBuildLib(
   SRCS ${KIT_SRCS}
   MOC_SRCS ${KIT_MOC_SRCS}
   UI_FORMS ${KIT_UI_FORMS}
-  INCLUDE_DIRECTORIES ${KIT_INCLUDE_DIRECTORIES}
   TARGET_LIBRARIES ${KIT_target_libraries}
   RESOURCES ${KIT_resources}
   LIBRARY_TYPE ${CTK_LIBRARY_MODE}

Libs/QtTesting/target_libraries.cmake

@@ -0,0 +1,9 @@
+#
+# See CMake/ctkFunctionGetTargetLibraries.cmake
+# 
+# This file should list the libraries required to build the current CTK libraries
+# 
+
+set(target_libraries
+  QtTesting_LIBRARIES
+  )

Libs/Testing/target_libraries.cmake

@@ -0,0 +1,8 @@
+#
+# See CMake/ctkFunctionGetTargetLibraries.cmake
+# 
+# This file should list the libraries required to build the current CTK libraries
+# 
+
+set(target_libraries
+  )

Libs/Visualization/VTK/Core/CMakeLists.txt

@@ -64,10 +64,8 @@ if(CTK_LIB_Scripting/Python/Core AND CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_
     )
 endif()
 
-set(KIT_INCLUDE_DIRECTORIES )
-
 if(CTK_LIB_Scripting/Python/Core AND CTK_LIB_Scripting/Python/Core_PYTHONQT_USE_VTK)
-  list(APPEND KIT_INCLUDE_DIRECTORIES
+  include(
     ${PYTHON_INCLUDE_DIRS}
     ${PYTHONQT_INCLUDE_DIR}
     )
@@ -143,7 +141,6 @@ ctkMacroBuildLib(
   SRCS ${KIT_SRCS}
   MOC_SRCS ${KIT_MOC_SRCS}
   UI_FORMS ${KIT_UI_FORMS}
-  INCLUDE_DIRECTORIES ${KIT_INCLUDE_DIRECTORIES}
   TARGET_LIBRARIES ${KIT_target_libraries}
   RESOURCES ${KIT_resources}
   LIBRARY_TYPE ${CTK_LIBRARY_MODE}

Plugins/org.commontk.dah.examplehost/CMakeLists.txt

@@ -29,16 +29,12 @@ set(PLUGIN_UI_FORMS
 set(PLUGIN_resources
 )
 
-# Additional directories to include - Note that CTK_INCLUDE_LIBRARIES is already included
-set(PLUGIN_include_directories
-)
 #Compute the plugin dependencies
 ctkFunctionGetTargetLibraries(PLUGIN_target_libraries)
 
 ctkMacroBuildPlugin(
   NAME ${PROJECT_NAME}
   EXPORT_DIRECTIVE ${PLUGIN_export_directive}
-  INCLUDE_DIRECTORIES ${PLUGIN_include_directories}
   SRCS ${PLUGIN_SRCS}
   MOC_SRCS ${PLUGIN_MOC_SRCS}
   UI_FORMS ${PLUGIN_UI_FORMS}

Utilities/DGraph/DGraph.cpp

@@ -268,12 +268,18 @@ int main(int argc, char** argv)
       {
       from = getOrGenerateId(vertexIdToLabel, vertexLabelToId, strings[0]);
       to = getOrGenerateId(vertexIdToLabel, vertexLabelToId, strings[1]);
-
       if (verbose)
         {
         std::cout << "Line='" << line << "', line number " << lineNumber << ", from (" << strings[0] << ", " << from << ") to (" << strings[1] << ", " << to << ")"  << std::endl;
         }
       }
+    else
+      {
+      if (verbose)
+        {
+        std::cout << "Line='" << line << "', line number " << lineNumber << ", from (" << strings[0] << ", " << from << ") to (<null>, " << to << ")"  << std::endl;
+        }
+      }
 
     if (to > -1)
       {
@@ -437,6 +443,11 @@ int main(int argc, char** argv)
     // TODO Make sure label is valid
     std::list<int> out;
     int labelId = vertexLabelToId[label];
+    if (labelId < 1)
+      {
+      std::cout << label;
+      return EXIT_SUCCESS;
+      }
     if (mygraph.topologicalSort(out, labelId))
       {
       std::list<int>::iterator outIterator;