##
# CMakeLists.txt  
#
# This file is part of the Chemical Data Processing Toolkit
#
# Copyright (C) 2003 Thomas Seidel <thomas.seidel@univie.ac.at>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program; see the file COPYING. If not, write to
# the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
##

CMAKE_MINIMUM_REQUIRED(VERSION 3.17.0 FATAL_ERROR)
CMAKE_POLICY(SET CMP0057 NEW)

SET(CMAKE_COLOR_MAKEFILE ON)

FILE(STRINGS Version CDPKIT_VERSION)

STRING(REGEX MATCH "([0-9]+)\.([0-9]+)\.([0-9]+)" MATCH_RES ${CDPKIT_VERSION})

SET(CDPKIT_VERSION_MAJOR ${CMAKE_MATCH_1})
SET(CDPKIT_VERSION_MINOR ${CMAKE_MATCH_2})
SET(CDPKIT_VERSION_PATCH ${CMAKE_MATCH_3})

IF(NOT CMAKE_BUILD_TYPE)
  MESSAGE(STATUS "Setting build type to 'Release' as none was specified")
  SET(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
ENDIF()

PROJECT(CDPKit VERSION ${CDPKIT_VERSION} HOMEPAGE_URL "https://cdpkit.org")

SET(PROJECT_NAME_WITH_VERSION "${PROJECT_NAME}-${CDPKIT_VERSION}")

IF(NOT DEFINED CDPL_CXX_UNIT_TESTS_ENABLED)
  SET(CDPL_CXX_UNIT_TESTS_ENABLED FALSE CACHE BOOL "Enable/disable build of c++ unit tests")
ENDIF()

SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DCDPL_MATH_CHECKS_DISABLE")

IF(MSVC)
  ADD_COMPILE_DEFINITIONS("BOOST_ALL_DYN_LINK" "BOOST_IOSTREAMS_NO_LIB" "_USE_MATH_DEFINES")
  SET(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
ELSE()
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-deprecated-declarations")
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -fvisibility-inlines-hidden")
ENDIF(MSVC)

SET(CMAKE_CXX_STANDARD 11)

IF(APPLE) 
  FIND_PROGRAM(CODESIGN_EXECUTABLE codesign REQUIRED)

  IF(NOT CDPKIT_CODE_SIGNING_IDENTITY)
    SET(CDPKIT_CODE_SIGNING_IDENTITY "-")
  ENDIF(NOT CDPKIT_CODE_SIGNING_IDENTITY)

  SET(CDPKIT_DEF_INSTALL_DIR "/Users/Shared}")
ELSEIF(WIN32)
  SET(CMAKE_SHARED_LIBRARY_PREFIX "lib")
  SET(CMAKE_STATIC_LIBRARY_PREFIX "lib")
  SET(CMAKE_IMPORT_LIBRARY_PREFIX "lib")
  SET(CDPKIT_DEF_INSTALL_DIR "C:/Program Files") 
ELSE()
  SET(CDPKIT_DEF_INSTALL_DIR "/opt")
ENDIF(APPLE)

IF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) 
  SET(CMAKE_INSTALL_PREFIX "${CDPKIT_DEF_INSTALL_DIR}" CACHE PATH "Install path prefix, prepended onto install directories" FORCE)
ENDIF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)

SET(CDPKIT_MIN_BOOST_VERSION "1.63.0")

SET(CDPKIT_DATA_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Data")
SET(CDPKIT_TEST_DATA_DIR "${CDPKIT_DATA_DIR}/Testing")
SET(CDPKIT_BUILTIN_DATA_DIR "${CDPKIT_DATA_DIR}/Builtin")
SET(CDPKIT_EXTERNAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/External")
SET(CDPKIT_CMAKE_SCRIPTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Scripts/CMake")
SET(CDPKIT_PYTHON_SCRIPTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Scripts/Python")
SET(CDPKIT_SHELL_SCRIPTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Scripts/Shell")
SET(CDPKIT_DOC_GRAPHICS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Doc/Graphics")
SET(CDPKIT_EXAMPLES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Examples")

IF(PYPI_PACKAGE_BUILD)
  SET(CDPKIT_PYTHON_INSTALL_DIR "Libs/Python")
  SET(CDPKIT_LIBRARY_INSTALL_DIR "Libs/Python/CDPL")
ELSE()
  SET(CDPKIT_PYTHON_INSTALL_DIR Python)
  SET(CDPKIT_LIBRARY_INSTALL_DIR Libs)
ENDIF(PYPI_PACKAGE_BUILD)

SET(CDPKIT_EXECUTABLE_INSTALL_DIR Bin)
SET(CDPKIT_INCLUDE_INSTALL_DIR Include)
SET(CDPKIT_DOC_INSTALL_DIR Doc)
SET(CDPKIT_EXAMPLES_INSTALL_DIR Examples)
SET(CDPKIT_COMPILER_ID ${CMAKE_CXX_COMPILER_ID})
SET(CDPKIT_COMPILER_VERSION ${CMAKE_CXX_COMPILER_VERSION})
SET(CDPKIT_BUILD_SYSTEM ${CMAKE_SYSTEM})

SET(CMAKE_MODULE_PATH "${CDPKIT_CMAKE_SCRIPTS_DIR}")

SET(CMAKE_SKIP_BUILD_RPATH FALSE)
SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) 
SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
SET(CMAKE_MACOSX_RPATH TRUE)

IF(APPLE)
  SET(CDPKIT_EXECUTABLE_INSTALL_RPATH "@executable_path/../${CDPKIT_LIBRARY_INSTALL_DIR}")
  SET(CDPKIT_LIBRARY_INSTALL_RPATH "@loader_path")

  IF(PYPI_PACKAGE_BUILD)
    SET(CDPKIT_PYTHON_MODULE_INSTALL_RPATH1 "@loader_path")
    SET(CDPKIT_PYTHON_MODULE_INSTALL_RPATH2 "@loader_path/..")
  ELSE()
    SET(CDPKIT_PYTHON_MODULE_INSTALL_RPATH1 "@loader_path/../../${CDPKIT_LIBRARY_INSTALL_DIR}")
    SET(CDPKIT_PYTHON_MODULE_INSTALL_RPATH2 "@loader_path/../../../${CDPKIT_LIBRARY_INSTALL_DIR}")
  ENDIF(PYPI_PACKAGE_BUILD)
ELSE()
  SET(CDPKIT_EXECUTABLE_INSTALL_RPATH "$ORIGIN/../${CDPKIT_LIBRARY_INSTALL_DIR}")
  SET(CDPKIT_LIBRARY_INSTALL_RPATH "$ORIGIN")

  IF(PYPI_PACKAGE_BUILD)
    SET(CDPKIT_PYTHON_MODULE_INSTALL_RPATH1 "$ORIGIN")
    SET(CDPKIT_PYTHON_MODULE_INSTALL_RPATH2 "$ORIGIN/..")
  ELSE()
    SET(CDPKIT_PYTHON_MODULE_INSTALL_RPATH1 "$ORIGIN/../../${CDPKIT_LIBRARY_INSTALL_DIR}")
    SET(CDPKIT_PYTHON_MODULE_INSTALL_RPATH2 "$ORIGIN/../../../${CDPKIT_LIBRARY_INSTALL_DIR}")
  ENDIF(PYPI_PACKAGE_BUILD)
ENDIF(APPLE)

SET(CDPL_VERSION "${CDPKIT_VERSION}")
SET(CDPL_SO_VERSION "${CDPKIT_VERSION_MAJOR}.${CDPKIT_VERSION_MINOR}")

SET(APPS_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Apps")
SET(CDPL_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Libs/C++/Source")
SET(CDPL_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Libs/C++/Include")
SET(CDPL_CONFIG_HEADER_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Include")
SET(CDPL_PYTHON_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/Python")

SET(CDPL_BASE_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Source/CDPL/Base")
SET(CDPL_CHEM_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Source/CDPL/Chem")
SET(CDPL_UTIL_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Source/CDPL/Util")
SET(CDPL_MATH_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Source/CDPL/Math")
SET(CDPL_VIS_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Source/CDPL/Vis")
SET(CDPL_PHARM_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Source/CDPL/Pharm")
SET(CDPL_BIOMOL_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Source/CDPL/Biomol")
SET(CDPL_GRID_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Source/CDPL/Grid")
SET(CDPL_FORCEFIELD_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Source/CDPL/ForceField")
SET(CDPL_CONFGEN_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Source/CDPL/ConfGen")
SET(CDPL_GRAIL_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Source/CDPL/GRAIL")
SET(CDPL_MOLPROP_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Source/CDPL/MolProp")
SET(CDPL_DESCR_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Source/CDPL/Descr")
SET(CDPL_SHAPE_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Libs/C++/Source/CDPL/Shape")
SET(CDPL_CXX_API_DOC_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/Doc/Doxygen/C++-API")

IF(NOT PYPI_PACKAGE_BUILD)
  IF(WIN32)
    SET(RUN_CXX_TESTS "${CMAKE_CURRENT_BINARY_DIR}/RunCXXTests.bat")
    SET(RUN_CXX_TESTS_IN "${CDPKIT_SHELL_SCRIPTS_DIR}/RunCXXTests.bat.in")
    SET(RUN_PYTHON_TESTS "${CMAKE_CURRENT_BINARY_DIR}/RunPythonTests.bat")
    SET(RUN_PYTHON_TESTS_IN "${CDPKIT_SHELL_SCRIPTS_DIR}/RunPythonTests.bat.in")
  ELSE(WIN32)
    SET(RUN_CXX_TESTS "${CMAKE_CURRENT_BINARY_DIR}/RunCXXTests.sh")
    SET(RUN_CXX_TESTS_IN "${CDPKIT_SHELL_SCRIPTS_DIR}/RunCXXTests.sh.in")
    SET(RUN_PYTHON_TESTS "${CMAKE_CURRENT_BINARY_DIR}/RunPythonTests.sh")
    SET(RUN_PYTHON_TESTS_IN "${CDPKIT_SHELL_SCRIPTS_DIR}/RunPythonTests.sh.in")
  ENDIF(WIN32)
ENDIF(NOT PYPI_PACKAGE_BUILD)

FIND_PACKAGE(Python3 REQUIRED Interpreter OPTIONAL_COMPONENTS Development NumPy)

SET(PYTHONINTERP_FOUND ${Python3_Interpreter_FOUND})
SET(PYTHONLIBS_FOUND ${Python3_Development_FOUND})
SET(PYTHON_EXECUTABLE ${Python3_EXECUTABLE})
SET(PYTHON_LIBRARIES ${Python3_LIBRARIES})
SET(PYTHON_INCLUDE_DIRS ${Python3_INCLUDE_DIRS})
SET(NUMPY_FOUND ${Python3_NumPy_FOUND})
SET(NUMPY_INCLUDE_DIRS ${Python3_NumPy_INCLUDE_DIRS})

IF(NOT PYTHONLIBS_FOUND AND PYPI_MANYLINUX_PACKAGE_BUILD)
  SET(PYTHONLIBS_FOUND TRUE)
  SET(PYTHON_LIBRARIES "")
ENDIF(NOT PYTHONLIBS_FOUND AND PYPI_MANYLINUX_PACKAGE_BUILD)

IF(UNIX AND PYPI_MANYLINUX_PACKAGE_BUILD)
  FIND_PROGRAM(PATCHELF_EXECUTABLE patchelf)
ENDIF(UNIX AND PYPI_MANYLINUX_PACKAGE_BUILD)

IF(NOT PYPI_PACKAGE_BUILD)
  CONFIGURE_FILE("${RUN_PYTHON_TESTS_IN}" "${RUN_PYTHON_TESTS}" @ONLY)
ENDIF(NOT PYPI_PACKAGE_BUILD)

FIND_PACKAGE(Threads)

IF(NOT Threads_FOUND)
  MESSAGE("!! Warning: Multi-threading support not available -> commandline applications won't be built.")
ENDIF(NOT Threads_FOUND)

SET(Boost_USE_MULTITHREAD ON)
SET(Boost_USE_STATIC_LIBS OFF)
SET(Boost_ADDITIONAL_VERSIONS "1.74.0" "1.75.0" "1.76.0" "1.77.0" "1.78.0" "1.79.0" "1.80.0" "1.82.0" "1.83.0" "1.84.0")

IF(PYPI_PACKAGE_BUILD)
  FIND_PACKAGE(Boost ${CDPKIT_MIN_BOOST_VERSION} REQUIRED iostreams filesystem system)
ELSE()
  FIND_PACKAGE(Boost ${CDPKIT_MIN_BOOST_VERSION} REQUIRED iostreams filesystem system OPTIONAL_COMPONENTS program_options unit_test_framework)
  
  IF(NOT Boost_PROGRAM_OPTIONS_FOUND)
    MESSAGE("!! Warning: Boost program_options library not found -> commandline applications won't be built.")
  ENDIF(NOT Boost_PROGRAM_OPTIONS_FOUND)

  IF(NOT Boost_UNIT_TEST_FRAMEWORK_FOUND)
    MESSAGE("!! Warning: Boost unit_test_framework not found -> can't build and run C++ unit test cases.")
    SET(CDPL_CXX_UNIT_TESTS_ENABLED FALSE)
  ELSE(NOT Boost_UNIT_TEST_FRAMEWORK_FOUND)
    CONFIGURE_FILE("${RUN_CXX_TESTS_IN}" "${RUN_CXX_TESTS}" @ONLY)
  ENDIF(NOT Boost_UNIT_TEST_FRAMEWORK_FOUND)
ENDIF(PYPI_PACKAGE_BUILD)

IF(NOT BOOST_PYTHON_VERSIONS)
  SET(BOOST_PYTHON_VERSIONS  "3" "35" "36" "37" "38" "39" "310" "311" "312")
ENDIF(NOT BOOST_PYTHON_VERSIONS)

FOREACH(PYTHON_VERSION ${BOOST_PYTHON_VERSIONS})
  FIND_PACKAGE(Boost ${CDPKIT_MIN_BOOST_VERSION} QUIET OPTIONAL_COMPONENTS python${PYTHON_VERSION})            

  IF(Boost_PYTHON${PYTHON_VERSION}_FOUND)
    SET(Boost_PYTHON_FOUND TRUE)
    SET(Boost_PYTHON_LIBRARY ${Boost_PYTHON${PYTHON_VERSION}_LIBRARY})
    BREAK()
  ENDIF(Boost_PYTHON${PYTHON_VERSION}_FOUND)
ENDFOREACH()

IF(Boost_PYTHON_FOUND AND PYTHONLIBS_FOUND)
  SET(BUILD_PYTHON_MODULES TRUE)
  SET(PYTHON_TESTS_ENABLED TRUE)
ELSE(Boost_PYTHON_FOUND AND PYTHONLIBS_FOUND)
  IF(PYPI_PACKAGE_BUILD)
    MESSAGE(FATAL_ERROR "!! Python library and/or Boost python library not found.")    
  ELSE()
    MESSAGE("!! Warning: Python library and/or Boost python library not found -> can't build CDPL Python bindings.")    
  ENDIF(PYPI_PACKAGE_BUILD)

  SET(BUILD_PYTHON_MODULES FALSE)
  SET(PYTHON_TESTS_ENABLED FALSE)
ENDIF(Boost_PYTHON_FOUND AND PYTHONLIBS_FOUND)

IF(NOT PYPI_PACKAGE_BUILD)
  FIND_PACKAGE(Qt5Gui PATHS "/opt/homebrew/opt/qt@5" "/usr/local/opt/qt@5")
  FIND_PACKAGE(Qt5Widgets PATHS "/opt/homebrew/opt/qt@5" "/usr/local/opt/qt@5")
  FIND_PACKAGE(Qt5PrintSupport PATHS "/opt/homebrew/opt/qt@5" "/usr/local/opt/qt@5")

  IF(NOT Qt5Gui_FOUND)
    MESSAGE("!! Warning: Qt5 not found -> can't build Qt rendering backend and Qt applications.")
  ELSE()
    GET_TARGET_PROPERTY(_QMAKE_EXECUTABLE Qt5::qmake IMPORTED_LOCATION)
    GET_FILENAME_COMPONENT(QT_BIN_DIR "${_QMAKE_EXECUTABLE}" DIRECTORY)

    IF(APPLE)
      FIND_PROGRAM(MACDEPLOYQT_EXECUTABLE macdeployqt HINTS "${QT_BIN_DIR}")

      IF(NOT MACDEPLOYQT_EXECUTABLE)
        MESSAGE("!! Warning:: macdeployqt not found -> can't make Qt applications self-contained.")
      ENDIF(NOT MACDEPLOYQT_EXECUTABLE)
    ENDIF(APPLE)
  ENDIF(NOT Qt5Gui_FOUND)
ENDIF(NOT PYPI_PACKAGE_BUILD)

FIND_PACKAGE(Cairo)

IF(NOT CAIRO_FOUND)
  MESSAGE("!! Warning: CAIRO library not found -> can't build Cairo rendering backend.")
ELSE(NOT CAIRO_FOUND)
  INCLUDE(CheckFunctionExists)

  SET(CMAKE_REQUIRED_INCLUDES "${CAIRO_INCLUDE_DIR}")
  SET(CMAKE_REQUIRED_LIBRARIES "${CAIRO_LIBRARIES}")

  CHECK_FUNCTION_EXISTS(cairo_surface_write_to_png_stream HAVE_CAIRO_PNG_SUPPORT)
  CHECK_FUNCTION_EXISTS(cairo_ps_surface_create HAVE_CAIRO_PS_SUPPORT)
  CHECK_FUNCTION_EXISTS(cairo_pdf_surface_create HAVE_CAIRO_PDF_SUPPORT)
  CHECK_FUNCTION_EXISTS(cairo_svg_surface_create HAVE_CAIRO_SVG_SUPPORT)
ENDIF(NOT CAIRO_FOUND)

IF(BUILD_PYTHON_MODULES)
  IF(NOT NUMPY_FOUND)
    MESSAGE("!! Warning: NumPy python package not found -> CDPL.Math NDArray support won't be built.")
  ENDIF(NOT NUMPY_FOUND)
ENDIF(BUILD_PYTHON_MODULES)

IF(NOT PYPI_PACKAGE_BUILD)
  FIND_PACKAGE(Doxygen)

  IF(NOT DOXYGEN_EXECUTABLE)
    MESSAGE("!! Warning: Doxygen not found -> can't generate CDPL API documentation.")
    SET(HAVE_DOT NO)
  ELSE(NOT DOXYGEN_EXECUTABLE)
    IF(DOXYGEN_DOT_EXECUTABLE)
      SET(HAVE_DOT YES)
    ELSE(DOXYGEN_DOT_EXECUTABLE)
      SET(HAVE_DOT NO)
    ENDIF(DOXYGEN_DOT_EXECUTABLE)
  ENDIF(NOT DOXYGEN_EXECUTABLE)

  IF(APPLE)
    IF(EXISTS "/opt/homebrew/opt/sphinx-doc")
      SET(Sphinx_DIR "/opt/homebrew/opt/sphinx-doc")
    ELSEIF(EXISTS "/usr/local/opt/sphinx-doc")
      SET(Sphinx_DIR "/usr/local/opt/sphinx-doc")
    ENDIF()
  ENDIF(APPLE)

  FIND_PACKAGE(Sphinx COMPONENTS build)

  IF(NOT SPHINX_FOUND)
    MESSAGE("!! Warning: Sphinx not found -> can't generate dependent documentation.")
  ENDIF(NOT SPHINX_FOUND)
ENDIF(NOT PYPI_PACKAGE_BUILD)

INCLUDE(CheckTypeSize)

CHECK_TYPE_SIZE("long int" SIZEOF_LONG_INT)
CHECK_TYPE_SIZE("unsigned int" SIZEOF_UNSIGNED_INT)
CHECK_TYPE_SIZE("float" SIZEOF_FLOAT)
CHECK_TYPE_SIZE("double" SIZEOF_DOUBLE)
CHECK_TYPE_SIZE("size_t" SIZEOF_SIZE_T)

IF(SIZEOF_LONG_INT LESS 4)
  MESSAGE(FATAL_ERROR "sizeof(long int) < 4.")
ENDIF(SIZEOF_LONG_INT LESS 4)

IF(SIZEOF_UNSIGNED_INT LESS 4)
  MESSAGE(FATAL_ERROR "sizeof(unsigned int) < 4.")
ENDIF(SIZEOF_UNSIGNED_INT LESS 4)

IF(NOT SIZEOF_FLOAT EQUAL 4)
  MESSAGE(FATAL_ERROR "sizeof(float) != 4.")
ENDIF(NOT SIZEOF_FLOAT EQUAL 4)

IF(NOT SIZEOF_DOUBLE EQUAL 8)
  MESSAGE(FATAL_ERROR "sizeof(double) != 8.")
ENDIF(NOT SIZEOF_DOUBLE EQUAL 8)

IF(SIZEOF_SIZE_T LESS 4)
  MESSAGE(FATAL_ERROR "sizeof(size_t) < 4.")
ENDIF(SIZEOF_SIZE_T LESS 4)

INCLUDE(CheckCXXSourceCompiles)

CHECK_CXX_SOURCE_COMPILES("#include <cstdint>\nint main() { std::uint64_t i; std::uint32_t j; std::uint8_t k; return 0; }" FIXED_WIDTH_UINT_TYPES)

IF(NOT FIXED_WIDTH_UINT_TYPES)
  MESSAGE(FATAL_ERROR "Required fixed width integer types not available.")
ENDIF(NOT FIXED_WIDTH_UINT_TYPES)

SET(HAVE_CAIRO ${CAIRO_FOUND})
SET(HAVE_QT ${Qt5Gui_FOUND})
SET(HAVE_NUMPY ${NUMPY_FOUND})

CONFIGURE_FILE("${CDPL_INCLUDE_DIR}/CDPL/Config.hpp.in" "${CDPL_CONFIG_HEADER_INCLUDE_DIR}/CDPL/Config.hpp") 
CONFIGURE_FILE("${CDPL_INCLUDE_DIR}/CDPL/Version.hpp.in" "${CDPL_CONFIG_HEADER_INCLUDE_DIR}/CDPL/Version.hpp") 

CONFIGURE_FILE("${CDPKIT_CMAKE_SCRIPTS_DIR}/GenerateBuildInfoHeader.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/GenerateBuildInfoHeader.cmake" @ONLY)
ADD_CUSTOM_TARGET(gen-build-info-header ALL
  "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/GenerateBuildInfoHeader.cmake")

CONFIGURE_FILE("${CDPKIT_CMAKE_SCRIPTS_DIR}/CMakeUninstall.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/CMakeUninstall.cmake" @ONLY)
ADD_CUSTOM_TARGET(uninstall
  "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/CMakeUninstall.cmake")

INCLUDE_DIRECTORIES("${CDPL_INCLUDE_DIR}" "${CDPL_CONFIG_HEADER_INCLUDE_DIR}" "${Boost_INCLUDE_DIR}")


# CPack related setup
SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "${PROJECT_NAME_WITH_VERSION}")
SET(CPACK_PACKAGE_VENDOR "Thomas Seidel/University of Vienna")
SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/COPYING")
SET(CPACK_PACKAGE_VERSION_MAJOR "${CDPKIT_VERSION_MAJOR}")
SET(CPACK_PACKAGE_VERSION_MINOR "${CDPKIT_VERSION_MINOR}")
SET(CPACK_PACKAGE_VERSION_PATCH "${CDPKIT_VERSION_PATCH}")
SET(CPACK_PACKAGE_VERSION "${CDPKIT_VERSION}")
SET(CPACK_PACKAGE_INSTALL_DIRECTORY "${PROJECT_NAME}")
SET(CPACK_PACKAGE_NAME "${PROJECT_NAME}")
SET(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME_WITH_VERSION}-${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
SET(CPACK_PACKAGE_DEFAULT_LOCATION "${CDPKIT_DEF_INSTALL_DIR}")
SET(CPACK_PACKAGING_INSTALL_PREFIX "/")
SET(CPACK_PACKAGE_RELOCATABLE TRUE) 
SET(CPACK_SOURCE_PACKAGE_FILE_NAME "${PROJECT_NAME_WITH_VERSION}")
SET(CPACK_SOURCE_GENERATOR "TGZ")
SET(CPACK_SOURCE_IGNORE_FILES "/[.]git/;.*#$;.*~$;cscope.*")

IF(WIN32)
  SET(CPACK_COMPONENT_APPLICATIONS_DISPLAY_NAME "Applications")
  SET(CPACK_COMPONENT_CDPLSTATICLIBRARIES_DISPLAY_NAME "Static Libraries")
  SET(CPACK_COMPONENT_CDPLSHAREDLIBRARIES_DISPLAY_NAME "Dynamic Runtime Libraries")
  SET(CPACK_COMPONENT_CDPLHEADERFILES_DISPLAY_NAME "Header Files")
  SET(CPACK_COMPONENT_DOCUMENTATION_DISPLAY_NAME "Documentation")
  SET(CPACK_COMPONENT_EXAMPLES_DISPLAY_NAME "Python Examples")
  SET(CPACK_COMPONENT_CDPLPYTHONMODULES_DISPLAY_NAME "Python Bindings")

  SET(CPACK_COMPONENT_CDPLHEADERFILES_GROUP CXXDevelopment)
  SET(CPACK_COMPONENT_CDPLSTATICLIBRARIES_GROUP CXXDevelopment)
  SET(CPACK_COMPONENT_CDPLPYTHONMODULES_GROUP PythonDevelopment)
  SET(CPACK_COMPONENT_EXAMPLES_GROUP PythonDevelopment)

  SET(CPACK_COMPONENT_GROUP_CXXDEVELOPMENT_DISPLAY_NAME "CDPL C++ Development")
  SET(CPACK_COMPONENT_GROUP_PYTHONDEVELOPMENT_DISPLAY_NAME "CDPL Python Development")

  SET(CPACK_COMPONENT_APPLICATIONS_DEPENDS CDPLSharedLibraries)
  SET(CPACK_COMPONENT_CDPLPYTHONMODULES_DEPENDS CDPLSharedLibraries)

  SET(CPACK_COMPONENT_CDPLIMPORTLIBRARIES_DISPLAY_NAME "DLL Import Libraries")
  SET(CPACK_COMPONENT_CDPLIMPORTLIBRARIES_GROUP CXXDevelopment)

  SET(CPACK_COMPONENTS_ALL 
    Documentation
    Examples
    CDPLSharedLibraries
    CDPLImportLibraries
    CDPLStaticLibraries
    CDPLHeaderFiles
    CDPLPythonModules
    Applications 
    )
  
  SET(CPACK_GENERATOR "NSIS")
  SET(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME_WITH_VERSION}-Win-${CMAKE_CXX_COMPILER_ID}-${CMAKE_SYSTEM_PROCESSOR}")
  SET(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "${PROJECT_NAME}")
  SET(CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL TRUE)
  SET(CPACK_NSIS_MODIFY_PATH FALSE)
  SET(CPACK_NSIS_DISPLAY_NAME "${PROJECT_NAME}")
  SET(CPACK_PACKAGE_EXECUTABLES "chox;ChOX")
  SET(CPACK_CREATE_DESKTOP_LINKS "ChOX")
  SET(CPACK_NSIS_URL_INFO_ABOUT "https://cdpkit.org")
  SET(CPACK_NSIS_CONTACT "Thomas Seidel <thomas.seidel@univie.ac.at>")
  SET(CPACK_NSIS_MENU_LINKS
    "${CDPKIT_DOC_INSTALL_DIR}/index.html" "Documentation"
    "Uninstall" "Uninstall CDPKit"
    )

ELSEIF(APPLE)
  SET(CPACK_GENERATOR "DragNDrop")
  SET(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME_WITH_VERSION}-macOS-${CMAKE_SYSTEM_PROCESSOR}")
  SET(CPACK_PACKAGING_INSTALL_PREFIX "/${PROJECT_NAME}")
  
ELSE()
  SET(CPACK_AT_SIGN "@")
  SET(CPACK_RESOURCE_FILE_LICENSE_CONTENT "@CPACK_RESOURCE_FILE_LICENSE_CONTENT@")

  CONFIGURE_FILE("${CDPKIT_SHELL_SCRIPTS_DIR}/CPackSTGZHeader.sh.in" "${CMAKE_CURRENT_BINARY_DIR}/CPackSTGZHeader.sh" @ONLY)

  UNSET(CPACK_RESOURCE_FILE_LICENSE_CONTENT)

  SET(CPACK_GENERATOR "STGZ")
  SET(CPACK_STGZ_HEADER_FILE "${CMAKE_CURRENT_BINARY_DIR}/CPackSTGZHeader.sh")
ENDIF(WIN32)

INCLUDE(CPack)

IF(NOT PYPI_PACKAGE_BUILD)
  INCLUDE(CTest)
ENDIF(NOT PYPI_PACKAGE_BUILD)

ADD_SUBDIRECTORY(External) 
ADD_SUBDIRECTORY(Libs)

IF(NOT PYPI_PACKAGE_BUILD)
  ADD_SUBDIRECTORY(Apps)
  ADD_SUBDIRECTORY(Doc)
  ADD_SUBDIRECTORY(Examples)
ENDIF(NOT PYPI_PACKAGE_BUILD)

IF(WIN32)
  SET(CMAKE_INSTALL_UCRT_LIBRARIES TRUE)
  SET(CMAKE_INSTALL_SYSTEM_RUNTIME_DESTINATION ${CDPKIT_EXECUTABLE_INSTALL_DIR})
  SET(CMAKE_INSTALL_SYSTEM_RUNTIME_COMPONENT CDPLSharedLibraries)
  
  INCLUDE(InstallRequiredSystemLibraries)
ENDIF(WIN32)
