Commit c13ff7ba authored by VTK Developers's avatar VTK Developers Committed by Brad King
Browse files

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>
parent d139b172
## 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 )
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
This diff is collapsed.
#
# 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)
#
# 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
)
#
# 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)
INCLUDE(${CMAKE_ROOT}/Modules/FindLibXml2.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 )
# 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})
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)
# 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)
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)
#########################################################################
# 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)
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)
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