Virtual Laboratory Environment vle

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

SET(VLE_MAJOR 0)
SET(VLE_MINOR 6)
SET(VLE_PATCH 2)
SET(VLE_EXTRA "")
SET(VLE_VERSION "${VLE_MAJOR}.${VLE_MINOR}.${VLE_PATCH}")
SET(VLE_VERSION_SHORT "${VLE_MAJOR}.${VLE_MINOR}")
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}")

#
 # 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}")

#
 # Append the library version information to the library target
 # properties.
#

SET (VLE_LIBRARY_PROPERTIES ${VLE_LIBRARY_PROPERTIES} VERSION "${VLE_VERSION}" SOVERSION "${VLE_MAJOR}.${VLE_MINOR}")
SET (VLE_APP_PROPERTIES ${VLE_APP_PROPERTIES} VERSION "${VLE_VERSION}")

#
 # CPack configuration
#

IF(CMAKE_MAJOR_VERSION MATCHES "2" AND CMAKE_MINOR_VERSION MATCHES "6")
  INCLUDE(CMakeCPack.cmake)
ENDIF(CMAKE_MAJOR_VERSION MATCHES "2" AND CMAKE_MINOR_VERSION MATCHES "6")

#
 # Debug mode
#

SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -W -pedantic")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_C_FLAGS}")

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
#

IF(CMAKE_MAJOR_VERSION MATCHES "2" AND CMAKE_MINOR_VERSION MATCHES "6")
  FIND_PACKAGE(PkgConfig REQUIRED)
ELSE(CMAKE_MAJOR_VERSION MATCHES "2" AND CMAKE_MINOR_VERSION MATCHES "6")
  SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
  FIND_PACKAGE(PkgConfig REQUIRED)
ENDIF(CMAKE_MAJOR_VERSION MATCHES "2" AND CMAKE_MINOR_VERSION MATCHES "6")

# FIXME use old-style link directories for now
IF (COMMAND CMAKE_POLICY)
  CMAKE_POLICY(SET CMP0003 OLD)
ENDIF (COMMAND CMAKE_POLICY)

PKG_CHECK_MODULES(GLIBMM REQUIRED glibmm-2.4)
PKG_CHECK_MODULES(GTHREAD REQUIRED gthread-2.0)
PKG_CHECK_MODULES(LIBXMLPP REQUIRED libxml++-2.6)
PKG_CHECK_MODULES(CAIROMM cairomm-1.0>=1.2)
PKG_CHECK_MODULES(GLADEMM libglademm-2.4)
PKG_CHECK_MODULES(GTKMM gtkmm-2.4)

OPTION(WITH_CAIRO "use the cairomm to build output plugin [default: on]" ON)
IF (WITH_CAIRO AND CAIROMM_FOUND)
    SET(VLE_HAVE_CAIRO 1 CACHE INTERNAL "" FORCE)
ELSE (WITH_CAIRO AND CAIROMM_FOUND)
    SET(VLE_HAVE_CAIRO 0 CACHE INTERNAL "" FORCE)
ENDIF (WITH_CAIRO AND CAIROMM_FOUND)

OPTION(WITH_EOV "use the gtkmm, glademm and cairo to build eov [default: on]" ON)
IF (WITH_EOV AND GLADEMM_FOUND AND GTKMM_FOUND AND VLE_HAVE_CAIRO)
  SET(HAVE_EOV 1 CACHE INTERNAL "" FORCE)
ELSE (WITH_EOV AND GLADEMM_FOUND AND GTKMM_FOUND AND VLE_HAVE_CAIRO)
  SET(HAVE_EOV 0 CACHE INTERNAL "" FORCE)
ENDIF (WITH_EOV AND GLADEMM_FOUND AND GTKMM_FOUND AND VLE_HAVE_CAIRO)

OPTION(WITH_GVLE "use the gtkmm and glademm to build gvle [default: on]" ON)
IF (WITH_GVLE AND GLADEMM_FOUND AND GTKMM_FOUND)
  SET(HAVE_GVLE 1 CACHE INTERNAL "" FORCE)
ELSE (WITH_GVLE AND GLADEMM_FOUND AND GTKMM_FOUND)
  SET(HAVE_GVLE 0 CACHE INTERNAL "" FORCE)
ENDIF (WITH_GVLE AND GLADEMM_FOUND AND GTKMM_FOUND)

#
 # 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)
IF(CMAKE_MAJOR_VERSION MATCHES "2" AND CMAKE_MINOR_VERSION MATCHES "6")
  SET(Boost_USE_STATIC_LIBS OFF)
  SET(Boost_USE_MULTITHREAD ON)
  IF (WITH_TEST)
    FIND_PACKAGE(Boost COMPONENTS unit_test_framework)
    IF (Boost_UNIT_TEST_FRAMEWORK_FOUND)
      SET(HAVE_UNITTESTFRAMEWORK 1 CACHE INTERNAL "" FORCE)
    ENDIF (Boost_UNIT_TEST_FRAMEWORK_FOUND)
  ELSE (WITH_TEST)
    FIND_PACKAGE(Boost)
  ENDIF (WITH_TEST)
ELSE(CMAKE_MAJOR_VERSION MATCHES "2" AND CMAKE_MINOR_VERSION MATCHES "6")
  FIND_PACKAGE(Boost)
  IF (Boost_FOUND)
    IF (WITH_TEST)
      FIND_LIBRARY(Boost_UNIT_TEST_FRAMEWORK_LIBRARY NAMES
        boost_unit_test_framework boost_unit_test_framework-mt PATHS
        Boost_LIBRARY_DIRS)
      IF (Boost_UNIT_TEST_FRAMEWORK_LIBRARY)
        SET(HAVE_UNITTESTFRAMEWORK 1 CACHE INTERNAL "" FORCE)
      ELSE (Boost_UNIT_TEST_FRAMEWORK_LIBRARY)
        SET(HAVE_UNITTESTFRAMEWORK 0 CACHE INTERNAL "" FORCE)
      ENDIF (Boost_UNIT_TEST_FRAMEWORK_LIBRARY)
    ELSE (WITH_TEST)
      SET(HAVE_UNITTESTFRAMEWORK 0 CACHE INTERNAL "" FORCE)
    ENDIF (WITH_TEST)
  ENDIF (Boost_FOUND)
ENDIF (CMAKE_MAJOR_VERSION MATCHES "2" AND CMAKE_MINOR_VERSION MATCHES "6")

#
 # 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(${PROJECT_SOURCE_DIR}/config.h.in ${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(${PROJECT_SOURCE_DIR}/src/vle/vle.pc.in ${VLE_BINARY_DIR}/vle-${VLE_VERSION_SHORT}.pc @ONLY)
INSTALL(FILES ${VLE_BINARY_DIR}/vle-${VLE_VERSION_SHORT}.pc DESTINATION lib/pkgconfig)

IF (HAVE_EOV)
  CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/src/vle/eov.pc.in ${VLE_BINARY_DIR}/eov-${VLE_VERSION_SHORT}.pc @ONLY)
  INSTALL(FILES ${VLE_BINARY_DIR}/eov-${VLE_VERSION_SHORT}.pc DESTINATION lib/pkgconfig)
ENDIF (HAVE_EOV)

#
 # Install the README
#

IF(UNIX)
  INSTALL(FILES "README" DESTINATION "${VLE_SHARE_DIRS}")
  INSTALL(FILES "COPYING" DESTINATION "${VLE_SHARE_DIRS}")
ELSE(UNIX)
  INSTALL(FILES "README" DESTINATION "${VLE_SHARE_DIRS}" RENAME "Readme.txt")
  INSTALL(FILES "COPYING" DESTINATION "${VLE_SHARE_DIRS}" RENAME "CopyRight.txt")
ENDIF(UNIX)

#
 # Browse the share subdirectory
#

ADD_SUBDIRECTORY(share)

#
 # Generating documentation with doxygen
#

OPTION(WITH_DOXYGEN "build the documentation with doxygen [default: off]" OFF)
IF (WITH_DOXYGEN)
  FIND_PACKAGE(Doxygen)
  IF (DOXYGEN)
    ADD_SUBDIRECTORY(doxygen)
  ELSE (DOXYGEN)
    MESSAGE(STATUS "WARNING: Doxygen not found - No reference manual create")
  ENDIF (DOXYGEN)
ENDIF(WITH_DOXYGEN)

#
 # Browse the src subdirectory
#

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_EOV)
  MESSAGE(STATUS "Build with eov................: yes")
ENDIF (HAVE_EOV)
IF (HAVE_CAIRO)
  MESSAGE(STATUS "Build with cairo plugin.......: yes")
ENDIF (HAVE_CAIRO)
IF (HAVE_GVLE)
  MESSAGE(STATUS "Build with gvle...............: yes")
ENDIF (HAVE_GVLE)
MESSAGE(STATUS "- - - -")

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