Remove monolithic VTK files not used after modularization

The modular VTK build system completely replaces the old monolithic
CMake code.

Co-Author: Marcus D. Hanwell <marcus.hanwell@kitware.com>
Co-Author: Chris Harris <chris.harris@kitware.com>
Co-Author: Brad King <brad.king@kitware.com>
Co-Author: Nikhil Shetty <nikhil.shetty@kitware.com>

AMR/CMakeLists.txt

-## Set the Kit name
-SET(KIT AMR)
-SET(UKIT AMR)
-SET(KIT_TCL_LIBS vtkCommonTCL vtkFilteringTCL vtkParallelTCL vtkGenericFilteringTCL )
-SET(KIT_PYTHON_LIBS vtkCommonPythonD vtkFilteringPythonD vtkParallelPythonD vtkGenericFilteringPythonD )
-SET(KIT_JAVA_LIBS vtkCommonJava vtkFilteringJava vtkParallelJava vtkGenericFilteringJava )
-SET(KIT_INTERFACE_LIBRARIES vtkCommon vtkFiltering vtkParallel vtkGenericFiltering )
-
-## Get the kit sources
-SET(Kit_SRCS
-    vtkAMRBaseParticlesReader.cxx
-    vtkAMRBaseReader.cxx
-    vtkAMRCutPlane.cxx
-    vtkAMRDataSetCache.cxx
-    vtkAMREnzoParticlesReader.cxx
-    vtkAMREnzoReader.cxx
-    vtkAMREnzoReaderInternal.cxx
-    vtkAMRFlashParticlesReader.cxx
-    vtkAMRFlashReader.cxx
-    vtkAMRFlashReaderInternal.cxx
-    vtkAMRGaussianPulseSource.cxx
-    vtkAMRResampleFilter.cxx
-    vtkAMRSliceFilter.cxx
-    vtkAMRToMultiBlockFilter.cxx
-    )
-
-## Set the libraries required by this kit
-SET(KIT_LIBS vtkParallel vtkCommon vtkFiltering vtkGenericFiltering ${VTK_HDF5_LIBRARIES})
-
-SET_SOURCE_FILES_PROPERTIES(
-    vtkAMRBaseReader
-    vtkAMRBaseParticlesReader
-    ABSTRACT
-)
-
-SET_SOURCE_FILES_PROPERTIES(
-  vtkAMREnzoReaderInternal
-  vtkAMRFlashReaderInternal
-  WRAP_EXCLUDE
-)
-## Include CMAKE code common to all kits
-INCLUDE(${VTK_CMAKE_DIR}/KitCommonBlock.cmake )

AMR/Testing/CMakeLists.txt

-ADD_SUBDIRECTORY(Cxx)
-
-IF(PYTHON_EXECUTABLE)
-  ADD_TEST(HeaderTesting-AMR ${PYTHON_EXECUTABLE}
-    ${VTK_SOURCE_DIR}/Common/Testing/HeaderTesting.py
-    "${VTK_SOURCE_DIR}/AMR"
-    VTK_AMR_EXPORT
-    vtkAMREnzoReaderInternal.h
-    vtkAMRFlashReaderInternal.h
-    )
-ENDIF(PYTHON_EXECUTABLE)
\ No newline at end of file

CMake/FindEXPAT.cmake

-#
-# Find the native EXPAT includes and library
-#
-# This module defines
-# EXPAT_INCLUDE_DIR, where to find expat.h, etc.
-# EXPAT_LIBRARIES, the libraries to link against to use EXPAT.
-# EXPAT_FOUND, If false, do not try to use EXPAT.
-
-# also defined, but not for general use are
-# EXPAT_LIBRARY, where to find the EXPAT library.
-
-FIND_PATH(EXPAT_INCLUDE_DIR expat.h)
-
-FIND_LIBRARY(EXPAT_LIBRARY expat)
-
-IF(EXPAT_INCLUDE_DIR)
-  IF(EXPAT_LIBRARY)
-    SET( EXPAT_FOUND "YES" )
-    SET( EXPAT_LIBRARIES ${EXPAT_LIBRARY} )
-  ENDIF(EXPAT_LIBRARY)
-ENDIF(EXPAT_INCLUDE_DIR)

CMake/FindFREETYPE.cmake

-#
-# Find the native FREETYPE includes and library
-# 
-
-# This module defines
-# FREETYPE_INCLUDE_DIR, where to find ft2build.h, ftheader.h, ...
-# FREETYPE_LIBRARIES, the libraries to link against to use FREETYPE.
-# FREETYPE_FOUND, If false, do not try to use FREETYPE.
-
-# also defined, but not for general use are
-# FREETYPE_LIBRARY, where to find the FREETYPE library.
-
-FIND_PATH(FREETYPE_INCLUDE_DIR_FT2BUILD ft2build.h)
-
-FIND_PATH(FREETYPE_INCLUDE_DIR_FTHEADER freetype/config/ftheader.h
-  /usr/include/freetype2
-  /usr/local/include/freetype2
-  PATH_SUFFIXES freetype2  
-)
-
-FIND_LIBRARY(FREETYPE_LIBRARY freetype)
-
-IF (FREETYPE_LIBRARY)
-  IF (FREETYPE_INCLUDE_DIR_FTHEADER AND FREETYPE_INCLUDE_DIR_FT2BUILD)
-    SET( FREETYPE_FOUND "YES" )
-    SET( FREETYPE_INCLUDE_DIR 
-      ${FREETYPE_INCLUDE_DIR_FT2BUILD}
-      ${FREETYPE_INCLUDE_DIR_FTHEADER} )
-    SET( FREETYPE_LIBRARIES ${FREETYPE_LIBRARY} )
-  ENDIF (FREETYPE_INCLUDE_DIR_FTHEADER AND FREETYPE_INCLUDE_DIR_FT2BUILD)
-ENDIF (FREETYPE_LIBRARY)
-
-MARK_AS_ADVANCED(
-  FREETYPE_INCLUDE_DIR_FT2BUILD
-  FREETYPE_INCLUDE_DIR_FTHEADER
-  )
-

CMake/FindHDF5.cmake

-#
-# Find the native HDF5 includes and library
-# Note: this is deprecated, and will be removed entirely
-# once vtk's min cmake >= 2.8.0
-#
-# HDF5_INCLUDE_DIR - where to find H5public.h, etc.
-# HDF5_LIBRARIES   - List of fully qualified libraries to link against when using hdf5.
-# HDF5_FOUND       - Do not attempt to use hdf5 if "no" or undefined.
-
-FIND_PATH(HDF5_INCLUDE_DIR H5public.h
-  /usr/local/include
-  /usr/include
-)
-
-FIND_LIBRARY(HDF5_LIBRARY hdf5
-  /usr/local/lib
-  /usr/lib
-)
-
-IF(HDF5_INCLUDE_DIR)
-  IF(HDF5_LIBRARY)
-    SET( HDF5_LIBRARIES ${HDF5_LIBRARY} )
-    SET( HDF5_FOUND "YES" )
-  ENDIF(HDF5_LIBRARY)
-ENDIF(HDF5_INCLUDE_DIR)

CMake/FindLIBXML2.cmake

-INCLUDE(${CMAKE_ROOT}/Modules/FindLibXml2.cmake)

CMake/FindPOSTGRES.cmake

-# Find POSTGRESQL library and header file
-# Sets
-#   POSTGRES_FOUND               to 0 or 1 depending on the result
-#   POSTGRES_INCLUDE_DIRECTORIES to directories required for using libpq
-#   POSTGRES_LIBRARIES           to libpq and any dependent libraries
-# If POSTGRES_REQUIRED is defined, then a fatal error message will be generated if libpq is not found
-
-if ( NOT POSTGRES_INCLUDE_DIRECTORIES OR NOT POSTGRES_LIBRARIES OR NOT POSTGRES_FOUND )
-
-  if ( $ENV{POSTGRES_DIR} )
-    file( TO_CMAKE_PATH "$ENV{POSTGRES_DIR}" _POSTGRES_DIR )
-  endif ( $ENV{POSTGRES_DIR} )
-
-  find_library( POSTGRES_LIBRARIES
-    NAMES pq libpq
-    PATHS
-      ${_POSTGRES_DIR}/lib64
-      ${CMAKE_INSTALL_PREFIX}/lib64
-      /usr/local/pgsql/lib64
-      /usr/local/lib64
-      /usr/lib64
-      ${_POSTGRES_DIR}
-      ${_POSTGRES_DIR}/lib
-      ${CMAKE_INSTALL_PREFIX}/bin
-      ${CMAKE_INSTALL_PREFIX}/lib
-      /usr/local/pgsql/lib
-      /usr/local/lib
-      /usr/lib
-    NO_DEFAULT_PATH
-  )
-
-  find_path( POSTGRES_INCLUDE_DIRECTORIES
-    NAMES libpq-fe.h
-    PATHS
-      ${_POSTGRES_DIR}
-      ${_POSTGRES_DIR}/include
-      ${CMAKE_INSTALL_PREFIX}/include
-      /usr/local/pgsql/include
-      /usr/local/include
-      /usr/include
-      /usr/include/postgresql
-    NO_DEFAULT_PATH
-  )
-
-  if ( NOT POSTGRES_INCLUDE_DIRECTORIES OR NOT POSTGRES_LIBRARIES ) 
-    if ( POSTGRES_REQUIRED )
-      message( FATAL_ERROR "POSTGRES is required. Set POSTGRES_DIR" )
-    endif ( POSTGRES_REQUIRED )
-  else ( NOT POSTGRES_INCLUDE_DIRECTORIES OR NOT POSTGRES_LIBRARIES ) 
-    set( POSTGRES_FOUND 1 )
-    mark_as_advanced( POSTGRES_FOUND )
-  endif ( NOT POSTGRES_INCLUDE_DIRECTORIES OR NOT POSTGRES_LIBRARIES )
-
-endif ( NOT POSTGRES_INCLUDE_DIRECTORIES OR NOT POSTGRES_LIBRARIES OR NOT POSTGRES_FOUND )
-
-mark_as_advanced( FORCE POSTGRES_INCLUDE_DIRECTORIES )
-mark_as_advanced( FORCE POSTGRES_LIBRARIES )

CMake/KitCommonBlock.cmake

-# Setup vtkInstantiator registration for this library's classes.
-VTK_MAKE_INSTANTIATOR3(vtk${KIT}Instantiator KitInstantiator_SRCS
-                       "${Kit_SRCS}"
-                       VTK_${UKIT}_EXPORT
-                       ${VTK_BINARY_DIR} "")
-
-VTK_ADD_LIBRARY(vtk${KIT} ${Kit_SRCS} ${Kit_EXTRA_SRCS} ${KitInstantiator_SRCS})
-SET(KIT_LIBRARY_TARGETS ${KIT_LIBRARY_TARGETS} vtk${KIT})
-
-# accumulate list of kit library target names
-# we export these in VTKConfig as VTK_LIBRARIES.
-set_property(GLOBAL APPEND PROPERTY VTK_LIBRARIES vtk${KIT})
-
-# Add target specific compile flags for ABI setttings
-IF(VTK_ABI_CXX_FLAGS)
-  SET_PROPERTY(TARGET vtk${KIT} APPEND
-    PROPERTY COMPILE_FLAGS "${VTK_ABI_CXX_FLAGS}")
-ENDIF(VTK_ABI_CXX_FLAGS)
-
-# Allow the user to customize their build with some local options
-#
-SET(LOCALUSERMACRODEFINED 0)
-INCLUDE (${VTK_BINARY_DIR}/${KIT}/LocalUserOptions.cmake OPTIONAL)
-INCLUDE (${VTK_SOURCE_DIR}/${KIT}/LocalUserOptions.cmake OPTIONAL)
-
-IF (VTK_WRAP_TCL OR VTK_WRAP_PYTHON OR VTK_WRAP_JAVA)
-  # set the include directories for the wrappers
-  SET(VTK_WRAP_INCLUDE_DIRS
-    ${VTK_INCLUDE_DIRS_BUILD_TREE}
-    ${VTK_INCLUDE_DIRS_SOURCE_TREE}
-    ${VTK_INCLUDE_DIRS_SYSTEM}
-  )
-  # if we are wrapping anything, then build hierarchy files
-  IF(VTK_IGNORE_BTX)
-  SET(KIT_HIERARCHY_FILE ${CMAKE_CURRENT_BINARY_DIR}/vtk${KIT}Hierarchy.txt)
-  VTK_WRAP_HIERARCHY(vtk${KIT}Hierarchy
-    ${CMAKE_CURRENT_BINARY_DIR} "${Kit_SRCS}")
-  ENDIF(VTK_IGNORE_BTX)
-ENDIF (VTK_WRAP_TCL OR VTK_WRAP_PYTHON OR VTK_WRAP_JAVA)
-
-# if we are wrapping into Tcl then add the library and extra
-# source files
-#
-IF (VTK_WRAP_TCL)
-  INCLUDE(KitCommonTclWrapBlock)
-ENDIF (VTK_WRAP_TCL)
-
-# if we are wrapping into Python then add the library and extra
-# source files
-#
-IF (VTK_WRAP_PYTHON)
-  INCLUDE(KitCommonPythonWrapBlock)
-ENDIF (VTK_WRAP_PYTHON)
-
-# if we are wrapping into Java then add the library and extra
-# source files
-#
-IF (VTK_WRAP_JAVA)
-  INCLUDE(KitCommonJavaWrapBlock)
-ENDIF (VTK_WRAP_JAVA)
-
-TARGET_LINK_LIBRARIES(vtk${KIT} ${KIT_INTERFACE_LIBRARIES} ${KIT_LIBS})
-
-IF(NOT VTK_INSTALL_NO_LIBRARIES)
-  INSTALL(TARGETS vtk${KIT}
-    EXPORT ${VTK_INSTALL_EXPORT_NAME}
-    RUNTIME DESTINATION ${VTK_INSTALL_BIN_DIR_CM24} COMPONENT RuntimeLibraries
-    LIBRARY DESTINATION ${VTK_INSTALL_LIB_DIR_CM24} COMPONENT RuntimeLibraries
-    ARCHIVE DESTINATION ${VTK_INSTALL_LIB_DIR_CM24} COMPONENT Development)
-ENDIF(NOT VTK_INSTALL_NO_LIBRARIES)
-IF(NOT VTK_INSTALL_NO_DEVELOPMENT)
-  SET(__files.h)
-  FOREACH(__file ${Kit_SRCS})
-    GET_FILENAME_COMPONENT(__fname ${__file} ABSOLUTE)
-    GET_FILENAME_COMPONENT(__fname.path ${__fname} PATH)
-    GET_FILENAME_COMPONENT(__fname.name ${__fname} NAME_WE)
-    IF ( EXISTS "${__fname.path}/${__fname.name}.h" )
-      SET(__files.h ${__files.h} "${__fname.path}/${__fname.name}.h")
-    ENDIF ( EXISTS "${__fname.path}/${__fname.name}.h" )
-  ENDFOREACH(__file)
-  INSTALL(FILES ${__files.h}
-    DESTINATION ${VTK_INSTALL_INCLUDE_DIR_CM24}
-    COMPONENT Development)
-ENDIF(NOT VTK_INSTALL_NO_DEVELOPMENT)
-
-IF(Kit_WRAP_HEADERS)
-  SET_SOURCE_FILES_PROPERTIES(${Kit_WRAP_HEADERS} PROPERTIES WRAP_HEADER 1)
-ENDIF(Kit_WRAP_HEADERS)
-SET(TMP_FILES ${Kit_SRCS} ${Kit_WRAP_HEADERS})
-VTK_EXPORT_KIT("${KIT}" "${UKIT}" "${TMP_FILES}")
-
-# If the user defined a custom macro, execute it now and pass in all the srcs
-#
-IF(LOCALUSERMACRODEFINED)
-  LocalUserOptionsMacro( "${Kit_SRCS}"       "${Kit_EXTRA_SRCS}"
-                         "${KitTCL_SRCS}"    "${Kit_TCL_EXTRA_SRCS}"
-                         "${KitJava_SRCS}"   "${Kit_JAVA_EXTRA_SRCS}"
-                         "${KitPython_SRCS}" "${Kit_PYTHON_EXTRA_SRCS}")
-ENDIF(LOCALUSERMACRODEFINED)
-
-
-# Apply user-defined properties to the library targets.
-IF(VTK_LIBRARY_PROPERTIES)
-  SET_TARGET_PROPERTIES(${KIT_LIBRARY_TARGETS} PROPERTIES
-    ${VTK_LIBRARY_PROPERTIES}
-    )
-ENDIF(VTK_LIBRARY_PROPERTIES)
-# Mark KIT_INTERFACE_LIBRARIES as LINK_INTERFACE_LIBRARIES such that any executable
-# or library that links vtk${KIT} also links against KIT_INTERFACE_LIBRARIES
-TARGET_LINK_LIBRARIES(vtk${KIT} LINK_INTERFACE_LIBRARIES ${KIT_INTERFACE_LIBRARIES})
-

CMake/KitCommonJavaWrapBlock.cmake

-VTK_WRAP_JAVA3(vtk${KIT}Java KitJava_SRCS "${Kit_SRCS};${Kit_JAVA_EXTRA_WRAP_SRCS}")
-VTK_ADD_LIBRARY(vtk${KIT}Java SHARED ${KitJava_SRCS} ${Kit_JAVA_EXTRA_SRCS})
-# Force JavaClasses to build in the right order by adding a depenency.
-ADD_DEPENDENCIES(vtk${KIT}JavaJavaClasses vtk${KIT}Java)
-SET(KIT_LIBRARY_TARGETS ${KIT_LIBRARY_TARGETS} vtk${KIT}Java)
-TARGET_LINK_LIBRARIES(vtk${KIT}Java vtk${KIT} ${KIT_JAVA_LIBS})
-IF(NOT VTK_INSTALL_NO_LIBRARIES)
-  INSTALL(TARGETS vtk${KIT}Java
-    EXPORT ${VTK_INSTALL_EXPORT_NAME}
-    RUNTIME DESTINATION ${VTK_INSTALL_BIN_DIR_CM24} COMPONENT RuntimeLibraries
-    LIBRARY DESTINATION ${VTK_INSTALL_LIB_DIR_CM24} COMPONENT RuntimeLibraries
-    ARCHIVE DESTINATION ${VTK_INSTALL_LIB_DIR_CM24} COMPONENT Development)
-ENDIF(NOT VTK_INSTALL_NO_LIBRARIES)
-ADD_DEPENDENCIES(vtk${KIT}Java vtk${KIT})
-IF(KIT_JAVA_DEPS)
-  ADD_DEPENDENCIES(vtk${KIT}Java ${KIT_JAVA_DEPS})
-ENDIF(KIT_JAVA_DEPS)
-

CMake/KitCommonPythonWrapBlock.cmake

-# Create custom commands to generate the python wrappers for this kit.
-SET(TMP_WRAP_FILES ${Kit_SRCS} ${Kit_WRAP_HEADERS})
-VTK_WRAP_PYTHON3(vtk${KIT}Python KitPython_SRCS "${TMP_WRAP_FILES}")
-
-INCLUDE_DIRECTORIES("${PYTHON_INCLUDE_PATH}")
-
-# Create a shared library containing the python wrappers.  Executables
-# can link to this but it is not directly loaded dynamically as a
-# module.
-VTK_ADD_LIBRARY(vtk${KIT}PythonD ${KitPython_SRCS} ${Kit_PYTHON_EXTRA_SRCS})
-TARGET_LINK_LIBRARIES(
-  vtk${KIT}PythonD vtk${KIT} vtkPythonCore ${KIT_PYTHON_LIBS})
-IF(NOT VTK_INSTALL_NO_LIBRARIES)
-  INSTALL(TARGETS vtk${KIT}PythonD
-    EXPORT ${VTK_INSTALL_EXPORT_NAME}
-    RUNTIME DESTINATION ${VTK_INSTALL_BIN_DIR_CM24} COMPONENT RuntimeLibraries
-    LIBRARY DESTINATION ${VTK_INSTALL_LIB_DIR_CM24} COMPONENT RuntimeLibraries
-    ARCHIVE DESTINATION ${VTK_INSTALL_LIB_DIR_CM24} COMPONENT Development)
-  SET(KIT_LIBRARY_TARGETS ${KIT_LIBRARY_TARGETS} vtk${KIT}PythonD)
-ENDIF(NOT VTK_INSTALL_NO_LIBRARIES)
-
-IF(VTK_WRAP_PYTHON_SIP)
-  INCLUDE(${VTK_CMAKE_DIR}/vtkWrapPythonSIP.cmake)
-  VTK_CREATE_SIP_MODULE(${KIT} "${Kit_SRCS}")
-ENDIF(VTK_WRAP_PYTHON_SIP)
-
-
-# Underlinking on purpose. The following library will not compile
-# with LDFLAGS=-Wl,--no-undefined by design:
-# On some UNIX platforms the python library is static and therefore
-# should not be linked into the shared library.  Instead the symbols
-# are exported from the python executable so that they can be used by
-# shared libraries that are linked or loaded.  On Windows and OSX we
-# want to link to the python libray to resolve its symbols
-# immediately.
-#IF(WIN32 OR APPLE)
-#  TARGET_LINK_LIBRARIES (vtk${KIT}PythonD ${VTK_PYTHON_LIBRARIES})
-#ENDIF(WIN32 OR APPLE)
-
-# Add a top-level dependency on the main kit library.  This is needed
-# to make sure no python source files are generated until the
-# hierarchy file is built (it is built when the kit library builds)
-ADD_DEPENDENCIES(vtk${KIT}PythonD vtk${KIT})
-
-# Add dependencies that may have been generated by VTK_WRAP_PYTHON3 to
-# the python wrapper library.  This is needed for the
-# pre-custom-command hack in Visual Studio 6.
-IF(KIT_PYTHON_DEPS)
-  ADD_DEPENDENCIES(vtk${KIT}PythonD ${KIT_PYTHON_DEPS})
-ENDIF(KIT_PYTHON_DEPS)
-
-# Create a python module that can be loaded dynamically.  It links to
-# the shared library containing the wrappers for this kit.
-PYTHON_ADD_MODULE(vtk${KIT}Python vtk${KIT}PythonInit.cxx)
-IF(PYTHON_ENABLE_MODULE_vtk${KIT}Python)
-  TARGET_LINK_LIBRARIES(vtk${KIT}Python vtk${KIT}PythonD)
-  
-  # Python extension modules on Windows must have the extension ".pyd"
-  # instead of ".dll" as of Python 2.5.  Older python versions do support
-  # this suffix.
-  IF(WIN32 AND NOT CYGWIN)
-    SET_TARGET_PROPERTIES(vtk${KIT}Python PROPERTIES SUFFIX ".pyd")
-  ENDIF(WIN32 AND NOT CYGWIN)
-
-  # Make sure that no prefix is set on the library
-  SET_TARGET_PROPERTIES(vtk${KIT}Python PROPERTIES PREFIX "")
-
-  # Compatibility for projects that still expect the "lib" prefix
-  IF(CYGWIN OR NOT WIN32)
-    SET(suf ${CMAKE_SHARED_MODULE_SUFFIX})
-    SET(src vtk${KIT}Python${suf})
-    SET(tgt ${LIBRARY_OUTPUT_PATH}/libvtk${KIT}Python${suf})
-    ADD_CUSTOM_COMMAND(TARGET vtk${KIT}Python POST_BUILD
-      COMMAND ${CMAKE_COMMAND} -E create_symlink ${src} ${tgt})
-  ENDIF(CYGWIN OR NOT WIN32)
-
-  # The python modules are installed by a setup.py script which does
-  # not know how to adjust the RPATH field of the binary.  Therefore
-  # we must simply build the modules with no RPATH at all.  The
-  # vtkpython executable in the build tree should have the needed
-  # RPATH anyway.
-  SET_TARGET_PROPERTIES(vtk${KIT}Python PROPERTIES SKIP_BUILD_RPATH 1)
-  
-  IF(WIN32 OR APPLE)
-    TARGET_LINK_LIBRARIES (vtk${KIT}Python ${VTK_PYTHON_LIBRARIES})
-  ENDIF(WIN32 OR APPLE)
-
-  # Generally the pyhon extension module created is installed using setup.py.
-  # However projects that include VTK (such as ParaView) can override this
-  # behaviour by not using setup.py, instead directly installing the extension
-  # module at the same location as other libraries.
-  IF (VTK_INSTALL_PYTHON_USING_CMAKE AND NOT VTK_INSTALL_NO_LIBRARIES)
-    INSTALL(TARGETS vtk${KIT}Python
-      EXPORT ${VTK_INSTALL_EXPORT_NAME}
-      RUNTIME DESTINATION ${VTK_INSTALL_BIN_DIR_CM24} COMPONENT RuntimeLibraries
-      LIBRARY DESTINATION ${VTK_INSTALL_LIB_DIR_CM24} COMPONENT RuntimeLibraries
-      ARCHIVE DESTINATION ${VTK_INSTALL_LIB_DIR_CM24} COMPONENT Development)
-  ENDIF (VTK_INSTALL_PYTHON_USING_CMAKE AND NOT VTK_INSTALL_NO_LIBRARIES)
-ENDIF(PYTHON_ENABLE_MODULE_vtk${KIT}Python)

CMake/KitCommonTclWrapBlock.cmake

-VTK_WRAP_TCL3(vtk${KIT}TCL KitTCL_SRCS
-  "${Kit_SRCS}"
-  "${Kit_TCL_EXTRA_CMDS}")
-VTK_ADD_LIBRARY(vtk${KIT}TCL ${KitTCL_SRCS} ${Kit_TCL_EXTRA_SRCS})
-SET(KIT_LIBRARY_TARGETS ${KIT_LIBRARY_TARGETS} vtk${KIT}TCL)
-TARGET_LINK_LIBRARIES (vtk${KIT}TCL vtk${KIT} ${KIT_TCL_LIBS})
-IF(NOT VTK_INSTALL_NO_LIBRARIES)
-  INSTALL(TARGETS vtk${KIT}TCL
-    EXPORT ${VTK_INSTALL_EXPORT_NAME}
-    RUNTIME DESTINATION ${VTK_INSTALL_BIN_DIR_CM24} COMPONENT RuntimeLibraries
-    LIBRARY DESTINATION ${VTK_INSTALL_LIB_DIR_CM24} COMPONENT RuntimeLibraries
-    ARCHIVE DESTINATION ${VTK_INSTALL_LIB_DIR_CM24} COMPONENT Development)
-ENDIF(NOT VTK_INSTALL_NO_LIBRARIES)
-ADD_DEPENDENCIES(vtk${KIT}TCL vtk${KIT})
-IF(KIT_TCL_DEPS)
-  ADD_DEPENDENCIES(vtk${KIT}TCL ${KIT_TCL_DEPS})
-ENDIF(KIT_TCL_DEPS)
-

CMake/vtkHDF5Library.cmake

-#########################################################################
-# Configure HDF5
-
-IF(NOT VTK_USE_SYSTEM_HDF5)
-
-  # Tell hdf5 that we are manually overriding certain settings
-  SET(HDF5_EXTERNALLY_CONFIGURED ON)
-  # Avoid duplicating names of installed libraries
-  SET(HDF5_EXTERNAL_LIB_PREFIX "vtk")
-  # Export configuration to this export variable
-  SET(HDF5_EXPORTED_TARGETS ${VTK_INSTALL_EXPORT_NAME})
-  
-  # Silence HDF5's warnings. We'll let them get fixed upstream
-  # and merge in updates as necessary.
-  SET(HDF5_DISABLE_COMPILER_WARNINGS ON CACHE BOOL "Disable HDF5 warnings" FORCE)
-
-  SET(HDF5_INSTALL_NO_DEVELOPMENT ${VTK_INSTALL_NO_DEVELOPMENT})
-  SET(HDF5_INSTALL_BIN_DIR ${VTK_INSTALL_BIN_DIR})
-  SET(HDF5_INSTALL_LIB_DIR ${VTK_INSTALL_LIB_DIR})
-  SET(HDF5_INSTALL_INCLUDE_DIR ${VTK_INSTALL_INCLUDE_DIR})
-
-  SET(HDF5_ENABLE_Z_LIB_SUPPORT ON CACHE BOOL "Enable Zlib Filters" FORCE)
-  SET(HDF5_BUILD_HL_LIB ON CACHE BOOL "Build HIGH Level HDF5 Library" FORCE)
-
-  # Setup all necessary overrides for zlib so that HDF5 uses our
-  # internally compiled zlib rather than any other version
-  IF(HDF5_ENABLE_Z_LIB_SUPPORT)
-    # We must tell the main HDF5 library that it depends on our zlib
-    SET(HDF5_LIB_DEPENDENCIES vtkzlib)
-    # Override the zlib header file
-    IF(VTK_USE_SYSTEM_ZLIB)
-      SET(H5_ZLIB_HEADER "zlib.h")
-    ELSE(VTK_USE_SYSTEM_ZLIB)
-      SET(H5_ZLIB_HEADER "vtk_zlib.h")
-      # Set vars that FindZlib would have set if used in sub project
-      SET(ZLIB_INCLUDE_DIRS "${VTK_ZLIB_INCLUDE_DIRS}")
-      SET(ZLIB_LIBRARIES vtkzlib)
-    ENDIF(VTK_USE_SYSTEM_ZLIB)
-  ENDIF(HDF5_ENABLE_Z_LIB_SUPPORT)
-
-  LIST(APPEND VTK_HDF5_LIBRARIES vtkhdf5_hl)
-
-  MARK_AS_ADVANCED(
-    H5_SET_LIB_OPTIONS
-    H5_LEGACY_NAMING
-    HDF5_ENABLE_COVERAGE
-    HDF5_DISABLE_COMPILER_WARNINGS
-    HDF5_ENABLE_PARALLEL
-    HDF5_USE_16_API_DEFAULT
-    HDF5_USE_FILTER_FLETCHER32
-    HDF5_USE_FILTER_NBIT
-    HDF5_USE_FILTER_SCALEOFFSET
-    HDF5_USE_FILTER_SHUFFLE
-    HDF5_ENABLE_Z_LIB_SUPPORT
-    HDF5_ENABLE_SZIP_SUPPORT
-    HDF5_ENABLE_SZIP_ENCODING
-    HDF5_ENABLE_THREADSAFE
-    HDF5_ENABLE_TRACE
-    HDF5_USE_H5DUMP_PACKED_BITS
-    HDF5_BUILD_FORTRAN
-    HDF5_BUILD_EXAMPLES
-    HDF5_BUILD_CPP_LIB
-    HDF5_BUILD_TOOLS
-    HDF5_BUILD_HL_LIB
-    HDF5_Enable_Clear_File_Buffers
-    HDF5_Enable_Instrument
-    HDF5_STRICT_FORMAT_CHECKS
-    HDF5_METADATA_TRACE_FILE
-    HDF5_WANT_DATA_ACCURACY
-    HDF5_WANT_DCONV_EXCEPTION
-    HDF5_ENABLE_LARGE_FILE
-    HDF5_STREAM_VFD
-    HDF5_ENABLE_HSIZET
-    H5_SET_LIB_OPTIONS
-    HDF5_BUILD_WITH_INSTALL_NAME
-    HDF5_PACKAGE_EXTLIBS
-    )
-
-ENDIF(NOT VTK_USE_SYSTEM_HDF5)

CMake/vtkTargetExportMacros.cmake

-if(NOT VTK_INSTALL_EXPORT_NAME)
-  set(VTK_INSTALL_EXPORT_NAME VTKTargets)
-endif()
-
-MACRO(VTK_ADD_LIBRARY name)
-  add_library(${name} ${ARGN})
-  if (NOT VTK_INSTALL_NO_LIBRARIES)
-    set_property(GLOBAL APPEND PROPERTY VTK_TARGETS ${name})
-  endif (NOT VTK_INSTALL_NO_LIBRARIES)
-ENDMACRO(VTK_ADD_LIBRARY)
-
-MACRO(VTK_ADD_EXECUTABLE name)
-  if(UNIX AND VTK_BUILD_FORWARDING_EXECUTABLES)
-    vtk_add_executable_with_forwarding(VTK_EXE_SUFFIX ${name} ${ARGN})
-    set_property(GLOBAL APPEND PROPERTY VTK_TARGETS ${name})
-  else()
-    add_executable(${name} ${ARGN})
-    set_property(GLOBAL APPEND PROPERTY VTK_TARGETS ${name})
-  endif()
-ENDMACRO(VTK_ADD_EXECUTABLE)

Charts/CMakeLists.txt

-SET(KIT Charts)
-SET(UKIT CHARTS)
-
-SET(KIT_TCL_LIBS vtkViewsTCL ${VTK_TK_LIBRARIES})
-SET(KIT_PYTHON_LIBS vtkViewsPythonD)
-SET(KIT_JAVA_LIBS vtkViewsJava)
-
-IF (JAVA_AWT_LIBRARY)
-  SET(KIT_JAVA_LIBS ${KIT_JAVA_LIBS} ${JAVA_AWT_LIBRARY})
-ENDIF (JAVA_AWT_LIBRARY)
-
-SET(KIT_INTERFACE_LIBRARIES vtkViews)
-SET(KIT_LIBS vtkftgl)
-
-SET(Kit_SRCS
-  vtkAbstractContextBufferId.cxx
-  vtkAbstractContextItem.cxx
-  vtkAxis.cxx
-  vtkAxisExtended.cxx
-  vtkBlockItem.cxx
-  vtkBrush.cxx
-  vtkChart.cxx
-  vtkChartLegend.cxx
-  vtkChartHistogram2D.cxx
-  vtkChartMatrix.cxx
-  vtkChartParallelCoordinates.cxx
-  vtkChartXY.cxx
-  vtkChartXYZ.cxx
-  vtkChartPie.cxx
-  vtkColorLegend.cxx
-  vtkPlotPie.cxx
-  vtkColorSeries.cxx
-  vtkColorTransferFunctionItem.cxx
-  vtkColorTransferControlPointsItem.cxx
-  vtkCompositeControlPointsItem.cxx
-  vtkCompositeTransferFunctionItem.cxx
-  vtkContext2D.cxx
-  vtkContext3D.cxx
-  vtkContextActor.cxx
-  vtkContextBufferId.cxx
-  vtkContextClip.cxx
-  vtkContextDevice2D.cxx
-  vtkContextDevice3D.cxx
-  vtkContextInteractorStyle.cxx
-  vtkContextItem.cxx
-  vtkContextKeyEvent.cxx
-  vtkContextMapper2D.cxx
-  vtkContextMouseEvent.cxx
-  vtkContextScene.cxx
-  vtkContextTransform.cxx
-  vtkContextView.cxx
-  vtkControlPointsItem.cxx
-  vtkImageItem.cxx
-  vtkLookupTableItem.cxx
-  vtkOpenGLContextBufferId.cxx
-  vtkOpenGL2ContextDevice2D.cxx
-  vtkOpenGLContextDevice2D.cxx
-  vtkOpenGLContextDevice3D.cxx
-  vtkPen.cxx
-  vtkPiecewiseControlPointsItem.cxx
-  vtkPiecewiseFunctionItem.cxx
-  vtkPiecewisePointHandleItem.cxx
-  vtkPlot.cxx
-  vtkPlotBar.cxx
-  vtkPlotGrid.cxx
-  vtkPlotHistogram2D.cxx
-  vtkPlotLine.cxx
-  vtkPlotStacked.cxx
-  vtkPlotParallelCoordinates.cxx
-  vtkPlotPoints.cxx
-  vtkScalarsToColorsItem.cxx
-  vtkScatterPlotMatrix.cxx
-  vtkTooltipItem.cxx
-  )
-
-SET_SOURCE_FILES_PROPERTIES(
-  vtkAbstractContextBufferId
-  vtkAbstractContextItem
-  vtkChart
-  vtkContextDevice2D
-  vtkContextDevice3D
-  vtkContextItem
-  vtkContextMapper2D
-  vtkControlPointsItem
-  vtkPlot
-  vtkScalarsToColorsItem
-  ABSTRACT
-  )
-
-SET_SOURCE_FILES_PROPERTIES(
-  vtkAbstractContextBufferId
-  vtkContextBufferId
-  vtkContextKeyEvent
-  vtkContextMouseEvent
-  vtkChartColors
-  vtkOpenGLContextBufferId
-  vtkOpenGL2ContextDevice2D
-  vtkOpenGLContextDevice2D
-  vtkOpenGLContextDevice3D
-  WRAP_EXCLUDE
-)
-
-# Need to be able to include QApplication if Qt is used for runtime checks
-IF(VTK_USE_QT)
-  SET(QT_DONT_USE_QTGUI)
-  INCLUDE(${QT_USE_FILE})
-  IF (APPLE)
-    LIST (APPEND KIT_INTERFACE_LIBRARIES ${QT_LIBRARIES})
-  ELSE (APPLE)
-    LIST (APPEND KIT_LIBS ${QT_LIBRARIES})
-  ENDIF (APPLE)
-ENDIF(VTK_USE_QT)
-
-#-----------------------------------------------------------------------------
-# Include CMake code common to all kits.
-INCLUDE(${VTK_CMAKE_DIR}/KitCommonBlock.cmake)
-#-----------------------------------------------------------------------------

Charts/Testing/CMakeLists.txt

-ADD_SUBDIRECTORY(Cxx)
-
-#IF (VTK_WRAP_TCL)
-#  ADD_SUBDIRECTORY(Tcl)
-#ENDIF (VTK_WRAP_TCL)
-
-IF(VTK_WRAP_PYTHON)
-  ADD_SUBDIRECTORY(Python)
-ENDIF(VTK_WRAP_PYTHON)
-
-IF(PYTHON_EXECUTABLE)
-  ADD_TEST(HeaderTesting-Charts ${PYTHON_EXECUTABLE}
-    ${VTK_SOURCE_DIR}/Common/Testing/HeaderTesting.py
-    "${VTK_SOURCE_DIR}/Charts"
-    VTK_CHARTS_EXPORT
-    vtkContextKeyEvent.h
-    vtkContextMouseEvent.h
-    vtkContextScenePrivate.h
-    vtkOpenGLContextDevice2DPrivate.h
-    )
-ENDIF(PYTHON_EXECUTABLE)

Charts/Testing/Python/CMakeLists.txt

-IF (VTK_USE_RENDERING AND VTK_USE_DISPLAY)
-
-  IF(VTK_PYTHON_EXE)
-    SET(tests)
-    IF(VTK_DATA_ROOT)
-      # Tests written in Python that require VTKData
-      # These tests should use vtk.test.Testing.
-      SET(tests
-        ${tests}
-        TestBarGraph
-        TestLinePlot
-        TestStackedPlot
-        TestLinePlotColors
-        TestParallelCoordinatesColors
-        TestScatterPlotColors
-      )
-    ELSE()
-      # Tests written in Python that do NOT require VTKData
-      # These tests should use vtk.test.Testing.
-      SET(tests
-        ${tests}
-      )
-    ENDIF()
-    IF(tests)
-      FOREACH(tfile ${tests})
-        ADD_TEST(Charts-${tfile}Python ${VTK_PYTHON_EXE}
-          ${VTK_SOURCE_DIR}/Charts/Testing/Python/${tfile}.py
-          -D ${VTK_DATA_ROOT}
-          -B ${VTK_DATA_ROOT}/Baseline/Charts)
-      ENDFOREACH()
-    ENDIF()
-  ENDIF()
-ENDIF()

Chemistry/Testing/CMakeLists.txt

-ADD_SUBDIRECTORY(Cxx)

Chemistry/Testing/Cxx/CMakeLists.txt

-IF (VTK_USE_RENDERING AND VTK_USE_CHEMISTRY)
-
-  SET(KIT Chemistry)
-
-  SET(MyTests
-    TestBallAndStick.cxx
-    TestBondColorModeDiscreteByAtom.cxx
-    TestBondColorModeSingleColor.cxx
-    TestCompositeRender.cxx
-    TestFastRender.cxx
-    TestLiquoriceSticks.cxx
-    TestMolecule.cxx
-    TestMoleculeSelection.cxx
-    TestMultiCylinderOn.cxx
-    TestMultiCylinderOff.cxx
-    TestPeriodicTable.cxx
-    TestProgrammableElectronicData.cxx
-    TestSimpleBondPerceiver.cxx
-    TestVDWSpheres.cxx
-    )
-
-  # Tests with data
-  IF(VTK_DATA_ROOT)
-    SET(MyTests
-      ${MyTests}
-      TestCMLMoleculeReader.cxx
-      )
-    IF(VTK_USE_OPENQUBE)
-      INCLUDE(${QT_USE_FILE})
-      # Add Eigen to the include path for the OpenQube headers
-      INCLUDE_DIRECTORIES(${EIGEN2_INCLUDE_DIR})
-      SET(MyTests
-        ${MyTests}
-        TestOpenQubeElectronicData.cxx
-        TestOpenQubeMOPACDensity.cxx
-        TestOpenQubeMOPACOrbital.cxx
-      )
-    ENDIF(VTK_USE_OPENQUBE)
-  ENDIF(VTK_DATA_ROOT)
-
-  # Use the testing object factory, to reduce boilerplate code in tests.
-  INCLUDE("${VTK_SOURCE_DIR}/Rendering/vtkTestingObjectFactory.cmake")
-  ADD_EXECUTABLE(${KIT}CxxTests ${Tests})
-  TARGET_LINK_LIBRARIES(${KIT}CxxTests
-                        vtkChemistry
-                        vtkRendering
-                        vtkVolumeRendering)
-
-  SET (TestsToRun ${Tests})
-  REMOVE (TestsToRun ${KIT}CxxTests.cxx)
-
-  # Add all the executables
-  FOREACH (test ${TestsToRun})
-    GET_FILENAME_COMPONENT(TName ${test} NAME_WE)
-    IF (VTK_DATA_ROOT)
-      IF(${${TName}Error})
-        SET(_error_threshold ${${TName}Error})
-      ELSE()
-        SET(_error_threshold 10)
-      ENDIF()
-      ADD_TEST(Chemistry-${TName} ${CXX_TEST_PATH}/${KIT}CxxTests ${TName}
-        -D ${VTK_DATA_ROOT}
-        -T ${VTK_BINARY_DIR}/Testing/Temporary
-        -V Baseline/${KIT}/${TName}.png
-        -E ${_error_threshold})
-    ELSE (VTK_DATA_ROOT)
-      ADD_TEST(Chemistry-${TName} ${CXX_TEST_PATH}/${KIT}CxxTests ${TName})
-    ENDIF (VTK_DATA_ROOT)
-  ENDFOREACH (test)
-
-ENDIF (VTK_USE_RENDERING AND VTK_USE_CHEMISTRY)

Common/Testing/CMakeLists.txt

-ADD_SUBDIRECTORY(Cxx)
-
-IF (VTK_WRAP_TCL)
-  ADD_SUBDIRECTORY(Tcl)
-ENDIF (VTK_WRAP_TCL)
-
-IF (VTK_WRAP_PYTHON)
-  ADD_SUBDIRECTORY(Python)
-ENDIF (VTK_WRAP_PYTHON)
-
-IF(PYTHON_EXECUTABLE)
-  ADD_TEST(HeaderTesting-Common ${PYTHON_EXECUTABLE}
-    ${VTK_SOURCE_DIR}/Common/Testing/HeaderTesting.py
-    "${VTK_SOURCE_DIR}/Common"
-    VTK_COMMON_EXPORT
-    vtkABI.h
-    vtkAbstractIterator.h
-    vtkAbstractList.h
-    vtkAbstractMap.h
-    vtkArray.h
-    vtkArrayCoordinateIterator.h
-    vtkArrayCoordinates.h
-    vtkArrayExtents.h
-    vtkArrayExtentsList.h
-    vtkArrayInterpolate.h
-    vtkArrayIteratorIncludes.h
-    vtkArrayIteratorTemplate.h
-    vtkArrayMap.h
-    vtkArrayMapIterator.h
-    vtkArrayPrint.h
-    vtkArrayRange.h
-    vtkArraySort.h
-    vtkArrayWeights.h
-    vtkAssemblyPaths.h
-    vtkBoundingBox.h
-    vtkBreakPoint.h
-    vtkByteSwap.h
-    vtkCallbackCommand.h
-    vtkColor.h
-    vtkCommand.h
-    vtkCommonInformationKeyManager.h
-    vtkContainer.h
-    vtkDataArrayCollection.h
-    vtkDataArrayTemplate.h
-    vtkDebugLeaks.h
-    vtkDebugLeaksManager.h
-    vtkDenseArray.h
-    vtkDynamicLoader.h
-    vtkErrorCode.h
-    vtkEventForwarderCommand.h
-    vtkFloatingPointExceptions.h
-    vtkGarbageCollector.h
-    vtkGarbageCollectorManager.h
-    vtkHashMap.h
-    vtkHashMapIterator.h
-    vtkIOStream.h
-    vtkIOStreamFwd.h
-    vtkIdListCollection.h
-    vtkImplicitFunctionCollection.h
-    vtkIndent.h
-    vtkInformation.h
-    vtkInformationInternals.h
-    vtkJavaAwt.h
-    vtkJavaUtil.h
-    vtkLargeInteger.h
-    vtkLinkedList.h
-    vtkLinkedListIterator.h
-    vtkMathUtilities.h
-    vtkNew.h
-    vtkOStrStreamWrapper.h
-    vtkOStreamWrapper.h
-    vtkObject.h
-    vtkObjectBase.h
-    vtkObjectFactoryCollection.h
-    vtkOldStyleCallbackCommand.h
-    vtkOnePieceExtentTranslator.h
-    vtkOverrideInformationCollection.h
-    vtkPlaneCollection.h
-    vtkPropCollection.h
-    vtkPythonCommand.h
-    vtkRayCastStructures.h
-    vtkRect.h
-    vtkRungeKutta2.h 
-    vtkSetGet.h
-    vtkSmartPointer.h
-    vtkSmartPointerBase.h
-    vtkSparseArray.h
-    vtkStdString.h
-    vtkStructuredData.h
-    vtkSystemIncludes.h
-    vtkTcl.h
-    vtkTclUtil.h
-    vtkTemplateAliasMacro.h
-    vtkTimeStamp.h
-    vtkTk.h
-    vtkTransformCollection.h
-    vtkTryDowncast.h
-    vtkType.h
-    vtkTypeTemplate.h
-    vtkTypeTraits.h
-    vtkTypedArray.h
-    vtkUnicodeString.h
-    vtkVariant.h
-    vtkVariantBoostSerialization.h
-    vtkVariantCast.h
-    vtkVariantCreate.h
-    vtkVariantExtract.h
-    vtkVariantInlineOperators.h
-    vtkVector.h
-    vtkTuple.h
-    vtkVectorIterator.h
-    vtkVectorOperators.h
-    vtkVersion.h
-    vtkWeakPointer.h
-    vtkWeakPointerBase.h
-    vtkWin32Header.h
-    vtkWindows.h
-    vtkXMLFileOutputWindow.h
-    )
-ENDIF(PYTHON_EXECUTABLE)
-
-#-----------------------------------------------------------------------------
-# Configure the VTK install test.  It is enabled only if the install
-# prefix is set to an InstallTest/Root directory under the top of the build
-# tree.  Note that the install prefix used for the install test must
-# not be a 1-level deep subdirectory under the top of the build tree.
-# If it were such then a few executables may be confused into thinking
-# they are running from the build tree instead of the install tree.
-IF(WIN32 OR APPLE)
-  STRING(TOLOWER "${CMAKE_INSTALL_PREFIX}" VTK_TEST_INSTALL_LEFT)
-  STRING(TOLOWER "${VTK_BINARY_DIR}/InstallTest/Root" VTK_TEST_INSTALL_RIGHT)
-ELSE(WIN32 OR APPLE)
-  SET(VTK_TEST_INSTALL_LEFT "${CMAKE_INSTALL_PREFIX}")
-  SET(VTK_TEST_INSTALL_RIGHT "${VTK_BINARY_DIR}/InstallTest/Root")
-ENDIF(WIN32 OR APPLE)
-STRING(COMPARE EQUAL "${VTK_TEST_INSTALL_LEFT}" "${VTK_TEST_INSTALL_RIGHT}"
-  VTK_TEST_INSTALL)
-
-# We cannot safely implement the install test unless the configuration
-# type is known when the test is run.
-IF(NOT VTK_TEST_CONFIG_TYPE_KNOWN)
-  SET(VTK_TEST_INSTALL 0)
-ENDIF(NOT VTK_TEST_CONFIG_TYPE_KNOWN)
-
-IF(VTK_TEST_INSTALL)
-  IF(CMAKE_CONFIGURATION_TYPES)
-    # There are multiple configurations.  Make sure the tested
-    # configuration is the one that is installed.
-    SET(DOLLAR "$")
-    SET(VTK_INSTALL_TEST_CONFIG_TYPE -C "${DOLLAR}{CTEST_CONFIGURATION_TYPE}")
-  ELSE(CMAKE_CONFIGURATION_TYPES)
-    # There is only one configuration.  It will be installed.
-    SET(VTK_INSTALL_TEST_CONFIG_TYPE)
-  ENDIF(CMAKE_CONFIGURATION_TYPES)
-
-  # Add a test to install VTK through the build system install target.
-  ADD_TEST(Install
-    ${CMAKE_CTEST_COMMAND}
-    ${VTK_INSTALL_TEST_CONFIG_TYPE}
-    --build-and-test ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR}
-    --build-generator ${CMAKE_GENERATOR}
-    --build-project VTK
-    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
-    --build-noclean
-    --build-target install)
-ENDIF(VTK_TEST_INSTALL)
-
-# Suppress memory checking of some tests
-CONFIGURE_FILE(${VTK_SOURCE_DIR}/Common/Testing/CTestCustom.ctest.in
-  ${VTK_BINARY_DIR}/Common/Testing/CTestCustom.ctest @ONLY)