Virtual Laboratory Environment vle

CMAKE_MINIMUM_REQUIRED(VERSION 2.4)
PROJECT(VLE CXX C)
ENABLE_TESTING()

SET(VLE_MAJOR 0)
SET(VLE_MINOR 5)
SET(VLE_PATCH 0)
SET(VLE_EXTRA "-rc3")
SET(VLE_VERSION "${VLE_MAJOR}.${VLE_MINOR}.0")
SET(VLE_NAME "vle")
SET(VLE_NAME_VERSION "${VLE_NAME}-${VLE_VERSION}")
SET(VLE_COMPLETE "${VLE_MAJOR}.${VLE_MINOR}.${VLE_PATCH}${VLE_EXTRA}")
SET(VLE_NAME_COMPLETE "${VLE_NAME}-${VLE_COMPLETE}")
 
 #
  # CPack configuration
 #
 
IF(CMAKE_MAJOR_VERSION MATCHES "2" AND CMAKE_MINOR_VERSION MATCHES "4")
  SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "VLE - Virtual Laboraory Environment")
  SET(CPACK_PACKAGE_NAME "VLE")
  SET(CPACK_PACKAGE_VENDOR "VLE Development Team")
  SET(CPACK_PACKAGE_DESCRIPTION_FILE "${PROJECT_SOURCE_DIR}/README")
  SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/COPYING")
  SET(CPACK_SOURCE_PACKAGE_FILE_NAME ${VLE_NAME_COMPLETE}-sources)
  SET(CPACK_PACKAGE_FILE_NAME
      "${VLE_NAME_COMPLETE}-${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
  SET(CPACK_PACKAGE_VERSION ${VLE_NAME_COMPLETE})
  SET(CPACK_PACKAGE_VERSION_MAJOR ${VLE_MAJOR})
  SET(CPACK_PACKAGE_VERSION_MINOR ${VLE_MINOR})
  SET(CPACK_PACKAGE_VERSION_PATCH ${VLE_PATCH})
  SET(CPACK_PACKAGE_INSTALL_DIRECTORY ${VLE_NAME_COMPLETE})
  SET(CPACK_PACKAGE_EXECUTABLES "vle" "vle" "oov" "oov")
  SET(CPACK_PACKAGE_ICON "${PROJECT_SOURCE_DIR}/share/pixmaps/vle.ico")
  SET(CPACK_GENERATOR "TBZ2;TGZ;ZIP")
  SET(CPACK_SOURCE_GENERATOR "TBZ2;TGZ;ZIP")
  SET(CPACK_SOURCE_IGNORE_FILES "/\\\\.git/;/\\\\.gitignore;/build/")
  INCLUDE(CPack)
ENDIF(CMAKE_MAJOR_VERSION MATCHES "2" AND CMAKE_MINOR_VERSION MATCHES "4")
 
 #
  # Installation variables
 #
 
SET(VLE_LIBRARY_DIRS "lib/${VLE_NAME_VERSION}")
SET(VLE_INCLUDE_DIRS "include/${VLE_NAME_VERSION}/vle")
SET(VLE_INCLUDE_DIR "include/${VLE_NAME_VERSION}")
SET(VLE_MANPAGE_PATH "share/man/man1")
SET(VLE_SHARE_DIRS "share/${VLE_NAME_VERSION}")

 #
  # Debug mode
 #
 
IF(UNIX AND NOT WIN32)
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -W -Werror")
  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -W -Werror")
ENDIF(UNIX AND NOT WIN32)

IF(NOT CMAKE_BUILD_TYPE)
  SET(CMAKE_BUILD_TYPE Debug CACHE STRING
    "Type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
    FORCE)
ENDIF(NOT CMAKE_BUILD_TYPE)
 
 #
  # Manage the Win32 port.
 #
 
IF(WIN32)
  SET(OS_SPECIFIC_LIBRARIES wsock32 netapi32 z intl iconv)
ELSE(WIN32)
  SET(OS_SPECIFIC_LIBRARIES)
ENDIF(WIN32)
 
 #
  # Modules
 #
 
INCLUDE(CheckIncludeFileCXX)
INCLUDE(CheckIncludeFile)
INCLUDE(CheckLibraryExists)
INCLUDE(CMakeDetermineCCompiler)
 
 #
  # Check libraries with pkgconfig
 #
 
SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
FIND_PACKAGE(PkgConfig)

PKG_CHECK_MODULES(GLIBMM REQUIRED glibmm-2.4)
PKG_CHECK_MODULES(GTHREAD REQUIRED gthread-2.0)
PKG_CHECK_MODULES(LIBXMLPP REQUIRED libxml++-2.6)

OPTION(WITH_CAIRO "use the cairomm to build output plugin [default: on]" ON)
IF (WITH_CAIRO)
  PKG_CHECK_MODULES(CAIROMM cairomm-1.0)
  IF (CAIROMM_FOUND)
    SET(HAVE_CAIRO 1 CACHE INTERNAL "" FORCE)
  ENDIF (CAIROMM_FOUND)
ENDIF (WITH_CAIRO)
 
 #
  # Test the libsqlxx dependencies
 #
 
OPTION(WITH_SQLXX "with libsqlxx for the odbc driver [default: on]" ON)
IF (WITH_SQLXX)
  CHECK_INCLUDE_FILE_CXX(sqlxx.h HAVE_SQLXX)
  IF (HAVE_SQLXX)
    SET(LIBSQLXX_LIBRARIES "sqlxx")
  ELSE (HAVE_SQLXX)
    SET(LIBSQLXX_LIBRARIES)
  ENDIF (HAVE_SQLXX)
ENDIF (WITH_SQLXX)
 
 #
  # Test the libboost header and libboost-text library.
 #
 
OPTION(WITH_TEST "use the libboost test unit library [default: on]" ON)

FIND_PACKAGE(Boost)
IF (Boost_FOUND)
  IF (WITH_TEST)
    FIND_LIBRARY(Boost_UNITTESTFRAMEWORK NAMES boost_unit_test_framework
      boost_unit_test_framework-mt PATHS Boost_LIBRARY_DIRS)
    IF (Boost_UNITTESTFRAMEWORK)
      SET(HAVE_UNITTESTFRAMEWORK 1 CACHE INTERNAL "" FORCE)
    ELSE (Boost_UNITTESTFRAMEWORK)
      SET(HAVE_UNITTESTFRAMEWORK 0 CACHE INTERNAL "" FORCE)
    ENDIF (Boost_UNITTESTFRAMEWORK)
  ELSE (WITH_TEST)
    SET(HAVE_UNITTESTFRAMEWORK 0 CACHE INTERNAL "" FORCE)
  ENDIF (WITH_TEST)
ELSE (Boost_FOUND)
  MESSAGE(ERROR "Boost include directory not found")
ENDIF (Boost_FOUND)
 
 #
  # Generate the config.h
 #
 
CHECK_INCLUDE_FILE_CXX(cxxabi.h HAVE_GCC_ABI_DEMANGLE)
CHECK_INCLUDE_FILE_CXX(execinfo.h HAVE_EXECINFO_H)
CHECK_INCLUDE_FILE_CXX(signal.h HAVE_SIGNAL_H)
INCLUDE_DIRECTORIES(${VLE_BINARY_DIR})
CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/config.h.cmake ${VLE_BINARY_DIR}/config.h)
 
 #
  # Generate the vle.pc pkg-config file.
  # Build some variable to build a correct Win32 pkg config file with:
  # prefix=/target to detect the DIRNAME
  # cflag=-Iboost_1_34_1 for the directory
 #

IF(UNIX AND NOT WIN32)
  SET(VLE_PKGCONFIG_PREFIXPATH "${CMAKE_INSTALL_PREFIX}")
  SET(VLE_PKGCONFIG_BOOSTINCLUDE_DIRS "${Boost_INCLUDE_DIRS}")
ELSE(UNIX AND NOT WIN32)
  SET(VLE_PKGCONFIG_PREFIXPATH "/target")
  GET_FILENAME_COMPONENT(BOOST_DIRNAME "${Boost_INCLUDE_DIRS}" NAME)
  SET(VLE_PKGCONFIG_BOOSTINCLUDE_DIRS "\${includedir}/${BOOST_DIRNAME}")
ENDIF(UNIX AND NOT WIN32)

CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/src/vle/vle.pc.in ${VLE_BINARY_DIR}/vle.pc
  @ONLY)
INSTALL(FILES ${VLE_BINARY_DIR}/vle.pc DESTINATION lib/pkgconfig)

 #
  # Generate the vle.nsi script.
 #

IF(WIN32)
  CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/share/vle.nsi.in ${VLE_BINARY_DIR}/vle.nsi
    @ONLY)
  INSTALL(FILES ${VLE_BINARY_DIR}/vle.nsi DESTINATION ${VLE_SHARE_DIRS})
  INSTALL(FILES COPYING DESTINATION ${VLE_SHARE_DIRS})
ENDIF(WIN32)

 #
  # Generating documentation with doxygen
 #

OPTION(WITH_DOXYGEN "build the documentation with doxygen [default: off]" OFF)
IF (WITH_DOXYGEN)
  FIND_PACKAGE(Doxygen)
  IF(NOT DOXYGEN_EXECUTABLE)
    MESSAGE(STATUS "WARNING: Doxygen not found so documentation not generated.")
  ENDIF(NOT DOXYGEN_EXECUTABLE)

  IF(DOXYGEN_EXECUTABLE AND UNIX)
    FILE(MAKE_DIRECTORY ${CMAKE_SOURCE_DIR}/share/doc)

    CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/share/Doxyfile.in
      ${CMAKE_SOURCE_DIR}/share/Doxyfile @ONLY)

    ADD_CUSTOM_COMMAND(
      OUTPUT ${CMAKE_SOURCE_DIR}/share/doc/doxygen/html/index.html
      COMMAND rm -rf ${CMAKE_SOURCE_DIR}/share/doc/doxygen
      COMMAND mkdir ${CMAKE_SOURCE_DIR}/share/doc/doxygen
      COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_SOURCE_DIR}/share/Doxyfile
      DEPENDS ${CMAKE_SOURCE_DIR}/share/Doxyfile
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})

    ADD_CUSTOM_TARGET(
      documentation
      DEPENDS
      ${CMAKE_SOURCE_DIR}/share/doc/doxygen/html/index.html)

    IF(EXISTS ${CMAKE_SOURCE_DIR}/share/doc)
      INSTALL(DIRECTORY ${CMAKE_SOURCE_DIR}/share/doc/doxygen/ DESTINATION
	"${VLE_SHARE_DIRS}/doc")
    ENDIF(EXISTS ${CMAKE_SOURCE_DIR}/share/doc)
  ENDIF(DOXYGEN_EXECUTABLE AND UNIX)
ENDIF(WITH_DOXYGEN)

 #
  # Browse the subdirectory now
 #

ADD_SUBDIRECTORY(share)
ADD_SUBDIRECTORY(src)

 #
  # Status
 #

MESSAGE(STATUS "- - - -")
MESSAGE(STATUS "${VLE_NAME_COMPLETE} configured successfully")
MESSAGE(STATUS "Using ${CMAKE_INSTALL_PREFIX} for installation")
MESSAGE(STATUS "Build type ${CMAKE_BUILD_TYPE}")
IF (HAVE_GCC_ABI_DEMANGLE)
  MESSAGE(STATUS "Build with GCC ABI Demangle...: yes")
ENDIF (HAVE_GCC_ABI_DEMANGLE)
IF (HAVE_SQLXX)
  MESSAGE(STATUS "Build with SQL................: yes")
ENDIF (HAVE_SQLXX)
IF (HAVE_EXECINFO_H)
  MESSAGE(STATUS "Build with execinfo.h.........: yes")
ENDIF (HAVE_EXECINFO_H)
IF (Boost_FOUND)
  MESSAGE(STATUS "Build with boost..............: yes")
ENDIF (Boost_FOUND)
IF (HAVE_UNITTESTFRAMEWORK)
  MESSAGE(STATUS "Build unit test...............: yes")
ENDIF (HAVE_UNITTESTFRAMEWORK)
IF (HAVE_CAIRO)
  MESSAGE(STATUS "Build with cairo plugin.......: yes")
ENDIF (HAVE_CAIRO)
MESSAGE(STATUS "- - - -")

# vim:ts=8:tw=80:sw=2:sts=2