ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-27 18:00:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

Minimal compilation fixes: Remove Python, Qt and boost async refs

Browse Source
This commit is contained in:
Louis Gombert 2024-08-12 08:33:53 +00:00
parent 1ead829f59
commit f3402508da
10 changed files with 142 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -339,7 +339,7 @@ SET(_${PROJECT_NAME}_exposed_targets
MeshDriverSTL MeshDriverUNV MEDWrapper MeshDriverSTL MeshDriverUNV MEDWrapper
SMDS SMESHimpl SMESHEngine SMESHClient SMESHDS SMDS SMESHimpl SMESHEngine SMESHClient SMESHDS
SMESHUtils StdMeshers StdMeshersEngine SMESHUtils StdMeshers StdMeshersEngine
SPADDERPluginTesterEngine SalomeIDLSMESH SalomeIDLSPADDER SalomeIDLSMESH SalomeIDLSPADDER
) )
IF(SALOME_BUILD_GUI) IF(SALOME_BUILD_GUI)

1
SalomeSMESHConfig.cmake.in
View File

@ -155,6 +155,5 @@ SET(SMESH_StdMeshers StdMeshers)
SET(SMESH_StdMeshersEngine StdMeshersEngine) SET(SMESH_StdMeshersEngine StdMeshersEngine)
SET(SMESH_StdMeshersGUI StdMeshersGUI) SET(SMESH_StdMeshersGUI StdMeshersGUI)
SET(SMESH_MeshJobManagerEngine MeshJobManagerEngine) SET(SMESH_MeshJobManagerEngine MeshJobManagerEngine)
SET(SMESH_SPADDERPluginTesterEngine SPADDERPluginTesterEngine)
SET(SMESH_SalomeIDLSMESH SalomeIDLSMESH) SET(SMESH_SalomeIDLSMESH SalomeIDLSMESH)
SET(SMESH_SalomeIDLSPADDER SalomeIDLSPADDER) SET(SMESH_SalomeIDLSPADDER SalomeIDLSPADDER)

12
src/SMESH/SMESH_Gen.cxx
View File

@ -51,8 +51,8 @@
#include "memoire.h" #include "memoire.h"
#include <functional> #include <functional>
#include <QString> // #include <QString>
#include <QProcess> // #include <QProcess>
#ifdef WIN32 #ifdef WIN32
#include <windows.h> #include <windows.h>
@ -302,6 +302,7 @@ const std::function<void(SMESH_subMesh*,
void SMESH_Gen::send_mesh(SMESH_Mesh& aMesh, std::string file_name) void SMESH_Gen::send_mesh(SMESH_Mesh& aMesh, std::string file_name)
{ {
#ifndef WIN32 #ifndef WIN32
#ifndef __EMSCRIPTEN__
SMESH_ParallelMesh& aParMesh = dynamic_cast<SMESH_ParallelMesh&>(aMesh); SMESH_ParallelMesh& aParMesh = dynamic_cast<SMESH_ParallelMesh&>(aMesh);
// Calling run_mesher // Calling run_mesher
// Path to mesher script // Path to mesher script
@ -353,6 +354,7 @@ void SMESH_Gen::send_mesh(SMESH_Mesh& aMesh, std::string file_name)
throw SALOME_Exception(msg); throw SALOME_Exception(msg);
} }
#endif #endif
#endif
} }
//============================================================================= //=============================================================================
@ -444,9 +446,9 @@ bool SMESH_Gen::parallelComputeSubMeshes(
shapeSM, aShapeOnly, allowedSubShapes, shapeSM, aShapeOnly, allowedSubShapes,
aShapesId); aShapesId);
}else{ }else{
boost::asio::post(*(aParMesh.GetPool()), std::bind(compute_function, smToCompute, computeEvent, // boost::asio::post(*(aParMesh.GetPool()), std::bind(compute_function, smToCompute, computeEvent,
shapeSM, aShapeOnly, allowedSubShapes, // shapeSM, aShapeOnly, allowedSubShapes,
aShapesId)); // aShapesId));
} }
} }

2
src/SMESH/SMESH_Mesh.hxx
View File

@ -52,7 +52,7 @@
#ifndef WIN32 #ifndef WIN32
#include <boost/filesystem.hpp> #include <boost/filesystem.hpp>
#endif #endif
#include <boost/thread.hpp> // #include <boost/thread.hpp>
#ifdef WIN32 #ifdef WIN32
#pragma warning(disable:4251) // Warning DLL Interface ... #pragma warning(disable:4251) // Warning DLL Interface ...

11
src/SMESH/SMESH_ParallelMesh.hxx
View File

@ -29,13 +29,14 @@
#include "SMESH_Mesh.hxx" #include "SMESH_Mesh.hxx"
#ifndef WIN32 #if (!WIN32 && !__EMSCRIPTEN__)
#include <boost/asio.hpp> #include <boost/asio.hpp>
#include <boost/thread/mutex.hpp>
#endif #endif
#include "SMESH_Gen.hxx" #include "SMESH_Gen.hxx"
#include "SMESH_subMesh.hxx" #include "SMESH_subMesh.hxx"
#ifdef WIN32 #if (WIN32 || __EMSCRIPTEN__)
#include <thread> #include <thread>
#include <boost/filesystem.hpp> #include <boost/filesystem.hpp>
#endif #endif
@ -52,7 +53,7 @@ class SMESH_EXPORT SMESH_ParallelMesh: public SMESH_Mesh
~SMESH_ParallelMesh(); ~SMESH_ParallelMesh();
// Locking mechanism // Locking mechanism
#ifndef WIN32 #if (!WIN32 && !__EMSCRIPTEN__)
void Lock() override {_my_lock.lock();}; void Lock() override {_my_lock.lock();};
void Unlock() override {_my_lock.unlock();}; void Unlock() override {_my_lock.unlock();};
// We need to recreate the pool afterthe join // We need to recreate the pool afterthe join
@ -60,7 +61,7 @@ class SMESH_EXPORT SMESH_ParallelMesh: public SMESH_Mesh
#endif #endif
// Thread Pool // Thread Pool
#ifndef WIN32 #if (!WIN32 && !__EMSCRIPTEN__)
void InitPoolThreads() {_pool = new boost::asio::thread_pool(GetPoolNbThreads());}; void InitPoolThreads() {_pool = new boost::asio::thread_pool(GetPoolNbThreads());};
boost::asio::thread_pool* GetPool() {return _pool;}; boost::asio::thread_pool* GetPool() {return _pool;};
void DeletePoolThreads() {delete _pool;}; void DeletePoolThreads() {delete _pool;};
@ -127,7 +128,7 @@ class SMESH_EXPORT SMESH_ParallelMesh: public SMESH_Mesh
SMESH_ParallelMesh(const SMESH_ParallelMesh& aMesh):SMESH_Mesh(aMesh) {}; SMESH_ParallelMesh(const SMESH_ParallelMesh& aMesh):SMESH_Mesh(aMesh) {};
private: private:
// Mutex for multhitreading write in SMESH_Mesh // Mutex for multhitreading write in SMESH_Mesh
#ifndef WIN32 #if (!WIN32 && !__EMSCRIPTEN__)
boost::mutex _my_lock; boost::mutex _my_lock;
// thread pool for computation // thread pool for computation
boost::asio::thread_pool * _pool = nullptr; boost::asio::thread_pool * _pool = nullptr;

182
src/SMESH_I/SMESH_Gen_i.cxx
View File

@ -2899,122 +2899,122 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateDualMesh(SMESH::SMESH_IDSource_ptr mesh
const char* meshName, const char* meshName,
CORBA::Boolean adapt_to_shape) CORBA::Boolean adapt_to_shape)
{ {
Unexpect aCatch(SALOME_SalomeException); // Unexpect aCatch(SALOME_SalomeException);
TPythonDump* pyDump = new TPythonDump(this); // prevent dump from CreateMesh() // TPythonDump* pyDump = new TPythonDump(this); // prevent dump from CreateMesh()
std::unique_ptr<TPythonDump> pyDumpDeleter( pyDump ); // std::unique_ptr<TPythonDump> pyDumpDeleter( pyDump );
// 1. Get source mesh // // 1. Get source mesh
if ( CORBA::is_nil( mesh )) // if ( CORBA::is_nil( mesh ))
THROW_SALOME_CORBA_EXCEPTION( "bad IDSource", SALOME::BAD_PARAM ); // THROW_SALOME_CORBA_EXCEPTION( "bad IDSource", SALOME::BAD_PARAM );
SMESH::SMESH_Mesh_var srcMesh = mesh->GetMesh(); // SMESH::SMESH_Mesh_var srcMesh = mesh->GetMesh();
SMESH_Mesh_i* srcMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( srcMesh ); // SMESH_Mesh_i* srcMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( srcMesh );
if ( !srcMesh_i ) // if ( !srcMesh_i )
THROW_SALOME_CORBA_EXCEPTION( "bad mesh of IDSource", SALOME::BAD_PARAM ); // THROW_SALOME_CORBA_EXCEPTION( "bad mesh of IDSource", SALOME::BAD_PARAM );
CORBA::String_var mesh_var=GetORB()->object_to_string(mesh); // CORBA::String_var mesh_var=GetORB()->object_to_string(mesh);
std::string mesh_ior = mesh_var.in(); // std::string mesh_ior = mesh_var.in();
//temporary folder for the generation of the med file // //temporary folder for the generation of the med file
fs::path tmp_folder = fs::temp_directory_path() / fs::unique_path(fs::path("dual_mesh-%%%%")); // fs::path tmp_folder = fs::temp_directory_path() / fs::unique_path(fs::path("dual_mesh-%%%%"));
fs::create_directories(tmp_folder); // fs::create_directories(tmp_folder);
fs::path dual_mesh_file = tmp_folder / fs::path("tmp_dual_mesh.med"); // fs::path dual_mesh_file = tmp_folder / fs::path("tmp_dual_mesh.med");
std::string mesh_name(meshName); // std::string mesh_name(meshName);
MESSAGE("Working in folder" + tmp_folder.string()); // MESSAGE("Working in folder" + tmp_folder.string());
// Running Python script // // Running Python script
assert(Py_IsInitialized()); // assert(Py_IsInitialized());
PyGILState_STATE gstate; // PyGILState_STATE gstate;
gstate = PyGILState_Ensure(); // gstate = PyGILState_Ensure();
std::string ats; // std::string ats;
if(adapt_to_shape) // if(adapt_to_shape)
ats = "True"; // ats = "True";
else // else
ats = "False"; // ats = "False";
std::string cmd="import salome.smesh.smesh_tools as smt\n"; // std::string cmd="import salome.smesh.smesh_tools as smt\n";
cmd +="smt.smesh_create_dual_mesh(\"" + mesh_ior + "\", r\"" + // cmd +="smt.smesh_create_dual_mesh(\"" + mesh_ior + "\", r\"" +
dual_mesh_file.string() + "\", mesh_name=\"" + mesh_name + "\", adapt_to_shape=" + ats + ")"; // dual_mesh_file.string() + "\", mesh_name=\"" + mesh_name + "\", adapt_to_shape=" + ats + ")";
MESSAGE(cmd); // MESSAGE(cmd);
PyObject *py_main = PyImport_AddModule("__main__"); // PyObject *py_main = PyImport_AddModule("__main__");
PyObject *py_dict = PyModule_GetDict(py_main); // PyObject *py_dict = PyModule_GetDict(py_main);
PyObject *local_dict = PyDict_New(); // PyObject *local_dict = PyDict_New();
PyRun_String(cmd.c_str(), Py_file_input, py_dict, local_dict); // PyRun_String(cmd.c_str(), Py_file_input, py_dict, local_dict);
if (PyErr_Occurred()) { // if (PyErr_Occurred()) {
// Restrieving python error // // Restrieving python error
MESSAGE("Catching error"); // MESSAGE("Catching error");
PyObject *errtype, *errvalue, *traceback; // PyObject *errtype, *errvalue, *traceback;
PyErr_Fetch(&errtype, &errvalue, &traceback); // PyErr_Fetch(&errtype, &errvalue, &traceback);
if(errvalue != NULL) { // if(errvalue != NULL) {
MESSAGE("Error has a value"); // MESSAGE("Error has a value");
PyObject *s = PyObject_Str(errvalue); // PyObject *s = PyObject_Str(errvalue);
Py_ssize_t size; // Py_ssize_t size;
std::string msg = PyUnicode_AsUTF8AndSize(s, &size); // std::string msg = PyUnicode_AsUTF8AndSize(s, &size);
msg = "Issue with the execution of create_dual_mesh:\n"+msg; // msg = "Issue with the execution of create_dual_mesh:\n"+msg;
MESSAGE("throwing exception"); // MESSAGE("throwing exception");
// We need to deactivate the GIL before throwing the exception // // We need to deactivate the GIL before throwing the exception
PyGILState_Release(gstate); // PyGILState_Release(gstate);
THROW_SALOME_CORBA_EXCEPTION(msg.c_str(), SALOME::INTERNAL_ERROR ); // THROW_SALOME_CORBA_EXCEPTION(msg.c_str(), SALOME::INTERNAL_ERROR );
Py_DECREF(s); // Py_DECREF(s);
} // }
Py_XDECREF(errvalue); // Py_XDECREF(errvalue);
Py_XDECREF(errtype); // Py_XDECREF(errtype);
Py_XDECREF(traceback); // Py_XDECREF(traceback);
} // }
PyGILState_Release(gstate); // PyGILState_Release(gstate);
MESSAGE("Mesh created in " + dual_mesh_file.string()); // MESSAGE("Mesh created in " + dual_mesh_file.string());
// Import created MED // // Import created MED
SMESH::SMESH_Mesh_var newMesh = CreateMesh(GEOM::GEOM_Object::_nil()); // SMESH::SMESH_Mesh_var newMesh = CreateMesh(GEOM::GEOM_Object::_nil());
SMESH_Mesh_i* newMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( newMesh ); // SMESH_Mesh_i* newMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( newMesh );
if ( !newMesh_i ) // if ( !newMesh_i )
THROW_SALOME_CORBA_EXCEPTION( "can't create a mesh", SALOME::INTERNAL_ERROR ); // THROW_SALOME_CORBA_EXCEPTION( "can't create a mesh", SALOME::INTERNAL_ERROR );
SALOMEDS::SObject_wrap meshSO = ObjectToSObject( newMesh ); // SALOMEDS::SObject_wrap meshSO = ObjectToSObject( newMesh );
if ( !meshSO->_is_nil() ) // if ( !meshSO->_is_nil() )
{ // {
SetName( meshSO, meshName, meshName ); // SetName( meshSO, meshName, meshName );
SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED"); // SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED");
} // }
int ret = newMesh_i->ImportMEDFile(dual_mesh_file.string().c_str(), meshName); // int ret = newMesh_i->ImportMEDFile(dual_mesh_file.string().c_str(), meshName);
if(ret) // if(ret)
THROW_SALOME_CORBA_EXCEPTION( "Issue when importing mesh", SALOME::INTERNAL_ERROR ); // THROW_SALOME_CORBA_EXCEPTION( "Issue when importing mesh", SALOME::INTERNAL_ERROR );
/* // /*
SMESH_Mesh& newMesh2 = newMesh_i->GetImpl(); // SMESH_Mesh& newMesh2 = newMesh_i->GetImpl();
MESSAGE("Loading file: " << dual_mesh_file.string() << " with mesh " << meshName); // MESSAGE("Loading file: " << dual_mesh_file.string() << " with mesh " << meshName);
int ret = newMesh2.MEDToMesh(dual_mesh_file.c_str(), meshName); // int ret = newMesh2.MEDToMesh(dual_mesh_file.c_str(), meshName);
*/ // */
newMesh_i->GetImpl().GetMeshDS()->Modified(); // newMesh_i->GetImpl().GetMeshDS()->Modified();
*pyDump << newMesh << " = " << this // *pyDump << newMesh << " = " << this
<< ".CreateDualMesh(" // << ".CreateDualMesh("
<< mesh << ", " // << mesh << ", "
<< "'" << mesh_name << "', " // << "'" << mesh_name << "', "
<< ats << ") "; // << ats << ") ";
pyDumpDeleter.reset(); // allow dump in GetGroups() // pyDumpDeleter.reset(); // allow dump in GetGroups()
if ( srcMesh_i->GetImpl().GetGroupIds().size() > 0 ) // dump created groups // if ( srcMesh_i->GetImpl().GetGroupIds().size() > 0 ) // dump created groups
MESSAGE("Dump of groups"); // MESSAGE("Dump of groups");
SMESH::ListOfGroups_var groups = newMesh->GetGroups(); // SMESH::ListOfGroups_var groups = newMesh->GetGroups();
#ifndef _DEBUG_ // #ifndef _DEBUG_
fs::remove_all(tmp_folder); // fs::remove_all(tmp_folder);
#endif // #endif
return newMesh._retn(); // return newMesh._retn();
} }
//================================================================================ //================================================================================

36
src/SMESH_I/SMESH_Homard_i.cxx
View File

@ -35,7 +35,7 @@
#include "SALOMEconfig.h" #include "SALOMEconfig.h"
// Have to be included before std headers // Have to be included before std headers
#include <Python.h> // #include <Python.h>
#include <structmember.h> #include <structmember.h>
#include <vector> #include <vector>
@ -1848,23 +1848,23 @@ CORBA::Long HOMARD_Gen_i::ComputeCAO()
// C. Lancement des projections // C. Lancement des projections
MESSAGE (". Lancement des projections"); MESSAGE (". Lancement des projections");
assert(Py_IsInitialized()); // assert(Py_IsInitialized());
PyGILState_STATE gstate; // PyGILState_STATE gstate;
gstate = PyGILState_Ensure(); // gstate = PyGILState_Ensure();
PyRun_SimpleString("from FrontTrack import FrontTrack"); // PyRun_SimpleString("from FrontTrack import FrontTrack");
// FrontTrack().track( fic_med_brut, fic_med_new, l_fr, xao_file ) // // FrontTrack().track( fic_med_brut, fic_med_new, l_fr, xao_file )
std::string pyCommand ("FrontTrack().track( \""); // std::string pyCommand ("FrontTrack().track( \"");
pyCommand += theInputMedFile + "\", \"" + theOutputMedFile + "\", ["; // pyCommand += theInputMedFile + "\", \"" + theOutputMedFile + "\", [";
for (int i = 0; i < icpt; i++) { // for (int i = 0; i < icpt; i++) {
if (i > 0) pyCommand += ", "; // if (i > 0) pyCommand += ", ";
pyCommand += "\""; // pyCommand += "\"";
pyCommand += theInputNodeFiles[i]; // pyCommand += theInputNodeFiles[i];
pyCommand += "\""; // pyCommand += "\"";
} // }
pyCommand += "], \"" + theXaoFileName + "\", False )"; // pyCommand += "], \"" + theXaoFileName + "\", False )";
MESSAGE (". Lancement des projections: pyCommand = " << pyCommand); // MESSAGE (". Lancement des projections: pyCommand = " << pyCommand);
PyRun_SimpleString(pyCommand.c_str()); // PyRun_SimpleString(pyCommand.c_str());
PyGILState_Release(gstate); // PyGILState_Release(gstate);
// D. Transfert des coordonnées modifiées dans le fichier historique de HOMARD // D. Transfert des coordonnées modifiées dans le fichier historique de HOMARD
// On lance une exécution spéciale de HOMARD en attendant // On lance une exécution spéciale de HOMARD en attendant

2
src/SMESH_SWIG/CMakeLists.txt
View File

@ -51,6 +51,7 @@ SET(StdMeshers_SCRIPTS
) )
# additional preprocessor / compiler flags # additional preprocessor / compiler flags
if (NOT DEFINED EMSCRIPTEN)
ADD_DEFINITIONS(${OMNIORB_DEFINITIONS}) ADD_DEFINITIONS(${OMNIORB_DEFINITIONS})
SET(SMeshHelper_HEADERS SMeshHelper.h SMeshHelper.i) SET(SMeshHelper_HEADERS SMeshHelper.h SMeshHelper.i)
SET(SMeshHelper_SOURCES SMeshHelper.cxx ${SMeshHelper_HEADERS}) SET(SMeshHelper_SOURCES SMeshHelper.cxx ${SMeshHelper_HEADERS})
@ -72,6 +73,7 @@ install(TARGETS _SMeshHelper DESTINATION ${SALOME_INSTALL_LIBS})
install(FILES ${SMeshHelper_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS}) install(FILES ${SMeshHelper_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
SALOME_INSTALL_SCRIPTS("${_swig_SCRIPTS}" ${SALOME_INSTALL_BINS} EXTRA_DPYS "${SWIG_MODULE_SMeshHelper_REAL_NAME}") SALOME_INSTALL_SCRIPTS("${_swig_SCRIPTS}" ${SALOME_INSTALL_BINS} EXTRA_DPYS "${SWIG_MODULE_SMeshHelper_REAL_NAME}")
SALOME_INSTALL_SCRIPTS("${smesh_exe_SCRIPTS}" ${SALOME_INSTALL_BINS}) SALOME_INSTALL_SCRIPTS("${smesh_exe_SCRIPTS}" ${SALOME_INSTALL_BINS})
endif()
# --- rules --- # --- rules ---
SALOME_INSTALL_SCRIPTS("${smesh_SCRIPTS}" ${SALOME_INSTALL_PYTHON}/salome/smesh DEF_PERMS) SALOME_INSTALL_SCRIPTS("${smesh_SCRIPTS}" ${SALOME_INSTALL_PYTHON}/salome/smesh DEF_PERMS)

3
src/SMESH_SWIG_WITHIHM/CMakeLists.txt
View File

@ -94,6 +94,8 @@ SET(_swig_SCRIPTS
) )
# --- rules --- # --- rules ---
if (NOT DEFINED EMSCRIPTEN)
IF(${CMAKE_VERSION} VERSION_LESS "3.8.0") IF(${CMAKE_VERSION} VERSION_LESS "3.8.0")
SWIG_ADD_MODULE(libSMESH_Swig python ${SMESH_Swig_SOURCES}) SWIG_ADD_MODULE(libSMESH_Swig python ${SMESH_Swig_SOURCES})
ELSE() ELSE()
@ -106,6 +108,7 @@ SWIG_CHECK_GENERATION(libSMESH_Swig)
IF(WIN32) IF(WIN32)
SET_TARGET_PROPERTIES(_libSMESH_Swig PROPERTIES DEBUG_OUTPUT_NAME _libSMESH_Swig_d) SET_TARGET_PROPERTIES(_libSMESH_Swig PROPERTIES DEBUG_OUTPUT_NAME _libSMESH_Swig_d)
ENDIF(WIN32) ENDIF(WIN32)
endif()
INSTALL(TARGETS _libSMESH_Swig DESTINATION ${SALOME_INSTALL_LIBS}) INSTALL(TARGETS _libSMESH_Swig DESTINATION ${SALOME_INSTALL_LIBS})

26
src/Tools/padder/meshjob/impl/CMakeLists.txt
View File

@ -83,13 +83,13 @@ SET(MeshJobManagerEngine_SOURCES
MeshJobManager_i.cxx MeshJobManager_i.cxx
) )
SET(SPADDERPluginTesterEngine_SOURCES # SET(SPADDERPluginTesterEngine_SOURCES
SPADDERPluginTester_i.hxx # SPADDERPluginTester_i.hxx
SPADDERPluginTester_i.cxx # SPADDERPluginTester_i.cxx
) # )
# - swiggy pop # - swiggy pop
if (NOT DEFINED EMSCRIPTEN)
SET(SMeshPadderHelper_HEADERS SMeshPadderHelper.h SMeshPadderHelper.i) SET(SMeshPadderHelper_HEADERS SMeshPadderHelper.h SMeshPadderHelper.i)
SET(SMeshPadderHelper_SOURCES SMeshPadderHelper.cxx ${SMeshPadderHelper_HEADERS}) SET(SMeshPadderHelper_SOURCES SMeshPadderHelper.cxx ${SMeshPadderHelper_HEADERS})
SET_SOURCE_FILES_PROPERTIES(SMeshPadderHelper.i PROPERTIES CPLUSPLUS ON) SET_SOURCE_FILES_PROPERTIES(SMeshPadderHelper.i PROPERTIES CPLUSPLUS ON)
@ -109,16 +109,16 @@ ENDIF(WIN32)
install(TARGETS _SMeshPadderHelper DESTINATION ${SALOME_INSTALL_LIBS}) install(TARGETS _SMeshPadderHelper DESTINATION ${SALOME_INSTALL_LIBS})
install(FILES ${SMeshPadderHelper_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS}) install(FILES ${SMeshPadderHelper_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
SALOME_INSTALL_SCRIPTS("${_swig_SCRIPTS}" ${SALOME_INSTALL_BINS} EXTRA_DPYS "${SWIG_MODULE_SMeshPadderHelper_REAL_NAME}") SALOME_INSTALL_SCRIPTS("${_swig_SCRIPTS}" ${SALOME_INSTALL_BINS} EXTRA_DPYS "${SWIG_MODULE_SMeshPadderHelper_REAL_NAME}")
endif()
# --- rules --- # --- rules ---
ADD_LIBRARY(MeshJobManagerEngine ${MeshJobManagerEngine_SOURCES}) # ADD_LIBRARY(MeshJobManagerEngine ${MeshJobManagerEngine_SOURCES})
TARGET_LINK_LIBRARIES(MeshJobManagerEngine ${MeshJobManagerEngine_LIBRARIES} ) # TARGET_LINK_LIBRARIES(MeshJobManagerEngine ${MeshJobManagerEngine_LIBRARIES} )
INSTALL(TARGETS MeshJobManagerEngine EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS}) # INSTALL(TARGETS MeshJobManagerEngine EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
ADD_LIBRARY(SPADDERPluginTesterEngine ${SPADDERPluginTesterEngine_SOURCES}) # ADD_LIBRARY(SPADDERPluginTesterEngine ${SPADDERPluginTesterEngine_SOURCES})
TARGET_LINK_LIBRARIES(SPADDERPluginTesterEngine ${SPADDERPluginTesterEngine_LIBRARIES} ) # TARGET_LINK_LIBRARIES(SPADDERPluginTesterEngine ${SPADDERPluginTesterEngine_LIBRARIES} )
INSTALL(TARGETS SPADDERPluginTesterEngine EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS}) # INSTALL(TARGETS SPADDERPluginTesterEngine EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
INSTALL(FILES ${MeshJobManagerEngine_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS}) # INSTALL(FILES ${MeshJobManagerEngine_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})