# 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 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 "SeedSelector") # the particular variant of CapTk (Full/Neuro/Torso/Viewer)
SET(PROJECT_NAME_EXTENDED "Cancer And Phenomics Toolkit (${PROJECT_NAME}): ${${PROJECT_NAME}_Variant}")
SET( PROJECT_VERSION_MAJOR 2016)
SET( PROJECT_VERSION_MINOR 10)
SET( PROJECT_VERSION_PATCH 14)
SET( PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
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_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)
  SET( CMAKE_CONFIGURATION_TYPES "Release" )
ELSE()
  IF(WIN32)
    SET( CMAKE_CONFIGURATION_TYPES "Debug" )
  ELSE(WIN32)
    SET( CMAKE_CONFIGURATION_TYPES "Release" )
  ENDIF()
ENDIF()

MARK_AS_ADVANCED(PACKAGE_PROJECT)

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

IF (PACKAGE_VIEWER)
  ADD_DEFINITIONS(-DPACKAGE_VIEWER)
ENDIF()

MARK_AS_ADVANCED(PACKAGE_VIEWER)

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

### 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 )
  #ADD_SUBDIRECTORY( docs_internal ) # uncomment this to generate website HTML and delete this before publishing code -- we probably don't need this any more 
ENDIF ()

ADD_SUBDIRECTORY(${PROJECT_SOURCE_DIR}/src)

# 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()

# turn developer_mode off for non-windows users bu default 
IF(WIN32)
ELSE(WIN32)
    SET(DEVELOPER_MODE OFF)
ENDIF(WIN32)

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

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}
    )
  ELSE(WIN32)
    ADD_EXECUTABLE(${EXE_NAME}
      ${EXE_SOURCES}
    )
  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} 
    )
  ELSE(WIN32)
    ADD_EXECUTABLE(${EXE_NAME}
      ${EXE_SOURCES}
      ${CBICA-TK_SOURCES}
      ${APPLICATION_SOURCES}
      ${APPLICATION_DEPENDS}
      ${GUI_SOURCES} 
    )
  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}
)

IF ( CMAKE_COMPILER_IS_GNUCC )
  #set_target_properties(${PROJECT_NAME} PROPERTIES LINK_SEARCH_START_STATIC 1)
  #set_target_properties(${PROJECT_NAME} PROPERTIES LINK_SEARCH_END_STATIC 1)
  #set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
  # 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 ( CMAKE_COMPILER_IS_GNUCC )

## Build test(s)
SET( BUILD_TESTING FALSE CACHE BOOL "Build testing" )
IF( BUILD_TESTING )
	ENABLE_TESTING()
	ADD_SUBDIRECTORY( testing )
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()

INSTALL(FILES "${PROJECT_SOURCE_DIR}/data/CapTk.qss" DESTINATION data)

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}")
  SET(CPACK_PACKAGE_INSTALL_DIRECTORY "${PROJECT_NAME}_${${PROJECT_NAME}_Variant}/${PROJECT_VERSION}")
  
  # CPack settings
  IF(WIN32)
    SET(CPACK_GENERATOR "NSIS")
    SET(CPACK_NSIS_EXECUTABLES_DIRECTORY "${CMAKE_INSTALL_PREFIX}/bin")
    #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'")
    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)
