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