CMakeLists.txt 16.4 KB
Newer Older
1
project(Xdmf)
2
cmake_minimum_required(VERSION 2.8.5)
Ken Leiter (Civ's avatar
Ken Leiter (Civ committed
3

4 5 6
#Needed to build DSM because relative paths are used to add its libraries
if (POLICY CMP0015)
	cmake_policy(SET CMP0015 NEW)
7
endif ()
8

9 10 11 12
if(MSVC10)
	SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR})
	SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR})
	SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR})
13 14
endif()

15 16
include(CheckCXXSourceCompiles)

17
set(XDMF_LIBNAME "Xdmf" CACHE STRING "Name for this xdmf library to avoid collision")
18

19 20 21 22 23 24 25 26 27
if(BUILD_SHARED_LIBS)
  set(LIBTYPE SHARED)
  set(BUILD_SHARED 1)
else()
  set(LIBTYPE STATIC)
endif()
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/XdmfConfig.hpp.in
               ${CMAKE_CURRENT_BINARY_DIR}/XdmfConfig.hpp)

28 29 30 31 32 33 34
if (WIN32)
  set(XDMF_STATIC_AND_SHARED OFF)
else()
  option(XDMF_STATIC_AND_SHARED
       "Build both static and shared libraries" ON)
  mark_as_advanced(FORCE XDMF_STATIC_AND_SHARED)
endif()
35 36 37 38 39 40 41

# Enable CMake testing
option(XDMF_BUILD_TESTING "Build Tests" OFF)
if(XDMF_BUILD_TESTING)
  enable_testing()
  include(CTest)
endif()
42

43
if (XDMF_STATIC_AND_SHARED)
44
  add_definitions(-DXDMFSTATIC)
45
endif ()
46

47
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
48
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/CMake/VersionSuite)
49 50 51 52 53 54 55 56 57
include_directories(${CMAKE_CURRENT_BINARY_DIR})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
list(APPEND CMAKE_MODULE_PATH
  ${CMAKE_CURRENT_SOURCE_DIR}/CMake
  ${CMAKE_CURRENT_SOURCE_DIR}/CMake/VersionSuite)
if(XDMF_BUILD_TESTING)
  list(APPEND CMAKE_MODULE_PATH
    ${CMAKE_CURRENT_SOURCE_DIR}/CMake/TestingSuite)
endif()
Ken Leiter (Civ's avatar
Ken Leiter (Civ committed
58

59
include(XdmfFunctions)
60

61 62 63
# Converting Install Prefix to an absolute path
get_filename_component(CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}" ABSOLUTE)

64
# RPath
65 66 67 68 69 70 71
option(XDMF_SET_RPATH ON)
if (XDMF_SET_RPATH)
  set(CMAKE_SKIP_BUILD_RPATH  FALSE)
  set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
  set(CMAKE_INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/lib)
  set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
endif ()
72

73 74 75
# Should we build with documentation
option(XDMF_BUILD_DOCUMENTATION OFF)
if(XDMF_BUILD_DOCUMENTATION)
76
  add_subdirectory(doc)
77
endif()
78

79 80 81 82
# Wrapper Setup
option(XDMF_WRAP_PYTHON OFF)
option(XDMF_WRAP_JAVA OFF)

83 84 85 86 87 88 89 90 91 92 93 94 95
#check for TIFF
find_package(TIFF)
if (TIFF_FOUND)
  add_definitions(-DXDMF_BUILD_TIFF)
  mark_as_advanced(FORCE TIFF_INCLUDE_DIR)
  mark_as_advanced(FORCE TIFF_LIBRARIES)
  mark_as_advanced(FORCE TIFF_LIBRARY)
  include_directories(${TIFF_INCLUDE_DIR})
  get_filename_component(TIFF_LIBRARY_DIR "${TIFF_LIBRARY}" PATH)
  set(XDMF_LIBRARY_DIRS ${XDMF_LIBRARY_DIRS} ${TIFF_LIBRARY_DIR})
  set(XDMF_LIBRARIES ${XDMF_LIBRARIES} ${TIFF_LIBRARIES})
endif (TIFF_FOUND)

96 97
# Test for DSM
option(XDMF_BUILD_DSM OFF)
98
mark_as_advanced(XDMF_BUILD_DSM)
99

100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
# Test for Cxx11
unset(HAVE_CXX11_SHARED_PTR CACHE)

check_cxx_source_compiles("
#include <memory>
using namespace std;

struct Base { virtual ~Base(){} };

int main(int ac, char * av[])
{
  shared_ptr<Base> ptr(new Base());
}
"
HAVE_CXX11_SHARED_PTR)

# Cxx11 does not work with swig due to an issue with swig
if (HAVE_CXX11_SHARED_PTR AND NOT XDMF_WRAP_PYTHON)
    set(HAVE_CXX11_SHARED_PTR ${HAVE_CXX11_SHARED_PTR} PARENT_SCOPE)
    add_definitions(-DHAVE_CXX11_SHARED_PTR)
endif ()


123
if(XDMF_BUILD_DSM)
124 125 126 127 128 129
  find_package(MPI REQUIRED)
  if(MPI_FOUND)
    include_directories(${MPI_INCLUDE_PATH})
    set(XDMF_LIBRARIES ${XDMF_LIBRARIES} ${MPI_LIBRARY} ${MPI_EXTRA_LIBRARY})
    get_filename_component(MPI_LIBRARY_DIR ${MPI_LIBRARY} PATH)
    set(XDMF_LIBRARY_DIRS ${XDMF_LIBRARY_DIRS} ${MPI_LIBRARY_DIR})
130 131 132 133
    # intel compiler requires an extra tag for CXX_FLAGS in order to properly build
    STRING(REGEX MATCH "icpc" IS_INTEL "${CMAKE_CXX_COMPILER}")
    if (NOT "${IS_INTEL}" STREQUAL "")
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMPICH_IGNORE_CXX_SEEK")
134 135
    endif ()
  endif()
136
  option(XDMF_BUILD_DSM_THREADS ON)
137 138 139
  if (XDMF_WRAP_PYTHON)
    mark_as_advanced(FORCE PYTHON_INCLUDE_MPI4PY_DIR)
    set(PYTHON_INCLUDE_MPI4PY_DIR "" CACHE STRING "Directory containing mpi4py/mpi4py.i")
140
  endif ()
141
  add_definitions(-DXDMF_BUILD_DSM)
142
endif()
143

144 145
# If we are wrapping either, we need swig
if(XDMF_WRAP_PYTHON OR XDMF_WRAP_JAVA)
146 147 148 149
  find_package(SWIG REQUIRED)
  include(${SWIG_USE_FILE})
  if(${SWIG_VERSION} LESS 2.0.0)
    message(SEND_ERROR "Swig must be version 2.0.0 or greater")
150 151
  endif()
endif()
152 153 154

# If we are wrapping python, let's include it in the top level
if(XDMF_WRAP_PYTHON)
155 156
  find_package(PythonInterp ${REQUESTED_PYTHON_VERSION} REQUIRED)
  find_package(PythonLibs ${REQUESTED_PYTHON_VERSION} REQUIRED)
157
  if (XDMF_BUILD_DSM)
158 159 160 161 162 163
    find_package (MPI4PY REQUIRED)
    if (MPI4PY_FOUND)
      if ("${PYTHON_INCLUDE_MPI4PY_DIR}" STREQUAL "")
        set(PYTHON_INCLUDE_MPI4PY_DIR ${MPI4PY_INCLUDE_DIR})
      endif ()
    endif ()
164
    include_directories(${PYTHON_INCLUDE_DIRS} ${MPI_CXX_INCLUDE_PATH} ${PYTHON_INCLUDE_MPI4PY_DIR})
165
  else ()
166
    include_directories(${PYTHON_INCLUDE_DIRS})
167
  endif ()
168 169 170 171 172 173 174 175

  # A macro to swig and create the python files
  # Since we essentually do the same thing inside and outside core, it
  # would be easier as a macro
  # Parameters:
  #     python_name = the name of the intended target to be wrapped
  #     ${ARGN} = any dependencies needed by the target
  # Output:
176 177
  #     Target Name = the output target name will have ${python_name} as its name
  macro(XDMF_SWIG_PYTHON python_name)
178
    set(CMAKE_SWIG_OUTDIR ${CMAKE_BINARY_DIR})
179 180
    # optimize swig generation --- these are all flags corresponding to -O
    # except -fvirtual which breaks visitor operation
181
    set(CMAKE_SWIG_FLAGS ${XDMF_SWIG_FLAGS} -modern -fastdispatch -nosafecstrings -noproxydel -fastproxy -fastinit -fastunpack -fastquery -modernargs -nobuildnone)
182 183 184
    #Enables DSM
    if (XDMF_BUILD_DSM)
      set(CMAKE_SWIG_FLAGS ${CMAKE_SWIG_FLAGS} -DXDMF_BUILD_DSM)
185 186
      if (XDMF_BUILD_DSM_THREADS)
        set(CMAKE_SWIG_FLAGS ${CMAKE_SWIG_FLAGS} -DXDMF_BUILD_DSM_THREADS)
187 188
      endif ()
    endif ()
189 190 191
    if (TIFF_FOUND)
      set(CMAKE_SWIG_FLAGS ${CMAKE_SWIG_FLAGS} -DXDMF_BUILD_TIFF)
    endif ()
192
    set_source_files_properties(${python_name}.i PROPERTIES CPLUSPLUS ON)
193
    set(swig_extra_generated_files "")
194 195
    swig_add_module(${python_name}Python python ${python_name}.i)
    swig_link_libraries(${python_name}Python ${python_name} ${PYTHON_LIBRARIES})
196 197
    set_property(DIRECTORY APPEND PROPERTY
      ADDITIONAL_MAKE_CLEAN_FILES
198
      ${CMAKE_CURRENT_BINARY_DIR}/${python_name}.pyc
199
    )
200 201 202

    if("${ARGN}" STRGREATER "")
      add_dependencies(${python_name} "${ARGN}")
203
    endif()
204 205

    if(WIN32)
206
      if(NOT MSVC10)
207
        set_target_properties(${SWIG_MODULE_${python_name}Python_REAL_NAME}
208 209 210
          PROPERTIES
          PREFIX ../
          IMPORT_PREFIX ../
211 212 213
          RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
          LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
          ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
214
      endif()
215
    endif()
216

217 218 219 220
    set_target_properties(${SWIG_MODULE_${python_name}Python_REAL_NAME}
      PROPERTIES
      OUTPUT_NAME "_${python_name}")

221 222 223 224 225
    set(
      PYTHON_INSTALL_DIR
      ${CMAKE_INSTALL_PREFIX}/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/xdmf
      )

226 227
    string(TOUPPER ${python_name} python_name_upper)
    set(${python_name_upper}_PYTHON
228
      ${PYTHON_INSTALL_DIR}/${python_name}.py)
229 230 231 232
    get_directory_property(${python_name}Parent PARENT_DIRECTORY)
    if(NOT "${${python_name}Parent}" STREQUAL "")
      set(${python_name_upper}_PYTHON ${${python_name_upper}_PYTHON}
        PARENT_SCOPE)
233
    endif()
234

235
    install(FILES ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${python_name}.py
236
      DESTINATION ${PYTHON_INSTALL_DIR})
237
    install(TARGETS ${SWIG_MODULE_${python_name}Python_REAL_NAME}
238
      DESTINATION ${PYTHON_INSTALL_DIR})
239 240
  endmacro()
endif()
241 242 243

# If we are wrapping java, let's include it in the top level
if(XDMF_WRAP_JAVA)
244 245 246 247 248 249 250 251 252 253 254 255 256
  find_package(Java REQUIRED)
  find_package(JNI REQUIRED)
  include_directories(${CMAKE_CURRENT_SOURCE_DIR}
    ${JAVA_INCLUDE_PATH}
    ${JAVA_INCLUDE_PATH2})

  # A macro to swig and create the jar files
  # Since we essentually do the same thing inside and outside core, it
  # would be easier as a macro
  # Parameters:
  #     java_name = the name of the intended target to be wrapped
  #     ${ARGN} = any dependencies needed by the target
  # Output:
257 258 259
  #     Target Name     = the output target name will have ${java_name}Java as its name
  #     Target Jar      = the output target jar will have ${java_name}Java.jar as its name
  macro(XDMF_SWIG_JAVA java_name)
260
    set(${java_name}_JAVA_JAR ${CMAKE_BINARY_DIR}/${java_name}.jar)
261
    set(XDMF_JAVA_PACKAGE_DIR mil/army/arl/xdmf)
262
    set(XDMF_JAVA_DIR ${CMAKE_BINARY_DIR}/${XDMF_JAVA_PACKAGE_DIR})
263
    set(CMAKE_SWIG_OUTDIR ${XDMF_JAVA_DIR})
264
    set(CMAKE_SWIG_FLAGS ${XDMF_SWIG_FLAGS} -v -make_default -package mil.army.arl.xdmf)
265
    set_source_files_properties(${java_name}.i PROPERTIES CPLUSPLUS ON)
266
    set(swig_extra_generated_files "")
267 268 269 270
    swig_add_module(${java_name}Java java ${java_name}.i)
    swig_link_libraries(${java_name}Java ${java_name})

    if(WIN32)
271 272 273 274 275
	  if(NOT MSVC10)
        set_target_properties(${SWIG_MODULE_${java_name}Java_REAL_NAME}
          PROPERTIES
          PREFIX ../
          IMPORT_PREFIX ../
276 277 278 279
          RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
          LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
          ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
	  endif()
280
      set(java_files *.java)
281
      set(java_dest "bin")
282
      set(separator "\;")
283
    else()
284
      set(java_files ${XDMF_JAVA_DIR}/*.java)
285
      set(java_dest "lib/java")
286
      set(separator ":")
287
    endif()
288 289 290 291 292 293 294 295

    add_custom_target(${java_name}_Java_Dir ALL DEPENDS ${XDMF_JAVA_DIR})
    add_custom_command(OUTPUT ${XDMF_JAVA_DIR}
      COMMAND ${CMAKE_COMMAND} -E make_directory ${XDMF_JAVA_DIR})
    add_custom_target(Compiled_${java_name}_Jar ALL DEPENDS
      ${${java_name}_JAVA_JAR})
    add_custom_command(OUTPUT ${${java_name}_JAVA_JAR}
      COMMAND ${CMAKE_COMMAND} -E chdir ${XDMF_JAVA_PACKAGE_DIR}
296
              ${JAVA_COMPILE} -cp \".${java_cp_jars}\" ${java_files}
297 298
      COMMAND ${JAVA_ARCHIVE} -cvf ${${java_name}_JAVA_JAR}
             "${XDMF_JAVA_PACKAGE_DIR}/*.class")
299 300 301 302 303
    add_dependencies(${java_name}Java ${java_name}_Java_Dir)
    add_dependencies(Compiled_${java_name}_Jar ${java_name}Java)

    if(NOT ${ARGN} EQUAL "")
      add_dependencies(Compiled_${java_name}_Jar "${ARGN}")
304
    endif()
305 306 307

    set_property(DIRECTORY APPEND PROPERTY
      ADDITIONAL_MAKE_CLEAN_FILES
308
      ${CMAKE_CURRENT_BINARY_DIR}/${java_name}.jar
309
      ${XDMF_JAVA_DIR})
310

311
    set(java_cp_jars "${java_cp_jars}${separator}${${java_name}_JAVA_JAR}")
312 313 314 315 316 317 318
    string(TOUPPER ${java_name} java_name_upper)
    set(${java_name_upper}_JAVA_JAR
      ${CMAKE_INSTALL_PREFIX}/lib/java/${java_name}.jar)
    get_directory_property(${java_name}Parent PARENT_DIRECTORY)
    if(NOT "${${java_name}Parent}" STREQUAL "")
      set(${java_name_upper}_JAVA_JAR ${${java_name_upper}_JAVA_JAR}
        PARENT_SCOPE)
319
      set(java_cp_jars "${java_cp_jars}" PARENT_SCOPE)
320
    endif()
321

322
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${java_name}.jar
323 324 325
      DESTINATION lib/java)
    install(TARGETS ${SWIG_MODULE_${java_name}Java_REAL_NAME}
      DESTINATION ${java_dest})
326 327
  endmacro()
endif()
328

329
add_subdirectory(core)
330
include_directories(${XdmfCore_INCLUDE_DIRS} ${XdmfDSM_INCLUDE_DIRS})
331
link_directories(${XDMF_LIBRARY_DIRS})
332

333 334
include(GNUInstallDirs)

335
option(XDMF_BUILD_CORE_ONLY OFF)
336
mark_as_advanced(XDMF_BUILD_CORE_ONLY)
337
if(NOT XDMF_BUILD_CORE_ONLY)
338
  set(XdmfSources
339
    XdmfAggregate
340 341 342 343 344 345 346
    XdmfAttribute
    XdmfAttributeCenter
    XdmfAttributeType
    XdmfCurvilinearGrid
    XdmfDomain
    XdmfGeometry
    XdmfGeometryType
347
    XdmfGraph
348 349 350
    XdmfGrid
    XdmfGridCollection
    XdmfGridCollectionType
351
    XdmfGridController
352
    XdmfGridTemplate
353 354 355 356 357 358 359
    XdmfItemFactory
    XdmfMap
    XdmfReader
    XdmfRectilinearGrid
    XdmfRegularGrid
    XdmfSet
    XdmfSetType
360
    XdmfTemplate
361 362 363 364
    XdmfTime
    XdmfTopology
    XdmfTopologyType
    XdmfUnstructuredGrid)
365

366 367 368 369 370 371 372
  if(XDMF_STATIC_AND_SHARED)
    add_library(XdmfObjects OBJECT ${XdmfSources})
    set_target_properties(XdmfObjects PROPERTIES
      POSITION_INDEPENDENT_CODE True)
    add_library(${XDMF_LIBNAME} $<TARGET_OBJECTS:XdmfObjects>)
    if (BUILD_SHARED_LIBS)
      add_library(Xdmf_Static STATIC $<TARGET_OBJECTS:XdmfObjects>)
373
      set_target_properties(Xdmf_Static PROPERTIES
374 375 376
          OUTPUT_NAME "Xdmf")
    endif (BUILD_SHARED_LIBS)
  else()
377 378 379 380 381 382 383 384 385
    if (WIN32)
      if (XDMF_BUILD_DSM)
        add_library(${XDMF_LIBNAME} ${LIBTYPE} ${XdmfSources} ${XdmfCoreSources} ${XdmfDSMSources})
      else ()
        add_library(${XDMF_LIBNAME} ${LIBTYPE} ${XdmfSources} ${XdmfCoreSources})
      endif ()
    else ()
      add_library(${XDMF_LIBNAME} ${LIBTYPE} ${XdmfSources})
    endif ()
386
  endif()
387
  if(XDMF_BUILD_DSM)
388 389 390 391 392
    if (NOT WIN32)
      target_link_libraries(${XDMF_LIBNAME} XdmfCore XdmfDSM)
    else ()
      target_link_libraries(${XDMF_LIBNAME} ${XdmfLibraries} ${XdmfDSMLinkLibraries})
    endif ()
393 394 395
    if(XDMF_STATIC_AND_SHARED AND BUILD_SHARED_LIBS)
        target_link_libraries(Xdmf_Static XdmfCore_Static XdmfDSM_Static)
    endif()
396
  else(XDMF_BUILD_DSM)
397 398 399 400 401
    if (NOT WIN32)
      target_link_libraries(${XDMF_LIBNAME} XdmfCore)
    else ()
      target_link_libraries(${XDMF_LIBNAME} ${XdmfLibraries})
    endif ()
402
    if(XDMF_STATIC_AND_SHARED AND BUILD_SHARED_LIBS)
403
      target_link_libraries(Xdmf_Static XdmfCore_Static)
404
    endif ()
405
  endif(XDMF_BUILD_DSM)
406 407 408
  if (COMMAND vtk_target_install)
    vtk_target_install(${XDMF_LIBNAME})
  endif()
409 410

  if(WIN32)
411 412
    if (BUILD_SHARED_LIBS)
      set_target_properties(${XDMF_LIBNAME} PROPERTIES
413 414 415 416 417
        DEFINE_SYMBOL XDMF_EXPORTS)
      if(XDMF_STATIC_AND_SHARED)
        set_target_properties(Xdmf_Static PROPERTIES
          DEFINE_SYMBOL Xdmf_EXPORTS)
      endif()
418
    endif ()
419
    if(NOT MSVC10)
420
      set_target_properties(${XDMF_LIBNAME} PROPERTIES
421 422
        PREFIX ../
        IMPORT_PREFIX ../
423 424 425
        RUNTIME_OUTPUT_DIRECTORY ${CMAKE_INSTALL_BINDIR}
        LIBRARY_OUTPUT_DIRECTORY ${CMAKE_INSTALL_LIBDIR}/${CMAKE_CFG_INTDIR}/
        ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_INSTALL_LIBDIR}/${CMAKE_CFG_INTDIR}/)
426
      if(XDMF_STATIC_AND_SHARED AND BUILD_SHARED_LIBS)
427 428 429
        set_target_properties(Xdmf_Static PROPERTIES
          PREFIX ../
          IMPORT_PREFIX ../
430 431 432
          RUNTIME_OUTPUT_DIRECTORY ${CMAKE_INSTALL_BINDIR}
          LIBRARY_OUTPUT_DIRECTORY ${CMAKE_INSTALL_LIBDIR}/${CMAKE_CFG_INTDIR}/
          ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_INSTALL_LIBDIR}/${CMAKE_CFG_INTDIR}/)
433 434 435
      endif ()
    endif()
  endif()
436 437

  if(XDMF_WRAP_JAVA)
438 439
    XDMF_SWIG_JAVA(${XDMF_LIBNAME} Compiled_XdmfCore_Jar)
  endif()
440 441

  if(XDMF_WRAP_PYTHON)
442 443 444 445
    if (NOT BUILD_SHARED_LIBS)
      message(FATAL_ERROR "Python Wrappers do not function"
                          " properly without shared libraries")
    endif (NOT BUILD_SHARED_LIBS)
446
    if (XDMF_BUILD_DSM)
447 448 449 450
      XDMF_SWIG_PYTHON(${XDMF_LIBNAME} XdmfCore XdmfDSM)
    else()
      XDMF_SWIG_PYTHON(${XDMF_LIBNAME} XdmfCore)
    endif()
451 452 453 454
    set(
      XDMF_PYTHON_INSTALL_DIR
      ${CMAKE_INSTALL_PREFIX}/lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/xdmf
      )
455
  endif()
456

457
  if(XDMF_BUILD_TESTING)
458
    add_subdirectory(tests)
459
  endif()
460 461 462 463

  option(XDMF_BUILD_UTILS OFF)
  if(XDMF_BUILD_UTILS)
    add_subdirectory(utils)
464
  endif()
465

466
  if(WIN32)
467 468
    set(XDMF_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/${XDMF_LIBNAME}.lib)
  endif()
Nico Schlömer's avatar
Nico Schlömer committed
469

470
  if(UNIX)
471
    if (BUILD_SHARED_LIBS)
472
      set(XDMF_LIBRARY ${CMAKE_INSTALL_LIBDIR}/lib${XDMF_LIBNAME}.so)
473
    else (BUILD_SHARED_LIBS)
474
      set(XDMF_LIBRARY ${CMAKE_INSTALL_LIBDIR}/lib${XDMF_LIBNAME}.a)
475
    endif (BUILD_SHARED_LIBS)
476
  endif(UNIX)
477

478
  if(APPLE)
479
    set(XDMF_LIBRARY ${CMAKE_INSTALL_LIBDIR}/lib${XDMF_LIBNAME}.dylib)
480
  endif()
Nico Schlömer's avatar
Nico Schlömer committed
481 482 483 484 485

  file(GLOB XdmfHeaders
    "*.hpp"
    "*.tpp"
    "*.i"
486
    "CMake/VersionSuite/*.hpp"
487
    "${CMAKE_CURRENT_BINARY_DIR}/*.hpp"
488
  )
489
  install(FILES ${XdmfHeaders} DESTINATION include)
490
  install(TARGETS ${XDMF_LIBNAME}
491 492 493
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
494
  if (XDMF_STATIC_AND_SHARED AND BUILD_SHARED_LIBS)
495
    install(TARGETS Xdmf_Static
496 497 498
      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
      LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
499
  endif()
500
endif()
501

502 503 504 505 506 507
if(WIN32 AND NOT CYGWIN)
  set(DEF_INSTALL_CMAKE_DIR CMake)
else()
  set(DEF_INSTALL_CMAKE_DIR
    "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
endif()
508
xdmf_create_config_file(${PROJECT_NAME})
509
install(FILES "${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
510
  DESTINATION ${DEF_INSTALL_CMAKE_DIR})