diff options
| author | Michele Mocciola | 2015-10-02 23:52:41 +0200 |
|---|---|---|
| committer | Michele Mocciola | 2015-10-02 23:52:41 +0200 |
| commit | 76ef3ab742be8c8cd270d2f1f026824a438dcbac (patch) | |
| tree | 98cfef5620aa10aa13b02c1283e2e12267e7b7ac | |
| download | aur-76ef3ab742be8c8cd270d2f1f026824a438dcbac.tar.gz | |
Initial commit
| -rw-r--r-- | .SRCINFO | 21 | ||||
| -rw-r--r-- | PKGBUILD | 102 | ||||
| -rw-r--r-- | netgen-4.9.13-for-CMake.patch | 2647 | ||||
| -rw-r--r-- | netgen-4.9.13-for-SALOME.patch | 1109 | ||||
| -rw-r--r-- | salome-netgenplugin.profile | 10 |
5 files changed, 3889 insertions, 0 deletions
diff --git a/.SRCINFO b/.SRCINFO new file mode 100644 index 000000000000..39dcba55c92c --- /dev/null +++ b/.SRCINFO @@ -0,0 +1,21 @@ +pkgbase = salome-netgenplugin + pkgdesc = Generic platform for Pre and Post-Processing for numerical simulation - NETGEN plugin + pkgver = 7.6.0 + pkgrel = 1 + url = http://www.salome-platform.org + arch = i686 + arch = x86_64 + license = LGPL + depends = salome-smesh>=7.6.0 + depends = salome-smesh<7.7.0 + source = http://downloads.sourceforge.net/netgen-mesher/netgen-4.9.13.tar.gz + source = netgen-4.9.13-for-SALOME.patch + source = netgen-4.9.13-for-CMake.patch + source = salome-netgenplugin.profile + md5sums = 2d56642ca673106837bcd08ff9913d57 + md5sums = b19f13b42651b992359eaf0ad4ae346b + md5sums = 4ae279ab4558b1719fe1d8d65a1ed1a1 + md5sums = d143fa3d279a64e0676eb0b43709ffee + +pkgname = salome-netgenplugin + diff --git a/PKGBUILD b/PKGBUILD new file mode 100644 index 000000000000..d0b6588994b5 --- /dev/null +++ b/PKGBUILD @@ -0,0 +1,102 @@ +# Maintainer: Michele Mocciola <mickele> + +pkgname=salome-netgenplugin +pkgver=7.6.0 +_netgenver=4.9.13 +pkgrel=1 +pkgdesc="Generic platform for Pre and Post-Processing for numerical simulation - NETGEN plugin" +url="http://www.salome-platform.org" +depends=('salome-smesh>=7.6.0' 'salome-smesh<7.7.0') +arch=('i686' 'x86_64') +license=('LGPL') +source=("http://downloads.sourceforge.net/netgen-mesher/netgen-${_netgenver}.tar.gz" "netgen-4.9.13-for-SALOME.patch" "netgen-4.9.13-for-CMake.patch" "salome-netgenplugin.profile") +options=() + +_source=netgenplugin +_installdir=/opt/salome/netgenplugin +_paraviewrootdir=/usr +_paraviewver=4.2 + +prepare(){ + cd "netgen-${_netgenver}" + patch -Np1 -i "${srcdir}/netgen-4.9.13-for-SALOME.patch" + patch -Np1 -i "${srcdir}/netgen-4.9.13-for-CMake.patch" + chmod u+x ./build_cmake + sed -e "s|python|python2|" -i ./build_cmake + sed -e "s|-avoid-version||" -i nglib/Makefile.am + sed -e "s|-avoid-version||" -i nglib/Makefile.in + + cd "${srcdir}" + msg "Connecting to git server..." + if [[ -d ${_source} ]] ; then + rm -rf ${_source} + fi + git clone git://git.salome-platform.org/plugins/${_source}.git + cd ${_source} + git checkout V${pkgver:0:1}_${pkgver:2:1}_${pkgver:4:1} + msg "GIT checkout done or server timeout" + + # python -> python2 + for _FILE in `grep -Rl "/usr/bin/env python" * ` + do + sed -e "s|/usr/bin/env python|/usr/bin/env python2|" -i ${_FILE} + done + for _FILE in `grep -Rl "'python'" * ` + do + sed -e "s|'python'|'python2'|" -i ${_FILE} + done + for _FILE in `grep -Rl '"python"' * ` + do + sed -e 's|"python"|"python2"|' -i ${_FILE} + done + for _FILE in `grep -Rl '"python ' * ` + do + sed -e 's|"python |"python2 |' -i ${_FILE} + done +} + +build() { + cd "netgen-${_netgenver}" + ./build_cmake ./ + cmake -DCMAKE_INSTALL_PREFIX=${_installdir} \ + -DCASROOT=/opt/opencascade + make + make DESTDIR="${srcdir}" install + + rm -rf "${srcdir}/${_source}/build" + mkdir -p "${srcdir}/${_source}/build" + cd "${srcdir}/${_source}/build" + source /etc/salome/profile.d/salome-kernel.sh + source /etc/salome/profile.d/salome-gui.sh + source /etc/salome/profile.d/salome-geom.sh + source /etc/salome/profile.d/salome-smesh.sh + cmake .. \ + -DCMAKE_INSTALL_PREFIX=${_installdir} \ + -DPYTHON_EXECUTABLE=/usr/bin/python2 \ + -DSWIG_EXECUTABLE=/usr/bin/swig-2 \ + -DVTK_DIR="${_paraviewrootdir}/lib/cmake/paraview-${_paraviewver}" \ + -DCAS_ROOT_DIR=/opt/opencascade \ + -DNETGEN_ROOT_DIR="${srcdir}${_installdir}" + + make +} + +package() { + cd "${srcdir}/netgen-${_netgenver}" + + make DESTDIR="${pkgdir}" install + + install -D -m644 "${srcdir}/netgen-${_netgenver}/doc/ng4.pdf" \ + "${pkgdir}/${_installdir}/doc/netgen/ng4.pdf" + + cd "${srcdir}/${_source}/build" + + make DESTDIR="$pkgdir" install + + install -D -m755 "$srcdir/$pkgname.profile" \ + "$pkgdir/etc/salome/profile.d/$pkgname.sh" +} +md5sums=('2d56642ca673106837bcd08ff9913d57' + 'b19f13b42651b992359eaf0ad4ae346b' + '4ae279ab4558b1719fe1d8d65a1ed1a1' + 'd143fa3d279a64e0676eb0b43709ffee') diff --git a/netgen-4.9.13-for-CMake.patch b/netgen-4.9.13-for-CMake.patch new file mode 100644 index 000000000000..b0ddc03162c5 --- /dev/null +++ b/netgen-4.9.13-for-CMake.patch @@ -0,0 +1,2647 @@ +diff -Naur netgen-4.9.13.occ/Makefile.am netgen-4.9.13/Makefile.am +--- netgen-4.9.13.occ/Makefile.am 2009-08-10 11:40:52.000000000 +0000 ++++ netgen-4.9.13/Makefile.am 2011-04-26 15:48:32.540050641 +0000 +@@ -2,7 +2,7 @@ + + METASOURCES = AUTO + +-SUBDIRS = libsrc ng nglib tutorials doc windows ++SUBDIRS = libsrc nglib tutorials doc windows + + # TESTS = ng/netgen -batchmode + +diff -Naur netgen-4.9.13.occ/build_cmake netgen-4.9.13/build_cmake +--- netgen-4.9.13.occ/build_cmake 1970-01-01 00:00:00.000000000 +0000 ++++ netgen-4.9.13/build_cmake 2011-04-26 15:16:35.400428886 +0000 +@@ -0,0 +1,9 @@ ++#!/bin/sh ++ ++CURRENT_DIR=`pwd` ++CONF_DIR=`echo $0 | sed -e "s,[^/]*$,,;s,/$,,;s,^$,.,"` ++cd ${CONF_DIR} ++python cmake/am2cmake.py --netgen ++status=$? ++cd ${CURRENT_DIR} ++exit $status +diff -Naur netgen-4.9.13.occ/build_cmake.bat netgen-4.9.13/build_cmake.bat +--- netgen-4.9.13.occ/build_cmake.bat 1970-01-01 00:00:00.000000000 +0000 ++++ netgen-4.9.13/build_cmake.bat 2011-04-26 15:16:50.690050021 +0000 +@@ -0,0 +1,2 @@ ++ ++%PYTHONBIN% cmake\am2cmake.py --netgen +diff -Naur netgen-4.9.13.occ/cmake/FindCAS.cmake netgen-4.9.13/cmake/FindCAS.cmake +--- netgen-4.9.13.occ/cmake/FindCAS.cmake 1970-01-01 00:00:00.000000000 +0000 ++++ netgen-4.9.13/cmake/FindCAS.cmake 2011-04-26 15:35:58.110362203 +0000 +@@ -0,0 +1,172 @@ ++# Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE ++# ++# This library is free software; you can redistribute it and/or ++# modify it under the terms of the GNU Lesser General Public ++# License as published by the Free Software Foundation; either ++# version 2.1 of the License. ++# ++# This library is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++# Lesser General Public License for more details. ++# ++# You should have received a copy of the GNU Lesser General Public ++# License along with this library; if not, write to the Free Software ++# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++# ++# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com ++# ++ ++SET(CASROOT $ENV{CASROOT}) ++ ++# SET(OCC_VERSION_MAJOR 6) ++# SET(OCC_VERSION_MINOR 3) ++# SET(OCC_VERSION_MAINTENANCE 10) ++ ++SET(CAS_CPPFLAGS) ++# SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -DOCC_VERSION_MAJOR=${OCC_VERSION_MAJOR}) ++# SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -DOCC_VERSION_MINOR=${OCC_VERSION_MINOR}) ++# SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -DOCC_VERSION_MAINTENANCE=${OCC_VERSION_MAINTENANCE}) ++SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -DLIN -DLINTEL -DCSFDB) ++SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -DNo_exception) ++SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -DHAVE_CONFIG_H) ++SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -DHAVE_LIMITS_H) ++SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -I${CASROOT}/inc) ++ ++IF(CMAKE_SIZEOF_VOID_P STREQUAL 8) ++ SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -D_OCC64) ++ENDIF(CMAKE_SIZEOF_VOID_P STREQUAL 8) ++ ++IF(NOT WINDOWS) ++ FIND_LIBRARY(Xmu Xmu) ++ IF(Xmu) ++ SET(CAS_LDPATH ${Xmu}) ++ ENDIF(Xmu) ++ENDIF(NOT WINDOWS) ++ ++IF(WINDOWS) ++ IF(CMAKE_BUILD_TYPE STREQUAL Debug) ++ SET(CASROOT_LIBDIR ${CASROOT}/win32/libd) ++ ELSE(CMAKE_BUILD_TYPE STREQUAL Debug) ++ SET(CASROOT_LIBDIR ${CASROOT}/win32/lib) ++ ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug) ++ELSE(WINDOWS) ++ SET(CASROOT_LIBDIR ${CASROOT}/lib) ++ENDIF(WINDOWS) ++ ++FIND_LIBRARY(BinLPlugin BinLPlugin PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(BinPlugin BinPlugin PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(BinTObjPlugin BinTObjPlugin PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(BinXCAFPlugin BinXCAFPlugin PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(FWOSPlugin FWOSPlugin PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(mscmd mscmd PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(PTKernel PTKernel PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(StdLPlugin StdLPlugin PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(StdPlugin StdPlugin PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKAdvTools TKAdvTools PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKBin TKBin PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKBinL TKBinL PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKBinTObj TKBinTObj PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKBinXCAF TKBinXCAF PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKBO TKBO PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKBool TKBool PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKBRep TKBRep PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKCAF TKCAF PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKCDF TKCDF PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKCDLFront TKCDLFront PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKCPPClient TKCPPClient PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKCPPExt TKCPPExt PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKCPPIntExt TKCPPIntExt PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKCPPJini TKCPPJini PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKCSFDBSchema TKCSFDBSchema PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKDCAF TKDCAF PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKDraw TKDraw PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKernel TKernel PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKFeat TKFeat PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKFillet TKFillet PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKG2d TKG2d PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKG3d TKG3d PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKGeomAlgo TKGeomAlgo PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKGeomBase TKGeomBase PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKHLR TKHLR PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKIDLFront TKIDLFront PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKIGES TKIGES PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKLCAF TKLCAF PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKMath TKMath PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKMesh TKMesh PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKMeshVS TKMeshVS PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKNIS TKNIS PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKOffset TKOffset PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKOpenGl TKOpenGl PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKPCAF TKPCAF PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKPLCAF TKPLCAF PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKPrim TKPrim PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKPShape TKPShape PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKService TKService PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKShapeSchema TKShapeSchema PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKShHealing TKShHealing PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKStdLSchema TKStdLSchema PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKStdSchema TKStdSchema PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKSTEP TKSTEP PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKSTEP209 TKSTEP209 PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKSTEPAttr TKSTEPAttr PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKSTEPBase TKSTEPBase PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKSTL TKSTL PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKTCPPExt TKTCPPExt PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKTObj TKTObj PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKTObjDRAW TKTObjDRAW PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKTopAlgo TKTopAlgo PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKTopTest TKTopTest PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKV2d TKV2d PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKV3d TKV3d PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKViewerTest TKViewerTest PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKVRML TKVRML PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKWOK TKWOK PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKWOKTcl TKWOKTcl PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKXCAF TKXCAF PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKXCAFSchema TKXCAFSchema PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKXDEDRAW TKXDEDRAW PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKXDEIGES TKXDEIGES PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKXDESTEP TKXDESTEP PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKXMesh TKXMesh PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKXml TKXml PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKXmlL TKXmlL PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKXmlTObj TKXmlTObj PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKXmlXCAF TKXmlXCAF PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(TKXSBase TKXSBase PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(TKXSDRAW TKXSDRAW PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(wokcmd wokcmd PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(wokdeliverysteps wokdeliverysteps PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(wokdfltsteps wokdfltsteps PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(wokobjssteps wokobjssteps PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(wokorbixsteps wokorbixsteps PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(woksteps woksteps PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(woktoolscmd woktoolscmd PATHS ${CASROOT_LIBDIR}) ++# FIND_LIBRARY(wokutilscmd wokutilscmd PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(XCAFPlugin XCAFPlugin PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(XmlLPlugin XmlLPlugin PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(XmlPlugin XmlPlugin PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(XmlTObjPlugin XmlTObjPlugin PATHS ${CASROOT_LIBDIR}) ++FIND_LIBRARY(XmlXCAFPlugin XmlXCAFPlugin PATHS ${CASROOT_LIBDIR}) ++ ++SET(CAS_KERNEL ${TKernel} ${TKMath}) ++SET(CAS_OCAF ${TKernel} ${TKMath} ${TKCDF} ${TKLCAF}) ++SET(CAS_VIEWER ${TKService} ${TKV3d} ${TKG3d} ${TKGeomBase} ${TKBRep}) ++SET(CAS_OCAFVIS ${TKCAF} ${TKBRep} ${TKG2d}) ++SET(CAS_MODELER ${TKG3d} ${TKGeomBase} ${TKGeomAlgo} ${TKBRep} ${TKTopAlgo} ${TKG2d}) ++ ++SET(TKV3d_EA ${TKernel} ${TKMath} ${TKV3d}) ++SET(TKBool_EA ${TKernel} ${TKMath} ${TKBRep} ${TKG2d} ${TKG3d} ${TKGeomBase} ${TKGeomAlgo} ${TKTopAlgo} ${TKBool}) ++SET(TKBRep_EA ${TKernel} ${TKMath} ${TKBRep}) ++SET(TKIGES_EA ${TKernel} ${TKMath} ${TKXSBase} ${TKBRep} ${TKIGES}) ++SET(TKSTEP_EA ${TKernel} ${TKMath} ${TKXSBase} ${TKBRep} ${TKSTEP}) ++SET(TKSTL_EA ${TKernel} ${TKMath} ${TKSTL}) ++SET(TKCAF_EA ${TKPrim} ${TKCAF}) ++ ++SET(TKV3d ${TKV3d_EA}) ++SET(TKBool ${TKBool_EA}) ++SET(TKBRep ${TKBRep_EA}) ++SET(TKIGES ${TKIGES_EA}) ++SET(TKSTEP ${TKSTEP_EA}) ++SET(TKSTL ${TKSTL_EA}) ++SET(TKCAF ${TKCAF_EA}) +diff -Naur netgen-4.9.13.occ/cmake/FindPLATFORM.cmake netgen-4.9.13/cmake/FindPLATFORM.cmake +--- netgen-4.9.13.occ/cmake/FindPLATFORM.cmake 1970-01-01 00:00:00.000000000 +0000 ++++ netgen-4.9.13/cmake/FindPLATFORM.cmake 2011-04-28 08:11:30.203175382 +0000 +@@ -0,0 +1,119 @@ ++# Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE ++# ++# This library is free software; you can redistribute it and/or ++# modify it under the terms of the GNU Lesser General Public ++# License as published by the Free Software Foundation; either ++# version 2.1 of the License. ++# ++# This library is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++# Lesser General Public License for more details. ++# ++# You should have received a copy of the GNU Lesser General Public ++# License along with this library; if not, write to the Free Software ++# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++# ++# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com ++# ++ ++MARK_AS_ADVANCED(ISSUE) ++FIND_FILE(ISSUE issue /etc) ++IF(ISSUE) ++ SET(WINDOWS 0) ++ELSE() ++ SET(WINDOWS 1) ++ENDIF(ISSUE) ++ ++IF(WINDOWS) ++ SET(MACHINE WINDOWS) ++ELSE(WINDOWS) ++ SET(MACHINE PCLINUX) ++ENDIF(WINDOWS) ++ ++SET(CMAKE_INSTALL_PREFIX_ENV $ENV{CMAKE_INSTALL_PREFIX}) ++IF(CMAKE_INSTALL_PREFIX_ENV) ++ SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX_ENV} CACHE PATH "installation prefix" FORCE) ++ENDIF(CMAKE_INSTALL_PREFIX_ENV) ++ ++IF(NOT CMAKE_BUILD_TYPE) ++ SET(CMAKE_BUILD_TYPE $ENV{CMAKE_BUILD_TYPE}) ++ENDIF(NOT CMAKE_BUILD_TYPE) ++ ++IF(NOT CMAKE_BUILD_TYPE) ++ SET(CMAKE_BUILD_TYPE Release) ++ENDIF(NOT CMAKE_BUILD_TYPE) ++ ++IF(WINDOWS) ++ELSE(WINDOWS) ++ SET(ADD_WERROR ON) ++ SET(NAMES ACCEPT_SALOME_WARNINGS ACCEPT_${MODULE}_WARNINGS I_AM_A_TROLL_I_DO_NOT_FIX_${MODULE}_WARNINGS) ++ FOREACH(name ${NAMES}) ++ SET(VAL $ENV{${name}}) ++ IF(X${VAL} STREQUAL X0) ++ SET(ADD_WERROR ON) ++ ENDIF(X${VAL} STREQUAL X0) ++ IF(X${VAL} STREQUAL X1) ++ SET(ADD_WERROR OFF) ++ ENDIF(X${VAL} STREQUAL X1) ++ ENDFOREACH(name ${NAMES}) ++ IF(ADD_WERROR) ++ SET(CMAKE_C_FLAGS "-Werror") ++ SET(CMAKE_CXX_FLAGS "-Werror") ++ ENDIF(ADD_WERROR) ++ENDIF(WINDOWS) ++ ++IF(CMAKE_BUILD_TYPE) ++ IF(WINDOWS) ++ MARK_AS_ADVANCED(CLEAR CMAKE_CONFIGURATION_TYPES) ++ SET(CMAKE_CONFIGURATION_TYPES ${CMAKE_BUILD_TYPE} CACHE STRING "compilation types" FORCE) ++ ELSE(WINDOWS) ++ IF(CMAKE_BUILD_TYPE STREQUAL Debug) ++ SET(CMAKE_C_FLAGS_DEBUG "-g") ++ SET(CMAKE_CXX_FLAGS_DEBUG "-g") ++ ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug) ++ IF(CMAKE_BUILD_TYPE STREQUAL Release) ++ SET(CMAKE_C_FLAGS_RELEASE "-O1 -DNDEBUG") ++ SET(CMAKE_CXX_FLAGS_RELEASE "-O1 -DNDEBUG") ++ ENDIF(CMAKE_BUILD_TYPE STREQUAL Release) ++ ENDIF(WINDOWS) ++ENDIF(CMAKE_BUILD_TYPE) ++ ++SET(PLATFORM_CPPFLAGS) ++SET(PLATFORM_LDFLAGS) ++SET(PLATFORM_LIBADD) ++IF(WINDOWS) ++ SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} /W0) ++ SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_CRT_SECURE_NO_WARNINGS) # To disable windows warnings for strcpy, fopen, ... ++ SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_SCL_SECURE_NO_WARNINGS) # To disable windows warnings std::copy, std::transform, ... ++ SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -DWNT) ++ SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -DPPRO_NT) # For medfile ++ SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_USE_MATH_DEFINES) # At least for MEDMEM ++ SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_WIN32_WINNT=0x0500) # Windows 2000 or later API is required ++ SET(PLATFORM_LIBADD ${PLATFORM_LIBADD} Ws2_32.lib) ++ SET(PLATFORM_LIBADD ${PLATFORM_LIBADD} Userenv.lib) # At least for GEOM suit ++ELSE(WINDOWS) ++ # SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -Wparentheses) ++ # SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -Wreturn-type) ++ # SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -Wmissing-declarations) ++ # SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -Wunused) ++ # SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -Wall) ++ SET(PLATFORM_LIBADD ${PLATFORM_LIBADD} -ldl) ++ENDIF(WINDOWS) ++ ++SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -DSIZEOF_FORTRAN_INTEGER=4 -DSIZEOF_LONG=${CMAKE_SIZEOF_VOID_P} -DSIZEOF_INT=4) ++ ++# SET(PLATFORM_CPPFLAGS) ++# # # SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -DWNT -D_CRT_SECURE_NO_WARNINGS) ++# # SET(RM del) ++#ELSE(WINDOWS) ++# # SET(RM /bin/rm) ++#ENDIF(WINDOWS) ++ ++### SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_DEBUG_) ++ ++##SET(RCP rcp) ++##SET(RSH rsh) ++##SET(RCP rcp) ++ ++## MESSAGE(FATAL_ERROR "ZZZZZZZ") +diff -Naur netgen-4.9.13.occ/cmake/am2cmake.py netgen-4.9.13/cmake/am2cmake.py +--- netgen-4.9.13.occ/cmake/am2cmake.py 1970-01-01 00:00:00.000000000 +0000 ++++ netgen-4.9.13/cmake/am2cmake.py 2011-04-28 08:16:50.931646630 +0000 +@@ -0,0 +1,2287 @@ ++# -*- coding: iso-8859-1 -*- ++# Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE ++# ++# This library is free software; you can redistribute it and/or ++# modify it under the terms of the GNU Lesser General Public ++# License as published by the Free Software Foundation; either ++# version 2.1 of the License. ++# ++# This library is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++# Lesser General Public License for more details. ++# ++# You should have received a copy of the GNU Lesser General Public ++# License along with this library; if not, write to the Free Software ++# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++# ++# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com ++# ++ ++import re ++ ++# ---- ++# A set of regular expressions used ... ++# ---- ++ ++p_multiline = re.compile(r""" ++\\ # One backslash ++\s* # 0 or more space ++\n # One CR ++""", re.VERBOSE) ++ ++p_dollar = re.compile(r""" ++\$\( # a $ then a ( ++(?P<val> # open the group val ++[^)]* # the group contain 0 or more non ) characters ++) # close the group ++\) # a ) at the end ++""", re.VERBOSE) ++ ++p_arobas = re.compile(r""" ++@ # a @ ++(?P<val> # open the group val ++[^@]* # the group contain 0 or more non @ characters ++) # close the group ++@ # a @ at the end ++""", re.VERBOSE) ++ ++p_if = re.compile(r""" ++^ # beginning of the string ++\s* # 0 or more space ++if # an if ++\s+ # 1 or more space ++(?P<val> # open the group val ++.+ # the group contain 1 or more non space characters ++) # close the group ++""", re.VERBOSE) ++ ++p_else = re.compile(r""" ++^ # beginning of the line ++\s* # 0 or more space ++else # ++\s* # 0 or more space ++""", re.VERBOSE) ++ ++p_endif = re.compile(r""" ++^ # beginning of the line ++\s* # 0 or more space ++endif # a endif ++\s* # 0 or more space ++""", re.VERBOSE) ++ ++p_attribution = re.compile(r""" ++^ # beginning of the line ++(?P<spaces> # open the group spaces ++\s* # 0 or more space ++) # close the group ++(?P<key> # open the group key ++\w+ # the group contain 1 or more alphanumeric characters ++) # close the group ++\s* # 0 or more space ++(?P<method> # open the group method ++\+? # 0 or 1 + ++= # One = ++) # close the group ++(?P<value> # open the group value ++.* # 0 or more any characters ++) # close the group ++""", re.VERBOSE) ++ ++# ----- ++ ++class CMakeFile(object): ++ ++ def __init__(self, the_root, root, dirs, files, f, module): ++ # ++ self.the_root = the_root ++ self.root = root ++ self.dirs = dirs ++ self.files = files ++ self.module = module ++ # ++ from os.path import join ++ self.amFile = join(root, f) ++ self.listsFile = join(root, "CMakeLists.txt") ++ # ++ self.parseFile() ++ # ++ return ++ ++ def parseFile(self): ++ ++ # -- ++ # Read the Makefile.am file ++ # -- ++ amFile = self.amFile ++ stream = open(amFile) ++ content = stream.read() ++ stream.close() ++ ++ # -- ++ # Replace the composed lines separated by "\\n" by an unique line ++ # -- ++ content = p_multiline.sub(r' ', content) ++ ++ # -- ++ # Compatibility netgen plugin ++ # -- ++ content = content.replace("../NETGEN/libNETGEN.la", "${NETGEN_LIBS}") ++ ++ # -- ++ cas_list = [ ++ "BinLPlugin", ++ "BinPlugin", ++ "BinTObjPlugin", ++ "BinXCAFPlugin", ++ "FWOSPlugin", ++ "PTKernel", ++ "StdLPlugin", ++ "StdPlugin", ++ "TKAdvTools", ++ "TKBin", ++ "TKBinL", ++ "TKBinTObj", ++ "TKBinXCAF", ++ "TKBO", ++ "TKBool", ++ "TKBRep", ++ "TKCAF", ++ "TKCDF", ++ "TKernel", ++ "TKFeat", ++ "TKFillet", ++ "TKG2d", ++ "TKG3d", ++ "TKGeomAlgo", ++ "TKGeomBase", ++ "TKHLR", ++ "TKIGES", ++ "TKLCAF", ++ "TKMath", ++ "TKMesh", ++ "TKMeshVS", ++ "TKNIS", ++ "TKOffset", ++ "TKOpenGl", ++ "TKPCAF", ++ "TKPLCAF", ++ "TKPrim", ++ "TKPShape", ++ "TKService", ++ "TKShapeSchema", ++ "TKShHealing", ++ "TKStdLSchema", ++ "TKStdSchema", ++ "TKSTEP", ++ "TKSTEP209", ++ "TKSTEPAttr", ++ "TKSTEPBase", ++ "TKSTL", ++ "TKTObj", ++ "TKTopAlgo", ++ "TKV2d", ++ "TKV3d", ++ "TKVRML", ++ "TKXCAF", ++ "TKXCAFSchema", ++ "TKXDEIGES", ++ "TKXDESTEP", ++ "TKXMesh", ++ "TKXml", ++ "TKXmlL", ++ "TKXmlTObj", ++ "TKXmlXCAF", ++ "TKXSBase", ++ "XCAFPlugin", ++ "XmlLPlugin", ++ "XmlPlugin", ++ "XmlTObjPlugin", ++ "XmlXCAFPlugin", ++ ] ++ vtk_list = [ ++ "vtkCommonPythonD", ++ "vtkGraphicsPythonD", ++ "vtkImagingPythonD", ++ ] ++ kernel_list = [ ++ "CalciumC", ++ "DF", ++ "Launcher", ++ "LifeCycleCORBATest", ++ "NamingServiceTest", ++ "OpUtil", ++ "Registry", ++ "ResourcesManager", ++ "SALOMEBasics", ++ "SalomeCatalog", ++ "SalomeCommunication", ++ "SalomeContainer", ++ "SalomeDatastream", ++ "SalomeDSCContainer", ++ "SalomeDSClient", ++ "SalomeDSCSupervBasic", ++ "SalomeDSCSuperv", ++ "SalomeDSImpl", ++ "SALOMEDSImplTest", ++ "SalomeDS", ++ "SALOMEDSTest", ++ "SalomeGenericObj", ++ "SalomeHDFPersist", ++ "SalomeIDLKernel", ++ "SalomeLauncher", ++ "SalomeLifeCycleCORBA", ++ "SALOMELocalTrace", ++ "SALOMELocalTraceTest", ++ "SalomeLoggerServer", ++ "SalomeMPIContainer", ++ "SalomeNotification", ++ "SalomeNS", ++ "SalomeResourcesManager", ++ "SalomeTestComponentEngine", ++ "SalomeTestMPIComponentEngine", ++ "SALOMETraceCollectorTest", ++ "TOOLSDS", ++ "UtilsTest", ++ "with_loggerTraceCollector", ++ ] ++ gui_list = [ ++ "caf", ++ "CAM", ++ "CASCatch", ++ "DDS", ++ "Event", ++ "GLViewer", ++ "LightApp", ++ "LogWindow", ++ "ObjBrowser", ++ "OCCViewer", ++ "OpenGLUtils", ++ "Plot2d", ++ "PyConsole", ++ "PyInterp", ++ "QDS", ++ "qtx", ++ "QxScene", ++ "SalomeApp", ++ "SalomeAppTest", ++ "SalomeIDLGUI", ++ "SalomeObject", ++ "SalomePrs", ++ "SalomePyQtGUILight", ++ "SalomePyQtGUI", ++ "SalomePyQt", ++ "SalomePy", ++ "SalomeSession", ++ "SalomeStyle", ++ "SOCC", ++ "SPlot2d", ++ "std", ++ "SUITApp", ++ "suit", ++ "SUPERVGraph", ++ "SVTK", ++ "ToolsGUI", ++ "ViewerTools", ++ "VTKViewer", ++ ] ++ geom_list = [ ++ "AdvancedGUI", ++ "BasicGUI", ++ "BlocksGUI", ++ "BooleanGUI", ++ "BREPExport", ++ "BREPImport", ++ "BuildGUI", ++ "DisplayGUI", ++ "DlgRef", ++ "EntityGUI", ++ "GenerationGUI", ++ "GEOMAlgo", ++ "GEOMArchimede", ++ "GEOMBase", ++ "GEOMbasic", ++ "GEOMClient", ++ "GEOMEngine", ++ "GEOMFiltersSelection", ++ "GEOMimpl", ++ "GEOMObject", ++ "GEOMSketcher", ++ "GEOM", ++ "GEOM_SupervEngine", ++ "GEOMToolsGUI", ++ "GroupGUI", ++ "IGESExport", ++ "IGESImport", ++ "MeasureGUI", ++ "NMTDS", ++ "NMTTools", ++ "OCC2VTK", ++ "OperationGUI", ++ "PrimitiveGUI", ++ "RepairGUI", ++ "SalomeIDLGEOM", ++ "ShHealOper", ++ "STEPExport", ++ "STEPImport", ++ "STLExport", ++ "TransformationGUI", ++ "VTKExport", ++ ] ++ med_list = [ ++ "interpkernel", ++ "InterpKernelTest", ++ "MEDClientcmodule", ++ "medcouplingclient", ++ "medcouplingcorba", ++ "medcouplingremapper", ++ "medcoupling", ++ "MEDEngine", ++ "medloader", ++ "MEDMEMCppTest", ++ "MEDMEMImpl", ++ "medmem", ++ "MED", ++ "medsplitter", ++ "MEDSPLITTERTest", ++ "med_V2_1", ++ "MEDWrapperBase", ++ "MEDWrapper", ++ "MEDWrapper_V2_1", ++ "MEDWrapper_V2_2", ++ "paramedcouplingcorba", ++ "paramedloader", ++ "paramedmemcompo", ++ "paramedmem", ++ "ParaMEDMEMTest", ++ "SalomeIDLMED", ++ "SalomeIDLMEDTests", ++ ] ++ smesh_list = [ ++ "GeomSelectionTools", ++ "MEFISTO2D", ++ "MeshDriverDAT", ++ "MeshDriverMED", ++ "MeshDriver", ++ "MeshDriverSTL", ++ "MeshDriverUNV", ++ "SalomeIDLSMESH", ++ "SMDS", ++ "SMESHClient", ++ "SMESHControls", ++ "SMESHDS", ++ "SMESHEngine", ++ "SMESHFiltersSelection", ++ "SMESHimpl", ++ "SMESHObject", ++ "SMESH", ++ "StdMeshersEngine", ++ "StdMeshersGUI", ++ "StdMeshers", ++ ] ++ full_list = cas_list + vtk_list ++ full_list += kernel_list + gui_list ++ full_list += geom_list + med_list + smesh_list ++ # -- ++ # E.A. : sort by len before substitution ... ++ # Why ? Thing to "-lMEDWrapper" then "-lMEDWrapper_V2_1" substition ++ # And you understand ... ++ # -- ++ full_list.sort(cmp = lambda x, y : cmp(len(y), len(x))) ++ # -- ++ for key in full_list: ++ content = content.replace("-l%s"%(key), "${%s}"%(key)) ++ pass ++ ++ # -- ++ # Split content in lines to treat each one separately ++ # -- ++ lines = content.split('\n') ++ ++ # -- ++ # newlines contains the lines of the future CMakeLists.txt file ++ # -- ++ newlines = [] ++ ++ # -- ++ # opened_ifs is used to deals with nested conditionnals ++ # -- ++ opened_ifs = [] ++ ++ # -- ++ # the __thedict__ dictionnary contains key, val ++ # of the Makefile.am file ++ # -- ++ self.__thedict__ = {} ++ ++ # -- ++ # Initialize file ... mainly includes other cmake files ++ # -- ++ self.initialize(newlines) ++ ++ # -- ++ # Do the job for each line ++ # -- ++ for line in lines: ++ self.treatLine(line, newlines, opened_ifs) ++ pass ++ ++ # -- ++ # Finalize file ... it is in here the cmake job is done ++ # -- ++ self.finalize(newlines) ++ ++ # -- ++ # Concatenate newlines into content ++ # -- ++ content = '\n'.join(newlines) ++ ++ # -- ++ # Add a CR at end if necessary ++ # -- ++ lines = content.split('\n') ++ # lines = [ l.strip() for l in lines ] ++ if len(lines[-1]) != 0: ++ lines.append('') ++ pass ++ content = '\n'.join(lines) ++ ++ # -- ++ self.content = content ++ ++ # -- ++ return ++ ++ def initialize(self, newlines): ++ if self.root == self.the_root: ++ # -- ++ newlines.append(""" ++ CMAKE_MINIMUM_REQUIRED(VERSION 2.4.7 FATAL_ERROR) ++ IF(COMMAND cmake_policy) ++ cmake_policy(SET CMP0003 NEW) ++ ENDIF(COMMAND cmake_policy) ++ """) ++ # -- ++ newlines.append(""" ++ ENABLE_TESTING() ++ """) ++ # -- ++ newlines.append(""" ++ SET(MODULE %s) ++ """%(self.module.upper())) ++ # -- ++ if self.module == "netgen": ++ newlines.append(""" ++ INCLUDE(${CMAKE_SOURCE_DIR}/cmake/FindPLATFORM.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/cmake/FindCAS.cmake) ++ """) ++ else: ++ if self.module == "kernel": ++ newlines.append(""" ++ INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPYTHON.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindHDF5.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindBOOST.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSWIG.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindMPI.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindLIBBATCH.cmake) ++ """) ++ pass ++ else: ++ if self.module == "med": ++ newlines.append(""" ++ SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR}) ++ IF(KERNEL_ROOT_DIR) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindMPI.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBBATCH.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake) ++ ELSE(KERNEL_ROOT_DIR) ++ INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindPLATFORM.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindMPI.cmake) ++ ENDIF(KERNEL_ROOT_DIR) ++ """) ++ else: ++ newlines.append(""" ++ SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR}) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindMPI.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBBATCH.cmake) ++ INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake) ++ """) ++ pass ++ if self.module == "gui": ++ newlines.append(""" ++ INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCAS.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQT4.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindOPENGL.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindVTK.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQWT.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake) ++ """) ++ else: ++ newlines.append(""" ++ SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR}) ++ IF(GUI_ROOT_DIR) ++ INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindCAS.cmake) ++ INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQT4.cmake) ++ INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindOPENGL.cmake) ++ INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindVTK.cmake) ++ INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQWT.cmake) ++ INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake) ++ INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindGUI.cmake) ++ ENDIF(GUI_ROOT_DIR) ++ """) ++ if self.module == "med": ++ newlines.append(""" ++ INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMEDFILE.cmake) ++ IF(WINDOWS) ++ INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindXDR.cmake) ++ ENDIF(WINDOWS) ++ """) ++ pass ++ if self.module == "smesh": ++ newlines.append(""" ++ SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR}) ++ SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR}) ++ INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake) ++ INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake) ++ INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake) ++ """) ++ pass ++ if self.module == "netgenplugin": ++ newlines.append(""" ++ SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR}) ++ SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR}) ++ SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR}) ++ INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake) ++ INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake) ++ INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindNETGEN.cmake) ++ """) ++ pass ++ if self.module == "blsurfplugin": ++ newlines.append(""" ++ SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR}) ++ SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR}) ++ SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR}) ++ INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake) ++ INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake) ++ INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindBLSURF.cmake) ++ """) ++ pass ++ if self.module in ["ghs3dplugin", "hexoticplugin"]: ++ newlines.append(""" ++ SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR}) ++ SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR}) ++ SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR}) ++ INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake) ++ INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake) ++ INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake) ++ """) ++ pass ++ if self.module == "ghs3dprlplugin": ++ newlines.append(""" ++ SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR}) ++ SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR}) ++ SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR}) ++ INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake) ++ INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake) ++ INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake) ++ INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake) ++ """) ++ pass ++ if self.module == "visu": ++ newlines.append(""" ++ SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR}) ++ INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake) ++ """) ++ pass ++ if self.module == "yacs": ++ newlines.append(""" ++ INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindEXPAT.cmake) ++ INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindGRAPHVIZ.cmake) ++ """) ++ pass ++ if self.module == "hxx2salome": ++ newlines.append(""" ++ SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR}) ++ INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake) ++ INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake) ++ """) ++ pass ++ pass ++ pass ++ pass ++ # -- ++ newlines.append(""" ++ SET(DOXYGEN_IS_OK 0) ++ """) ++ if self.module not in ['med']: ++ newlines.append(""" ++ IF(WINDOWS) ++ SET(CPPUNIT_IS_OK 0) ++ ENDIF(WINDOWS) ++ """) ++ pass ++ # -- ++ if self.module == "kernel": ++ newlines.append(""" ++ SET(WITH_LOCAL 1) ++ SET(WITH_BATCH 1) ++ SET(CALCIUM_IDL_INT_F77 long) ++ SET(CALCIUM_CORBA_INT_F77 CORBA::Long) ++ SET(LONG_OR_INT int) ++ """) ++ elif self.module == "gui": ++ newlines.append(""" ++ SET(GUI_ENABLE_CORBA ${CORBA_GEN}) ++ SET(ENABLE_VTKVIEWER ON) ++ SET(ENABLE_SALOMEOBJECT ON) ++ SET(ENABLE_OCCVIEWER ON) ++ SET(ENABLE_GLVIEWER ON) ++ SET(ENABLE_PLOT2DVIEWER ON) ++ SET(ENABLE_PYCONSOLE ON) ++ SET(ENABLE_SUPERVGRAPHVIEWER ON) ++ SET(ENABLE_QXGRAPHVIEWER ON) ++ """) ++ pass ++ elif self.module == "jobmanager": ++ newlines.append(""" ++ IF(GUI_ROOT_DIR) ++ SET(HAS_GUI ON) ++ ENDIF(GUI_ROOT_DIR) ++ """) ++ pass ++ elif self.module == "geom": ++ newlines.append(""" ++ IF(GUI_ROOT_DIR) ++ SET(GEOM_ENABLE_GUI ON) ++ ENDIF(GUI_ROOT_DIR) ++ """) ++ pass ++ elif self.module == "medfile": ++ newlines.append(""" ++ SET(MED_NUM_MAJEUR 2) ++ SET(MED_NUM_MINEUR 3) ++ SET(MED_NUM_RELEASE 5) ++ SET(LONG_OR_INT int) ++ IF(NOT WINDOWS) ++ SET(FLIBS -lgfortranbegin -lgfortran) ++ ENDIF(NOT WINDOWS) ++ """) ++ pass ++ elif self.module == "med": ++ newlines.append(""" ++ IF(KERNEL_ROOT_DIR) ++ SET(MED_ENABLE_KERNEL ON) ++ IF(NOT WINDOWS) ++ SET(MED_ENABLE_SPLITTER ON) ++ ENDIF(NOT WINDOWS) ++ ENDIF(KERNEL_ROOT_DIR) ++ IF(GUI_ROOT_DIR) ++ SET(MED_ENABLE_GUI ON) ++ ENDIF(GUI_ROOT_DIR) ++ """) ++ pass ++ elif self.module == "smesh": ++ newlines.append(""" ++ IF(GUI_ROOT_DIR) ++ SET(SMESH_ENABLE_GUI ON) ++ ENDIF(GUI_ROOT_DIR) ++ """) ++ pass ++ elif self.module == "netgen": ++ newlines.append(""" ++ SET(OCCFLAGS ${CAS_CPPFLAGS}) ++ SET(OCCLIBS ${CAS_LDPATH}) ++ SET(OCCLIBS ${OCCLIBS} ${TKernel} ${TKGeomBase} ${TKMath} ${TKG2d} ${TKG3d} ${TKXSBase} ${TKOffset} ${TKFillet} ${TKShHealing}) ++ SET(OCCLIBS ${OCCLIBS} ${TKMesh} ${TKMeshVS} ${TKTopAlgo} ${TKGeomAlgo} ${TKBool} ${TKPrim} ${TKBO} ${TKIGES} ${TKBRep}) ++ SET(OCCLIBS ${OCCLIBS} ${TKSTEPBase} ${TKSTEP} ${TKSTL} ${TKSTEPAttr} ${TKSTEP209} ${TKXDESTEP} ${TKXDEIGES} ${TKXCAF} ${TKLCAF} ${FWOSPlugin}) ++ """) ++ pass ++ elif self.module == "netgenplugin": ++ newlines.append(""" ++ IF(GUI_ROOT_DIR) ++ SET(NETGENPLUGIN_ENABLE_GUI ON) ++ ENDIF(GUI_ROOT_DIR) ++ """) ++ pass ++ elif self.module == "blsurfplugin": ++ newlines.append(""" ++ IF(GUI_ROOT_DIR) ++ SET(BLSURFPLUGIN_ENABLE_GUI ON) ++ ENDIF(GUI_ROOT_DIR) ++ """) ++ pass ++ elif self.module == "ghs3dplugin": ++ newlines.append(""" ++ IF(GUI_ROOT_DIR) ++ SET(GHS3DPLUGIN_ENABLE_GUI ON) ++ ENDIF(GUI_ROOT_DIR) ++ """) ++ pass ++ elif self.module == "hexoticplugin": ++ newlines.append(""" ++ IF(GUI_ROOT_DIR) ++ SET(HEXOTICPLUGIN_ENABLE_GUI ON) ++ ENDIF(GUI_ROOT_DIR) ++ """) ++ pass ++ elif self.module == "ghs3dprlplugin": ++ newlines.append(""" ++ IF(GUI_ROOT_DIR) ++ SET(GHS3DPRLPLUGIN_ENABLE_GUI ON) ++ ENDIF(GUI_ROOT_DIR) ++ """) ++ pass ++ elif self.module == "yacs": ++ newlines.append(""" ++ SET(SALOME_KERNEL ON) ++ SET(HAS_GUI ON) ++ SET(WITH_QT4 ON) ++ """) ++ pass ++ # -- ++ newlines.append(""" ++ set(VERSION 6.3.0) ++ set(XVERSION 0x060300) ++ """) ++ pass ++ # -- ++ newlines.append(""" ++ SET(VERSION_INFO 0.0.0) ++ SET(SOVERSION_INFO 0) ++ SET(SUBDIRS) ++ SET(AM_CPPFLAGS) ++ SET(AM_CXXFLAGS) ++ SET(LDADD) ++ SET(pythondir lib/python${PYTHON_VERSION}/site-packages) ++ SET(salomepythondir ${pythondir}/salome) ++ SET(salomepypkgdir ${salomepythondir}/salome) ++ """) ++ if self.module == "netgen": ++ newlines.append(r''' ++ SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DNO_PARALLEL_THREADS -DOCCGEOMETRY -I${CMAKE_BINARY_DIR} -I${CMAKE_CURRENT_SOURCE_DIR}) ++ ''') ++ elif self.module == "kernel": ++ newlines.append(r''' ++ SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h) ++ SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h) ++ ''') ++ else: ++ if self.module not in ["yacs"]: ++ newlines.append(r''' ++ IF(KERNEL_ROOT_DIR) ++ SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h) ++ SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h) ++ ENDIF(KERNEL_ROOT_DIR) ++ ''') ++ pass ++ if self.module == "gui": ++ newlines.append(r''' ++ IF(KERNEL_ROOT_DIR) ++ SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SALOMEDS_OBSERVER) ++ SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SALOMEDS_OBSERVER) ++ ENDIF(KERNEL_ROOT_DIR) ++ ''') ++ pass ++ if self.module in ["smesh", "netgenplugin", "blsurfplugin", "ghs3dplugin"]: ++ newlines.append(r''' ++ SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SMESH_CANCEL_COMPUTE) ++ SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SMESH_CANCEL_COMPUTE) ++ ''') ++ pass ++ if self.module == "hxx2salome": ++ key = "_SRC" ++ if self.the_root[-len(key):] != key: ++ msg = "Source dir must finished with %s !"%(key) ++ raise Exception(msg) ++ hxxmodule = self.the_root[:-len(key)] ++ from os.path import basename ++ hxxmodule = basename(hxxmodule) ++ hxxmodule = hxxmodule.lower() ++ self.hxxmodule = hxxmodule ++ newlines.append(r''' ++ SET(HXXCPP_ROOT_DIR $ENV{%sCPP_ROOT_DIR}) ++ SET(AM_CPPFLAGS ${AM_CPPFLAGS} -I${HXXCPP_ROOT_DIR}/include) ++ SET(AM_CXXFLAGS ${AM_CXXFLAGS} -I${HXXCPP_ROOT_DIR}/include) ++ SET(LDADD ${LDADD} -L${HXXCPP_ROOT_DIR}/lib) ++ '''%(hxxmodule.upper())) ++ pass ++ pass ++ # -- ++ return ++ ++ def treatLine(self, line, newlines, opened_ifs): ++ ++ # -- ++ # Print the comment above the line itself ++ # -- ++ if line.find('#') >= 0: ++ fields = line.split('#') ++ line = fields[0] ++ comment = '#'.join([''] + fields[1:]) ++ newlines.append(comment) ++ if len(line) == 0: ++ return ++ pass ++ ++ # -- ++ # If the line begins with 'include ', just comment it ++ # -- ++ if line.find("include ") == 0: ++ newlines.append("# " + line) ++ return ++ ++ # -- ++ # If the line begins with '-include', just comment it ++ # -- ++ if line.find("-include") == 0: ++ newlines.append("# " + line) ++ return ++ ++ # -- ++ # If the line is a definition of a make rule, just comment it ++ # -- ++ if line.count(':') == 1: ++ newlines.append("# " + line) ++ return ++ ++ # -- ++ # A particuliar case where there are two ":" on the same line ++ # -- ++ if line.find('install-exec-local:') == 0: ++ newlines.append("# " + line) ++ return ++ ++ # -- ++ # If the line begin by a tabulation, consider it's a makefile command and comment it ++ # -- ++ if line.find("\t") == 0: ++ newlines.append("# " + line) ++ return ++ ++ # -- ++ # -- ++ key = "-version-info" ++ if line.find(key) >= 0: ++ # -- ++ before = line.split(key)[0] ++ after = line[len(before)+len(key):] ++ sep = after[0] ++ after = after[1:] ++ version_info = after.split()[0] ++ line = line.replace(key+sep+version_info, "") ++ # -- ++ version_info = version_info.replace(':', '.') ++ soversion_info = version_info.split('.')[0] ++ newlines.append("SET(VERSION_INFO " + version_info + ")") ++ newlines.append("SET(SOVERSION_INFO " + soversion_info + ")") ++ # -- ++ pass ++ ++ # -- ++ # Replace the $(TOTO) by ${TOTO} ++ # Replace the @TOTO@ by ${TOTO} ++ # -- ++ line = p_dollar.sub(r"${\1}", line) ++ line = p_arobas.sub(r"${\1}", line) ++ ++ # -- ++ line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}") ++ line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}") ++ line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}") ++ line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}") ++ line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share") ++ ++ # -- ++ # Check if the line is a 'if' condition ++ # If yes, replace it by a cmake grammar ++ # -- ++ match = p_if.match(line) ++ if match: ++ theif = match.group("val") ++ if theif[0] == "!": ++ theif = "NOT " + theif[1:] ++ pass ++ line = p_if.sub(r"IF(%s)"%(theif), line) ++ opened_ifs.append(theif) ++ newlines.append(line) ++ return ++ ++ # -- ++ # Check if the line is a 'else' condition ++ # If yes, replace it by a cmake grammar ++ # -- ++ match = p_else.match(line) ++ if match: ++ line = "ELSE(%s)"%(opened_ifs[-1]) ++ newlines.append(line) ++ return ++ ++ # -- ++ # Check if the line is a 'endif' condition ++ # If yes, replace it by a cmake grammar ++ # -- ++ match = p_endif.match(line) ++ if match: ++ line = "ENDIF(%s)"%(opened_ifs[-1]) ++ opened_ifs[-1:] = [] ++ newlines.append(line) ++ return ++ ++ # -- ++ # Check if the line is an attribution '=' or '+=' ++ # -- ++ match = p_attribution.match(line) ++ if match: ++ self.treatAttribution(match, newlines) ++ return ++ ++ # -- ++ newlines.append(line) ++ ++ # -- ++ return ++ ++ def treatAttribution(self, match, newlines): ++ ++ spaces = match.group("spaces") ++ key = match.group("key") ++ method = match.group("method") ++ value = match.group("value") ++ # print [spaces, key, method, value] ++ ++ # -- ++ # Open cmake SET command ++ # -- ++ newlines.append(spaces + "SET(" + key) ++ ++ # -- ++ # If method is '+=', put the previous definition as first value ++ # -- ++ if method == "+=": ++ newlines.append("%s ${%s}"%(spaces, key)) ++ pass ++ ++ # -- ++ fields = value.split() ++ for i in range(len(fields)): ++ newlines.append("%s %s"%(spaces, fields[i])) ++ pass ++ ++ # -- ++ if method == "+=": ++ # -- ++ # The try: except KeyError is here if the += ++ # is an error which occurs in salome ... ++ # -- ++ try: ++ self.__thedict__[key] += fields[:] ++ except KeyError: ++ self.__thedict__[key] = fields[:] ++ pass ++ pass ++ else: ++ self.__thedict__[key] = fields[:] ++ pass ++ ++ # -- ++ # Close cmake SET command ++ # -- ++ ++ newlines.append("%s)"%(spaces)) ++ ++ return ++ ++ def finalize(self, newlines): ++ ++ # -- ++ # Convert the .in files in build dir ++ # -- ++ ++ import operator ++ mod = self.module ++ if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'): ++ newlines.append(r''' ++ SET(top_builddir ++ ${CMAKE_BINARY_DIR} ++ ) ++ SET(top_srcdir ++ ${CMAKE_SOURCE_DIR} ++ ) ++ SET(srcdir ++ ${CMAKE_CURRENT_SOURCE_DIR} ++ ) ++ SET(builddir ++ ${CMAKE_CURRENT_BINARY_DIR} ++ ) ++ SET(datadir ++ ${CMAKE_INSTALL_PREFIX}/share ++ ) ++ SET(docdir ++ ${datadir}/doc/salome ++ ) ++ ''') ++ self.files.append("static/header.html.in") ++ elif self.root[-len(mod):] == mod.upper() and operator.contains(self.root, 'doc') or mod in ['kernel', 'gui', 'geom', 'med', 'smesh', 'visu'] and self.root[-len('tui'):] == 'tui': ++ newlines.append(r''' ++ SET(top_builddir ++ ${CMAKE_BINARY_DIR} ++ ) ++ SET(top_srcdir ++ ${CMAKE_SOURCE_DIR} ++ ) ++ SET(srcdir ++ ${CMAKE_CURRENT_SOURCE_DIR} ++ ) ++ SET(builddir ++ ${CMAKE_CURRENT_BINARY_DIR} ++ ) ++ SET(datadir ++ ${CMAKE_INSTALL_PREFIX}/share ++ ) ++ SET(docdir ++ ${datadir}/doc/salome ++ ) ++ ''') ++ self.files.append("static/header.html.in") ++ if self.module == "yacs": ++ key = "salomegui" ++ if self.root[-len(key):] == key: ++ self.files.append("resources/YACSCatalog.xml.in") ++ pass ++ pass ++ for f in self.files: ++ if f[-3:] == ".in": ++ if self.module == 'yacs' and f == "Doxyfile.in": ++ continue ++ if f == "sstream.in": ++ continue ++ if f in ["runContainer.in", "stopContainer.in"]: ++ if self.module == "med": ++ if self.root[-3:] == "csh": ++ continue ++ pass ++ pass ++ if f == "SALOMEconfig.ref.in": ++ out = "SALOMEconfig.h" ++ else: ++ out = f[:-3] ++ pass ++ newlines.append(r''' ++ SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s) ++ '''%(f)) ++ newlines.append(r''' ++ SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s) ++ '''%(out)) ++ newlines.append(r''' ++ MESSAGE(STATUS "Creation of ${output}") ++ CONFIGURE_FILE(${input} ${output}) ++ ''') ++ pass ++ pass ++ ++ # -- ++ # add commands for generating of user's documentation ++ # -- ++ ++ upmod = self.module.upper() ++ doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/gui/%s"%(upmod) ++ doc_tui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s"%(upmod) ++ doc_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome" ++ head_source = "${CMAKE_CURRENT_SOURCE_DIR}/images/head.png" ++ if mod == 'kernel': ++ copytree_src = "${CMAKE_SOURCE_DIR}/salome_adm/cmake_files" ++ else: ++ copytree_src = "$ENV{KERNEL_ROOT_DIR}/salome_adm/cmake_files" ++ str = "import re \nimport sys \noutfile = open(sys.argv[1], 'wb') \nfor line in open(sys.argv[2], 'rb').readlines():" ++ str += "\n if re.match('class '+sys.argv[3]+'DC', line): \n continue \n line = re.sub(r'^\s+\#', '#', line) \n line = re.sub(r'^\s+def', 'def', line) \n line = re.sub(sys.argv[3]+'DC', sys.argv[3], line)" ++ str += "\n outfile.write(line) \noutfile.close()" ++ ++ if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'): ++ if mod == 'med': ++ doc_source = "${CMAKE_CURRENT_BINARY_DIR}/doc_ref_user/html" ++ input = "Doxyfile_med_user" ++ else: ++ doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod) ++ input = "" ++ newlines.append("""\t ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} %s ++ COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''', True); import copytree1; copytree1.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s''')" ++ VERBATIM ++ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ++ )"""%(input, copytree_src, doc_gui_destination, doc_source, doc_gui_destination, head_source, doc_gui_destination)) ++ ++ if mod in ['geom', 'smesh', 'visu'] and self.root[-len(mod):] == upmod and operator.contains(self.root, 'doc'): ++ ign = r"""'tempfile', '*usr_docs*', '*CMakeFiles*', '*.cmake', 'doxyfile*', '*.vcproj', 'static', 'Makefile*'""" ++ if mod in ['geom', 'smesh']: ++ if mod == 'geom': ++ tmp = 'geompy' ++ input = "COMMAND ${DOXYGEN_EXECUTABLE} doxyfile_tui \n\t\t" ++ else: ++ tmp = 'smesh' ++ input = '' ++ newlines.append(r""" ++ FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/tempfile "%s") ++ ADD_CUSTOM_TARGET(usr_docs ${PYTHON_EXECUTABLE} tempfile ${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%sDC.py %s ++ %sCOMMAND ${DOXYGEN_EXECUTABLE} doxyfile_py ++ COMMAND ${DOXYGEN_EXECUTABLE} doxyfile ++ COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py''')" ++ COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''', True); import copytree1; copytree1.copytree(r'''${CMAKE_CURRENT_BINARY_DIR}''', r'''%s''', ignore=copytree1.ignore_patterns(%s)); shutil.copy(r'''%s''', r'''%s''')" ++ VERBATIM ++ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ++ )"""%(str, upmod, tmp, upmod, tmp, tmp, input, upmod, tmp, copytree_src, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination)) ++ else: ++ newlines.append("""\t ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} doxyfile_idl ++ COMMAND ${DOXYGEN_EXECUTABLE} doxyfile ++ COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''',True); import copytree1; copytree1.copytree(r'''${CMAKE_CURRENT_BINARY_DIR}''',r'''%s''', ignore=copytree1.ignore_patterns(%s)); shutil.copy(r'''%s''',r'''%s''')" ++ VERBATIM ++ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ++ )"""%(copytree_src, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination)) ++ ++ # -- ++ # add commands for generating of developer's documentation ++ # -- ++ ++ upmod = self.module.upper() ++ if mod in ['kernel', 'gui', 'med', 'smesh', 'visu'] and self.root[-len('tui'):] == 'tui': ++ if mod == 'kernel': ++ tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE} -u ++ COMMAND ${DOXYGEN_EXECUTABLE} ++ COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_CURRENT_BINARY_DIR}/doxyfile.bak''')" """ ++ tmp1="" ++ else: ++ tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE}""" ++ if mod == 'visu': ++ tmp1= r"""\n COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/visuscreen.png''', r'''%s''')" """%(doc_tui_destination) ++ elif mod == 'smesh': ++ extra_srcdir = "${CMAKE_CURRENT_SOURCE_DIR}/extra" ++ tmp1= """\n COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/smeshscreen.png''', r'''%s'''); copy(r'''%s/AddNetgenInSalome2.pdf''', r'''%s'''); copy(r'''%s/PluginMeshers.html''', r'''%s''')" ++ COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''%s/AddNetgenInSalome2.ps''', r'''%s'''); copy(r'''%s/AddNetgenInSalome2.sxw''', r'''%s''')" """%(doc_tui_destination, extra_srcdir,doc_destination, extra_srcdir,doc_destination, extra_srcdir,doc_destination,extra_srcdir,doc_destination) ++ else: ++ tmp1="" ++ doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod) ++ newlines.append(tmp + """ ++ COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''', True); import copytree1; copytree1.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s''')" """%(copytree_src, doc_tui_destination, doc_source, doc_tui_destination, head_source, doc_tui_destination) + tmp1 + """ ++ VERBATIM ++ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ++ )""") ++ if mod == 'geom' and self.root[-len('tui'):] == 'tui': ++ tmp = 'geompy' ++ doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod) ++ newlines.append(r""" ++ FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/tempfile "%s") ++ ADD_CUSTOM_TARGET(dev_docs ${PYTHON_EXECUTABLE} tempfile ${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%sDC.py %s ++ COMMAND ${DOXYGEN_EXECUTABLE} doxyfile ++ COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py''')" ++ COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''', True); import copytree1; copytree1.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s'''); shutil.copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/geomscreen.png''', r'''%s''')" ++ VERBATIM ++ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ++ )"""%(str, upmod, tmp, upmod, tmp, tmp, upmod, tmp, copytree_src, doc_tui_destination, doc_source, doc_tui_destination, head_source, doc_tui_destination, doc_tui_destination)) ++ ++ # -- ++ # convert the SUBDIRS in cmake grammar ++ # -- ++ if 1: # self.__thedict__.has_key("SUBDIRS"): ++ newlines.append(r''' ++ FOREACH(dir ${SUBDIRS}) ++ IF(NOT dir STREQUAL .) ++ ADD_SUBDIRECTORY(${dir}) ++ ENDIF(NOT dir STREQUAL .) ++ ENDFOREACH(dir ${SUBDIRS}) ++ ''') ++ pass ++ ++ # -- ++ # -- ++ for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES"]: ++ if self.__thedict__.has_key(key): ++ self.addLibTarget(key, newlines) ++ pass ++ pass ++ ++ # -- ++ # -- ++ for key in ["bin_PROGRAMS", "check_PROGRAMS"]: ++ if self.__thedict__.has_key(key): ++ self.addBinTarget(key, newlines) ++ pass ++ pass ++ ++ # -- ++ # -- ++ if self.__thedict__.has_key("BASEIDL_FILES"): ++ if not self.__thedict__.has_key("IDL_FILES"): ++ self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"] ++ newlines.append(''' ++ SET(IDL_FILES ${BASEIDL_FILES}) ++ ''') ++ pass ++ pass ++ ++ # -- ++ # -- ++ ++ key = "IDL_FILES" ++ if self.__thedict__.has_key(key): ++ if self.module == "kernel": ++ newlines.append(''' ++ SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl) ++ ''') ++ pass ++ newlines.append(''' ++ FOREACH(input ${IDL_FILES}) ++ STRING(REGEX REPLACE ".idl" "" base ${input}) ++ SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc) ++ SET(outputs ${src}) ++ SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc) ++ SET(outputs ${outputs} ${dynsrc}) ++ SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh) ++ SET(outputs ${outputs} ${inc}) ++ IF(input STREQUAL Calcium_Ports.idl) ++ SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input}) ++ ELSE(input STREQUAL Calcium_Ports.idl) ++ SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input}) ++ ENDIF(input STREQUAL Calcium_Ports.idl) ++ SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS}) ++ STRING(REGEX MATCH "-bcxx" ISBCXX ${flags}) ++ IF(NOT ISBCXX) ++ SET(flags -bcxx ${flags}) ++ ENDIF(NOT ISBCXX) ++ ADD_CUSTOM_COMMAND( ++ OUTPUT ${outputs} ++ COMMAND ${OMNIORB_IDL} ${flags} ${input} ++ MAIN_DEPENDENCY ${input} ++ ) ++ ''') ++ newlines.append(''' ++ install(FILES ${input} DESTINATION idl/salome) ++ ''') ++ if self.module not in ["pyhello"]: ++ newlines.append(''' ++ SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh) ++ install(FILES ${IDL_HEADER} DESTINATION include/salome) ++ ''') ++ pass ++ newlines.append(''' ++ INSTALL(CODE "SET(IDL_FILE ${input})") ++ INSTALL(CODE "SET(DIR ${salomepythondir})") ++ IF(WINDOWS) ++ INSTALL(CODE "SET(DIR bin/salome)") ++ ENDIF(WINDOWS) ++ INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})") ++ INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})") ++ # -- ++ SET(flags) ++ FOREACH(f ${IDLPYFLAGS}) ++ SET(flags "${flags} ${f}") ++ ENDFOREACH(f ${IDLPYFLAGS}) ++ STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags}) ++ IF(NOT ISBPYTHON) ++ SET(flags "-bpython ${flags}") ++ ENDIF(NOT ISBPYTHON) ++ SET(IDLPYFLAGS ${flags}) ++ STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS}) ++ INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})") ++ # -- ++ ''') ++ if self.module == "kernel": ++ newlines.append(''' ++ INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake) ++ ''') ++ else: ++ newlines.append(''' ++ STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR}) ++ INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake) ++ ''') ++ pass ++ newlines.append(''' ++ ENDFOREACH(input ${IDL_FILES}) ++ ''') ++ pass ++ ++ # -- ++ # -- ++ for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]: ++ if self.__thedict__.has_key(key): ++ newlines.append(''' ++ SET(SWIG_SOURCES ${%s}) ++ '''%(key)) ++ self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key] ++ pass ++ pass ++ ++ # -- ++ # -- ++ if self.__thedict__.has_key("SWIG_SOURCES"): ++ newlines.append(''' ++ IF(SWIG_SOURCES MATCHES ";") ++ STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}") ++ ELSE(SWIG_SOURCES MATCHES ";") ++ SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}") ++ ENDIF(SWIG_SOURCES MATCHES ";") ++ SET(flags) ++ FOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS}) ++ SET(test ON) ++ IF(flags) ++ LIST(FIND flags ${f} index) ++ IF(NOT index EQUAL -1) ++ SET(test OFF) ++ ENDIF(NOT index EQUAL -1) ++ ENDIF(flags) ++ IF(test) ++ SET(flags ${flags} ${f}) ++ ENDIF(test) ++ ENDFOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS}) ++ ADD_CUSTOM_COMMAND( ++ OUTPUT ${build_srcs} ++ COMMAND ${SWIG_EXECUTABLE} ${flags} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST} ++ MAIN_DEPENDENCY ${SWIG_SOURCES} ++ ) ++ ''') ++ pass ++ ++ # -- ++ # -- ++ if self.__thedict__.has_key("BUILT_SOURCES"): ++ newlines.append(''' ++ FOREACH(f ${BUILT_SOURCES}) ++ IF(f MATCHES "WRAP.cxx$") ++ # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f}) ++ STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f}) ++ ADD_CUSTOM_COMMAND( ++ OUTPUT ${f} # ${inc} ++ COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input} ++ MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input} ++ ) ++ ENDIF(f MATCHES "WRAP.cxx$") ++ ENDFOREACH(f ${BUILT_SOURCES}) ++ ''') ++ pass ++ ++ # -- ++ # -- ++ key = "MOC_FILES" ++ if self.__thedict__.has_key(key): ++ newlines.append(''' ++ FOREACH(output ${MOC_FILES}) ++ ''') ++ if self.module in ["jobmanager", "yacs"]: ++ newlines.append(''' ++ STRING(REGEX REPLACE _moc.cxx .hxx input ${output}) ++ ''') ++ else: ++ newlines.append(''' ++ STRING(REGEX REPLACE _moc.cxx .h input ${output}) ++ ''') ++ pass ++ newlines.append(''' ++ SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input}) ++ SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output}) ++ ADD_CUSTOM_COMMAND( ++ OUTPUT ${output} ++ COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output} ++ MAIN_DEPENDENCY ${input} ++ ) ++ ENDFOREACH(output ${MOC_FILES}) ++ ''') ++ pass ++ ++ # -- ++ # -- ++ key = "UIC_FILES" ++ if self.__thedict__.has_key(key): ++ newlines.append(''' ++ FOREACH(output ${UIC_FILES}) ++ STRING(REPLACE "ui_" "" input ${output}) ++ STRING(REPLACE ".h" ".ui" input ${input}) ++ SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input}) ++ SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output}) ++ ADD_CUSTOM_COMMAND( ++ OUTPUT ${output} ++ COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input} ++ MAIN_DEPENDENCY ${input} ++ ) ++ ENDFOREACH(output ${UIC_FILES}) ++ ''') ++ pass ++ ++ # -- ++ # -- ++ key = "QRC_FILES" ++ if self.__thedict__.has_key(key): ++ newlines.append(''' ++ FOREACH(output ${QRC_FILES}) ++ STRING(REGEX REPLACE "qrc_" "" input ${output}) ++ STRING(REGEX REPLACE ".cxx" ".qrc" input ${input}) ++ STRING(REGEX REPLACE ".qrc" "" name ${input}) ++ SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input}) ++ SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output}) ++ ADD_CUSTOM_COMMAND( ++ OUTPUT ${output} ++ COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name} ++ MAIN_DEPENDENCY ${input} ++ ) ++ ENDFOREACH(output ${QRC_FILES}) ++ ''') ++ pass ++ ++ # -- ++ # -- ++ key = "SIP_FILES" ++ if self.__thedict__.has_key(key): ++ newlines.append(''' ++ FOREACH(input ${SIP_FILES}) ++ SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input}) ++ SET(output) ++ FOREACH(out ${SIP_SRC}) ++ SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out}) ++ ENDFOREACH(out ${SIP_SRC}) ++ ADD_CUSTOM_COMMAND( ++ OUTPUT ${output} ++ COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input} ++ MAIN_DEPENDENCY ${input} ++ ) ++ ENDFOREACH(input ${SIP_FILES}) ++ ''') ++ pass ++ ++ # -- ++ # For make check ++ # -- ++ for key in ["TESTS"]: ++ if self.__thedict__.has_key(key): ++ newlines.append(''' ++ SET(UNIT_TEST_PROG ${%s}) ++ '''%(key)) ++ self.__thedict__["UNIT_TEST_PROG"] = self.__thedict__[key] ++ pass ++ pass ++ key = "UNIT_TEST_PROG" ++ if self.__thedict__.has_key(key): ++ newlines.append(''' ++ FOREACH(input ${UNIT_TEST_PROG}) ++ GET_FILENAME_COMPONENT(ext ${input} EXT) ++ IF(ext STREQUAL .py) ++ SET(test ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${input}) ++ ELSE(ext STREQUAL .py) ++ IF(WINDOWS) ++ SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe.exe) ++ ELSE() ++ SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe) ++ ENDIF() ++ ENDIF(ext STREQUAL .py) ++ ADD_TEST(${input} ${test}) ++ SET(fail_regex "KO") ++ SET_PROPERTY(TEST ${input} PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}") ++ # IF(NOT WINDOWS) ++ # ADD_TEST(${input}_valgrind valgrind ${test}) ++ # SET_PROPERTY(TEST ${input}_valgrind PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}") ++ # SET_PROPERTY(TEST ${input}_valgrind PROPERTY PASS_REGULAR_EXPRESSION "no leaks are possible") ++ # ENDIF() ++ ENDFOREACH(input ${UNIT_TEST_PROG}) ++ ''') ++ pass ++ ++ # -- ++ # Treat the install targets ++ # -- ++ resdir = self.module ++ if resdir == "hxx2salome": ++ resdir = self.hxxmodule ++ pass ++ d = { ++ "salomeadmux_DATA" : "salome_adm/unix", ++ "dist_salomeadmux_DATA" : "salome_adm/unix", ++ "dist_salome_cmake_DATA" : "salome_adm/cmake_files", ++ "dist_salomem4_DATA" : "salome_adm/unix/config_files", ++ "dist_salome4depr_DATA" : "salome_adm/unix/config_files/DEPRECATED", ++ "dist_admlocalm4_DATA" : "adm_local/unix/config_files", ++ "dist_admlocal_cmake_DATA" : "adm_local/cmake_files", ++ "salomeinclude_DATA" : "include/salome", ++ "salomeinclude_HEADERS" : "include/salome", ++ "nodist_salomeinclude_HEADERS" : "include/salome", ++ "dist_salomeres_DATA" : "share/salome/resources/%s"%(resdir), ++ "nodist_salomeres_DATA" : "share/salome/resources/%s"%(resdir), ++ "nodist_salomeres_SCRIPTS" : "share/salome/resources/%s"%(resdir), ++ "dist_salomescript_SCRIPTS" : "bin/salome", ++ "dist_salomescript_DATA" : "bin/salome", ++ "dist_salomescript_PYTHON" : "bin/salome", ++ "nodist_salomescript_DATA" : "bin/salome", ++ "salomepython_PYTHON" : "${salomepythondir}", ++ "nodist_salomepython_PYTHON" : "${salomepythondir}", ++ "dist_salomepython_DATA" : "${salomepythondir}", ++ "sharedpkgpython_PYTHON" : "${salomepythondir}/shared_modules", ++ "salomepypkg_PYTHON" : "${salomepypkgdir}", ++ "mypkgpython_PYTHON" : "${mypkgpythondir}", ++ } ++ if self.module == "jobmanager": ++ d["bin_SCRIPTS"] = "bin" ++ pass ++ if self.module == "medfile": ++ d = { ++ "include_HEADERS" : "include", ++ "nodist_include_HEADERS" : "include", ++ "bin_SCRIPTS" : "bin", ++ "doc_DATA" : "${docdir}", ++ } ++ pass ++ if self.module == "netgen": ++ d = { ++ "include_HEADERS" : "include", ++ "noinst_HEADERS" : "share/netgen/include", ++ "dist_pkgdata_DATA" : "share/netgen", ++ "dist_doc_DATA" : "share/doc/netgen", ++ } ++ pass ++ for key, value in d.items(): ++ if self.__thedict__.has_key(key): ++ self.addInstallTarget(key, value, newlines) ++ pass ++ pass ++ ++ # -- ++ return ++ ++ def setLibAdd(self, key, newlines): ++ # -- ++ newlines.append(r''' ++ SET(libadd) ++ ''') ++ # -- ++ newlines.append(r''' ++ IF(WINDOWS) ++ SET(targets) ++ SET(targets ${targets} MEFISTO2D) ++ FOREACH(target ${targets}) ++ IF(name STREQUAL ${target}) ++ SET(dir $ENV{F2CHOME}) ++ STRING(REPLACE "\\\\" "/" dir ${dir}) ++ SET(libadd ${libadd} ${dir}/LIBF77.lib) ++ SET(libadd ${libadd} ${dir}/LIBI77.lib) ++ ENDIF(name STREQUAL ${target}) ++ ENDFOREACH(target ${targets}) ++ ENDIF(WINDOWS) ++ ''') ++ # -- ++ newlines.append(r''' ++ SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${LDADD} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS}) ++ FOREACH(lib SALOMEBasics SalomeBatch) ++ IF(name STREQUAL lib) ++ SET(libs ${libs} ${PTHREAD_LIBS}) ++ ENDIF(name STREQUAL lib) ++ ENDFOREACH(lib SALOMEBasics SalomeBatch) ++ ''') ++ # -- ++ newlines.append(r''' ++ FOREACH(lib ${libs}) ++ GET_FILENAME_COMPONENT(ext ${lib} EXT) ++ IF(ext STREQUAL .la) ++ GET_FILENAME_COMPONENT(lib ${lib} NAME_WE) ++ STRING(REGEX REPLACE "^lib" "" lib ${lib}) ++ ENDIF(ext STREQUAL .la) ++ SET(vars) ++ SET(vars ${vars} -no-undefined) ++ SET(vars ${vars} -lvtkWidgets) ++ IF(WINDOWS) ++ SET(vars ${vars} -module) ++ SET(vars ${vars} -Wl,-E) ++ SET(vars ${vars} -Xlinker) ++ SET(vars ${vars} -export-dynamic) ++ SET(vars ${vars} -lm) ++ SET(vars ${vars} -lboost_thread) ++ SET(vars ${vars} -lboost_signals) ++ SET(vars ${vars} -pthread -lpthread -ldl) ++ ENDIF(WINDOWS) ++ FOREACH(v ${vars}) ++ IF(lib STREQUAL v) ++ SET(lib) ++ ENDIF(lib STREQUAL v) ++ ENDFOREACH(v ${vars}) ++ SET(test OFF) ++ IF(lib) ++ STRING(REGEX MATCH "^-lQt" test ${lib}) ++ ENDIF(lib) ++ IF(NOT test) ++ SET(libadd ${libadd} ${lib}) ++ ENDIF(NOT test) ++ ENDFOREACH(lib ${libs}) ++ TARGET_LINK_LIBRARIES(${name} ${libadd}) ++ ''') ++ # -- ++ newlines.append(r''' ++ IF(WINDOWS) ++ SET(targets) ++ SET(targets ${targets} MEFISTO2D) ++ FOREACH(target ${targets}) ++ IF(name STREQUAL ${target}) ++ IF(CMAKE_BUILD_TYPE STREQUAL Debug) ++ SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT") ++ ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug) ++ ENDIF(name STREQUAL ${target}) ++ ENDFOREACH(target ${targets}) ++ ENDIF(WINDOWS) ++ ''') ++ # -- ++ return ++ ++ def setCompilationFlags(self, key, newlines): ++ newlines.append(r''' ++ SET(var) ++ IF(WINDOWS) ++ SET(targets) ++ SET(targets ${targets} SalomeIDLKernel) ++ SET(targets ${targets} SalomeDS) ++ SET(targets ${targets} SALOMEDSTest) ++ SET(targets ${targets} SALOMEDS_Client_exe) ++ SET(targets ${targets} SalomeIDLGEOM) ++ SET(targets ${targets} GEOMEngine) ++ SET(targets ${targets} MEDEngine) ++ SET(targets ${targets} SMESHEngine) ++ SET(targets ${targets} SMESH) ++ FOREACH(target ${targets}) ++ IF(name STREQUAL ${target}) ++ SET(var ${var} -DNOGDI) ++ ENDIF(name STREQUAL ${target}) ++ ENDFOREACH(target ${targets}) ++ ENDIF(WINDOWS) ++ ''') ++ # -- ++ if self.module in ["medfile", "yacs"]: ++ newlines.append(r''' ++ IF(WINDOWS) ++ SET(var ${var} -DNOGDI) ++ ENDIF(WINDOWS) ++ ''') ++ pass ++ # -- ++ newlines.append(r''' ++ IF(WINDOWS) ++ SET(targets) ++ SET(targets ${targets} MEFISTO2D) ++ FOREACH(target ${targets}) ++ IF(name STREQUAL ${target}) ++ SET(dir $ENV{F2CHOME}) ++ STRING(REPLACE "\\\\" "/" dir ${dir}) ++ SET(var ${var} -I${dir}) ++ SET(var ${var} -DF2C_BUILD) ++ ENDIF(name STREQUAL ${target}) ++ ENDFOREACH(target ${targets}) ++ ENDIF(WINDOWS) ++ ''') ++ # -- ++ if self.module in ["geom", "med"]: ++ newlines.append(r''' ++ SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR}) ++ SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR}) ++ ''') ++ pass ++ newlines.append(r''' ++ SET(var ${var} ${AM_CPPFLAGS}) ++ SET(var ${var} ${AM_CXXFLAGS}) ++ ''') ++ # -- ++ newlines.append(r''' ++ IF(type STREQUAL STATIC) ++ SET(var ${var} -fPIC) ++ ENDIF(type STREQUAL STATIC) ++ ''') ++ # -- ++ if self.module == "yacs": ++ newlines.append(r''' ++ SET(var ${var} -DYACS_PTHREAD) ++ SET(var ${var} -DCMAKE_BUILD) ++ SET(var ${var} -DSALOME_KERNEL) ++ SET(var ${var} -DDSC_PORTS) ++ SET(var ${var} -DOMNIORB) ++ ''') ++ pass ++ newlines.append(r''' ++ SET(var ${var} ${PLATFORM_CPPFLAGS}) ++ SET(var ${var} ${PTHREAD_CFLAGS}) ++ SET(var ${var} ${${amname}_CPPFLAGS}) ++ SET(var ${var} ${${amname}_CXXFLAGS}) ++ SET(var ${var} ${${amname}_CFLAGS}) ++ SET(vars) ++ IF(WINDOWS) ++ SET(vars ${vars} -include SALOMEconfig.h) ++ SET(vars ${vars} -ftemplate-depth-32) ++ SET(vars ${vars} -fPIC) ++ SET(vars ${vars} -g) ++ ENDIF(WINDOWS) ++ SET(flags) ++ FOREACH(f ${var}) ++ FOREACH(v ${vars}) ++ IF(f STREQUAL v) ++ SET(f) ++ ENDIF(f STREQUAL v) ++ ENDFOREACH(v ${vars}) ++ IF(f) ++ string(REGEX MATCH "^-I" test_include ${f}) ++ if(test_include) ++ string(REGEX REPLACE "^-I" "" include_dir ${f}) ++ if(include_dir) ++ if(include_dir STREQUAL /usr/include) ++ else(include_dir STREQUAL /usr/include) ++ string(REGEX MATCH "^\\." test_dot ${include_dir}) ++ if(test_dot) ++ set(include_dir ${CMAKE_CURRENT_BINARY_DIR}/${include_dir}) ++ endif(test_dot) ++ include_directories(${include_dir}) ++ endif(include_dir STREQUAL /usr/include) ++ endif(include_dir) ++ else(test_include) ++ SET(flags "${flags} ${f}") ++ endif(test_include) ++ ENDIF(f) ++ ENDFOREACH(f ${var}) ++ SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}") ++ ''') ++ return ++ ++ def addLibTarget(self, key, newlines): ++ newlines.append(r''' ++ FOREACH(amname ${%s}) ++ '''%(key)) ++ # -- ++ # Replace .la by _la ... ++ # -- ++ newlines.append(r''' ++ STRING(REPLACE .la _la amname ${amname}) ++ ''') ++ # -- ++ # Remove the _la for the cmake name ++ # -- ++ newlines.append(r''' ++ STRING(LENGTH ${amname} len) ++ MATH(EXPR newlen "${len}-3") ++ STRING(SUBSTRING ${amname} 0 ${newlen} name) ++ ''') ++ # -- ++ # Does the target begins with lib ?? ++ # If yes, remove lib at beginning for cmake name ++ # -- ++ newlines.append(r''' ++ STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name}) ++ IF(BEGIN_WITH_lib) ++ STRING(LENGTH ${name} len) ++ MATH(EXPR newlen "${len}-3") ++ STRING(SUBSTRING ${name} 3 ${newlen} name) ++ ENDIF(BEGIN_WITH_lib) ++ ''') ++ # -- ++ # Does the target is an idl library ++ # -- ++ newlines.append(r''' ++ STRING(REGEX MATCH "IDL" ISIDL ${name}) ++ ''') ++ # -- ++ # Set the type of the library ++ # -- ++ newlines.append(r''' ++ IF(ISIDL) ++ IF(WINDOWS) ++ SET(type STATIC) ++ ELSE(WINDOWS) ++ SET(type SHARED) ++ ENDIF(WINDOWS) ++ ELSE(ISIDL) ++ SET(type SHARED) ++ ENDIF(ISIDL) ++ ''') ++ if key == "noinst_LTLIBRARIES": ++ newlines.append(r''' ++ IF(WINDOWS) ++ SET(type STATIC) ++ ELSE(WINDOWS) ++ SET(type STATIC) ++ ENDIF(WINDOWS) ++ ''') ++ pass ++ # -- ++ # Set sources for the library ++ # -- ++ newlines.append(r''' ++ SET(srcs) ++ FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES}) ++ GET_FILENAME_COMPONENT(ext ${src} EXT) ++ IF(ext STREQUAL .f) ++ IF(src STREQUAL trte.f) ++ SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src}) ++ STRING(REPLACE ".f" ".c" src ${src}) ++ SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src}) ++ SET(output ${src}) ++ SET(cmd f2c) ++ IF(NOT WINDOWS) ++ IF(CMAKE_SIZEOF_VOID_P STREQUAL 8) ++ SET(cmd valgrind f2c) # f2c seems to be buggy on 64 bits ... but with valgrind, it works :) ++ ENDIF() ++ ENDIF(NOT WINDOWS) ++ ADD_CUSTOM_COMMAND( ++ OUTPUT ${output} ++ COMMAND ${cmd} ${input} ++ MAIN_DEPENDENCY ${input} ++ ) ++ ELSE(src STREQUAL trte.f) ++ SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src}) ++ STRING(REPLACE ".f" ".o" src ${src}) ++ SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src}) ++ SET(output ${src}) ++ IF(WINDOWS) ++ SET(F77 g77) ++ ELSE(WINDOWS) ++ SET(F77 gfortran) ++ ENDIF(WINDOWS) ++ ADD_CUSTOM_COMMAND( ++ OUTPUT ${output} ++ COMMAND ${F77} -c -o ${output} ${input} ++ MAIN_DEPENDENCY ${input} ++ ) ++ ENDIF(src STREQUAL trte.f) ++ ENDIF(ext STREQUAL .f) ++ SET(srcs ${srcs} ${src}) ++ ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES}) ++ ''') ++ newlines.append(r''' ++ SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES}) ++ FOREACH(f ${l}) ++ SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f}) ++ SET(srcs ${srcs} ${src}) ++ ENDFOREACH(f ${l}) ++ ''') ++ newlines.append(r''' ++ SET(build_srcs) ++ SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES}) ++ FOREACH(f ${l}) ++ GET_FILENAME_COMPONENT(ext ${f} EXT) ++ IF(ext STREQUAL .py) ++ SET(fff) ++ ELSE(ext STREQUAL .py) ++ SET(fff ${CMAKE_CURRENT_BINARY_DIR}/${f}) ++ ENDIF(ext STREQUAL .py) ++ IF(fff) ++ IF(build_srcs) ++ LIST(FIND build_srcs ${fff} index) ++ IF(NOT index EQUAL -1) ++ SET(fff) ++ ENDIF(NOT index EQUAL -1) ++ ENDIF(build_srcs) ++ ENDIF(fff) ++ IF(fff) ++ SET(build_srcs ${build_srcs} ${fff}) ++ ENDIF(fff) ++ ENDFOREACH(f ${l}) ++ ''') ++ # -- ++ # Add the library to cmake ++ # -- ++ newlines.append(r''' ++ ADD_LIBRARY(${name} ${type} ${srcs}) ++ ''') ++ # -- ++ # The compilation flags ++ # -- ++ self.setCompilationFlags(key, newlines) ++ # -- ++ newlines.append(r''' ++ SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO}) ++ ''') ++ # -- ++ self.setLibAdd(key, newlines) ++ # -- ++ if 1: # key != "noinst_LTLIBRARIES": ++ newlines.append(r''' ++ SET(key %s) ++ '''%(key)) ++ newlines.append(r''' ++ SET(test ON) ++ IF(${key} STREQUAL noinst_LTLIBRARIES) ++ SET(test OFF) ++ ENDIF(${key} STREQUAL noinst_LTLIBRARIES) ++ ''') ++ if self.module == "netgen" : ++ newlines.append(r''' ++ IF(${key} STREQUAL noinst_LTLIBRARIES) ++ IF(WINDOWS) ++ SET(test ON) ++ ENDIF(WINDOWS) ++ ENDIF(${key} STREQUAL noinst_LTLIBRARIES) ++ ''') ++ pass ++ newlines.append(r''' ++ IF(test) ++ ''') ++ if self.module in ["medfile", "netgen"]: ++ newlines.append(r''' ++ SET(DEST lib) ++ ''') ++ else: ++ newlines.append(r''' ++ SET(DEST lib/salome) ++ ''') ++ pass ++ newlines.append(r''' ++ IF(BEGIN_WITH_lib) ++ INSTALL(TARGETS ${name} DESTINATION ${DEST}) ++ ''') ++ if self.module == "gui": ++ newlines.append(r''' ++ FOREACH(lib SalomePyQt) ++ IF(name STREQUAL lib) ++ IF(WINDOWS) ++ IF(CMAKE_BUILD_TYPE STREQUAL Release) ++ INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd) ++ ELSE(CMAKE_BUILD_TYPE STREQUAL Release) ++ INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd) ++ ENDIF(CMAKE_BUILD_TYPE STREQUAL Release) ++ ELSE(WINDOWS) ++ INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so) ++ ENDIF(WINDOWS) ++ ENDIF(name STREQUAL lib) ++ ENDFOREACH(lib SalomePyQt) ++ FOREACH(lib SalomePy) ++ IF(name STREQUAL lib) ++ IF(WINDOWS) ++ IF(CMAKE_BUILD_TYPE STREQUAL Release) ++ INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd) ++ ELSE(CMAKE_BUILD_TYPE STREQUAL Release) ++ INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd) ++ ENDIF(CMAKE_BUILD_TYPE STREQUAL Release) ++ ENDIF(WINDOWS) ++ ENDIF(name STREQUAL lib) ++ ENDFOREACH(lib SalomePy) ++ ''') ++ pass ++ if self.module == "geom": ++ newlines.append(r''' ++ IF(WINDOWS) ++ STRING(REGEX MATCH "Export" ISExport ${name}) ++ IF(ISExport) ++ INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll) ++ ENDIF(ISExport) ++ STRING(REGEX MATCH "Import" ISImport ${name}) ++ IF(ISImport) ++ INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll) ++ ENDIF(ISImport) ++ ENDIF(WINDOWS) ++ ''') ++ pass ++ newlines.append(r''' ++ ELSE(BEGIN_WITH_lib) ++ ''') ++ newlines.append(r''' ++ IF(WINDOWS) ++ INSTALL(TARGETS ${name} DESTINATION ${salomepythondir}) ++ IF(CMAKE_BUILD_TYPE STREQUAL Release) ++ INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}.pyd) ++ ELSE(CMAKE_BUILD_TYPE STREQUAL Release) ++ INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}_d.pyd) ++ ENDIF(CMAKE_BUILD_TYPE STREQUAL Release) ++ ELSE(WINDOWS) ++ GET_TARGET_PROPERTY(version ${name} VERSION) ++ GET_TARGET_PROPERTY(soversion ${name} SOVERSION) ++ INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${version}) ++ INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${soversion}) ++ INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so) ++ ENDIF(WINDOWS) ++ ''') ++ newlines.append(r''' ++ ENDIF(BEGIN_WITH_lib) ++ ''') ++ newlines.append(r''' ++ ENDIF(test) ++ ''') ++ pass ++ # -- ++ newlines.append(r''' ++ ENDFOREACH(amname ${%s}) ++ '''%(key)) ++ # -- ++ return ++ ++ def addBinTarget(self, key, newlines): ++ # -- ++ newlines.append(r''' ++ FOREACH(amname ${%s}) ++ '''%(key)) ++ # -- ++ newlines.append(r''' ++ SET(test ON) ++ ''') ++ if key == "check_PROGRAMS": ++ newlines.append(r''' ++ IF(bin_PROGRAMS) ++ STRING(REGEX MATCH ${amname} is_present ${bin_PROGRAMS}) ++ IF(is_present) ++ SET(test OFF) ++ ENDIF(is_present) ++ ENDIF(bin_PROGRAMS) ++ ''') ++ pass ++ newlines.append(r''' ++ IF(test) ++ ''') ++ # -- ++ newlines.append(r''' ++ SET(name "${amname}_exe") ++ SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES}) ++ SET(l ${nodist_${amname}_SOURCES}) ++ FOREACH(f ${l}) ++ SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f}) ++ SET(srcs ${srcs} ${src}) ++ ENDFOREACH(f ${l}) ++ LIST(LENGTH srcs nb) ++ IF(nb) ++ ADD_EXECUTABLE(${name} ${srcs}) ++ ''') ++ # -- ++ self.setCompilationFlags(key, newlines) ++ # -- ++ self.setLibAdd(key, newlines) ++ # -- ++ if self.module in ["jobmanager", "medfile", "netgen"]: ++ newlines.append(r''' ++ SET(DEST bin) ++ ''') ++ else: ++ newlines.append(r''' ++ SET(DEST bin/salome) ++ ''') ++ pass ++ # -- ++ if key == "bin_PROGRAMS": ++ newlines.append(r''' ++ IF(WINDOWS) ++ INSTALL(TARGETS ${name} DESTINATION ${DEST}) ++ INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe) ++ INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)") ++ ELSE(WINDOWS) ++ SET(PERMS) ++ SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE) ++ SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE) ++ SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE) ++ INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname}) ++ ENDIF(WINDOWS) ++ ''') ++ pass ++ # -- ++ newlines.append(r''' ++ ENDIF(nb) ++ ''') ++ # -- ++ newlines.append(r''' ++ ENDIF(test) ++ ''') ++ newlines.append(r''' ++ ENDFOREACH(amname ${%s}) ++ '''%(key)) ++ # -- ++ return ++ ++ def addInstallTarget(self, key, destination, newlines): ++ newlines.append(r"FOREACH(f ${%s})"%(key)) ++ newlines.append(r''' ++ SET(DEST %s) ++ '''%(destination)) ++ newlines.append(r''' ++ STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in) ++ IF(test_SALOMEconfig.h.in) ++ INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in) ++ ELSE(test_SALOMEconfig.h.in) ++ SET(dummy dummy-NOTFOUND) ++ MARK_AS_ADVANCED(dummy) ++ # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f}) ++ FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH) ++ IF(dummy) ++ ''') ++ if key in ['dist_salomescript_SCRIPTS']: ++ newlines.append(r''' ++ SET(PERMS) ++ SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE) ++ SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE) ++ SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE) ++ INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS}) ++ ''') ++ else: ++ newlines.append(r''' ++ GET_FILENAME_COMPONENT(ext ${f} EXT) ++ IF(ext STREQUAL .py) ++ IF(DEST STREQUAL bin/salome) ++ SET(PERMS) ++ SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE) ++ SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE) ++ SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE) ++ INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS}) ++ ELSE(DEST STREQUAL bin/salome) ++ INSTALL(FILES ${f} DESTINATION ${DEST}) ++ ENDIF(DEST STREQUAL bin/salome) ++ ELSE(ext STREQUAL .py) ++ INSTALL(FILES ${f} DESTINATION ${DEST}) ++ ENDIF(ext STREQUAL .py) ++ ''') ++ pass ++ newlines.append(r''' ++ ELSE(dummy) ++ GET_FILENAME_COMPONENT(ext ${f} EXT) ++ IF(ext STREQUAL .qm) ++ STRING(REGEX REPLACE .qm .ts input ${f}) ++ ''') ++ if self.module in ["kernel", "gui", "yacs"]: ++ newlines.append(r''' ++ SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input}) ++ ''') ++ else: ++ newlines.append(r''' ++ SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input}) ++ ''') ++ pass ++ newlines.append(r''' ++ SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f}) ++ # ADD_CUSTOM_COMMAND( ++ # OUTPUT ${output} ++ # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output} ++ # MAIN_DEPENDENCY ${input} ++ # ) ++ EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}) ++ ENDIF(ext STREQUAL .qm) ++ INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST}) ++ ENDIF(dummy) ++ ENDIF(test_SALOMEconfig.h.in) ++ ''') ++ newlines.append(r''' ++ GET_FILENAME_COMPONENT(ext ${f} EXT) ++ IF(ext STREQUAL .py) ++ INSTALL(CODE "SET(PYTHON_FILE ${f})") ++ INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})") ++ INSTALL(CODE "SET(DEST ${DEST})") ++ INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})") ++ ''') ++ if self.module == "kernel": ++ newlines.append(''' ++ IF(f STREQUAL SALOME_ContainerPy.py) ++ ELSE(f STREQUAL SALOME_ContainerPy.py) ++ IF(f STREQUAL am2cmake.py) ++ ELSE(f STREQUAL am2cmake.py) ++ IF(f STREQUAL copytree1.py) ++ ELSE(f STREQUAL copytree1.py) ++ INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake) ++ ENDIF(f STREQUAL copytree1.py) ++ ENDIF(f STREQUAL am2cmake.py) ++ ENDIF(f STREQUAL SALOME_ContainerPy.py) ++ ''') ++ else: ++ newlines.append(''' ++ STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR}) ++ INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake) ++ ''') ++ pass ++ newlines.append(r''' ++ ENDIF(ext STREQUAL .py) ++ ''') ++ newlines.append(r"ENDFOREACH(f ${%s})"%(key)) ++ return ++ ++ def writeListsFile(self): ++ f = open(self.listsFile, "w") ++ f.write(self.content) ++ f.close() ++ return ++ ++ pass ++ ++def convertAmFile(the_root, root, dirs, files, f, module): ++ cmake = CMakeFile(the_root, root, dirs, files, f, module) ++ cmake.writeListsFile() ++ return ++ ++def usage(exit_status): ++ from sys import exit ++ from sys import argv ++ print "Usage: %s --module"%(argv[0]) ++ exit(exit_status) ++ return ++ ++if __name__ == "__main__": ++ # ++ from sys import argv ++ if len(argv) != 2: ++ usage(1) ++ pass ++ # ++ module = argv[1] ++ if module.find('--') != 0: ++ usage(1) ++ pass ++ module = module[2:] ++ if len(module) == 0: ++ usage(1) ++ pass ++ # ++ from os import getcwd ++ the_root = getcwd() ++ # ++ nok = 0 ++ # ++ from os import walk ++ for root, dirs, files in walk(the_root): ++ # -- ++ # E.A. : Remove 'CVS' in dirs ++ # E.A. : It allows to not recurse in CVS dirs ++ # E.A. : See os module python documentation ++ # -- ++ try: ++ dirs.remove('CVS') ++ except ValueError: ++ pass ++ # -- ++ if "Makefile.am.cmake" in files: ++ if "Makefile.am" in files: ++ files.remove("Makefile.am") ++ pass ++ pass ++ # -- ++ from sys import stdout ++ for f in files: ++ if f in ["Makefile.am", "Makefile.am.cmake"]: ++ convertAmFile(the_root, root, dirs, files, f, module) ++ nok += 1 ++ pass ++ pass ++ pass ++ # ++ if nok: ++ if nok == 1: ++ msg = "%s file has been converted to cmake"%(nok) ++ else: ++ msg = "%s files have been converted to cmake"%(nok) ++ pass ++ stdout.write(msg) ++ stdout.write("\n") ++ stdout.flush() ++ pass ++ pass +diff -Naur netgen-4.9.13.occ/config.h.in netgen-4.9.13/config.h.in +--- netgen-4.9.13.occ/config.h.in 2010-05-20 23:29:37.000000000 +0000 ++++ netgen-4.9.13/config.h.in 2011-04-28 08:21:18.760077010 +0000 +@@ -68,7 +68,7 @@ + #undef PACKAGE_TARNAME + + /* Define to the version of this package. */ +-#undef PACKAGE_VERSION ++#define PACKAGE_VERSION "4.9.13" + + /* Define to 1 if you have the ANSI C header files. */ + #undef STDC_HEADERS +diff -Naur netgen-4.9.13.occ/libsrc/include/Makefile.am netgen-4.9.13/libsrc/include/Makefile.am +--- netgen-4.9.13.occ/libsrc/include/Makefile.am 2009-08-10 11:40:50.000000000 +0000 ++++ netgen-4.9.13/libsrc/include/Makefile.am 2011-04-26 15:48:56.300050773 +0000 +@@ -1,7 +1,9 @@ +-noinst_HEADERS = acisgeom.hpp gprim.hpp meshing.hpp occgeom.hpp \ ++noinst_HEADERS_orig = acisgeom.hpp gprim.hpp meshing.hpp occgeom.hpp \ + visual.hpp csg.hpp incvis.hpp myadt.hpp opti.hpp geometry2d.hpp \ + linalg.hpp mydefs.hpp parallel.hpp stlgeom.hpp mystdlib.h + ++noinst_HEADERS = incvis.hpp mydefs.hpp mystdlib.h ++ + include_HEADERS = nginterface.h nginterface_v2.hpp parallelinterface.hpp + + AM_CPPFLAGS = diff --git a/netgen-4.9.13-for-SALOME.patch b/netgen-4.9.13-for-SALOME.patch new file mode 100644 index 000000000000..5fa84997f284 --- /dev/null +++ b/netgen-4.9.13-for-SALOME.patch @@ -0,0 +1,1109 @@ +diff -Naur netgen-4.9.13_orig/libsrc/meshing/meshtype.cpp netgen-4.9.13_new/libsrc/meshing/meshtype.cpp +--- netgen-4.9.13_orig/libsrc/meshing/meshtype.cpp 2009-09-13 14:28:38.000000000 +0400 ++++ netgen-4.9.13_new/libsrc/meshing/meshtype.cpp 2014-07-22 13:01:28.000000000 +0400 +@@ -1,4 +1,5 @@ + #include <mystdlib.h> ++#include <float.h> // to get DBL_MIN defined + + #include "meshing.hpp" + +@@ -650,7 +651,8 @@ + + double det = trans.Det(); + +- if (det <= 0) ++ // if (det <= 0) ++ if (det <= DBL_MIN) // avoid FPE + err += 1e12; + else + err += frob * frob / det; +@@ -706,7 +708,8 @@ + + double det = trans(0,0)*trans(1,1)-trans(1,0)*trans(0,1); + +- if (det <= 0) ++ // if (det <= 0) ++ if (det <= DBL_MIN) // avoid FPE + { + dd = 0; + return 1e12; +@@ -790,7 +793,8 @@ + = dtrans(0,0) * trans(1,1) - trans(0,1) * dtrans(1,0) + + trans(0,0) * dtrans(1,1) - dtrans(0,1) * trans(1,0); + +- if (det <= 0) ++ // if (det <= 0) ++ if (det <= DBL_MIN) // avoid FPE + err += 1e12; + else + { +@@ -840,7 +844,8 @@ + frob /= 2; + + double det = trans.Det(); +- if (det <= 0) ++ //if (det <= 0) ++ if (det <= DBL_MIN) // avoid FPE + err += 1e12; + else + err += frob * frob / det; +@@ -1857,7 +1862,8 @@ + case PYRAMID: + { + double noz = 1-p(2); +- if (noz == 0.0) noz = 1e-10; ++ //if (noz == 0.0) noz = 1e-10; ++ if (noz <= DBL_MIN) noz = 1e-10; // avoid FPE + + double xi = p(0) / noz; + double eta = p(1) / noz; +@@ -2035,7 +2041,8 @@ + + double det = -trans.Det(); + +- if (det <= 0) ++ //if (det <= 0) ++ if (det <= DBL_MIN) // avoid FPE + err += 1e12; + else + err += frob * frob * frob / det; +@@ -2107,7 +2114,8 @@ + ddet *= -1; + + +- if (det <= 0) ++ //if (det <= 0) ++ if (det <= DBL_MIN) // avoid FPE + err += 1e12; + else + { +@@ -2189,7 +2197,7 @@ + + det *= -1; + +- if (det <= 0) ++ if (det <= DBL_MIN) + err += 1e12; + else + { +@@ -2522,10 +2530,10 @@ + + MeshingParameters :: MeshingParameters () + { +- optimize3d = "cmdmustm"; ++ optimize3d = (char*)"cmdmustm"; // optimize3d = "cmdmustm"; + //optimize3d = "cmdmstm"; + optsteps3d = 3; +- optimize2d = "smsmsmSmSmSm"; ++ optimize2d = (char*)"smsmsmSmSmSm"; // optimize2d = "smsmsmSmSmSm"; + optsteps2d = 3; + opterrpow = 2; + blockfill = 1; +diff -Naur netgen-4.9.13_orig/libsrc/meshing/meshtype.hpp netgen-4.9.13_new/libsrc/meshing/meshtype.hpp +--- netgen-4.9.13_orig/libsrc/meshing/meshtype.hpp 2009-11-09 13:50:43.000000000 +0300 ++++ netgen-4.9.13_new/libsrc/meshing/meshtype.hpp 2014-07-22 13:01:28.000000000 +0400 +@@ -12,6 +12,7 @@ + Classes for NETGEN + */ + ++class Mesh; // added due to compilation errors on some platforms + + enum ELEMENT_TYPE { + SEGMENT = 1, SEGMENT3 = 2, +diff -Naur netgen-4.9.13_orig/libsrc/meshing/smoothing2.cpp netgen-4.9.13_new/libsrc/meshing/smoothing2.cpp +--- netgen-4.9.13_orig/libsrc/meshing/smoothing2.cpp 2009-11-09 13:47:09.000000000 +0300 ++++ netgen-4.9.13_new/libsrc/meshing/smoothing2.cpp 2014-07-22 13:01:28.000000000 +0400 +@@ -302,7 +302,8 @@ + vgrad = 0; + badness = 0; + +- meshthis -> GetNormalVector (surfi, sp1, gi1, n); ++ //normal already computed: meshthis -> GetNormalVector (surfi, sp1, gi1, n); ++ n = normal; + pp1 = sp1 + x(0) * t1 + x(1) * t2; + + // meshthis -> ProjectPoint (surfi, pp1); +@@ -360,7 +361,8 @@ + vgrad = 0; + badness = 0; + +- meshthis -> GetNormalVector (surfi, sp1, gi1, n); ++ //normal already computed: meshthis -> GetNormalVector (surfi, sp1, gi1, n); ++ n = normal; + + pp1 = sp1 + x(0) * t1 + x(1) * t2; + +@@ -514,7 +516,8 @@ + vgrad = 0; + badness = 0; + +- meshthis -> GetNormalVector (surfi, sp1, gi1, n); ++ //normal already computed: meshthis -> GetNormalVector (surfi, sp1, gi1, n); ++ n = normal; + + pp1 = sp1 + x(0) * t1 + x(1) * t2; + +@@ -586,7 +589,8 @@ + vgrad = 0; + badness = 0; + +- meshthis -> GetNormalVector (surfi, sp1, gi1, n); ++ //normal already computed: meshthis -> GetNormalVector (surfi, sp1, gi1, n); ++ n = normal; + + // pp1 = sp1; + // pp1.Add2 (x.Get(1), t1, x.Get(2), t2); +@@ -973,7 +977,7 @@ + { + mesh[pi] = Point<3> (origp); + } +- ++ break; // exit as <fact> is not used anymore + } + } + +diff -Naur netgen-4.9.13_orig/libsrc/occ/occconstruction.cpp netgen-4.9.13_new/libsrc/occ/occconstruction.cpp +--- netgen-4.9.13_orig/libsrc/occ/occconstruction.cpp 2009-08-24 06:32:47.000000000 +0400 ++++ netgen-4.9.13_new/libsrc/occ/occconstruction.cpp 2014-07-22 13:01:28.000000000 +0400 +@@ -28,7 +28,7 @@ + #include <BRepAlgoAPI_Common.hxx> + #include <BRepAlgoAPI_Fuse.hxx> + #include <BRepAlgoAPI_Section.hxx> +-#include <BRepOffsetAPI_Sewing.hxx> ++//#include <BRepOffsetAPI_Sewing.hxx> + //#include <BRepAlgo_Sewing.hxx> + #include <BRepOffsetAPI_MakeOffsetShape.hxx> + #include <ShapeFix_Shape.hxx> +diff -Naur netgen-4.9.13_orig/libsrc/occ/occgenmesh.cpp netgen-4.9.13_new/libsrc/occ/occgenmesh.cpp +--- netgen-4.9.13_orig/libsrc/occ/occgenmesh.cpp 2010-03-16 09:30:07.000000000 +0300 ++++ netgen-4.9.13_new/libsrc/occ/occgenmesh.cpp 2014-07-22 13:01:28.000000000 +0400 +@@ -15,6 +15,8 @@ + + #define DIVIDEEDGESECTIONS 1000 + #define IGNORECURVELENGTH 1e-4 ++// a small value used to avoid FPE ++#define VSMALL 1e-10 + + + bool merge_solids = 1; +@@ -26,7 +28,8 @@ + double nq = n*q; + + Point<3> p = p0 + 0.5*n; +- double lambda = (p-l.p0)*n / nq; ++ // double lambda = (p-l.p0)*n / nq; -- avoid FPE ++ double lambda = (fabs(nq) > 1e-10) ? (p-l.p0)*n / nq : -1; + + if (lambda >= 0 && lambda <= 1) + { +@@ -54,6 +57,8 @@ + + + ++ ++ static // useless out of this file + double ComputeH (double kappa) + { + double hret; +@@ -62,7 +67,8 @@ + if (mparam.maxh * kappa < 1) + hret = mparam.maxh; + else +- hret = 1 / kappa; ++ // hret = 1 / kappa; -- avoid FPE ++ hret = 1 / (kappa + VSMALL); + + if (mparam.maxh < hret) + hret = mparam.maxh; +@@ -71,8 +77,7 @@ + } + + +- +- ++ static // useless out of this file + void RestrictHTriangle (gp_Pnt2d & par0, gp_Pnt2d & par1, gp_Pnt2d & par2, + BRepLProp_SLProps * prop, Mesh & mesh, int depth, double h = 0) + { +@@ -168,8 +173,8 @@ + if(h < 1e-4*maxside) + return; + +- +- if (h > 30) return; ++ // commented to restrict H on a large sphere for example ++ //if (h > 30) return; + } + + if (h < maxside && depth < 10) +@@ -228,6 +233,7 @@ + + + ++ static // useless out of this file + void DivideEdge (TopoDS_Edge & edge, Array<MeshPoint> & ps, + Array<double> & params, Mesh & mesh) + { +@@ -247,8 +253,8 @@ + hvalue[0] = 0; + pnt = c->Value(s0); + +- double olddist = 0; +- double dist = 0; ++ //double olddist = 0; -- useless variables ++ //double dist = 0; + + int tmpVal = (int)(DIVIDEEDGESECTIONS); + +@@ -256,15 +262,19 @@ + { + oldpnt = pnt; + pnt = c->Value(s0+(i/double(DIVIDEEDGESECTIONS))*(s1-s0)); ++ // -- no more than 1 segment per <edge length>/DIVIDEEDGESECTIONS + hvalue[i] = hvalue[i-1] + +- 1.0/mesh.GetH(Point3d(pnt.X(), pnt.Y(), pnt.Z()))* +- pnt.Distance(oldpnt); ++ // 1.0/mesh.GetH(Point3d(pnt.X(), pnt.Y(), pnt.Z()))* ++ // pnt.Distance(oldpnt); ++ min( 1.0, ++ 1.0/mesh.GetH(Point3d(pnt.X(), pnt.Y(), pnt.Z()))* ++ pnt.Distance(oldpnt)); + + //(*testout) << "mesh.GetH(Point3d(pnt.X(), pnt.Y(), pnt.Z())) " << mesh.GetH(Point3d(pnt.X(), pnt.Y(), pnt.Z())) + // << " pnt.Distance(oldpnt) " << pnt.Distance(oldpnt) << endl; + +- olddist = dist; +- dist = pnt.Distance(oldpnt); ++ //olddist = dist; -- useless variables ++ //dist = pnt.Distance(oldpnt); + } + + // nsubedges = int(ceil(hvalue[DIVIDEEDGESECTIONS])); +@@ -279,7 +289,10 @@ + { + if (hvalue[i1]/hvalue[DIVIDEEDGESECTIONS]*nsubedges >= i) + { +- params[i] = s0+(i1/double(DIVIDEEDGESECTIONS))*(s1-s0); ++ // -- for nsubedges comparable to DIVIDEEDGESECTIONS ++ //params[i] = s0+(i1/double(DIVIDEEDGESECTIONS))*(s1-s0); ++ double d1 = i1 - (hvalue[i1] - i*hvalue[DIVIDEEDGESECTIONS]/nsubedges)/(hvalue[i1]-hvalue[i1-1]); ++ params[i] = s0+(d1/double(DIVIDEEDGESECTIONS))*(s1-s0); + pnt = c->Value(params[i]); + ps[i-1] = MeshPoint (Point3d(pnt.X(), pnt.Y(), pnt.Z())); + i++; +@@ -323,6 +336,9 @@ + (*testout) << "nedges = " << nedges << endl; + + double eps = 1e-6 * geom.GetBoundingBox().Diam(); ++ const double eps2 = eps * eps; // -- small optimization ++ ++ int first_vp = mesh.GetNP()+1; // -- to support SALOME sub-meshes + + for (int i = 1; i <= nvertices; i++) + { +@@ -332,7 +348,8 @@ + bool exists = 0; + if (merge_solids) + for (PointIndex pi = 1; pi <= mesh.GetNP(); pi++) +- if ( Dist2 (mesh[pi], Point<3>(mp)) < eps*eps) ++ //if ( Dist2 (mesh[pi], Point<3>(mp)) < eps*eps) ++ if ( Dist2 (mesh[pi], Point<3>(mp)) < eps2 ) // -- small optimization + { + exists = 1; + break; +@@ -362,6 +379,7 @@ + { + TopoDS_Face face = TopoDS::Face(exp1.Current()); + int facenr = geom.fmap.FindIndex(face); ++ if ( facenr < 1 ) continue; // -- to support SALOME sub-meshes + + if (face2solid[0][facenr-1] == 0) + face2solid[0][facenr-1] = solidnr; +@@ -381,6 +399,7 @@ + int facenr = 0; + int edgenr = 0; + ++ edgenr = mesh.GetNSeg(); // to support SALOME sub-meshes + + (*testout) << "faces = " << geom.fmap.Extent() << endl; + int curr = 0; +@@ -442,6 +461,7 @@ + //(*testout) << "ignoring degenerated edge" << endl; + continue; + } ++ if ( geom.emap.FindIndex(edge) < 1 ) continue; // to support SALOME sub-meshes + + if (geom.vmap.FindIndex(TopExp::FirstVertex (edge)) == + geom.vmap.FindIndex(TopExp::LastVertex (edge))) +@@ -474,20 +494,104 @@ + + if (!merge_solids) + { +- pnums[0] = geom.vmap.FindIndex (TopExp::FirstVertex (edge)); +- pnums[pnums.Size()-1] = geom.vmap.FindIndex (TopExp::LastVertex (edge)); ++ //pnums[0] = geom.vmap.FindIndex (TopExp::FirstVertex (edge)); ++ //pnums[pnums.Size()-1] = geom.vmap.FindIndex (TopExp::LastVertex (edge)); ++ MeshPoint dfltP ( Point<3> ( 0, 0, 0 ) ); ++ int *ipp[] = { &pnums[0], &pnums[pnums.Size()-1] }; ++ TopoDS_Iterator vIt( edge, false ); ++ TopoDS_Vertex v[2]; ++ v[0] = TopoDS::Vertex( vIt.Value() ); vIt.Next(); ++ v[1] = TopoDS::Vertex( vIt.Value() ); ++ if ( v[0].Orientation() == TopAbs_REVERSED ) ++ std::swap( v[0], v[1] ); ++ for ( int i = 0; i < 2; ++i) ++ { ++ int &ip = *ipp[i]; ++ ip = geom.vmap.FindIndex ( v[i] ); ++ if ( ip == 0 || ip > nvertices ) ++ { ++ int iv = ip; ++ if ( ip == 0 ) ++ ip = iv = geom.vmap.Add( v[i] ); ++ gp_Pnt pnt = BRep_Tool::Pnt( v[i] ); ++ MeshPoint mp( Point<3>(pnt.X(), pnt.Y(), pnt.Z()) ); ++ for (PointIndex pi = 1; pi < first_vp; pi++) ++ if ( Dist2 (mesh.Point(pi), Point<3>(mp)) < 1e-100 ) ++ { ++ ip = pi; ++ if ( mesh.Point(ip).GetLayer() != dfltP.GetLayer() && mesh.Point(ip).GetLayer() != iv ) ++ continue; ++ if ( mesh.Point(ip).GetLayer() == dfltP.GetLayer()) ++ mesh.Point(ip) = MeshPoint( mesh.Point(ip), iv ); ++ break; ++ } ++ } ++ else ++ { ++ ip += first_vp - 1; ++ } ++ } + } + else + { +- Point<3> fp = occ2ng (BRep_Tool::Pnt (TopExp::FirstVertex (edge))); +- Point<3> lp = occ2ng (BRep_Tool::Pnt (TopExp::LastVertex (edge))); ++ TopoDS_Iterator vIt( edge, false ); ++ TopoDS_Vertex v1 = TopoDS::Vertex( vIt.Value() ); vIt.Next(); ++ TopoDS_Vertex v2 = TopoDS::Vertex( vIt.Value() ); ++ if ( v1.Orientation() == TopAbs_REVERSED ) ++ std::swap( v1, v2 ); ++ const bool isClosedEdge = v1.IsSame( v2 ); ++ ++ Point<3> fp = occ2ng (BRep_Tool::Pnt (v1)); ++ Point<3> lp = occ2ng (BRep_Tool::Pnt (v2)); ++ double tol2 = std::min( eps*eps, 1e-6 * Dist2( fp, lp )); ++ if ( isClosedEdge ) ++ tol2 = BRep_Tool::Tolerance( v1 ) * BRep_Tool::Tolerance( v1 ); + + pnums[0] = -1; + pnums.Last() = -1; + for (PointIndex pi = 1; pi < first_ep; pi++) + { +- if (Dist2 (mesh[pi], fp) < eps*eps) pnums[0] = pi; +- if (Dist2 (mesh[pi], lp) < eps*eps) pnums.Last() = pi; ++ if (Dist2 (mesh[pi], fp) < tol2) pnums[0] = pi; ++ if (Dist2 (mesh[pi], lp) < tol2) pnums.Last() = pi; ++ } ++ if (( isClosedEdge && pnums[0] != pnums.Last() ) || ++ ( !isClosedEdge && pnums[0] == pnums.Last() )) ++ pnums[0] = pnums.Last() = -1; ++ if ( pnums[0] == -1 || pnums.Last() == -1 ) ++ { ++ // take into account a possible large gap between a vertex and an edge curve ++ // end and a large vertex tolerance covering the whole edge ++ if ( pnums[0] == -1 ) ++ { ++ double tol = BRep_Tool::Tolerance( v1 ); ++ for (PointIndex pi = 1; pi < first_ep; pi++) ++ if (pi != pnums.Last() && Dist2 (mesh[pi], fp) < 2*tol*tol) ++ pnums[0] = pi; ++ ++ if ( pnums[0] == -1 ) ++ pnums[0] = first_ep-1- nvertices + geom.vmap.FindIndex ( v1 ); ++ } ++ if ( isClosedEdge ) ++ { ++ pnums.Last() = pnums[0]; ++ } ++ else ++ { ++ if ( pnums.Last() == -1 ) ++ { ++ double tol = BRep_Tool::Tolerance( v2 ); ++ for (PointIndex pi = 1; pi < first_ep; pi++) ++ if (pi != pnums[0] && Dist2 (mesh[pi], lp) < 2*tol*tol) ++ pnums.Last() = pi; ++ ++ if ( pnums.Last() == -1 ) ++ pnums.Last() = first_ep-1-nvertices + geom.vmap.FindIndex ( v2 ); ++ } ++ ++ if ( Dist2( fp, mesh[PointIndex(pnums[0])]) > ++ Dist2( lp, mesh[PointIndex(pnums.Last())])) ++ std::swap( pnums[0], pnums.Last() ); ++ } + } + } + +@@ -497,17 +601,20 @@ + bool exists = 0; + int j; + for (j = first_ep; j <= mesh.GetNP(); j++) ++ { ++ if (!merge_solids && mesh.Point(j).GetLayer() != geomedgenr ) continue; // to support SALOME fuse edges + if ((mesh.Point(j)-Point<3>(mp[i-1])).Length() < eps) + { + exists = 1; + break; + } ++ } + + if (exists) + pnums[i] = j; + else + { +- mesh.AddPoint (mp[i-1]); ++ mesh.AddPoint (mp[i-1], geomedgenr); // to support SALOME fuse edges + (*testout) << "add meshpoint " << mp[i-1] << endl; + pnums[i] = mesh.GetNP(); + } +@@ -591,6 +698,8 @@ + // (*testout) << "edge " << mesh.LineSegment(i).edgenr << " face " << mesh.LineSegment(i).si + // << " p1 " << mesh.LineSegment(i)[0] << " p2 " << mesh.LineSegment(i)[1] << endl; + // exit(10); ++ for (int j = 1; j <= mesh.GetNP(); j++) // to support SALOME fuse edges: set level to zero
++ mesh.Point(j) = MeshPoint( (Point<3>&) mesh.Point(j) ); + + mesh.CalcSurfacesOfNode(); + multithread.task = savetask; +@@ -633,7 +742,8 @@ + } + + (*testout) << "mesh face " << k << endl; +- multithread.percent = 100 * k / (mesh.GetNFD()+1e-10); ++ // multithread.percent = 100 * k / (mesh.GetNFD()+1e-10); -- avoid FPE ++ multithread.percent = 100 * k / (mesh.GetNFD() + VSMALL); + geom.facemeshstatus[k-1] = -1; + + +@@ -901,7 +1011,8 @@ + // if (k != 36) continue; + + // (*testout) << "optimize face " << k << endl; +- multithread.percent = 100 * k / (mesh.GetNFD()+1e-10); ++ //multithread.percent = 100 * k / (mesh.GetNFD()+1e-10); -- avoid FPE ++ multithread.percent = 100 * k / (mesh.GetNFD() + VSMALL); + + FaceDescriptor & fd = mesh.GetFaceDescriptor(k); + +@@ -1456,3 +1567,4 @@ + } + + #endif ++ +diff -Naur netgen-4.9.13_orig/libsrc/occ/occgeom.cpp netgen-4.9.13_new/libsrc/occ/occgeom.cpp +--- netgen-4.9.13_orig/libsrc/occ/occgeom.cpp 2010-03-05 16:16:21.000000000 +0300 ++++ netgen-4.9.13_new/libsrc/occ/occgeom.cpp 2014-07-22 13:01:28.000000000 +0400 +@@ -8,6 +8,8 @@ + #include "ShapeAnalysis_CheckSmallFace.hxx" + #include "ShapeAnalysis_DataMapOfShapeListOfReal.hxx" + #include "ShapeAnalysis_Surface.hxx" ++#include <BRepTopAdaptor_FClass2d.hxx> // -- to optimize Project() and FastProject() ++#include <TopAbs_State.hxx> + #include "BRepAlgoAPI_Fuse.hxx" + #include "BRepCheck_Analyzer.hxx" + #include "BRepLib.hxx" +@@ -16,10 +18,17 @@ + #include "ShapeFix_FixSmallFace.hxx" + #include "Partition_Spliter.hxx" + +- + namespace netgen + { +- void OCCGeometry :: PrintNrShapes () ++ // free data used to optimize Project() and FastProject() ++ OCCGeometry::~OCCGeometry() ++ { ++ NCollection_DataMap<int,BRepTopAdaptor_FClass2d*>::Iterator it(fclsmap); ++ for (; it.More(); it.Next()) ++ delete it.Value(); ++ } ++ ++ void OCCGeometry :: PrintNrShapes () + { + TopExp_Explorer e; + int count = 0; +@@ -951,25 +960,58 @@ + } + + ++ // returns a projector and a classifier for the given surface ++ void OCCGeometry::GetFaceTools(int surfi, Handle(ShapeAnalysis_Surface)& proj, ++ BRepTopAdaptor_FClass2d*& cls) const ++ { ++ //MSV: organize caching projector in the map ++ if (fprjmap.IsBound(surfi)) ++ { ++ proj = fprjmap.Find(surfi); ++ cls = fclsmap.Find(surfi); ++ } ++ else ++ { ++ const TopoDS_Face& aFace = TopoDS::Face(fmap(surfi)); ++ Handle(Geom_Surface) aSurf = BRep_Tool::Surface(aFace); ++ proj = new ShapeAnalysis_Surface(aSurf); ++ fprjmap.Bind(surfi, proj); ++ cls = new BRepTopAdaptor_FClass2d(aFace,Precision::Confusion()); ++ fclsmap.Bind(surfi, cls); ++ } ++ } + +- +- void OCCGeometry :: Project (int surfi, Point<3> & p) const ++ // void OCCGeometry :: Project (int surfi, Point<3> & p) const ++ bool OCCGeometry :: Project (int surfi, Point<3> & p, double& u, double& v) const + { + static int cnt = 0; + if (++cnt % 1000 == 0) cout << "Project cnt = " << cnt << endl; + + gp_Pnt pnt(p(0), p(1), p(2)); + +- double u,v; +- Handle( Geom_Surface ) thesurf = BRep_Tool::Surface(TopoDS::Face(fmap(surfi))); +- Handle( ShapeAnalysis_Surface ) su = new ShapeAnalysis_Surface( thesurf ); +- gp_Pnt2d suval = su->ValueOfUV ( pnt, BRep_Tool::Tolerance( TopoDS::Face(fmap(surfi)) ) ); +- suval.Coord( u, v); +- pnt = thesurf->Value( u, v ); +- +- ++ // -- Optimization: use cached projector and classifier ++ // double u,v; ++ // Handle( Geom_Surface ) thesurf = BRep_Tool::Surface(TopoDS::Face(fmap(surfi))); ++ // Handle( ShapeAnalysis_Surface ) su = new ShapeAnalysis_Surface( thesurf ); ++ // gp_Pnt2d suval = su->ValueOfUV ( pnt, BRep_Tool::Tolerance( TopoDS::Face(fmap(surfi)) ) ); ++ // suval.Coord( u, v); ++ // pnt = thesurf->Value( u, v ); ++ ++ Handle(ShapeAnalysis_Surface) proj; ++ BRepTopAdaptor_FClass2d *cls; ++ GetFaceTools(surfi, proj, cls); ++ ++ gp_Pnt2d p2d = proj->ValueOfUV(pnt, Precision::Confusion()); ++ if (cls->Perform(p2d) == TopAbs_OUT) ++ { ++ return false; ++ } ++ pnt = proj->Value(p2d); ++ p2d.Coord(u, v); ++ + p = Point<3> (pnt.X(), pnt.Y(), pnt.Z()); + ++ return true; + } + + +@@ -979,54 +1021,69 @@ + { + gp_Pnt p(ap(0), ap(1), ap(2)); + +- Handle(Geom_Surface) surface = BRep_Tool::Surface(TopoDS::Face(fmap(surfi))); +- +- gp_Pnt x = surface->Value (u,v); +- +- if (p.SquareDistance(x) <= sqr(PROJECTION_TOLERANCE)) return true; +- +- gp_Vec du, dv; +- +- surface->D1(u,v,x,du,dv); +- +- int count = 0; +- +- gp_Pnt xold; +- gp_Vec n; +- double det, lambda, mu; +- +- do { +- count++; +- +- n = du^dv; +- +- det = Det3 (n.X(), du.X(), dv.X(), +- n.Y(), du.Y(), dv.Y(), +- n.Z(), du.Z(), dv.Z()); +- +- if (det < 1e-15) return false; +- +- lambda = Det3 (n.X(), p.X()-x.X(), dv.X(), +- n.Y(), p.Y()-x.Y(), dv.Y(), +- n.Z(), p.Z()-x.Z(), dv.Z())/det; +- +- mu = Det3 (n.X(), du.X(), p.X()-x.X(), +- n.Y(), du.Y(), p.Y()-x.Y(), +- n.Z(), du.Z(), p.Z()-x.Z())/det; +- +- u += lambda; +- v += mu; +- +- xold = x; +- surface->D1(u,v,x,du,dv); +- +- } while (xold.SquareDistance(x) > sqr(PROJECTION_TOLERANCE) && count < 50); +- +- // (*testout) << "FastProject count: " << count << endl; +- +- if (count == 50) return false; +- +- ap = Point<3> (x.X(), x.Y(), x.Z()); ++ // -- Optimization: use cached projector and classifier ++ // Handle(Geom_Surface) surface = BRep_Tool::Surface(TopoDS::Face(fmap(surfi))); ++ // ++ // gp_Pnt x = surface->Value (u,v); ++ // ++ // if (p.SquareDistance(x) <= sqr(PROJECTION_TOLERANCE)) return true; ++ // ++ // gp_Vec du, dv; ++ // ++ // surface->D1(u,v,x,du,dv); ++ // ++ // int count = 0; ++ // ++ // gp_Pnt xold; ++ // gp_Vec n; ++ // double det, lambda, mu; ++ // ++ // do { ++ // count++; ++ // ++ // n = du^dv; ++ // ++ // det = Det3 (n.X(), du.X(), dv.X(), ++ // n.Y(), du.Y(), dv.Y(), ++ // n.Z(), du.Z(), dv.Z()); ++ // ++ // if (det < 1e-15) return false; ++ // ++ // lambda = Det3 (n.X(), p.X()-x.X(), dv.X(), ++ // n.Y(), p.Y()-x.Y(), dv.Y(), ++ // n.Z(), p.Z()-x.Z(), dv.Z())/det; ++ // ++ // mu = Det3 (n.X(), du.X(), p.X()-x.X(), ++ // n.Y(), du.Y(), p.Y()-x.Y(), ++ // n.Z(), du.Z(), p.Z()-x.Z())/det; ++ // ++ // u += lambda; ++ // v += mu; ++ // ++ // xold = x; ++ // surface->D1(u,v,x,du,dv); ++ // ++ // } while (xold.SquareDistance(x) > sqr(PROJECTION_TOLERANCE) && count < 50); ++ // ++ // // (*testout) << "FastProject count: " << count << endl; ++ // ++ // if (count == 50) return false; ++ // ++ // ap = Point<3> (x.X(), x.Y(), x.Z()); ++ Handle(ShapeAnalysis_Surface) proj; ++ BRepTopAdaptor_FClass2d *cls; ++ GetFaceTools(surfi, proj, cls); ++ ++ gp_Pnt2d p2d = proj->NextValueOfUV(gp_Pnt2d(u,v), p, Precision::Confusion()); ++ if (cls->Perform(p2d) == TopAbs_OUT) ++ { ++ //cout << "Projection fails" << endl; ++ return false; ++ } ++ ++ p = proj->Value(p2d); ++ p2d.Coord(u, v); ++ ap = Point<3> (p.X(), p.Y(), p.Z()); + + return true; + } +@@ -1038,9 +1095,9 @@ + { + cout << "writing stl..."; cout.flush(); + StlAPI_Writer writer; +- writer.RelativeMode() = Standard_False; ++ // writer.RelativeMode() = Standard_False; + +- writer.SetDeflection(0.02); ++ // writer.SetDeflection(0.02); + writer.Write(shape,filename); + + cout << "done" << endl; +diff -Naur netgen-4.9.13_orig/libsrc/occ/occgeom.hpp netgen-4.9.13_new/libsrc/occ/occgeom.hpp +--- netgen-4.9.13_orig/libsrc/occ/occgeom.hpp 2010-01-14 19:56:19.000000000 +0300 ++++ netgen-4.9.13_new/libsrc/occ/occgeom.hpp 2014-07-22 13:09:03.000000000 +0400 +@@ -15,8 +15,8 @@ + #include "Geom_Curve.hxx" + #include "Geom2d_Curve.hxx" + #include "Geom_Surface.hxx" +-#include "GeomAPI_ProjectPointOnSurf.hxx" +-#include "GeomAPI_ProjectPointOnCurve.hxx" ++// #include "GeomAPI_ProjectPointOnSurf.hxx" ++// #include "GeomAPI_ProjectPointOnCurve.hxx" + #include "BRepTools.hxx" + #include "TopExp.hxx" + #include "BRepBuilderAPI_MakeVertex.hxx" +@@ -42,8 +42,8 @@ + #include "Geom_Curve.hxx" + #include "Geom2d_Curve.hxx" + #include "Geom_Surface.hxx" +-#include "GeomAPI_ProjectPointOnSurf.hxx" +-#include "GeomAPI_ProjectPointOnCurve.hxx" ++// #include "GeomAPI_ProjectPointOnSurf.hxx" ++// #include "GeomAPI_ProjectPointOnCurve.hxx" + #include "TopoDS_Wire.hxx" + #include "BRepTools_WireExplorer.hxx" + #include "BRepTools.hxx" +@@ -68,18 +68,26 @@ + #include "IGESToBRep_Reader.hxx" + #include "Interface_Static.hxx" + #include "GeomAPI_ExtremaCurveCurve.hxx" +-#include "Standard_ErrorHandler.hxx" ++//#include "Standard_ErrorHandler.hxx" + #include "Standard_Failure.hxx" + #include "ShapeUpgrade_ShellSewing.hxx" + #include "ShapeFix_Shape.hxx" + #include "ShapeFix_Wireframe.hxx" ++#include <Standard_Version.hxx> ++#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) <= 0x060702 ++// porting to OCCT6.7.3 + #include "BRepMesh.hxx" ++#endif + #include "BRepMesh_IncrementalMesh.hxx" + #include "BRepBndLib.hxx" + #include "Bnd_Box.hxx" + #include "ShapeAnalysis.hxx" + #include "ShapeBuild_ReShape.hxx" + ++// -- Optimization: to use cached projector and classifier ++#include <NCollection_DataMap.hxx> ++class Handle_ShapeAnalysis_Surface; ++class BRepTopAdaptor_FClass2d; + + // Philippose - 29/01/2009 + // OpenCascade XDE Support +@@ -190,6 +198,9 @@ + class OCCGeometry : public NetgenGeometry + { + Point<3> center; ++ // -- Optimization: to use cached projector and classifier ++ mutable NCollection_DataMap<int,Handle_ShapeAnalysis_Surface> fprjmap; ++ mutable NCollection_DataMap<int,BRepTopAdaptor_FClass2d*> fclsmap; + + public: + TopoDS_Shape shape; +@@ -241,6 +252,8 @@ + vmap.Clear(); + } + ++ ~OCCGeometry(); // -- to free cached projector and classifier ++ + void BuildFMap(); + + Box<3> GetBoundingBox() +@@ -260,9 +273,14 @@ + Point<3> Center() + { return center;} + +- void Project (int surfi, Point<3> & p) const; ++ // void Project (int surfi, Point<3> & p) const; -- optimization ++ bool Project (int surfi, Point<3> & p, double& u, double& v) const; + bool FastProject (int surfi, Point<3> & ap, double& u, double& v) const; + ++ // -- Optimization: to use cached projector and classifier ++ void GetFaceTools(int surfi, Handle(ShapeAnalysis_Surface)& proj, ++ BRepTopAdaptor_FClass2d*& cls) const; ++ + OCCSurface GetSurface (int surfi) + { + cout << "OCCGeometry::GetSurface using PLANESPACE" << endl; +diff -Naur netgen-4.9.13_orig/libsrc/occ/occmeshsurf.cpp netgen-4.9.13_new/libsrc/occ/occmeshsurf.cpp +--- netgen-4.9.13_orig/libsrc/occ/occmeshsurf.cpp 2009-08-24 06:32:47.000000000 +0400 ++++ netgen-4.9.13_new/libsrc/occ/occmeshsurf.cpp 2014-07-22 13:01:28.000000000 +0400 +@@ -6,6 +6,7 @@ + #include <meshing.hpp> + #include <GeomLProp_SLProps.hxx> + #include <ShapeAnalysis_Surface.hxx> ++#include <GeomAPI_ProjectPointOnCurve.hxx> // -- moved here from occgeom.hpp + + + namespace netgen +@@ -434,23 +435,33 @@ + + void MeshOptimize2dOCCSurfaces :: ProjectPoint (INDEX surfind, Point<3> & p) const + { +- geometry.Project (surfind, p); ++ // geometry.Project (surfind, p); -- signature of Project() changed for optimization ++ double u, v; ++ geometry.Project (surfind, p, u, v); + } + + + int MeshOptimize2dOCCSurfaces :: ProjectPointGI (INDEX surfind, Point<3> & p, PointGeomInfo & gi) const + { +- double u = gi.u; +- double v = gi.v; ++ //double u = gi.u; ++ //double v = gi.v; + + Point<3> hp = p; +- if (geometry.FastProject (surfind, hp, u, v)) +- { +- p = hp; +- return 1; +- } +- ProjectPoint (surfind, p); +- return CalcPointGeomInfo (surfind, gi, p); ++ // -- u and v are computed by FastProject() and Project(), no need to call CalcPointGeomInfo() ++ // if (geometry.FastProject (surfind, hp, u, v)) ++ // { ++ // p = hp; ++ // return 1; ++ // } ++ // ProjectPoint (surfind, p); ++ // return CalcPointGeomInfo (surfind, gi, p); ++ bool ok; ++ if (gi.trignum > 0) ++ ok = geometry.FastProject (surfind, hp, gi.u, gi.v); ++ else ++ ok = geometry.Project (surfind, hp, gi.u, gi.v); ++ p = hp; ++ return ok; + } + + +@@ -680,7 +691,8 @@ + if (!geometry.FastProject (surfi, hnewp, u, v)) + { + // cout << "Fast projection to surface fails! Using OCC projection" << endl; +- geometry.Project (surfi, hnewp); ++ // geometry.Project (surfi, hnewp); -- Project() changed for optimization ++ geometry.Project (surfi, hnewp, u, v); + } + + newgi.trignum = 1; +@@ -689,7 +701,7 @@ + } + + newp = hnewp; +- } ++ }//; -- to compile with -Wall -pedantic + + + void OCCRefinementSurfaces :: +@@ -708,14 +720,18 @@ + hnewp = Point<3> (pnt.X(), pnt.Y(), pnt.Z()); + newp = hnewp; + newgi = ap1; +- }; ++ } + + + void OCCRefinementSurfaces :: ProjectToSurface (Point<3> & p, int surfi) + { + if (surfi > 0) +- geometry.Project (surfi, p); +- }; ++ // geometry.Project (surfi, p); -- Project() changed for optimization ++ { ++ double u, v; ++ geometry.Project (surfi, p, u, v); ++ } ++ }//; -- to compile with -Wall -pedantic + + void OCCRefinementSurfaces :: ProjectToSurface (Point<3> & p, int surfi, PointGeomInfo & gi) + { +@@ -723,9 +739,10 @@ + if (!geometry.FastProject (surfi, p, gi.u, gi.v)) + { + cout << "Fast projection to surface fails! Using OCC projection" << endl; +- geometry.Project (surfi, p); ++ double u, v; ++ geometry.Project (surfi, p, u, v); + } +- }; ++ } + + + +diff -Naur netgen-4.9.13_orig/libsrc/occ/Partition_Inter3d.cxx netgen-4.9.13_new/libsrc/occ/Partition_Inter3d.cxx +--- netgen-4.9.13_orig/libsrc/occ/Partition_Inter3d.cxx 2009-08-24 06:12:24.000000000 +0400 ++++ netgen-4.9.13_new/libsrc/occ/Partition_Inter3d.cxx 2014-07-22 13:01:28.000000000 +0400 +@@ -86,6 +86,9 @@ + #include <TopOpeBRepTool_OutCurveType.hxx> + #include <TopOpeBRep_DSFiller.hxx> + #include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx> ++ ++#include <Standard_Version.hxx> ++ + #include <stdio.h> + + //======================================================================= +@@ -243,7 +246,12 @@ + Standard_Integer i, nbExt = anExtPS.NbExt(); + Extrema_POnSurf aPOnSurf; + for (i = 1; i <= nbExt; ++i ) ++#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060400 ++// porting to OCCT6.5.1 ++ if (anExtPS.SquareDistance( i ) <= TolE * TolE) { ++#else + if (anExtPS.Value( i ) <= TolE) { ++#endif + aPOnSurf = anExtPS.Point( i ); + break; + } +diff -Naur netgen-4.9.13_orig/libsrc/occ/Partition_Loop2d.cxx netgen-4.9.13_new/libsrc/occ/Partition_Loop2d.cxx +--- netgen-4.9.13_orig/libsrc/occ/Partition_Loop2d.cxx 2009-08-24 06:12:24.000000000 +0400 ++++ netgen-4.9.13_new/libsrc/occ/Partition_Loop2d.cxx 2014-07-22 13:01:28.000000000 +0400 +@@ -22,7 +22,6 @@ + #include <BRepAdaptor_Surface.hxx> + #include <BRepAlgo_AsDes.hxx> + #include <BRepAlgo_FaceRestrictor.hxx> +-#include <BRepOffset_DataMapOfShapeReal.hxx> + #include <BRepTopAdaptor_FClass2d.hxx> + #include <BRep_Builder.hxx> + #include <BRep_Tool.hxx> +@@ -51,6 +50,15 @@ + #include <gp_Pnt.hxx> + #include <gp_Pnt2d.hxx> + ++#include <Standard_Version.hxx> ++ ++#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060400 ++// porting to OCCT6.5.1 ++#include <TopTools_DataMapOfShapeReal.hxx> ++#else ++#include <BRepOffset_DataMapOfShapeReal.hxx> ++#endif ++ + //======================================================================= + //function : Partition_Loop2d + //purpose : +@@ -209,7 +217,7 @@ + Cc->D1(uc, PC, CTg1); + if (!isForward) CTg1.Reverse(); + +- Standard_Real anglemin = 3 * PI, tolAng = 1.e-8; ++ Standard_Real anglemin = 3 * M_PI, tolAng = 1.e-8; + + // select an edge whose first derivative is most left of CTg1 + // ie an angle between Tg1 and CTg1 is least +@@ -233,7 +241,7 @@ + // -PI < angle < PI + Standard_Real angle = Tg1.Angle(CTg1); + +- if (PI - Abs(angle) <= tolAng) ++ if (M_PI - Abs(angle) <= tolAng) + { + // an angle is too close to PI; assure that an angle sign really + // reflects an edge position: +PI - an edge is worst, +@@ -519,7 +527,12 @@ + DC.Initialize( DegEdge, F ); + + // avoid intersecting twice the same edge ++#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060400 ++// porting to OCCT6.5.1 ++ TopTools_DataMapOfShapeReal EUMap ( EdgesList.Extent() ); ++#else + BRepOffset_DataMapOfShapeReal EUMap ( EdgesList.Extent() ); ++#endif + + Standard_Real U, f, l; + BRep_Tool::Range (DegEdge, f, l); +diff -Naur netgen-4.9.13_orig/libsrc/occ/Partition_Loop.cxx netgen-4.9.13_new/libsrc/occ/Partition_Loop.cxx +--- netgen-4.9.13_orig/libsrc/occ/Partition_Loop.cxx 2009-08-24 06:12:24.000000000 +0400 ++++ netgen-4.9.13_new/libsrc/occ/Partition_Loop.cxx 2014-07-22 13:01:28.000000000 +0400 +@@ -178,7 +178,7 @@ + } + } + +- Standard_Real anglemax = - PI; ++ Standard_Real anglemax = - M_PI; + TopoDS_Edge SelectedEdge; + for ( itl.Initialize(LE); itl.More(); itl.Next()) { + const TopoDS_Edge& E = TopoDS::Edge(itl.Value()); +diff -Naur netgen-4.9.13_orig/libsrc/occ/Partition_Spliter.cxx netgen-4.9.13_new/libsrc/occ/Partition_Spliter.cxx +--- netgen-4.9.13_orig/libsrc/occ/Partition_Spliter.cxx 2009-08-24 06:12:24.000000000 +0400 ++++ netgen-4.9.13_new/libsrc/occ/Partition_Spliter.cxx 2014-07-22 13:01:28.000000000 +0400 +@@ -79,6 +79,8 @@ + #include <GeomAdaptor_Curve.hxx> + #include <TopOpeBRepTool_CurveTool.hxx> + ++#include <Standard_Version.hxx> ++ + #ifdef DEB + //# define PART_PERF + #endif +@@ -1169,7 +1171,12 @@ + for (; j<=nbj && ok; ++j) { + if (Extrema.IsMin(j)) { + hasMin = Standard_True; ++#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060400 ++// porting to OCCT6.5.1 ++ ok = Extrema.SquareDistance(j) <= tol * tol; ++#else + ok = Extrema.Value(j) <= tol; ++#endif + } + } + } +diff -Naur netgen-4.9.13_orig/libsrc/occ/utilities.h netgen-4.9.13_new/libsrc/occ/utilities.h +--- netgen-4.9.13_orig/libsrc/occ/utilities.h 2009-08-24 06:12:24.000000000 +0400 ++++ netgen-4.9.13_new/libsrc/occ/utilities.h 2014-07-22 13:01:28.000000000 +0400 +@@ -33,6 +33,7 @@ + + #include <string> + #include <iostream> ++#include <iomanip> + #include <cstdlib> + // #include "SALOME_Log.hxx" + +diff -Naur netgen-4.9.13_orig/libsrc/stlgeom/stlgeommesh.cpp netgen-4.9.13_new/libsrc/stlgeom/stlgeommesh.cpp +--- netgen-4.9.13_orig/libsrc/stlgeom/stlgeommesh.cpp 2009-08-10 15:40:51.000000000 +0400 ++++ netgen-4.9.13_new/libsrc/stlgeom/stlgeommesh.cpp 2014-07-22 13:01:28.000000000 +0400 +@@ -1435,7 +1435,8 @@ + + if (!optstring || strlen(optstring) == 0) + { +- mparam.optimize2d = "smcm"; ++ //mparam.optimize2d = (char*)"smcm"; ++ mparam.optimize2d = (char*)"smcm"; + } + else + { +@@ -1451,7 +1452,8 @@ + mparam.grading); + mesh -> LoadLocalMeshSize (mparam.meshsizefilename); + mesh -> CalcLocalHFromSurfaceCurvature (stlparam.resthsurfmeshcurvfac); +- mparam.optimize2d = "cmsmSm"; ++ //mparam.optimize2d = (char*)"cmsmSm"; ++ mparam.optimize2d = (char*)"cmsmSm"; + STLSurfaceOptimization (*stlgeometry, *mesh, mparam); + #ifdef STAT_STREAM + (*statout) << GetTime() << " & "; +@@ -1557,7 +1559,8 @@ + + if (!optstring || strlen(optstring) == 0) + { +- mparam.optimize3d = "cmdmstm"; ++ //mparam.optimize3d = "cmdmstm"; ++ mparam.optimize3d = (char*)"cmdmstm"; + } + else + { +diff -Naur netgen-4.9.13_orig/nglib/nglib.h netgen-4.9.13_new/nglib/nglib.h +--- netgen-4.9.13_orig/nglib/nglib.h 2010-05-18 15:20:25.000000000 +0400 ++++ netgen-4.9.13_new/nglib/nglib.h 2014-07-22 13:01:28.000000000 +0400 +@@ -24,7 +24,7 @@ + // Philippose - 14.02.2009 + // Modifications for creating a DLL in Windows + #ifdef WIN32 +- #ifdef NGLIB_EXPORTS || nglib_EXPORTS ++ #if defined NGLIB_EXPORTS || defined nglib_EXPORTS + #define DLL_HEADER __declspec(dllexport) + #else + #define DLL_HEADER __declspec(dllimport) diff --git a/salome-netgenplugin.profile b/salome-netgenplugin.profile new file mode 100644 index 000000000000..1897d5041996 --- /dev/null +++ b/salome-netgenplugin.profile @@ -0,0 +1,10 @@ +export NETGEN_ROOT_DIR=/opt/salome/netgenplugin +export NETGENPLUGIN_ROOT_DIR=/opt/salome/netgenplugin + +export PYTHONPATH=$NETGENPLUGIN_ROOT_DIR/lib/python2.7/site-packages/salome:$PYTHONPATH + +export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$NETGEN_ROOT_DIR/lib +export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$NETGENPLUGIN_ROOT_DIR/lib/salome + +export PATH=$PATH:$NETGEN_ROOT_DIR/bin +export PATH=$PATH:$NETGENPLUGIN_ROOT_DIR/bin/salome |