# parent CMakeLists file

CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
CMAKE_POLICY(VERSION 2.8)
IF(COMMAND cmake_policy)
  CMAKE_POLICY(SET CMP0003 NEW)
  CMAKE_POLICY(SET CMP0020 NEW)
  CMAKE_POLICY(SET CMP0010 NEW)
  #CMAKE_POLICY(SET CMP0048 NEW) # only with CMake 3
ENDIF(COMMAND cmake_policy)

# set project name. The exe name is taken from this
PROJECT( CaPTk )
SET( EXE_NAME "${PROJECT_NAME}_Console" )
SET (${PROJECT_NAME}_Variant "Full") # the particular variant of CaPTk (Full/Neuro/Torso/Viewer)
SET( PROJECT_VERSION_MAJOR 1)
SET( PROJECT_VERSION_MINOR 0)
SET( PROJECT_VERSION_PATCH 1.20170207)
SET( PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
IF(${PROJECT_NAME}_Variant MATCHES "Full")
  SET(PROJECT_NAME_EXTENDED "Cancer Imaging Phenomics Toolkit (${PROJECT_NAME})")
ELSE()  
  SET(PROJECT_NAME_EXTENDED "Cancer Imaging Phenomics Toolkit (${PROJECT_NAME}_${${PROJECT_NAME}_Variant})")
ENDIF()
SET(PROJECT_VENDOR "CBICA - UPenn")
SET(LICENSE_FILE "${PROJECT_SOURCE_DIR}/licenses/Combined.txt")
SET(README_FILE  "${PROJECT_SOURCE_DIR}/README.txt")
SET(PROJECT_DOMAIN "https://www.cbica.upenn.edu/sbia/software/")
SET(PROJECT_CONTACT "software@cbica.upenn.edu")
ADD_DEFINITIONS(-DPROJECT_NAME="${PROJECT_NAME}")
ADD_DEFINITIONS(-DPROJECT_VERSION="${PROJECT_VERSION}")
ADD_DEFINITIONS(-DEXE_NAME="${EXE_NAME}")
ADD_DEFINITIONS(-DCaPTk_Variant="${CaPTk_Variant}")
ADD_DEFINITIONS(-DPROJECT_NAME_EXTENDED="${PROJECT_NAME_EXTENDED}")
ADD_DEFINITIONS(-DCONTACT="${PROJECT_CONTACT}")
ADD_DEFINITIONS(-DPROJECT_CONTACT="${PROJECT_CONTACT}")
ADD_DEFINITIONS(-DPROJECT_DOMAIN="${PROJECT_DOMAIN}")
ADD_DEFINITIONS(-DPROJECT_LICENSE="${LICENSE_FILE}")
ADD_DEFINITIONS(-DLICENSE="${LICENSE_FILE}")
ADD_DEFINITIONS(-DPROJECT_README="${README_FILE}")
ADD_DEFINITIONS(-DREADME="${README_FILE}")
ADD_DEFINITIONS(-DPROJECT_SOURCE_DIR="${PROJECT_SOURCE_DIR}/")
# package the project 
SET( PACKAGE_PROJECT ON CACHE BOOL "Do you want to package this application (needs NSIS on Windows and DragNDrop on Apple)?" )
IF(PACKAGE_PROJECT)
	####### Get SVN revision info...
	# Based on:
	#	https://www.mail-archive.com/cmake@cmake.org/msg10238.html	
	#	http://public.kitware.com/pipermail/cmake/2014-July/058004.html
	#   	cmake --help-module FindSubversion
	#  dunno if this will work with TortoiseSVN, may require (optional)
	#  Tortoise CLI components
	find_package(Subversion)
	if(SUBVERSION_FOUND)
		Subversion_WC_INFO(${PROJECT_SOURCE_DIR} SVN)
		message("Current revision is ${SVN_WC_REVISION}")
		message("Last changed at ${SVN_WC_LAST_CHANGED_DATE}")
  		SET( PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}.svn${SVN_WC_REVISION}")
  		#SET(PROJECT_NAME_EXTENDED "Cancer Imaging Phenomics Toolkit (${PROJECT_NAME}): ${${PROJECT_NAME}_Variant} Rev ${SVN_WC_REVISION} Changed ${SVN_WC_LAST_CHANGED_DATE}")
	endif(SUBVERSION_FOUND)
  #string(TIMESTAMP VERSION_TIME "%Y-%m-%d %H:%M")
  #add_definitions(-DVERSION_TIME="${VERSION_TIME}")
  SET( CMAKE_CONFIGURATION_TYPES "Release" )
ELSE()
  IF(WIN32)
    SET( CMAKE_CONFIGURATION_TYPES "Debug;Release" )
  ELSE(WIN32)
    SET( CMAKE_CONFIGURATION_TYPES "Release" )
  ENDIF()
ENDIF()

MARK_AS_ADVANCED(PACKAGE_PROJECT)

# option to compile only the viewer
SET( PACKAGE_CONSOLE_ONLY OFF CACHE BOOL "Do you want only the interactive capabilities of ${PROJECT_NAME}? Enabling this will remove all algorithms from compilation." )

IF (PACKAGE_CONSOLE_ONLY)
  ADD_DEFINITIONS(-DPACKAGE_CONSOLE_ONLY)
ENDIF()

MARK_AS_ADVANCED(PACKAGE_CONSOLE_ONLY)

SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake_modules)

# find dependencies START
FIND_PACKAGE(ITK)
INCLUDE("${ITK_USE_FILE}")

FIND_PACKAGE(OpenCV REQUIRED)
MESSAGE( STATUS "OpenCV dirs:${OpenCV_INCLUDE_DIRS}")
INCLUDE_DIRECTORIES(${OpenCV_INCLUDE_DIRS})

FIND_PACKAGE(OpenMP REQUIRED)
SET( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}" )
SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}" )

FIND_PACKAGE(VTK "5.10.0" REQUIRED)
INCLUDE("${VTK_USE_FILE}")
IF(VTK_VERSION VERSION_LESS 6.0.0)
	SET(VTK_LIBRARIES
		vtkCommon
		vtkRendering
		vtkIO
		vtkFiltering
		vtkGraphics
		vtkWidgets
		vtkImaging
		vtkHybrid
    QVTK
	)
ENDIF(VTK_VERSION VERSION_LESS 6.0.0)
IF(VTK_VERSION VERSION_LESS 5.6.0)
	SET(VTK_LIBRARIES
		${VTK_LIBRARIES}
		vtkQVTK
	)
ENDIF(VTK_VERSION VERSION_LESS 5.6.0)

FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(UseQt4)
INCLUDE(${QT_USE_FILE})

ADD_DEFINITIONS(-DQT_THREAD_SUPPORT)
SET(QT_USE_QTGUI TRUE)
SET(QT_USE_QTMAIN TRUE) 
SET(QT_USE_QTGUI TRUE)
ADD_DEFINITIONS(${QT_DEFINITIONS})
ADD_DEFINITIONS(-DQT_PLUGIN)
LINK_DIRECTORIES(${QT_LIBRARY_DIR})

# find dependencies END

# add source code include directories
INCLUDE_DIRECTORIES(
	${QT_INCLUDES}
	${QT_INCLUDE_DIR}
	${QT_QTGUI_INCLUDE_DIR}
	${QT_QTCORE_INCLUDE_DIR}
  ${PROJECT_SOURCE_DIR}/src/
  ${PROJECT_SOURCE_DIR}/src/applications/
  ${PROJECT_SOURCE_DIR}/src/applications/py
  ${PROJECT_SOURCE_DIR}/src/applications/common_includes/
  ${PROJECT_SOURCE_DIR}/src/cbica_toolkit/
  ${PROJECT_SOURCE_DIR}/src/gui/
  ${APPLICATION_INCLUDES}
)

SET(DATA_DIR "${PROJECT_SOURCE_DIR}/data/")

ADD_DEFINITIONS(-DDATA_DIR="${DATA_DIR}")
ADD_DEFINITIONS(-DICON_DIR="${DATA_DIR}/icons")
ADD_DEFINITIONS(-DAPP_LIST="${APP_LIST}")
ADD_DEFINITIONS(-DPREPROCESS_ALGOS="${PREPROCESSING_ALGOS}")
ADD_DEFINITIONS(-DAPP_LIST_PY_GUI="${APPS_LIST_PY_GUI}")
ADD_DEFINITIONS(-DAPP_LIST_PY_CLI="${APPS_LIST_PY_CLI}")
#ADD_DEFINITIONS(${QT_DEFINITIONS})

### Building the documentation
## The following 4 lines are for generation of public documentation
SET( BUILD_DOCUMENTATION ON CACHE BOOL "Do you want to build Documentation (needs Doxygen)?" )
MARK_AS_ADVANCED(BUILD_DOCUMENTATION)
IF( BUILD_DOCUMENTATION )
  ADD_SUBDIRECTORY( docs )
ENDIF ()

ADD_SUBDIRECTORY(${PROJECT_SOURCE_DIR}/src)

#SET(CMAKE_AUTOMOC ON)
#SET(CMAKE_AUTORCC ON)

# generate moc files for each GUI element 
SET(GUI_SOURCES_DIR "${PROJECT_SOURCE_DIR}/src/gui")
FOREACH(gui_tool ${UI_ELEMENTS})
  SET(GUI_SOURCES 
    ${GUI_SOURCES} 
    "${GUI_SOURCES_DIR}/${gui_tool}.h"
    "${GUI_SOURCES_DIR}/ui_${gui_tool}.h"
    "${GUI_SOURCES_DIR}/${gui_tool}.cpp"
  )
  
	QT4_WRAP_CPP(GUI_SOURCES 
  "${GUI_SOURCES_DIR}/${gui_tool}.h"
  )
ENDFOREACH(gui_tool)

# keep source files structured as folders for clarity
SET_PROPERTY( GLOBAL PROPERTY USE_FOLDERS ON )
SOURCE_GROUP( GUI FILES ${GUI_SOURCES} )
SOURCE_GROUP( CBICA-TK FILES ${CBICA-TK_SOURCES} )
SOURCE_GROUP( APPLICATIONS FILES ${APPLICATION_SOURCES} )
SOURCE_GROUP( APPLICATIONS_Dependencies FILES ${APPLICATION_DEPENDS} )

# remove some MSVC flags
IF(MSVC)
	ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS)
ENDIF(MSVC)

# option to invoke developer mode
SET( DEVELOPER_MODE ON CACHE BOOL "Do you want to enable developer mode? This splits the compilation up into different libraries, thereby reducing compile time for changes." )

MARK_AS_ADVANCED(DEVELOPER_MODE)

# ensure developer_mode doesn't conflict with packaging the project
IF(PACKAGE_PROJECT)
  SET( DEVELOPER_MODE OFF )
ENDIF()

# link dependent libraries
SET( DEPENDENT_LIBS 
  Qt4::QtCore
  Qt4::QtGui
  QVTK 
  ${ITK_LIBRARIES} 
  ${VTK_LIBRARIES}
  ${OpenCV_LIBRARIES}
)

#qt4_add_resources(lib_resources ${PROJECT_SOURCE_DIR}/data/icons/captk.rc)

# add c++11 flag if it is GCC v<5
IF(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
  IF(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
    INCLUDE( CheckCXXCompilerFlag )
    CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
    CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
    IF( COMPILER_SUPPORTS_CXX11 )
	MESSAGE(STATUS "Compiler ${CMAKE_CXX_COMPILER} version ${CMAKE_CXX_COMPILER_VERSION} supports C++11")
    	SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
    elseif(COMPILER_SUPPORTS_CXX0X )
	MESSAGE(STATUS "Compiler ${CMAKE_CXX_COMPILER} version ${CMAKE_CXX_COMPILER_VERSION} supports C++0x")
    	SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
    else()
    	MESSAGE(ERROR "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
    endif()
  ELSE(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
	MESSAGE(STATUS "Compiler ${CMAKE_CXX_COMPILER} version ${CMAKE_CXX_COMPILER_VERSION} is above 5.0, known support for C++11, C++0x")
    	SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
    	SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
  ENDIF(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
ENDIF() 


IF(DEVELOPER_MODE)
  ADD_DEFINITIONS(-DDEVELOPER_MODE)
  SET_PROPERTY( GLOBAL PROPERTY USE_FOLDERS ON )

  SET( LIBNAME_GUI "${PROJECT_NAME}_GUI" )
  SET( LIBNAME_Utilities "${PROJECT_NAME}_Utilities" )
  SET( LIBNAME_Applications "${PROJECT_NAME}_Applications" )

  IF(WIN32)
    ADD_LIBRARY( 
      ${LIBNAME_GUI} 
      ${GUI_SOURCES} 
    )
    
    ADD_LIBRARY( 
      ${LIBNAME_Utilities} 
      ${CBICA-TK_SOURCES}
    )
    
    ADD_LIBRARY( 
      ${LIBNAME_Applications} 
      ${APPLICATION_SOURCES}
      ${APPLICATION_DEPENDS}
    )
  ELSE()
    ADD_LIBRARY( 
      ${LIBNAME_GUI} SHARED
      ${GUI_SOURCES} 
    )
    
    ADD_LIBRARY( 
      ${LIBNAME_Utilities} SHARED
      ${CBICA-TK_SOURCES}
    )
    
    ADD_LIBRARY( 
      ${LIBNAME_Applications} SHARED
      ${APPLICATION_SOURCES}
      ${APPLICATION_DEPENDS}
    )
  ENDIF()
  
  SET(CaPTk_Libs_Folder "CaPTk_Libs")

  SET_TARGET_PROPERTIES( ${LIBNAME_GUI} PROPERTIES FOLDER "${CaPTk_Libs_Folder}" )
  SET_TARGET_PROPERTIES( ${LIBNAME_Utilities} PROPERTIES FOLDER "${CaPTk_Libs_Folder}" )
  SET_TARGET_PROPERTIES( ${LIBNAME_Applications} PROPERTIES FOLDER "${CaPTk_Libs_Folder}" )

  SET(DEPENDENT_LIBS 
    ${DEPENDENT_LIBS} 
    ${LIBNAME_GUI}
    ${LIBNAME_Utilities}
    ${LIBNAME_Applications}
  )
  

  # define the executable
  IF(WIN32)
    # ensures no console pops up when launching the program
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP")
    ADD_EXECUTABLE(${EXE_NAME} WIN32 
      ${EXE_SOURCES}
      ${PROJECT_SOURCE_DIR}/data/icons/captk.rc
    )
  ELSE(WIN32)
    ADD_EXECUTABLE(${EXE_NAME}
      ${EXE_SOURCES}
    )
  ENDIF()

  IF(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
    # this ensures that the libc and libcxx are always linked statically
    SET_PROPERTY( TARGET ${EXE_NAME} APPEND_STRING PROPERTY COMPILE_FLAGS -w)  
    SET( CMAKE_EXE_LINKER_FLAGS "-static-libgcc -static-libstdc++")  
  ENDIF()
  
ELSE(DEVELOPER_MODE)

  # define the executable
  IF(WIN32)
    # ensures no console pops up when launching the program
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP")
    ADD_EXECUTABLE(${EXE_NAME} WIN32 
      ${EXE_SOURCES}
      ${CBICA-TK_SOURCES}
      ${APPLICATION_SOURCES}
      ${APPLICATION_DEPENDS}
      ${GUI_SOURCES} 
      #../data/icons/captk.rc
    )
  ELSE(WIN32)
    ADD_EXECUTABLE(${EXE_NAME}
      ${EXE_SOURCES}
      ${CBICA-TK_SOURCES}
      ${APPLICATION_SOURCES}
      ${APPLICATION_DEPENDS}
      ${GUI_SOURCES} 
      #../data/icons/captk.rc
    )
  ENDIF()
  
ENDIF(DEVELOPER_MODE)

TARGET_LINK_LIBRARIES(${EXE_NAME}
  ${DEPENDENT_LIBS} 
)

# set properties for the executable
SET_TARGET_PROPERTIES(${EXE_NAME} 
  PROPERTIES INSTALL_RPATH_USE_LINK_PATH TRUE
  OUTPUT_NAME ${EXE_NAME}
)


## Build test(s)
SET( BUILD_TESTING FALSE CACHE BOOL "Build testing" )
IF( BUILD_TESTING )
  ENABLE_TESTING()
  ADD_SUBDIRECTORY( testing )
  INCLUDE(CTest)
ENDIF( BUILD_TESTING )

# installation
INSTALL(TARGETS ${EXE_NAME} 
  BUNDLE DESTINATION .
  RUNTIME DESTINATION bin
  LIBRARY DESTINATION lib
  #DESTINATION bin
  CONFIGURATIONS "${CMAKE_CONFIGURATION_TYPES}"
)

# ensure all licenses are in the package
FILE(GLOB_RECURSE ALL_LICENSES "${PROJECT_SOURCE_DIR}/licenses/*.txt") 
FOREACH(license ${ALL_LICENSES})
  INSTALL(FILES "${license}" DESTINATION licenses)
ENDFOREACH()
#INSTALL(FILES "${README_FILE}" DESTINATION ".")

# ensure all icons are in the package
FILE(GLOB_RECURSE ALL_ICONS "${PROJECT_SOURCE_DIR}/data/icons/*.png") 
FOREACH(icon ${ALL_ICONS})
  INSTALL(FILES "${icon}" DESTINATION data/icons)
ENDFOREACH()
IF(WIN32)
  # Do not use GLOB_RECURSE to find binary files to install, as this will
  # install duplicate copies of files from ITK-SNAP tree into both the
  # top-level 'bin' dir and w/in the copy of the ITK-SNAP tree.
  #
  # In future, each binary project (LIBRA, WhiteStripe, SBRT*) should have it's own tree,
  # installed recursively (maintaining the tree structure). Even if there
  # seems to be duplication of files (ie., Qt4.dll in both WhiteStripe &
  # SBRT), there's no guarantee that each project uses the same options for
  # each DLL, so they should be separate. Multiple applications may be part of
  # a unified project (ie., SBRT*), in which case they can be managed as a
  # collection.
  INSTALL(DIRECTORY "${PROJECT_SOURCE_DIR}/src/applications/binaries/windows/" DESTINATION bin FILES_MATCHING PATTERN "*.dll")
  INSTALL(DIRECTORY "${PROJECT_SOURCE_DIR}/src/applications/binaries/windows/" DESTINATION bin FILES_MATCHING PATTERN "*.exe")
  INSTALL(DIRECTORY "${PROJECT_SOURCE_DIR}/src/applications/binaries/windows/" DESTINATION bin FILES_MATCHING PATTERN "*.bat")
  INSTALL(DIRECTORY "${PROJECT_SOURCE_DIR}/src/applications/binaries/windows/platforms" DESTINATION bin)
  INSTALL(DIRECTORY "${PROJECT_SOURCE_DIR}/src/applications/binaries/windows/ConfettiBundleAtlas" DESTINATION bin)
  INSTALL(DIRECTORY "${PROJECT_SOURCE_DIR}/src/applications/binaries/windows/ITK-SNAP" DESTINATION bin)
  INSTALL(DIRECTORY "${PROJECT_SOURCE_DIR}/src/applications/binaries/windows/Mathworks" DESTINATION bin)
  
ENDIF()

SET( STYLESHEET_FILE "captk.qss" )
ADD_DEFINITIONS(-DSTYLESHEET_FILE="${STYLESHEET_FILE}")

INSTALL(FILES "${PROJECT_SOURCE_DIR}/data/${STYLESHEET_FILE}" DESTINATION bin)
INSTALL(FILES "${PROJECT_SOURCE_DIR}/data/AAAC/AAAC0_flair_pp_shrunk.nii.gz" DESTINATION data)
INSTALL(FILES "${PROJECT_SOURCE_DIR}/data/help.html" DESTINATION bin)

IF(WIN32)
  FILE(GLOB_RECURSE ALL_DEPENDENT_LIBS "${PROJECT_BINARY_DIR}/${CMAKE_CONFIGURATION_TYPES}/*.dll")
ELSE(WIN32)
  FILE(GLOB_RECURSE ALL_DEPENDENT_LIBS "${PROJECT_BINARY_DIR}/${CMAKE_CONFIGURATION_TYPES}/*.so")
ENDIF()
FOREACH(dependent_lib ${ALL_DEPENDENT_LIBS})
  INSTALL(FILES "${dependent_lib}" DESTINATION bin)
ENDFOREACH()

IF(PACKAGE_PROJECT)

  SET(DEPENDENCY_DIRS ${VTK_LIBRARY_DIRS}/${CMAKE_CONFIGURATION_TYPES}/ ${QT_BINARY_DIR})
  IF(APPLE)
    SET(EXECUTABLE "${PROJECT_BINARY_DIR}/${CMAKE_CONFIGURATION_TYPES}/${EXE_NAME}.app")
  ELSEIF(WIN32)
    SET(EXECUTABLE "${PROJECT_BINARY_DIR}/${CMAKE_CONFIGURATION_TYPES}/${EXE_NAME}.exe")
  ELSE()
    SET(EXECUTABLE "${PROJECT_BINARY_DIR}/${CMAKE_CONFIGURATION_TYPES}/${EXE_NAME}")
  ENDIF()

  SET(CPACK_PACKAGE_EXECUTABLES "${EXECUTABLE}" "${EXE_NAME}")
  
  IF(${PROJECT_NAME}_Variant MATCHES "Full")
    SET(CPACK_PACKAGE_INSTALL_DIRECTORY "${PROJECT_NAME}/${PROJECT_VERSION}")
  ELSE()  
    SET(CPACK_PACKAGE_INSTALL_DIRECTORY "${PROJECT_NAME}/${PROJECT_VERSION}_${${PROJECT_NAME}_Variant}")
  ENDIF()
  
  IF(WIN32)
    SET(CPACK_PACKAGE_INSTALL_DIRECTORY "${PROJECT_NAME}_${${PROJECT_NAME}_Variant}\\\\${PROJECT_VERSION}")
  ENDIF()
  
  FILE(GLOB_RECURSE ALL_DOC_FILES "${PROJECT_BINARY_DIR}/docs/html/*.*")
  FOREACH(docFiles ${ALL_DOC_FILES})
    INSTALL(FILES "${docFiles}" DESTINATION data/docs)
  ENDFOREACH()
  
  INSTALL(FILES "${PROJECT_SOURCE_DIR}/data/SBRT/SVM_Model.csv" DESTINATION data/SBRT)
  INSTALL(FILES "${PROJECT_SOURCE_DIR}/data/icons/captk.rc" DESTINATION data/icons)
  
  # [TBD] testing new script that checks system info
  INCLUDE(SystemSpecificInformation)
  MESSAGE( STATUS "SPECIFIC_COMPILER_NAME = ${SPECIFIC_COMPILER_NAME}" )
  MESSAGE( STATUS "SPECIFIC_SYSTEM_VERSION_NAME = ${SPECIFIC_SYSTEM_VERSION_NAME}" )
  MESSAGE( STATUS "SPECIFIC_SYSTEM_PREFERED_CPACK_GENERATOR = ${SPECIFIC_SYSTEM_PREFERED_CPACK_GENERATOR}" )
  
  # CPack settings
  IF(WIN32)
    SET(CPACK_GENERATOR "NSIS")
    SET(CPACK_NSIS_INSTALL_ROOT "C:")
    SET(CPACK_NSIS_EXECUTABLES_DIRECTORY "${CMAKE_INSTALL_PREFIX}/bin")
    #SET(CPACK_NSIS_EXECUTABLES_DIRECTORY ".")
    SET(CPACK_NSIS_DEFINES "RequestExecutionLevel user")
    #SET(CPACK_NSIS_MUI_ICON "${PROJECT_ICONS_DIRECTORY}/NSIS.ico")
    #SET(CPACK_NSIS_INSTALLED_ICON_NAME "${PROJECT_NAME}${CMAKE_EXECUTABLE_SUFFIX}")
    SET(CPACK_NSIS_MENU_LINKS "${LICENSE_FILE}" "License" "${README_FILE}" "Readme")
    SET(CPACK_NSIS_MUI_FINISHPAGE_RUN "${CPACK_NSIS_INSTALLED_ICON_NAME}")
    SET(CPACK_NSIS_CONTACT "${PROJECT_CONTACT}")
    SET(CPACK_NSIS_HELP_LINK "https:\\\\\\\\www.cbica.upenn.edu\\\\sbia\\\\software\\\\")
    SET(CPACK_NSIS_URL_INFO_ABOUT "https:\\\\\\\\www.cbica.upenn.edu\\\\sbia\\\\software\\\\")
    SET(CPACK_NSIS_DISPLAY_NAME "${PROJECT_NAME}") 
    SET(CPACK_NSIS_MODIFY_PATH "ON")
    SET(CPACK_NSIS_CREATE_ICONS "CreateShortCut '\$SMPROGRAMS\\\\$STARTMENU_FOLDER\\\\${EXE_NAME}.lnk' '\$INSTDIR\\\\bin\\\\${EXE_NAME}.exe'")
    # Commands to add PATH variables pointing to Matlab MCR and ITK-SNAP,
    # taken from:
    #	http://www.mantidproject.org/NSIS_CPACK_Customisations
    #SET (CPACK_NSIS_EXTRA_INSTALL_COMMANDS "Push \\\"PATH\\\"
    #Push \\\"A\\\"
    #Push \\\"HKCU\\\"
    #Push \\\"$INSTDIR\\\\lib\\\\Mathworks\\\\MCR_R2013A_Win64\\\"
    #Call EnvVarUpdate
    #Pop  \\\$0" )
    SET(CPACK_NSIS_CREATE_ICONS_EXTRA "CreateShortCut '$DESKTOP\\\\${EXE_NAME}.lnk' '$INSTDIR\\\\bin\\\\${EXE_NAME}.exe'")
    SET(CPACK_NSIS_DELETE_ICONS "Delete '$SMPROGRAMS\\\\$START_MENU\\\\${EXE_NAME}.lnk'")
    SET(CPACK_NSIS_DELETE_ICONS_EXTRA "Delete '$DESKTOP\\\\${EXE_NAME}.lnk'")
    SET(CPACK_NSIS_CREATE_ICONS_EXTRA "CreateShortCut '$INSTDIR\\\\${EXE_NAME}.lnk' '$INSTDIR\\\\bin\\\\${EXE_NAME}.exe'")
    SET(CPACK_NSIS_DELETE_ICONS "Delete '$INSTDIR\\\\${EXE_NAME}.lnk'")
    SET(CPACK_NSIS_INSTALLED_ICON_NAME "${EXE_NAME}") 
    SET(CPACK_SYSTEM_NAME "Win64")
  ELSEIF(APPLE)
    SET(CMAKE_INSTALL_PREFIX "/Applications")
    SET(CPACK_GENERATOR "DragNDrop")
    SET(CPACK_DMG_FORMAT "UDBZ")
    SET(CPACK_DMG_VOLUME_NAME "${EXE_NAME}")
    SET(CPACK_SYSTEM_NAME "OSX")
    #SET(CPACK_DMG_DS_STORE "${ICONS_DIR}/DMGDSStore")
    #SET(CPACK_DMG_BACKGROUND_IMAGE "${ICONS_DIR}/DMGBackground.png")
  ELSEIF(UNIX)
    SET(CPACK_CMAKE_GENERATOR "Unix Makefiles")
    SET(CPACK_GENERATOR "STGZ;TGZ")
    SET(CPACK_SOURCE_GENERATOR "STGZ;TGZ")
    SET(CPACK_SYSTEM_NAME "${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
    SET(CPACK_SYSTEM_NAME "Linux-i686")
    SET(CPACK_TOPLEVEL_TAG "Linux-i686")
    SET(CPACK_SOURCE_STRIP_FILES "")
    SET(CPACK_STRIP_FILES "${EXECUTABLE}")
  ENDIF()
  # common
  SET(CPACK_PACKAGE_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
  SET(CPACK_PACKAGE_VERSION_MINOR "${PROJECT_VERSION_MINOR}")
  SET(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")
  SET(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
  SET(CPACK_PACKAGE_VENDOR "${PROJECT_VENDOR}")
  SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "CaPTk is a collection of algorithms from CBICA")
  SET(CPACK_SOURCE_IGNORE_FILES "\\\\.svn/;^${PROJECT_SOURCE_DIR}/doc/")
  SET(CPACK_SOURCE_PACKAGE_FILE_NAME "captk-${SW_VER}-source" CACHE INTERNAL "tarball basename")
  SET(CPACK_RESOURCE_FILE_README "${README_FILE}")
  SET(CPACK_RESOURCE_FILE_LICENSE "${LICENSE_FILE}") 
  SET(CPACK_COMPONENT_LIBRARIES_INSTALL_TYPES Developer Full)
  SET(CPACK_COMPONENT_HEADERS_INSTALL_TYPES Developer Full)
  SET(CPACK_COMPONENT_APPLICATIONS_INSTALL_TYPES Full)
  SET(CPACK_ALL_INSTALL_TYPES Full Developer)
  SET(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}_${PROJECT_VERSION}")

  INCLUDE(CPack)
  INCLUDE(InstallRequiredSystemLibraries)

  IF(EXISTS ${EXECUTABLE}) # don't do anything if the EXE is not found - doing this instead of "install_qt4_exe" since it works
    #IF(APPLE OR WIN32)
      #INCLUDE(DeployQt4)
      #INCLUDE(BundleUtilities)
      #MESSAGE(STATUS "Qt libs: ${QT_QTCORE_LIBRARY};${QT_QTGUI_LIBRARY}")
      #MESSAGE(STATUS "Qt lib dir: ${QT_LIBRARY_DIR}")
      #MESSAGE(STATUS "Qt bin dir: ${QT_BINARY_DIR}")
      #MESSAGE(STATUS "VTK bin dir: ${VTK_LIBRARY_DIRS}/${CMAKE_CONFIGURATION_TYPES}/")
      #FIXUP_BUNDLE("${EXECUTABLE}" "" "${DEPENDENCY_DIRS}")
      #FIXUP_QT4_EXECUTABLE("${EXECUTABLE}" "" "" "${QT_LIBRARY_DIR}" "" "")
      #SET(qtconf_dest_dir /Contents/Resources)
      #INSTALL(CODE 
      #  "
      #  FILE(WRITE \"\${CMAKE_INSTALL_PREFIX}/${qtconf_dest_dir}/qt.conf\" \"\")
      #  " 
      #  COMPONENT Runtime
      #)
      INSTALL( CODE 
        "
        INCLUDE(BundleUtilities)
        FIXUP_BUNDLE( \"${EXECUTABLE}\" \"\" \"${QT_BINARY_DIR}\" )
        " 
        Component Runtime 
      )
      #INSTALL_QT4_EXECUTABLE("${EXECUTABLE}" "" "${QT_LIBS}" "${QT_LIBRARY_DIR}" "" "" "")
    #ENDIF()
  ENDIF()

ENDIF(PACKAGE_PROJECT)
