#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+PROJECT(SALOME_KERNEL)
+
CMAKE_MINIMUM_REQUIRED(VERSION 2.8.8 FATAL_ERROR)
-PROJECT(SalomeKERNEL C CXX)
-
-# Ensure a proper linker behavior:
-CMAKE_POLICY(SET CMP0003 NEW)
-
-# Versioning
-# ===========
-# Project name, upper case
-STRING(TOUPPER ${PROJECT_NAME} PROJECT_NAME_UC)
-
-SET(${PROJECT_NAME_UC}_MAJOR_VERSION 2)
-SET(${PROJECT_NAME_UC}_MINOR_VERSION 0)
-SET(${PROJECT_NAME_UC}_PATCH_VERSION 0)
-SET(${PROJECT_NAME_UC}_VERSION
- ${${PROJECT_NAME_UC}_MAJOR_VERSION}.${${PROJECT_NAME_UC}_MINOR_VERSION}.${${PROJECT_NAME_UC}_PATCH_VERSION})
-# Temporary backward compatibility:
-SET(VERSION ${${PROJECT_NAME_UC}_VERSION})
+
+IF(COMMAND cmake_policy)
+ cmake_policy(SET CMP0003 NEW)
+ENDIF(COMMAND cmake_policy)
+
+# directories for packages detection
+SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files)
+
+find_package(PLATFORM)
+
+IF(APPLE)
+ SET(CMAKE_C_COMPILER gcc)
+ SET(CMAKE_CXX_COMPILER g++)
+ # because default is clang(llvm) with mountain lion at least
+ENDIF(APPLE)
+
+
+# Temporary step instead Find Calcium.cmake
+SET(CALCIUM_IDL_INT_F77 long)
+SET(CALCIUM_CORBA_INT_F77 CORBA::Long)
+SET(LONG_OR_INT int)
+
+# Temporary definitions
+SET(DOXYGEN_IS_OK 0)
+IF(WINDOWS)
+ SET(CPPUNIT_IS_OK 0)
+ENDIF(WINDOWS)
+SET(WITH_LOCAL 1)
+SET(WITH_BATCH 1)
+
+ENABLE_TESTING()
+SET(VERSION "7.2.0")
SET(VERSION_DEV "0")
-# Our own set of macros:
-LIST(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/salome_adm/cmake_files")
+SET(BUILD_SHARED_LIBS true)
+
+#Defining all options first
+option(SALOME_USE_MPI "Use MPI containers" OFF)
+option(SALOME_USE_CORBA "Use distribute application with components" ON)
+option(SALOME_USE_DOC "Generate documentation" ON)
+option(SALOME_USE_TEST "Generate test" OFF)
+option(SALOME_USE_LIBBATCH "Generate Launcher" ON)
+
+# Threads
+SET(CMAKE_THREAD_PREFER_PTHREAD)
+find_package(Threads REQUIRED)
+
+# required prerequisites
+
+find_package(SalomePYTHON)
+find_package(SalomeSWIG)
+find_package(SalomeLIBXML2)
+find_package(SalomeHDF5)
+find_package(SalomeBOOST)
+
+# optional prerequisites
+
+if(SALOME_USE_MPI OR HDF5_IS_PARALLEL)
+ find_package(SalomeMPI)
+endif(SALOME_USE_MPI OR HDF5_IS_PARALLEL)
+
+if(SALOME_USE_CORBA)
+ find_package(OMNIORB)
+endif(SALOME_USE_CORBA)
+
+if(SALOME_USE_TEST)
+ find_package(SalomeCPPUNIT)
+endif(SALOME_USE_TEST)
+
+if(SALOME_USE_DOC)
+ find_package(SalomeDOXYGEN)
+ find_package(SalomeSPHINX)
+endif(SALOME_USE_DOC)
+
+if(SALOME_USE_LIBBATCH)
+ find_package(SalomeLIBBATCH)
+endif(SALOME_USE_LIBBATCH)
+
INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/SalomeMacros.cmake)
-# Platform setup
-# ==============
-INCLUDE(SalomeSetupPlatform)
-# Always build libraries as shared objects:
-SET(BUILD_SHARED_LIBS TRUE)
-# Temporary step instead of Find Calcium.cmake
SET(CALCIUM_IDL_INT_F77 long)
SET(CALCIUM_CORBA_INT_F77 CORBA::Long)
SET(LONG_OR_INT int)
-# Global definitions
-ADD_DEFINITIONS(-DSIZEOF_FORTRAN_INTEGER=4 -DSIZEOF_INT=4)
-## OmniORB already defines SIZEOF_LONG
-# ADD_DEFINITIONS(-DSIZEOF_LONG=${SIZE_OF_LONG})
-
-# User options
-# ============
-OPTION(SALOME_USE_MPI "Use MPI containers" OFF)
-OPTION(SALOME_BUILD_DOC "Generate SALOME KERNEL documentation" ON)
-OPTION(SALOME_BUILD_TESTS "Build SALOME tests" ON)
-
-# Advanced:
-OPTION(SALOME_LIGHT_ONLY "Build SALOME Light only (no CORBA)" OFF)
-OPTION(SALOME_USE_LIBBATCH "Use LibBatch in KERNEL" ON)
-OPTION(SALOME_PACO_PARALLEL "Build with PACO in parallel" OFF)
-OPTION(SALOME_LAUNCHER_ONLY "Build only the Launcher part" OFF)
-MARK_AS_ADVANCED(SALOME_LIGHT_ONLY SALOME_USE_LIBBATCH SALOME_PACO_PARALLEL SALOME_LAUNCHER_ONLY)
-
-# Directories
-# ===========
-SET(SALOME_INSTALL_BINS bin/salome CACHE PATH "Install path: SALOME binaries")
-SET(SALOME_INSTALL_LIBS lib/salome CACHE PATH "Install path: SALOME libs")
-SET(SALOME_INSTALL_IDLS idl/salome CACHE PATH "Install path: SALOME IDL files")
-SET(SALOME_INSTALL_HEADERS include/salome CACHE PATH "Install path: SALOME headers")
-SET(SALOME_INSTALL_SCRIPT_SCRIPTS ${SALOME_INSTALL_BINS} CACHE PATH
- "Install path: SALOME scripts")
-SET(SALOME_INSTALL_SCRIPT_DATA ${SALOME_INSTALL_BINS} CACHE PATH
- "Install path: SALOME script data")
-SET(SALOME_INSTALL_SCRIPT_PYTHON ${SALOME_INSTALL_BINS} CACHE PATH
- "Install path: SALOME Python scripts")
-SET(SALOME_INSTALL_APPLISKEL_SCRIPTS ${SALOME_INSTALL_BINS}/appliskel CACHE PATH
- "Install path: SALOME application skeleton - scripts")
-SET(SALOME_INSTALL_APPLISKEL_PYTHON ${SALOME_INSTALL_BINS}/appliskel CACHE PATH
- "Install path: SALOME application skeleton - Python")
-SET(SALOME_INSTALL_CMAKE salome_adm/cmake_files CACHE PATH "Install path: SALOME CMake files")
-
-SET(_pydir lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages)
-SET(SALOME_INSTALL_PYTHON ${_pydir}/salome CACHE PATH "Install path: SALOME Python stuff")
-SET(SALOME_INSTALL_PYTHON_SHARED ${SALOME_INSTALL_PYTHON}/shared_modules CACHE PATH
- "Install path: SALOME Python shared modules")
-
-# Kernel specific:
-SET(SALOME_KERNEL_INSTALL_RES_DATA share/salome/resources/kernel CACHE PATH "Install path: SALOME KERNEL specific data")
-SET(SALOME_KERNEL_INSTALL_RES_SCRIPTS share/salome/resources/kernel CACHE PATH "Install path: SALOME KERNEL specific scripts")
-
-MARK_AS_ADVANCED(SALOME_INSTALL_BINS SALOME_INSTALL_LIBS SALOME_INSTALL_IDLS SALOME_INSTALL_HEADERS)
-MARK_AS_ADVANCED(SALOME_INSTALL_SCRIPT_SCRIPTS SALOME_INSTALL_SCRIPT_DATA SALOME_INSTALL_SCRIPT_PYTHON)
-MARK_AS_ADVANCED(SALOME_INSTALL_APPLISKEL_SCRIPTS SALOME_INSTALL_APPLISKEL_PYTHON SALOME_INSTALL_CMAKE)
-MARK_AS_ADVANCED(SALOME_INSTALL_PYTHON SALOME_INSTALL_PYTHON_SHARED SALOME_KERNEL_INSTALL_RES_DATA SALOME_KERNEL_INSTALL_RES_SCRIPTS)
-
-# Required prerequisites
-# Find "big" prerequisites first - they reference themselves many others
-# -> this can help finding the smaller prerequisites and detect conficts.
-# =======================
-
-FIND_PACKAGE(SalomeLibBatch REQUIRED)
-FIND_PACKAGE(SalomePython REQUIRED)
-FIND_PACKAGE(SalomePThread REQUIRED)
-FIND_PACKAGE(SalomeSWIG REQUIRED)
-FIND_PACKAGE(SalomeLibXml2 REQUIRED)
-
-# HDF5 requires a bit more work to ensure MPI is selected:
-FIND_PACKAGE(SalomeHDF5 REQUIRED)
-ADD_DEFINITIONS(-DH5_USE_16_API)
-IF(WINDOWS)
- ADD_DEFINITIONS(-D_HDF5USEDLL_)
-ENDIF()
-IF(HDF5_IS_PARALLEL AND NOT SALOME_USE_MPI)
- MESSAGE(FATAL_ERROR "HDF5 is compiled with MPI, you have to set SALOME_USE_MPI to ON")
-ENDIF()
-
-# Boost
-FIND_PACKAGE(SalomeBoost REQUIRED)
-IF(WIN32)
- SET(BOOST_DEFINITIONS -DBOOST_DISABLE_ASSERTS)
-ENDIF()
-
-# Optional prerequisites
-# ======================
-
-IF(NOT SALOME_LIGHT_ONLY)
- FIND_PACKAGE(SalomeOmniORB REQUIRED)
-ENDIF()
-IF(SALOME_USE_MPI)
- FIND_PACKAGE(SalomeMPI REQUIRED)
- SET(MPI_INCLUDE_DIRS ${MPI_C_INCLUDE_PATH} ${MPI_CXX_INCLUDE_PATH})
- SET(MPI_LIBRARIES ${MPI_C_LIBRARIES} ${MPI_CXX_LIBRARIES})
-ENDIF()
-IF(SALOME_BUILD_TESTS)
- ENABLE_TESTING()
- FIND_PACKAGE(SalomeCppUnit REQUIRED)
-ENDIF()
-IF(SALOME_BUILD_DOC)
- FIND_PACKAGE(SalomeDoxygen REQUIRED)
- FIND_PACKAGE(SalomeGraphviz) # Remains optional even here.
- FIND_PACKAGE(SalomeSphinx REQUIRED)
-ENDIF()
-
-# Sources
-# ========
-IF(NOT SALOME_LIGHT_ONLY)
+
+
+SET(KERNEL_salomebin_BINS bin/salome)
+
+SET(KERNEL_salomelib_LIBS lib/salome)
+
+SET(KERNEL_salomeidl_IDLS idl/salome)
+
+SET(KERNEL_salomeinclude_HEADERS include/salome)
+
+SET(KERNEL_salomeres_DATA share/salome/resources/kernel)
+
+SET(KERNEL_salomeres_SCRIPTS share/salome/resources/kernel)
+
+SET(KERNEL_salomescript_SCRIPTS bin/salome)
+
+SET(KERNEL_salomescript_DATA bin/salome)
+
+SET(KERNEL_salomescript_PYTHON bin/salome)
+
+SET(KERNEL_appliskel_SCRIPTS bin/salome/appliskel)
+
+SET(KERNEL_appliskel_PYTHON bin/salome/appliskel)
+
+SET(KERNEL_pythondir lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages)
+
+SET(KERNEL_salomepythondir ${KERNEL_pythondir}/salome)
+
+SET(KERNEL_sharedpkgpython_PYTHON ${KERNEL_salomepythondir}/shared_modules)
+
+SET(KERNEL_salomeadmcmake salome_adm/cmake_files)
+
+IF(SALOME_USE_CORBA)
ADD_SUBDIRECTORY(idl)
-ENDIF()
+ENDIF(SALOME_USE_CORBA)
+
ADD_SUBDIRECTORY(src)
ADD_SUBDIRECTORY(resources)
-ADD_SUBDIRECTORY(bin)
-ADD_SUBDIRECTORY(salome_adm)
-IF(SALOME_BUILD_DOC)
- ADD_SUBDIRECTORY(doc)
-ENDIF()
-# Header configuration
-# ====================
+IF(NOT WITHONLYLAUNCHER)
+ ADD_SUBDIRECTORY(bin)
+ ADD_SUBDIRECTORY(salome_adm)
+ENDIF(NOT WITHONLYLAUNCHER)
+
SET(input ${CMAKE_CURRENT_SOURCE_DIR}/KERNEL_version.h.in)
SET(output ${CMAKE_CURRENT_BINARY_DIR}/KERNEL_version.h)
MESSAGE(STATUS "Creation of ${output}")
CONFIGURE_FILE(${input} ${output} @ONLY)
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/KERNEL_version.h DESTINATION ${SALOME_INSTALL_HEADERS})
-
-# Configuration export
-# ====================
-INCLUDE(CMakePackageConfigHelpers)
-
-# Add all targets to the build-tree export set
-EXPORT(TARGETS SALOMEBasics
- FILE ${PROJECT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake)
-
-# Create the configuration files:
-# - in the build tree:
-
-# Ensure the variables are always defined for the configure:
-SET(CPPUNIT_ROOT_DIR "${CPPUNIT_ROOT_DIR}")
-SET(GRAPHVIZ_ROOT_DIR "${GRAPHVIZ_ROOT_DIR}")
-SET(DOXYGEN_ROOT_DIR "${DOXYGEN_ROOT_DIR}")
-SET(SPHINX_ROOT_DIR "${SPHINX_ROOT_DIR}")
-SET(MPI_ROOT_DIR "${MPI_ROOT_DIR}")
-SET(OMNIORB_ROOT_DIR "${OMNIORB_ROOT_DIR}")
-SET(LIBBATCH_ROOT_DIR "${LIBBATCH_ROOT_DIR}")
-
-SET(CONF_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/include" "${PROJECT_BINARY_DIR}/include")
-CONFIGURE_PACKAGE_CONFIG_FILE(salome_adm/cmake_files/${PROJECT_NAME}Config.cmake.in
- ${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
- INSTALL_DESTINATION "${SALOME_INSTALL_CMAKE}"
- PATH_VARS CONF_INCLUDE_DIRS SALOME_INSTALL_CMAKE CMAKE_INSTALL_PREFIX
- CPPUNIT_ROOT_DIR GRAPHVIZ_ROOT_DIR DOXYGEN_ROOT_DIR
- SPHINX_ROOT_DIR MPI_ROOT_DIR OMNIORB_ROOT_DIR LIBBATCH_ROOT_DIR
- PTHREAD_ROOT_DIR BOOST_ROOT_DIR HDF5_ROOT_DIR LIBXML2_ROOT_DIR
- PYTHON_ROOT_DIR SWIG_ROOT_DIR)
-
-# - in the install tree:
-# Get the relative path of the include directory so
-# we can register it in the generated configuration files:
-SET(CONF_INCLUDE_DIRS "${CMAKE_INSTALL_PREFIX}/${INSTALL_INCLUDE_DIR}")
-CONFIGURE_PACKAGE_CONFIG_FILE(salome_adm/cmake_files/${PROJECT_NAME}Config.cmake.in
- ${PROJECT_BINARY_DIR}/to_install/${PROJECT_NAME}Config.cmake
- INSTALL_DESTINATION "${SALOME_INSTALL_CMAKE}"
- PATH_VARS CONF_INCLUDE_DIRS SALOME_INSTALL_CMAKE CMAKE_INSTALL_PREFIX
- CPPUNIT_ROOT_DIR GRAPHVIZ_ROOT_DIR DOXYGEN_ROOT_DIR
- SPHINX_ROOT_DIR MPI_ROOT_DIR OMNIORB_ROOT_DIR LIBBATCH_ROOT_DIR
- PTHREAD_ROOT_DIR BOOST_ROOT_DIR HDF5_ROOT_DIR LIBXML2_ROOT_DIR
- PYTHON_ROOT_DIR SWIG_ROOT_DIR)
-
-WRITE_BASIC_PACKAGE_VERSION_FILE(${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
- VERSION ${${PROJECT_NAME_UC}_VERSION}
- COMPATIBILITY AnyNewerVersion)
-
-# Install the CMake configuration files:
-INSTALL(FILES
- "${PROJECT_BINARY_DIR}/to_install/${PROJECT_NAME}Config.cmake"
- "${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
- DESTINATION "${SALOME_INSTALL_CMAKE}")
-
-# Install the export set for use with the install-tree
-INSTALL(EXPORT salomeKernelTargets DESTINATION "${SALOME_INSTALL_CMAKE}")
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/KERNEL_version.h DESTINATION ${KERNEL_salomeinclude_HEADERS})
+
+IF(SALOME_USE_DOC)
+ ADD_SUBDIRECTORY(doc)
+ENDIF(SALOME_USE_DOC)
CONFIGURE_FILE(VERSION.in VERSION @ONLY)
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/VERSION DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/VERSION DESTINATION ${KERNEL_salomebin_BINS})
# ===============================================================
# Files to be installed
# ===============================================================
# These files are data, module or lib files
-INSTALL(FILES config_appli.xml salome.launch DESTINATION ${SALOME_INSTALL_SCRIPT_DATA})
+INSTALL(FILES config_appli.xml salome.launch DESTINATION ${KERNEL_salomescript_DATA})
# These files are executable scripts
SET(SCRIPTS
waitContainers.py
waitNS.py
)
-SALOME_INSTALL_SCRIPTS("${SCRIPTS}" ${SALOME_INSTALL_SCRIPT_SCRIPTS})
+SALOME_INSTALL_SCRIPTS("${SCRIPTS}" ${KERNEL_salomescript_SCRIPTS})
kill_remote_containers.py
)
-SALOME_INSTALL_SCRIPTS("${SCRIPTS}" ${SALOME_INSTALL_SCRIPT_SCRIPTS}/appliskel)
+SALOME_INSTALL_SCRIPTS("${SCRIPTS}" ${KERNEL_salomescript_SCRIPTS}/appliskel)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/UseOmniORB.cmake)
+INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/UseOMNIORB.cmake)
INCLUDE_DIRECTORIES(
${OMNIORB_INCLUDE_DIR}
ADD_DEFINITIONS(${COMMON_FLAGS})
TARGET_LINK_LIBRARIES(SalomeIDLKernel ${OMNIORB_LIBRARIES})
-INSTALL(TARGETS SalomeIDLKernel DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeIDLKernel DESTINATION ${KERNEL_salomelib_LIBS})
-IF(SALOME_PACO_PARALLEL)
+IF(WITH_PACO_PARALLEL)
SET(SalomeParallelIDLKernel_IDLSOURCES
SALOME_ComponentPaCO.idl
SALOME_PortsPaCO.idl
OMNIORB_ADD_MODULE(SalomeParallelIDLKernel "${SalomeIDLKernel_IDLSOURCES}" "${IDL_INCLUDE_DIRS}")
TARGET_LINK_LIBRARIES(SalomeParallelIDLKernel ${OMNIORB_LIBRARIES})
- INSTALL(TARGETS SalomeParallelIDLKernel DESTINATION ${SALOME_INSTALL_LIBS})
-ENDIF()
+ INSTALL(TARGETS SalomeParallelIDLKernel DESTINATION ${KERNEL_salomelib_LIBS})
+ENDIF(WITH_PACO_PARALLEL)
# ===============================================================
# These files are data, module or lib files
-INSTALL(FILES CatalogModulePersonnel.xml_skel DESTINATION ${SALOME_KERNEL_INSTALL_RES_DATA})
+INSTALL(FILES CatalogModulePersonnel.xml_skel DESTINATION ${KERNEL_salomeres_DATA})
CONFIGURE_FILE(CatalogResources.xml.in CatalogResources.xml @ONLY)
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/CatalogResources.xml DESTINATION ${SALOME_KERNEL_INSTALL_RES_DATA})
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/CatalogResources.xml DESTINATION ${KERNEL_salomeres_DATA})
-IF(NOT SALOME_LAUNCHER_ONLY)
- INSTALL(FILES channel.cfg SALOMEDS_Resources DESTINATION ${SALOME_KERNEL_INSTALL_RES_DATA})
+IF(NOT WITHONLYLAUNCHER)
+ INSTALL(FILES channel.cfg SALOMEDS_Resources DESTINATION ${KERNEL_salomeres_DATA})
CONFIGURE_FILE(KERNELCatalog.xml.in KERNELCatalog.xml @ONLY)
- INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/KERNELCatalog.xml DESTINATION ${SALOME_KERNEL_INSTALL_RES_DATA})
+ INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/KERNELCatalog.xml DESTINATION ${KERNEL_salomeres_DATA})
-ENDIF()
+ENDIF(NOT WITHONLYLAUNCHER)
ADD_SUBDIRECTORY(unix)
ADD_SUBDIRECTORY(cmake_files)
-SALOME_CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/SALOMEconfig.ref.in" "${CMAKE_CURRENT_BINARY_DIR}/SALOMEconfig.h" INSTALL ${SALOME_INSTALL_HEADERS})
+SALOME_CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/SALOMEconfig.ref.in" "${CMAKE_CURRENT_BINARY_DIR}/SALOMEconfig.h" INSTALL ${KERNEL_salomeinclude_HEADERS})
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/SALOMEconfig.ref.in DESTINATION salome_adm/unix RENAME SALOMEconfig.h.in)
\ No newline at end of file
install_python_from_idl.cmake
install_and_compile_python_file.cmake
)
-INSTALL(FILES ${DATA} DESTINATION ${SALOME_INSTALL_CMAKE}/deprecated)
+INSTALL(FILES ${DATA} DESTINATION ${KERNEL_salomeadmcmake}/deprecated)
)
ADD_LIBRARY(SALOMEBasics ${SALOMEBasics_SOURCES})
-INSTALL(TARGETS SALOMEBasics EXPORT salomeKernelTargets DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SALOMEBasics DESTINATION ${KERNEL_salomelib_LIBS})
-TARGET_LINK_LIBRARIES(SALOMEBasics ${PLATFORM_LIBS})
+TARGET_LINK_LIBRARIES(SALOMEBasics ${CMAKE_THREAD_LIBS_INIT} ${PLATFORM_LIBS})
FILE(GLOB SALOMEBasics_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${SALOMEBasics_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${SALOMEBasics_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
#
FILE(GLOB SALOMEBasics_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${SALOMEBasics_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${SALOMEBasics_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
DSC
)
-SET(SUBDIR_MPI MPIContainer TestMPIContainer)
-SET(SUBDIR_PARALLEL ParallelContainer)
-
-# CppUnit directories:
SET(SUBDIR_CPPUNIT_BASE
Basics/Test
SALOMELocalTrace/Test
)
+
SET(SUBDIR_CPPUNIT_CORBA
Logger/Test
SALOMETraceCollector/Test
SALOMEDS/Test
KernelHelpers/Test
)
+
SET(SUBDIR_CPPUNIT_GENERAL UnitTests)
+SET(SUBDIR_MPI MPIContainer TestMPIContainer)
+SET(SUBDIR_PARALLEL ParallelContainer)
-IF(SALOME_LAUNCHER_ONLY)
+IF(WITHONLYLAUNCHER)
SET(SUBDIRS Basics ResourcesManager Launcher)
-ELSE()
+ELSE(WITHONLYLAUNCHER)
SET(SUBDIRS ${SUBDIR_BASE})
- IF(NOT SALOME_LIGHT_ONLY)
- LIST(APPEND SUBDIRS ${SUBDIR_CORBA})
- ENDIF()
+ENDIF(WITHONLYLAUNCHER)
+
+IF(SALOME_USE_CORBA)
+ SET(SUBDIRS ${SUBDIRS} ${SUBDIR_CORBA})
+ENDIF(SALOME_USE_CORBA)
- IF(SALOME_USE_MPI)
- LIST(APPEND SUBDIRS ${SUBDIR_MPI})
+IF(SALOME_USE_MPI)
+ SET(SUBDIRS
+ ${SUBDIRS}
+ ${SUBDIR_MPI}
+ )
ENDIF(SALOME_USE_MPI)
-IF(SALOME_BUILD_TESTS)
- LIST(APPEND SUBDIRS ${SUBDIR_CPPUNIT_BASE} ${SUBDIR_CPPUNIT_GENERAL})
- IF(NOT SALOME_LIGHT_ONLY)
- LIST(APPEND SUBDIRS ${SUBDIR_CPPUNIT_CORBA})
- ENDIF()
- ENDIF()
+IF(CPPUNIT_IS_OK)
+ IF(SALOME_USE_CORBA)
+ SET(SUBDIRS
+ ${SUBDIRS}
+ ${SUBDIR_CPPUNIT_BASE}
+ ${SUBDIR_CPPUNIT_CORBA}
+ ${SUBDIR_CPPUNIT_GENERAL}
+ )
+ ELSE(SALOME_USE_CORBA)
+ SET(SUBDIRS
+ ${SUBDIRS}
+ ${SUBDIR_CPPUNIT_BASE}
+ ${SUBDIR_CPPUNIT_GENERAL}
+ )
+ ENDIF(SALOME_USE_CORBA)
+ENDIF(CPPUNIT_IS_OK)
- IF(SALOME_PACO_PARALLEL)
- LIST(APPEND SUBDIRS ${SUBDIR_PARALLEL})
- ENDIF()
-ENDIF()
+IF(WITH_PACO_PARALLEL)
+ SET(SUBDIRS
+ ${SUBDIRS}
+ ${SUBDIR_PARALLEL}
+ )
+ENDIF(WITH_PACO_PARALLEL)
-FOREACH(_dir ${SUBDIRS})
- ADD_SUBDIRECTORY(${_dir})
-ENDFOREACH()
+FOREACH(DIR ${SUBDIRS})
+ ADD_SUBDIRECTORY(${DIR})
+ENDFOREACH(DIR ${SUBDIRS})
#
INCLUDE_DIRECTORIES(
+ ${PTHREAD_INCLUDE_DIRS}
${OMNIORB_INCLUDE_DIR}
${MPI_CXX_INCLUDE_PATH}
${PYTHON_INCLUDE_DIRS}
ADD_LIBRARY(SalomeCommunication ${SalomeCommunication_SOURCES})
TARGET_LINK_LIBRARIES(SalomeCommunication ${COMMON_LIBS})
-INSTALL(TARGETS SalomeCommunication DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeCommunication DESTINATION ${KERNEL_salomelib_LIBS})
SET(COMMON_HEADERS_HXX
MatrixClient.hxx
SenderFactory.hxx
)
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_DEPENDENCIES(_libSALOME_Comm SalomeIDLKernel)
-INSTALL(TARGETS _libSALOME_Comm DESTINATION ${SALOME_INSTALL_PYTHON})
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libSALOME_Comm.py DESTINATION ${SALOME_INSTALL_PYTHON})
+INSTALL(TARGETS _libSALOME_Comm DESTINATION ${KERNEL_salomepythondir})
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libSALOME_Comm.py DESTINATION ${KERNEL_salomepythondir})
#include "SenderFactory.hxx"
%}
-%typemap(in) SALOME::SenderDouble_ptr
+%typemap(python,in) SALOME::SenderDouble_ptr
{
PyObject* pdict = PyDict_New();
PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
$1 = t;
}
-%typemap(in) SALOME::SenderInt_ptr
+%typemap(python,in) SALOME::SenderInt_ptr
{
PyObject* pdict = PyDict_New();
PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
$1 = t;
}
-%typemap(out) SALOME::SenderDouble_ptr
+%typemap(python,out) SALOME::SenderDouble_ptr
{
PyObject* pdict = PyDict_New();
PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
$result = PyObject_CallMethod(orb, (char*)"string_to_object", (char*)"O", tmp);
}
-%typemap(out) SALOME::SenderInt_ptr
+%typemap(python,out) SALOME::SenderInt_ptr
{
PyObject* pdict = PyDict_New();
PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
#
INCLUDE_DIRECTORIES(
+ ${PTHREAD_INCLUDE_DIRS}
${OMNIORB_INCLUDE_DIR}
- ${PTHREAD_INCLUDE_DIR}
${HDF5_INCLUDE_DIRS}
${LIBXML2_INCLUDE_DIR}
${PYTHON_INCLUDE_DIRS}
)
ENDIF(WITH_MPI_SEQ_CONTAINER)
-IF(SALOME_PACO_PARALLEL)
+IF(WITH_PACO_PARALLEL)
ADD_DEFINITIONS(-DWITH_PACO_PARALLEL ${PACO_DEFINITIONS})
SET(COMMON_LIBS
${COMMON_LIBS}
${PACO_LIBS}
)
-ENDIF()
+ENDIF(WITH_PACO_PARALLEL)
SET(SalomeContainer_SOURCES
Component_i.cxx
)
ADD_LIBRARY(SalomeContainer ${SalomeContainer_SOURCES})
-TARGET_LINK_LIBRARIES(SalomeContainer ${COMMON_LIBS} ${PTHREAD_LIBRARIES})
-INSTALL(TARGETS SalomeContainer DESTINATION ${SALOME_INSTALL_LIBS})
+TARGET_LINK_LIBRARIES(SalomeContainer ${COMMON_LIBS})
+INSTALL(TARGETS SalomeContainer DESTINATION ${KERNEL_salomelib_LIBS})
SET(SALOME_Container_LIBS
SalomeContainer
SALOMEBasics
${COMMON_LIBS}
${HDF5_LIBRARIES}
- ${MPI_LIBRARIES}
)
ADD_EXECUTABLE(SALOME_Container SALOME_Container.cxx SALOME_Container_SignalsHandler.cxx)
TARGET_LINK_LIBRARIES(SALOME_Container ${SALOME_Container_LIBS})
-IF(SALOME_BUILD_TESTS)
+IF(SALOME_USE_TEST)
ADD_EXECUTABLE(TestSalome_file TestSalome_file.cxx)
TARGET_LINK_LIBRARIES(TestSalome_file SALOMETraceCollectorTest ${SALOME_Container_LIBS})
-ENDIF()
-INSTALL(TARGETS SALOME_Container DESTINATION ${SALOME_INSTALL_BINS})
+ENDIF(SALOME_USE_TEST)
+INSTALL(TARGETS SALOME_Container DESTINATION ${KERNEL_salomebin_BINS})
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS("${SCRIPTS}" ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS("${SCRIPTS}" ${KERNEL_salomescript_PYTHON})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
)
ADD_LIBRARY(DF ${DF_SOURCES})
-INSTALL(TARGETS DF DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS DF DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(testDF testDF.cxx)
TARGET_LINK_LIBRARIES(testDF DF)
-INSTALL(TARGETS testDF DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS testDF DESTINATION ${KERNEL_salomebin_BINS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
)
ENDIF(NOT WINDOWS)
-IF(SALOME_PACO_PARALLEL)
+IF(WITH_PACO_PARALLEL)
SET(SUBDIR_PAR
ParallelDSC
)
-ENDIF()
+ENDIF(WITH_PACO_PARALLEL)
SET(SUBDIRS
${SUBDIRS_COMMON}
ADD_LIBRARY(SalomeDSCContainer ${SalomeDSCContainer_SOURCES})
TARGET_LINK_LIBRARIES(SalomeDSCContainer SalomeContainer ${OMNIORB_LIBRARIES})
-INSTALL(TARGETS SalomeDSCContainer DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeDSCContainer DESTINATION ${KERNEL_salomelib_LIBS})
SET(SALOME_ConnectionManagerServer_SOURCES
SALOME_ConnectionManagerServer.cxx
ADD_EXECUTABLE(SALOME_ConnectionManagerServer ${SALOME_ConnectionManagerServer_SOURCES})
TARGET_LINK_LIBRARIES(SALOME_ConnectionManagerServer ${SALOME_ConnectionManagerServer_LIBS})
-INSTALL(TARGETS SALOME_ConnectionManagerServer DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS SALOME_ConnectionManagerServer DESTINATION ${KERNEL_salomebin_BINS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
SWIG_ADD_MODULE(calcium python calcium.i)
SWIG_LINK_LIBRARIES(calcium ${_calcium_LIBS})
-INSTALL(TARGETS _calcium DESTINATION ${SALOME_INSTALL_PYTHON})
+INSTALL(TARGETS _calcium DESTINATION ${KERNEL_salomepythondir})
SET(SCRIPTS
dsccalcium.py
)
-SALOME_INSTALL_SCRIPTS( ${SCRIPTS} ${SALOME_INSTALL_PYTHON})
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/calcium.py DESTINATION ${SALOME_INSTALL_PYTHON})
+SALOME_INSTALL_SCRIPTS( ${SCRIPTS} ${KERNEL_salomepythondir})
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/calcium.py DESTINATION ${KERNEL_salomepythondir})
INCLUDE_DIRECTORIES(
${OMNIORB_INCLUDE_DIR}
- ${PTHREAD_INCLUDE_DIR}
${CMAKE_BINARY_DIR}/idl
${CMAKE_BINARY_DIR}/salome_adm
${CMAKE_SOURCE_DIR}/src/DSC/DSC_Basic
ADD_DEFINITIONS(${OMNIORB_DEFINITIONS})
ADD_LIBRARY(SalomeDSCSupervBasic ${SalomeDSCSupervBasic_SOURCES})
TARGET_LINK_LIBRARIES(SalomeDSCSupervBasic SalomeDSCSuperv)
-INSTALL(TARGETS SalomeDSCSupervBasic DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeDSCSupervBasic DESTINATION ${KERNEL_salomelib_LIBS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_LIBRARY(SalomeDSCSuperv ${SalomeDSCSuperv_SOURCES})
TARGET_LINK_LIBRARIES(SalomeDSCSuperv SalomeDSCContainer ${PLATFORM_LIBS})
-INSTALL(TARGETS SalomeDSCSuperv DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeDSCSuperv DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(test_DSC_Exception test_DSC_Exception.cxx)
-TARGET_LINK_LIBRARIES(test_DSC_Exception OpUtil SALOMELocalTrace
- ${OMNIORB_LIBRARIES} ${PLATFORM_LIBS} ${PTHREAD_LIBRARIES})
+TARGET_LINK_LIBRARIES(test_DSC_Exception OpUtil SALOMELocalTrace ${OMNIORB_LIBRARIES} ${PLATFORM_LIBS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_LIBRARY(SalomeDatastream fake.cc)
TARGET_LINK_LIBRARIES(SalomeDatastream ${COMMON_LIBS})
-INSTALL(TARGETS SalomeDatastream DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeDatastream DESTINATION ${KERNEL_salomelib_LIBS})
SET(COMMON_HEADERS_HXX
AdjacentFunctor.hxx
IteratorTraits.hxx
)
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_DEFINITIONS(${BOOST_DEFINITIONS} ${OMNIORB_DEFINITIONS})
ADD_LIBRARY(SalomeCalcium ${SalomeCalcium_SOURCES})
-TARGET_LINK_LIBRARIES(SalomeCalcium SalomeDSCSuperv SalomeContainer ${OMNIORB_LIBRARIES} ${PLATFORM_LIBS})
+TARGET_LINK_LIBRARIES(SalomeCalcium SalomeDSCSuperv SalomeContainer ${CMAKE_THREAD_LIBS_INIT} ${OMNIORB_LIBRARIES} ${PLATFORM_LIBS})
-INSTALL(TARGETS SalomeCalcium DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeCalcium DESTINATION ${KERNEL_salomelib_LIBS})
SET(CalciumC_SOURCES
CalciumC.c
ADD_LIBRARY(CalciumC ${CalciumC_SOURCES})
TARGET_LINK_LIBRARIES(CalciumC SalomeDSCSuperv SalomeCalcium)
-INSTALL(TARGETS CalciumC DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS CalciumC DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(test_DataIdContainer_Calcium test_DataIdContainer.cxx)
TARGET_LINK_LIBRARIES(test_DataIdContainer_Calcium SalomeDSCSuperv SalomeContainer SalomeCalcium OpUtil SALOMELocalTrace ${OMNIORB_LIBRARIES} ${PLATFORM_LIBS})
${CMAKE_CURRENT_BINARY_DIR}/CalciumProvidesPort.hxx
${CMAKE_CURRENT_BINARY_DIR}/calcium_integer_port_uses.hxx
)
-INSTALL(FILES ${COMMON_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS} DESTINATION ${KERNEL_salomeinclude_HEADERS})
#include "calciumf.h"
#include "CalciumFortranInt.h"
#include <stdio.h>
-#include <omniconfig.h> // to get SIZEOF_LONG
#ifdef __cplusplus
extern "C" {
ADD_LIBRARY(SalomePalm palm_port_factory.cxx)
TARGET_LINK_LIBRARIES(SalomePalm SalomeDSCSuperv ${OMNIORB_LIBRARIES})
-INSTALL(TARGETS SalomePalm DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomePalm DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(test_DataIdContainer_Palm test_DataIdContainer.cxx)
ADD_DEPENDENCIES(test_DataIdContainer_Palm SalomeIDLKernel)
TARGET_LINK_LIBRARIES(test_DataIdContainer_Palm ${OMNIORB_LIBRARIES})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_LIBRARY(SalomeParallelDSCContainer ${SalomeParallelDSCContainer_SOURCES})
SET_TARGET_PROPERTIES(SalomeParallelDSCContainer PROPERTIES COMPILE_FLAGS "${COMMON_FLAGS}")
-INSTALL(TARGETS SalomeParallelDSCContainer DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeParallelDSCContainer DESTINATION ${KERNEL_salomelib_LIBS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_DEFINITIONS(${OMNIORB_DEFINITIONS})
ADD_LIBRARY(SalomeGenericObj SALOME_GenericObj_i.cc)
TARGET_LINK_LIBRARIES(SalomeGenericObj SALOMELocalTrace SalomeIDLKernel)
-INSTALL(TARGETS SalomeGenericObj DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeGenericObj DESTINATION ${KERNEL_salomelib_LIBS})
-INSTALL(FILES SALOME_GenericObj_i.hh SALOME_GenericObj_wrap.hxx DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES SALOME_GenericObj_i.hh SALOME_GenericObj_wrap.hxx DESTINATION ${KERNEL_salomeinclude_HEADERS})
INCLUDE_DIRECTORIES(
${HDF5_INCLUDE_DIRS}
- ${MPI_INCLUDE_DIRS}
)
+
FILE(GLOB SalomeHDFPersist_SOURCES_C "${CMAKE_CURRENT_SOURCE_DIR}/HDF*.c")
FILE(GLOB SalomeHDFPersist_SOURCES_CC "${CMAKE_CURRENT_SOURCE_DIR}/HDF*.cc")
SET(SalomeHDFPersist_SOURCES ${SalomeHDFPersist_SOURCES_C} ${SalomeHDFPersist_SOURCES_CC})
ADD_DEFINITIONS(${HDF5_DEFINITIONS})
ADD_LIBRARY(SalomeHDFPersist ${SalomeHDFPersist_SOURCES})
-TARGET_LINK_LIBRARIES(SalomeHDFPersist ${HDF5_LIBRARIES} ${MPI_LIBRARIES} ${PLATFORM_LIBS})
-INSTALL(TARGETS SalomeHDFPersist DESTINATION ${SALOME_INSTALL_LIBS})
+TARGET_LINK_LIBRARIES(SalomeHDFPersist ${HDF5_LIBRARIES} ${PLATFORM_LIBS})
+INSTALL(TARGETS SalomeHDFPersist DESTINATION ${KERNEL_salomelib_LIBS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
FILE(GLOB COMMON_HEADERS_H "${CMAKE_CURRENT_SOURCE_DIR}/*.h")
${COMMON_HEADERS_HXX}
${COMMON_HEADERS_H}
)
-INSTALL(FILES ${COMMON_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS} DESTINATION ${KERNEL_salomeinclude_HEADERS})
omnipatch.py
)
-SET(salomepython_PYTHON
+IF(SALOME_USE_CORBA)
+ SET(salomepython_PYTHON
${salomepython_PYTHON}
Help.py
PyInterp.py
salome_pynode.py
salome_genericobj.py
)
+ENDIF(SALOME_USE_CORBA)
-SALOME_INSTALL_SCRIPTS("${salomepython_PYTHON}" ${SALOME_INSTALL_PYTHON})
-SALOME_INSTALL_SCRIPTS(kernel_shared_modules.py ${SALOME_INSTALL_PYTHON_SHARED})
-SALOME_INSTALL_SCRIPTS(__init__.py ${SALOME_INSTALL_PYTHON}/salome)
+SALOME_INSTALL_SCRIPTS("${salomepython_PYTHON}" ${KERNEL_salomepythondir})
+SALOME_INSTALL_SCRIPTS(kernel_shared_modules.py ${KERNEL_sharedpkgpython_PYTHON})
+SALOME_INSTALL_SCRIPTS(__init__.py ${KERNEL_salomepythondir}/salome)
studyedit.py
services.py
)
-SALOME_INSTALL_SCRIPTS("${mypkgpython_PYTHON}" ${SALOME_INSTALL_PYTHON}/salome/kernel)
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/logconfig.py DESTINATION ${SALOME_INSTALL_PYTHON}/salome/kernel)
\ No newline at end of file
+SALOME_INSTALL_SCRIPTS("${mypkgpython_PYTHON}" ${KERNEL_salomepythondir}/salome/kernel)
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/logconfig.py DESTINATION ${KERNEL_salomepythondir}/salome/kernel)
\ No newline at end of file
)
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS("${mypkgpython_PYTHON}" ${SALOME_INSTALL_PYTHON}/salome/kernel/parametric)
+SALOME_INSTALL_SCRIPTS("${mypkgpython_PYTHON}" ${KERNEL_salomepythondir}/salome/kernel/parametric)
ADD_LIBRARY(SalomeKernelHelpers ${SalomeKernelHelpers_SOURCES})
TARGET_LINK_LIBRARIES(SalomeKernelHelpers ${SalomeKernelHelpers_LIBS})
-INSTALL(TARGETS SalomeKernelHelpers DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeKernelHelpers DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(KernelHelpersUseCases KernelHelpersUseCases.cxx)
TARGET_LINK_LIBRARIES(KernelHelpersUseCases SalomeKernelHelpers ${SalomeKernelHelpers_LIBS})
-INSTALL(TARGETS KernelHelpersUseCases DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS KernelHelpersUseCases DESTINATION ${KERNEL_salomebin_BINS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
)
SET(SalomeKernelHelpersTest_LIBS
- ${CPPUNIT_LIBRARIES}
+ ${CPPUNIT_LIBS}
SalomeKernelHelpers
${OMNIORB_LIBRARIES}
SalomeNS
ADD_LIBRARY(SalomeKernelHelpersTest KernelHelpersUnitTests.cxx)
TARGET_LINK_LIBRARIES(SalomeKernelHelpersTest ${SalomeKernelHelpersTest_LIBS})
-INSTALL(TARGETS SalomeKernelHelpersTest DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeKernelHelpersTest DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(TestKernelHelpers TestKernelHelpers.cxx)
TARGET_LINK_LIBRARIES(TestKernelHelpers SalomeKernelHelpersTest ${SalomeKernelHelpersTest_LIBS})
ADD_TEST(TestKernelHelpers TestKernelHelpers)
-INSTALL(TARGETS TestKernelHelpers DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS TestKernelHelpers DESTINATION ${KERNEL_salomebin_BINS})
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS(TestKernelHelpers.py ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS(TestKernelHelpers.py ${KERNEL_salomescript_PYTHON})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_LIBRARY(Launcher ${Launcher_SOURCES})
TARGET_LINK_LIBRARIES(Launcher ResourcesManager ${LIBBATCH_LIBRARIES} ${MPI_CXX_LIBRARIES} ${LIBXML2_LIBS})
-INSTALL(TARGETS Launcher DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS Launcher DESTINATION ${KERNEL_salomelib_LIBS})
SET(TestLauncher_LIBS
${LIBXML2_LIBRARIES}
ADD_EXECUTABLE(TestLauncher TestLauncher.cxx)
TARGET_LINK_LIBRARIES(TestLauncher ${TestLauncher_LIBS})
-INSTALL(TARGETS TestLauncher DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS TestLauncher DESTINATION ${KERNEL_salomebin_BINS})
-IF(NOT SALOME_LAUNCHER_ONLY)
+IF(NOT WITHONLYLAUNCHER)
ADD_LIBRARY(SalomeLauncher BatchTest.cxx SALOME_Launcher.cxx)
TARGET_LINK_LIBRARIES(SalomeLauncher Launcher ${COMMON_LIBS})
- INSTALL(TARGETS SalomeLauncher DESTINATION ${SALOME_INSTALL_LIBS})
+ INSTALL(TARGETS SalomeLauncher DESTINATION ${KERNEL_salomelib_LIBS})
SET(SALOME_LauncherServer_LIBS
Launcher
${PYTHON_LIBRARIES}
)
+
+
ADD_EXECUTABLE(SALOME_LauncherServer SALOME_LauncherServer.cxx)
TARGET_LINK_LIBRARIES(SALOME_LauncherServer ${SALOME_LauncherServer_LIBS})
- INSTALL(TARGETS SALOME_LauncherServer DESTINATION ${SALOME_INSTALL_BINS})
-ENDIF()
+ INSTALL(TARGETS SALOME_LauncherServer DESTINATION ${KERNEL_salomebin_BINS})
+ENDIF(NOT WITHONLYLAUNCHER)
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_LIBRARY(SalomeLifeCycleCORBA SALOME_LifeCycleCORBA.cxx SALOME_FileTransferCORBA.cxx)
TARGET_LINK_LIBRARIES(SalomeLifeCycleCORBA ${COMMON_LIBS})
-INSTALL(TARGETS SalomeLifeCycleCORBA DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeLifeCycleCORBA DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(Test_LifeCycleCORBA Test_LifeCycleCORBA.cxx)
TARGET_LINK_LIBRARIES(Test_LifeCycleCORBA SalomeLifeCycleCORBA Registry SalomeNotification SalomeContainer ${COMMON_LIBS} ${OMNIORB_LIBRARIES})
ADD_EXECUTABLE(TestContainerManager TestContainerManager.cxx)
TARGET_LINK_LIBRARIES(TestContainerManager SalomeLifeCycleCORBA Registry SalomeNotification SalomeContainer ${COMMON_LIBS} ${OMNIORB_LIBRARIES})
-INSTALL(TARGETS Test_LifeCycleCORBA TestContainerManager DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS Test_LifeCycleCORBA TestContainerManager DESTINATION ${KERNEL_salomebin_BINS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
)
SET(COMMON_LIBS
- ${CPPUNIT_LIBRARIES}
+ ${CPPUNIT_LIBS}
SALOMEBasics
SalomeResourcesManager
SalomeContainer
ADD_LIBRARY(LifeCycleCORBATest LifeCycleCORBATest.cxx)
TARGET_LINK_LIBRARIES(LifeCycleCORBATest ${COMMON_LIBS})
-INSTALL(TARGETS LifeCycleCORBATest DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS LifeCycleCORBATest DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(TestLifeCycleCORBA TestLifeCycleCORBA.cxx)
TARGET_LINK_LIBRARIES(TestLifeCycleCORBA LifeCycleCORBATest NamingServiceTest SalomeLifeCycleCORBA ${COMMON_LIBS})
-INSTALL(TARGETS TestLifeCycleCORBA DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS TestLifeCycleCORBA DESTINATION ${KERNEL_salomebin_BINS})
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS(TestLifeCycleCORBA.py ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS(TestLifeCycleCORBA.py ${KERNEL_salomescript_PYTHON})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
SET_TARGET_PROPERTIES(_libSALOME_LifeCycleCORBA PROPERTIES DEBUG_OUTPUT_NAME _libSALOME_LifeCycleCORBA_d)
ENDIF(${MACHINE} STREQUAL WINDOWS)
-INSTALL(TARGETS _libSALOME_LifeCycleCORBA DESTINATION ${SALOME_INSTALL_PYTHON})
+INSTALL(TARGETS _libSALOME_LifeCycleCORBA DESTINATION ${KERNEL_salomepythondir})
SET(SCRIPTS
LifeCycleCORBA.py
TestLifeCycleCORBA.py
)
-SALOME_INSTALL_SCRIPTS("${SCRIPTS}" ${SALOME_INSTALL_SCRIPT_PYTHON})
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libSALOME_LifeCycleCORBA.py DESTINATION ${SALOME_INSTALL_PYTHON})
+SALOME_INSTALL_SCRIPTS("${SCRIPTS}" ${KERNEL_salomescript_PYTHON})
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libSALOME_LifeCycleCORBA.py DESTINATION ${KERNEL_salomepythondir})
TestLifeCycleCORBA_SWIG.py
)
-SALOME_INSTALL_SCRIPTS("${SCRIPTS}" ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS("${SCRIPTS}" ${KERNEL_salomescript_PYTHON})
ADD_LIBRARY(SalomeLoggerServer SALOME_Trace.cxx SALOME_Logger_Server.cxx)
TARGET_LINK_LIBRARIES(SalomeLoggerServer SalomeIDLKernel ${OMNIORB_LIBRARIES} ${PLATFORM_LIBS})
-INSTALL(TARGETS SalomeLoggerServer DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeLoggerServer DESTINATION ${KERNEL_salomelib_LIBS})
SET(SALOME_Logger_Server_SOURCES
SALOME_Logger_Server_main.cxx
ADD_EXECUTABLE(SALOME_Logger_Server ${SALOME_Logger_Server_SOURCES})
TARGET_LINK_LIBRARIES(SALOME_Logger_Server ${SALOME_Logger_Server_LIBS})
-INSTALL(TARGETS SALOME_Logger_Server DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS SALOME_Logger_Server DESTINATION ${KERNEL_salomebin_BINS})
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS(SALOME_Trace.py ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS(SALOME_Trace.py ${KERNEL_salomescript_PYTHON})
-INSTALL(FILES SALOME_Trace.hxx DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES SALOME_Trace.hxx DESTINATION ${KERNEL_salomeinclude_HEADERS})
#
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS(TestKiller.py ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS(TestKiller.py ${KERNEL_salomescript_PYTHON})
INCLUDE_DIRECTORIES(
${MPI_CXX_INCLUDE_PATH}
- ${PTHREAD_INCLUDE_DIR}
${PYTHON_INCLUDE_DIRS}
${OMNIORB_INCLUDE_DIR}
${CMAKE_BINARY_DIR}/salome_adm
ADD_LIBRARY(SalomeMPIContainer MPIObject_i.cxx MPIContainer_i.cxx)
TARGET_LINK_LIBRARIES(SalomeMPIContainer ${COMMON_LIBS})
-INSTALL(TARGETS SalomeMPIContainer DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeMPIContainer DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(SALOME_MPIContainer SALOME_MPIContainer.cxx)
TARGET_LINK_LIBRARIES(SALOME_MPIContainer SalomeMPIContainer ${COMMON_LIBS} ${PYTHON_LIBRARIES} ${MPI_CXX_LIBRARIES})
ADD_EXECUTABLE(testMPI2 testMPI2.cxx)
TARGET_LINK_LIBRARIES(testMPI2 ${MPI_CXX_LIBRARIES})
-INSTALL(TARGETS SALOME_MPIContainer testMPI2 DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS SALOME_MPIContainer testMPI2 DESTINATION ${KERNEL_salomebin_BINS})
-INSTALL(FILES launch_testMPI2.csh DESTINATION ${SALOME_INSTALL_SCRIPT_SCRIPTS})
+INSTALL(FILES launch_testMPI2.csh DESTINATION ${KERNEL_salomescript_SCRIPTS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
SALOMEBasics
SalomeIDLKernel
${LIBXML2_LIBRARIES}
- ${PTHREAD_LIBRARIES}
)
SET(SalomeCatalog_SOURCES
ADD_LIBRARY(SalomeCatalog ${SalomeCatalog_SOURCES})
TARGET_LINK_LIBRARIES(SalomeCatalog ${COMMON_LIBS})
-INSTALL(TARGETS SalomeCatalog DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeCatalog DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(SALOME_ModuleCatalog_Server SALOME_ModuleCatalog_Server.cxx)
TARGET_LINK_LIBRARIES(SALOME_ModuleCatalog_Server SalomeCatalog ${COMMON_LIBS} ${OMNIORB_LIBRARIES})
ADD_EXECUTABLE(SALOME_ModuleCatalog_Client SALOME_ModuleCatalog_Client.cxx)
TARGET_LINK_LIBRARIES(SALOME_ModuleCatalog_Client SalomeCatalog ${COMMON_LIBS} ${OMNIORB_LIBRARIES})
-INSTALL(TARGETS SALOME_ModuleCatalog_Server SALOME_ModuleCatalog_Client DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS SALOME_ModuleCatalog_Server SALOME_ModuleCatalog_Client DESTINATION ${KERNEL_salomebin_BINS})
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS(TestModuleCatalog.py ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS(TestModuleCatalog.py ${KERNEL_salomescript_PYTHON})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
# ===============================================================
# Files to be installed
# ===============================================================
-SALOME_INSTALL_SCRIPTS(IDLparser.py ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS(IDLparser.py ${KERNEL_salomescript_PYTHON})
${CMAKE_CURRENT_SOURCE_DIR}/../SALOMELocalTrace
)
-# SWIG module name differs from file name - avoid unnecessary rebuild:
-SET_SOURCE_FILES_PROPERTIES(NOTIFICATION.i PROPERTIES SWIG_MODULE_NAME libNOTIFICATION)
-
SWIG_ADD_MODULE(libNOTIFICATION python NOTIFICATION.i NOTIFICATION_Swig.cxx)
SWIG_LINK_LIBRARIES(libNOTIFICATION ${PYTHON_LIBRARIES} SalomeNotification)
ADD_DEFINITIONS(${OMNIORB_DEFINITIONS} ${PLATFORM_DEFINITIONS})
SET_TARGET_PROPERTIES(_libNOTIFICATION PROPERTIES DEBUG_OUTPUT_NAME _libNOTIFICATION_d)
ENDIF(${MACHINE} STREQUAL WINDOWS)
-INSTALL(TARGETS _libNOTIFICATION DESTINATION ${SALOME_INSTALL_PYTHON})
+INSTALL(TARGETS _libNOTIFICATION DESTINATION ${KERNEL_salomepythondir})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
INSTALL(FILES ${COMON_HEADERS_HXX} DESTINATION ${MED_salomeinclude_HEADERS})
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libNOTIFICATION.py DESTINATION ${SALOME_INSTALL_PYTHON})
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libNOTIFICATION.py DESTINATION ${KERNEL_salomepythondir})
ADD_DEPENDENCIES(SalomeNS SalomeIDLKernel)
TARGET_LINK_LIBRARIES(SalomeNS OpUtil)
-INSTALL(TARGETS SalomeNS DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeNS DESTINATION ${KERNEL_salomelib_LIBS})
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS(SALOME_NamingServicePy.py ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS(SALOME_NamingServicePy.py ${KERNEL_salomescript_PYTHON})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
# This local variable defines the list of dependant libraries common to all target in this package.
SET(COMMON_LIBS
- ${CPPUNIT_LIBRARIES}
+ ${CPPUNIT_LIBS}
SalomeNS
SalomeLifeCycleCORBA
${OMNIORB_LIBRARIES}
ADD_LIBRARY(NamingServiceTest NamingServiceTest.cxx)
TARGET_LINK_LIBRARIES(NamingServiceTest ${COMMON_LIBS})
-INSTALL(TARGETS NamingServiceTest DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS NamingServiceTest DESTINATION ${KERNEL_salomelib_LIBS})
SET(TestNamingService_LIBS
NamingServiceTest
ADD_EXECUTABLE(TestNamingService TestNamingService.cxx)
TARGET_LINK_LIBRARIES(TestNamingService ${TestNamingService_LIBS})
-INSTALL(TARGETS TestNamingService DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS TestNamingService DESTINATION ${KERNEL_salomebin_BINS})
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS(TestNamingService.py ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS(TestNamingService.py ${KERNEL_salomescript_PYTHON})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_LIBRARY(SalomeNotification ${SalomeNotification_SOURCES})
TARGET_LINK_LIBRARIES(SalomeNotification ${COMMON_LIBS})
-INSTALL(TARGETS SalomeNotification DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeNotification DESTINATION ${KERNEL_salomelib_LIBS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
SET(COMMON_HEADERS ${COMMON_HEADERS_HXX} CosNotifyShorthands.h)
-INSTALL(FILES ${COMMON_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_LIBRARY(SalomeParallelContainer ${SalomeParallelContainer_SOURCES})
TARGET_LINK_LIBRARIES(SalomeParallelContainer ${COMMON_LIBS} ${MPI_CXX_LIBRARIES})
-INSTALL(TARGETS Registry DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS Registry DESTINATION ${KERNEL_salomelib_LIBS})
IF(SALOME_USE_MPI)
SET(SALOME_ParallelContainerProxyMpi_LIBS
ADD_EXECUTABLE(SALOME_ParallelContainerNodeMpi SALOME_ParallelContainerNodeMpi.cxx)
TARGET_LINK_LIBRARIES(SALOME_ParallelContainerNodeMpi ${SALOME_ParallelContainerProxyMpi_LIBS})
- INSTALL(TARGETS SALOME_ParallelContainerProxyMpi SALOME_ParallelContainerNodeMpi DESTINATION ${SALOME_INSTALL_BINS})
+ INSTALL(TARGETS SALOME_ParallelContainerProxyMpi SALOME_ParallelContainerNodeMpi DESTINATION ${KERNEL_salomebin_BINS})
ENDIF(SALOME_USE_MPI)
SET(SALOME_ParallelContainerProxyDummy_LIBS
ADD_EXECUTABLE(SALOME_ParallelContainerNodeDummy SALOME_ParallelContainerNodeDummy.cxx)
TARGET_LINK_LIBRARIES(SALOME_ParallelContainerNodeDummy ${SALOME_ParallelContainerProxyDummy_LIBS})
-INSTALL(TARGETS SALOME_ParallelContainerNodeDummy SALOME_ParallelContainerProxyDummy DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS SALOME_ParallelContainerNodeDummy SALOME_ParallelContainerProxyDummy DESTINATION ${KERNEL_salomebin_BINS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_LIBRARY(Registry RegistryConnexion.cxx RegistryService.cxx)
ADD_DEFINITIONS(${OMNIORB_DEFINITIONS})
TARGET_LINK_LIBRARIES(Registry SalomeNS OpUtil SALOMELocalTrace SalomeIDLKernel ${PLATFORM_LIBS})
-INSTALL(TARGETS Registry DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS Registry DESTINATION ${KERNEL_salomelib_LIBS})
SET(SALOME_Registry_Server_LIBS
SalomeIDLKernel
SALOMELocalTrace
SALOMEBasics
${PLATFORM_LIBS}
- ${PTHREAD_LIBRARIES}
)
ADD_EXECUTABLE(SALOME_Registry_Server SALOME_Registry_Server.cxx)
TARGET_LINK_LIBRARIES(SALOME_Registry_Server ${SALOME_Registry_Server_LIBS})
-INSTALL(TARGETS SALOME_Registry_Server DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS SALOME_Registry_Server DESTINATION ${KERNEL_salomebin_BINS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_LIBRARY(ResourcesManager ${ResourcesManager_SOURCES})
TARGET_LINK_LIBRARIES(ResourcesManager SALOMEBasics OpUtil ${LIBXML2_LIBRARIES})
-INSTALL(TARGETS ResourcesManager DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS ResourcesManager DESTINATION ${KERNEL_salomelib_LIBS})
-IF(NOT SALOME_LAUNCHER_ONLY)
+IF(NOT WITHONLYLAUNCHER)
ADD_LIBRARY(SalomeResourcesManager SALOME_ResourcesManager.cxx)
TARGET_LINK_LIBRARIES(SalomeResourcesManager ResourcesManager ${COMMON_LIBS})
- INSTALL(TARGETS SalomeResourcesManager DESTINATION ${SALOME_INSTALL_LIBS})
-ENDIF()
+ INSTALL(TARGETS SalomeResourcesManager DESTINATION ${KERNEL_salomelib_LIBS})
+ENDIF(NOT WITHONLYLAUNCHER)
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_LIBRARY(SalomeDS ${SalomeDS_SOURCES})
TARGET_LINK_LIBRARIES(SalomeDS ${COMMON_LIBS})
-INSTALL(TARGETS SalomeDS DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeDS DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(SALOMEDS_Server SALOMEDS_Server.cxx)
TARGET_LINK_LIBRARIES(SALOMEDS_Server SalomeDS SALOMEBasics ${COMMON_LIBS} ${OMNIORB_LIBRARIES})
ADD_EXECUTABLE(SALOMEDS_Client SALOMEDS_Client.cxx)
TARGET_LINK_LIBRARIES(SALOMEDS_Client SalomeDS SALOMEBasics ${COMMON_LIBS} ${OMNIORB_LIBRARIES})
-INSTALL(TARGETS SALOMEDS_Server SALOMEDS_Client DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS SALOMEDS_Server SALOMEDS_Client DESTINATION ${KERNEL_salomebin_BINS})
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS(SALOME_DriverPy.py ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS(SALOME_DriverPy.py ${KERNEL_salomescript_PYTHON})
SET(COMMON_HEADERS_HXX
SALOMEDS_StudyManager_i.hxx
SALOMEDS_wrap.hxx
SALOMEDS_Attributes_wrap.hxx
)
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
# This local variable defines the list of dependant libraries common to all target in this package.
SET(COMMON_LIBS
- ${CPPUNIT_LIBRARIES}
+ ${CPPUNIT_LIBS}
SALOMEBasics
SalomeResourcesManager
SalomeContainer
ADD_LIBRARY(SALOMEDSTest SALOMEDSTest.cxx)
TARGET_LINK_LIBRARIES(SALOMEDSTest ${COMMON_LIBS})
-INSTALL(TARGETS SALOMEDSTest DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SALOMEDSTest DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(TestSALOMEDS TestSALOMEDS.cxx)
TARGET_LINK_LIBRARIES(TestSALOMEDS SALOMEDSTest SALOMEBasics ${COMMON_LIBS} ${OMNIORB_LIBRARIES})
-INSTALL(TARGETS TestSALOMEDS DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS TestSALOMEDS DESTINATION ${KERNEL_salomebin_BINS})
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS(TestSALOMEDS.py ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS(TestSALOMEDS.py ${KERNEL_salomescript_PYTHON})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_LIBRARY(SalomeDSClient SALOMEDSClient_ClientFactory.cxx)
TARGET_LINK_LIBRARIES(SalomeDSClient SalomeIDLKernel)
-INSTALL(TARGETS SalomeDSClient DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeDSClient DESTINATION ${KERNEL_salomelib_LIBS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_LIBRARY(SalomeDSImpl ${SalomeDSImpl_SOURCES})
TARGET_LINK_LIBRARIES(SalomeDSImpl SALOMELocalTrace ${COMMON_LIBS} ${PLATFORM_LIBS})
-INSTALL(TARGETS SalomeDSImpl DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeDSImpl DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(testDS testDS.cxx)
TARGET_LINK_LIBRARIES(testDS SalomeDSImpl ${COMMON_LIBS} ${PLATFORM_LIBS})
-INSTALL(TARGETS testDS DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS testDS DESTINATION ${KERNEL_salomebin_BINS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
SET(NOINST_HEADERS_HXX
FOREACH(HEADER ${NOINST_HEADERS_HXX})
LIST(REMOVE_ITEM COMMON_HEADERS_HXX ${CMAKE_CURRENT_SOURCE_DIR}/${HEADER})
ENDFOREACH(HEADER ${NOINST_HEADERS_HXX})
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
#endif
-bool SALOMEDS_Exists(const std::string thePath)
+bool Exists(const std::string thePath)
{
#ifdef WIN32
if ( GetFileAttributes ( thePath.c_str() ) == 0xFFFFFFFF ) {
std::string aDir = aTmpDir;
- if(SALOMEDS_Exists(aDir)) {
- for(aRND = 0; SALOMEDS_Exists(aDir); aRND++) {
+ if(Exists(aDir)) {
+ for(aRND = 0; Exists(aDir); aRND++) {
sprintf(buffer, "%d", aRND);
aDir = aTmpDir+buffer; //Build a unique directory name
}
for(i=1; i<=aLength; i++) {
std::string aFile(aDirName);
aFile += theFiles[i-1];
- if(!SALOMEDS_Exists(aFile)) continue;
+ if(!Exists(aFile)) continue;
#ifdef WIN32
DeleteFile(aFile.c_str());
}
if(IsDirDeleted) {
- if(SALOMEDS_Exists(aDirName)) {
+ if(Exists(aDirName)) {
#ifdef WIN32
RemoveDirectory(aDirName.c_str());
#else
# This local variable defines the list of dependant libraries common to all target in this package.
SET(COMMON_LIBS
- ${CPPUNIT_LIBRARIES}
+ ${CPPUNIT_LIBS}
SALOMEBasics
SalomeResourcesManager
SalomeContainer
ADD_LIBRARY(SALOMEDSImplTest SALOMEDSImplTest.cxx)
TARGET_LINK_LIBRARIES(SALOMEDSImplTest ${COMMON_LIBS})
-INSTALL(TARGETS SALOMEDSImplTest DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SALOMEDSImplTest DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(TestSALOMEDSImpl TestSALOMEDSImpl.cxx)
TARGET_LINK_LIBRARIES(TestSALOMEDSImpl SALOMEDSImplTest SalomeDSImpl NamingServiceTest ${COMMON_LIBS})
-INSTALL(TARGETS TestSALOMEDSImpl DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS TestSALOMEDSImpl DESTINATION ${KERNEL_salomebin_BINS})
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS(TestSALOMEDSImpl.py ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS(TestSALOMEDSImpl.py ${KERNEL_salomescript_PYTHON})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
#
INCLUDE_DIRECTORIES(
- ${PTHREAD_INCLUDE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/../Basics
)
)
ADD_LIBRARY(SALOMELocalTrace ${SALOMELocalTrace_SOURCES})
-TARGET_LINK_LIBRARIES(SALOMELocalTrace SALOMEBasics ${PLATFORM_LIBS} ${PTHREAD_LIBRARIES})
-INSTALL(TARGETS SALOMELocalTrace DESTINATION ${SALOME_INSTALL_LIBS})
+TARGET_LINK_LIBRARIES(SALOMELocalTrace SALOMEBasics ${PLATFORM_LIBS} ${CMAKE_THREAD_LIBS_INIT})
+INSTALL(TARGETS SALOMELocalTrace DESTINATION ${KERNEL_salomelib_LIBS})
-INSTALL(FILES ${COMMON_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_DEFINITIONS(${CPPUNIT_DEFINITIONS})
ADD_LIBRARY(SALOMELocalTraceTest SALOMELocalTraceTest.cxx)
-TARGET_LINK_LIBRARIES(SALOMELocalTraceTest SALOMELocalTrace ${CPPUNIT_LIBRARIES} ${PTHREAD_LIBRARIES} ${PLATFORM_LIBS})
-INSTALL(TARGETS SALOMELocalTraceTest DESTINATION ${SALOME_INSTALL_LIBS})
+TARGET_LINK_LIBRARIES(SALOMELocalTraceTest SALOMELocalTrace ${CPPUNIT_LIBS} ${CMAKE_THREAD_LIBS_INIT} ${PLATFORM_LIBS})
+INSTALL(TARGETS SALOMELocalTraceTest DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(TestSALOMELocalTrace TestSALOMELocalTrace.cxx)
-TARGET_LINK_LIBRARIES(TestSALOMELocalTrace SALOMELocalTraceTest SALOMELocalTrace SALOMEBasics ${CPPUNIT_LIBRARIES} ${PLATFORM_LIBS})
-INSTALL(TARGETS TestSALOMELocalTrace DESTINATION ${SALOME_INSTALL_BINS})
+TARGET_LINK_LIBRARIES(TestSALOMELocalTrace SALOMELocalTraceTest SALOMELocalTrace SALOMEBasics ${CPPUNIT_LIBS} ${PLATFORM_LIBS})
+INSTALL(TARGETS TestSALOMELocalTrace DESTINATION ${KERNEL_salomebin_BINS})
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS(TestSALOMELocalTrace.py ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS(TestSALOMELocalTrace.py ${KERNEL_salomescript_PYTHON})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_DEFINITIONS(${OMNIORB_DEFINITIONS} ${PTHREAD_DEFINITIONS})
ADD_LIBRARY(with_loggerTraceCollector SALOMETraceCollector.cxx TraceCollector_WaitForServerReadiness.cxx)
-TARGET_LINK_LIBRARIES(with_loggerTraceCollector SALOMELocalTrace SalomeIDLKernel ${OMNIORB_LIBRARIES} ${PTHREAD_LIBRARIES})
-INSTALL(TARGETS with_loggerTraceCollector DESTINATION ${SALOME_INSTALL_LIBS})
+TARGET_LINK_LIBRARIES(with_loggerTraceCollector SALOMELocalTrace SalomeIDLKernel ${OMNIORB_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+INSTALL(TARGETS with_loggerTraceCollector DESTINATION ${KERNEL_salomelib_LIBS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
SALOMELocalTraceTest
SALOMELocalTrace
SALOMEBasics
- ${PTHREAD_LIBRARIES}
+ ${CMAKE_THREAD_LIBS_INIT}
${PLATFORM_LIBS}
- ${CPPUNIT_LIBRARIES}
)
ADD_DEFINITIONS(${CPPUNIT_DEFINITIONS} ${PLATFORM_DEFINITIONS})
ADD_LIBRARY(SALOMETraceCollectorTest SALOMETraceCollectorTest.cxx)
TARGET_LINK_LIBRARIES(SALOMETraceCollectorTest ${COMMON_LIBS})
-INSTALL(TARGETS SALOMETraceCollectorTest DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SALOMETraceCollectorTest DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(TestSALOMETraceCollector TestSALOMETraceCollector.cxx)
TARGET_LINK_LIBRARIES(TestSALOMETraceCollector SALOMETraceCollectorTest ${COMMON_LIBS})
-INSTALL(TARGETS TestSALOMETraceCollector DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS TestSALOMETraceCollector DESTINATION ${KERNEL_salomebin_BINS})
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS(TestSALOMETraceCollector.py ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS(TestSALOMETraceCollector.py ${KERNEL_salomescript_PYTHON})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_LIBRARY(TOOLSDS SALOMEDS_Tool.cxx)
ADD_DEFINITIONS(${OMNIORB_DEFINITIONS} ${HDF5_DEFINITIONS} ${BOOST_DEFINITIONS})
TARGET_LINK_LIBRARIES(TOOLSDS OpUtil SalomeIDLKernel ${OMNIORB_LIBRARIES})
-INSTALL(TARGETS TOOLSDS DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS TOOLSDS DESTINATION ${KERNEL_salomelib_LIBS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
ADD_LIBRARY(SalomeTestComponentEngine ${SalomeTestComponentEngine_SOURCES})
TARGET_LINK_LIBRARIES(SalomeTestComponentEngine ${COMMON_LIBS})
-INSTALL(TARGETS SalomeTestComponentEngine DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeTestComponentEngine DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(TestLogger TestLogger.cxx)
TARGET_LINK_LIBRARIES(TestLogger SalomeTestComponentEngine SALOMEBasics ${COMMON_LIBS} ${OMNIORB_LIBRARIES})
ADD_EXECUTABLE(TestContainer TestContainer.cxx)
TARGET_LINK_LIBRARIES(TestContainer SalomeTestComponentEngine SALOMEBasics ${COMMON_LIBS} ${OMNIORB_LIBRARIES})
-INSTALL(TARGETS TestLogger TestContainer DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS TestLogger TestContainer DESTINATION ${KERNEL_salomebin_BINS})
# Executable scripts to be installed
SET(SCRIPTS
TestComponentPy.py
TestLogger.py
)
-SALOME_INSTALL_SCRIPTS("${SCRIPTS}" ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS("${SCRIPTS}" ${KERNEL_salomescript_PYTHON})
ADD_LIBRARY(SalomeTestMPIComponentEngine TestMPIComponentEngine.cxx)
TARGET_LINK_LIBRARIES(SalomeTestMPIComponentEngine ${COMMON_LIBS})
-INSTALL(TARGETS SalomeTestMPIComponentEngine DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS SalomeTestMPIComponentEngine DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(TestMPIContainer TestMPIContainer.cxx)
TARGET_LINK_LIBRARIES(TestMPIContainer SalomeTestMPIComponentEngine ${COMMON_LIBS} ${MPI_CXX_LIBRARIES})
-INSTALL(TARGETS TestMPIContainer DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS TestMPIContainer DESTINATION ${KERNEL_salomebin_BINS})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
# ===============================================================
# Executable scripts to be installed
-SALOME_INSTALL_SCRIPTS(UnitTests.py ${SALOME_INSTALL_SCRIPT_SCRIPTS})
+SALOME_INSTALL_SCRIPTS(UnitTests.py ${KERNEL_salomescript_SCRIPTS})
# ===============================================================
# Executables targets
ADD_DEFINITIONS(${CPPUNIT_DEFINITIONS})
SET(COMMON_LIBS
- ${CPPUNIT_LIBRARIES}
+ ${CPPUNIT_LIBS}
SALOMEBasics
SALOMELocalTrace
SALOMELocalTraceTest
)
-INCLUDE_DIRECTORIES(
+IF(SALOME_USE_CORBA)
+ INCLUDE_DIRECTORIES(
${OMNIORB_INCLUDE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/../SALOMETraceCollector
${CMAKE_CURRENT_SOURCE_DIR}/../SALOMETraceCollector/Test
SalomeIDLKernel
${OMNIORB_LIBRARIES}
)
+ENDIF(SALOME_USE_CORBA)
ADD_EXECUTABLE(UnitTests UnitTests.cxx)
TARGET_LINK_LIBRARIES(UnitTests ${COMMON_LIBS})
-INSTALL(TARGETS UnitTests DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS UnitTests DESTINATION ${KERNEL_salomebin_BINS})
ADD_DEFINITIONS(${OMNIORB_DEFINITIONS} ${PTHREAD_DEFINITIONS})
ADD_LIBRARY(OpUtil ${OpUtil_SOURCES})
-TARGET_LINK_LIBRARIES(OpUtil SALOMELocalTrace SalomeIDLKernel ${OMNIORB_LIBRARIES} ${PTHREAD_LIBRARIES})
-INSTALL(TARGETS OpUtil DESTINATION ${SALOME_INSTALL_LIBS})
+TARGET_LINK_LIBRARIES(OpUtil SALOMELocalTrace SalomeIDLKernel ${OMNIORB_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+INSTALL(TARGETS OpUtil DESTINATION ${KERNEL_salomelib_LIBS})
SET(COMMON_SCRIPTS
Utils_Identity.py
SALOME_utilities.py
)
-SALOME_INSTALL_SCRIPTS("${COMMON_SCRIPTS}" ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS("${COMMON_SCRIPTS}" ${KERNEL_salomescript_PYTHON})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
)
SET(COMMON_LIBS
- ${CPPUNIT_LIBRARIES}
+ ${CPPUNIT_LIBS}
OpUtil
SALOMELocalTraceTest
SALOMELocalTrace
ADD_LIBRARY(UtilsTest UtilsTest.cxx)
TARGET_LINK_LIBRARIES(UtilsTest ${COMMON_LIBS} )
-INSTALL(TARGETS UtilsTest DESTINATION ${SALOME_INSTALL_LIBS})
+INSTALL(TARGETS UtilsTest DESTINATION ${KERNEL_salomelib_LIBS})
ADD_EXECUTABLE(TestUtils TestUtils.cxx)
SET_TARGET_PROPERTIES(TestUtils PROPERTIES COMPILE_FLAGS "${CPPUNIT_DEFINITIONS} ${PLATFORM_DEFINITIONS}")
TARGET_LINK_LIBRARIES(TestUtils ${COMMON_LIBS} UtilsTest ${OMNIORB_LIBRARIES})
-INSTALL(TARGETS TestUtils DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(TARGETS TestUtils DESTINATION ${KERNEL_salomebin_BINS})
-SALOME_INSTALL_SCRIPTS(TestUtils.py ${SALOME_INSTALL_SCRIPT_PYTHON})
+SALOME_INSTALL_SCRIPTS(TestUtils.py ${KERNEL_salomescript_PYTHON})
FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${KERNEL_salomeinclude_HEADERS})
