[SCM] Gmsh packaging. Gmsh is an automatic 3D finite element mesh generator. branch, master, updated. debian/2.5.1_beta2_svn11604_dfsg-3-3-g7064590

Anton Gladky gladky.anton at gmail.com
Sun Apr 8 05:34:03 UTC 2012


The following commit has been merged in the master branch:
commit c805ae4c4428a419aa15c18b9fcc151a1682ab4d
Author: Anton Gladky <gladky.anton at gmail.com>
Date:   Sun Apr 8 07:32:49 2012 +0200

    Fix linking problem of shared library.

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a9925b3..570439e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -797,15 +797,6 @@ if(HAVE_SOLVER)
 endif(HAVE_SOLVER)
 
 if(ENABLE_OCC)
-  if(WIN32 OR CYGWIN)
-    if(HAVE_64BIT_SIZE_T)
-      set(OCC_SYS_NAME win64)
-    else(HAVE_64BIT_SIZE_T)
-      set(OCC_SYS_NAME win32)
-    endif(HAVE_64BIT_SIZE_T)
-  else(WIN32 OR CYGWIN)
-    set(OCC_SYS_NAME ${CMAKE_SYSTEM_NAME})
-  endif(WIN32 OR CYGWIN)
   set(OCC_LIBS_REQUIRED
       # subset of DataExchange
       TKSTEP TKSTEP209 TKSTEPAttr TKSTEPBase TKIGES TKXSBase
@@ -816,6 +807,30 @@ if(ENABLE_OCC)
       TKBRep TKGeomBase TKG3d TKG2d
       # FoundationClasses
       TKAdvTools TKMath TKernel)
+  # First try to detect OpenCascade Community Edition, based on CMake
+  find_package(OCE QUIET COMPONENTS ${OCC_LIBS_REQUIRED})
+  if(OCE_ALL_FOUND)
+    list(APPEND EXTERNAL_LIBRARIES ${OCC_LIBS_REQUIRED})
+    list(APPEND EXTERNAL_INCLUDES ${OCE_INCLUDE_DIRS})
+    set_config_option(HAVE_OCC "OpenCascade(OCE)")
+    add_definitions(-DHAVE_NO_OCC_CONFIG_H)
+    if(HAVE_64BIT_SIZE_T)
+      add_definitions(-D_OCC64)
+    endif(HAVE_64BIT_SIZE_T)
+    if(CYGWIN)
+      list(APPEND EXTERNAL_LIBRARIES "winspool")
+    elseif(MSVC)
+      add_definitions(-DWNT)
+    endif(CYGWIN)
+  else(OCE_ALL_FOUND)
+    if(OCE_FOUND)
+      message(STATUS "Found OCE version ${OCE_VERSION}, but those libraries are missing: " ${OCE_MISSING_TOOLKITS})
+    endif(OCE_FOUND)
+    if(WIN32 OR CYGWIN)
+      set(OCC_SYS_NAME win32)
+    else(WIN32 OR CYGWIN)
+      set(OCC_SYS_NAME ${CMAKE_SYSTEM_NAME})
+    endif(WIN32 OR CYGWIN)
   list(LENGTH OCC_LIBS_REQUIRED NUM_OCC_LIBS_REQUIRED)
   set(OCC_LIBS)
   foreach(OCC ${OCC_LIBS_REQUIRED})
@@ -852,6 +867,7 @@ if(ENABLE_OCC)
       endif(NOT OCC_CONFIG_H)
     endif(OCC_INC)
   endif(NUM_OCC_LIBS EQUAL NUM_OCC_LIBS_REQUIRED)
+  endif(OCE_ALL_FOUND)
   if(HAVE_OCC AND ENABLE_SALOME)
     add_subdirectory(contrib/Salome)
     include_directories(contrib/Salome)
@@ -999,7 +1015,7 @@ endforeach(DIR)
 # want to build the lib we need to recompile everything (the first
 # time--it's a separate target)
 add_library(lib STATIC EXCLUDE_FROM_ALL ${GMSH_SRC})
-set_target_properties(lib PROPERTIES OUTPUT_NAME Gmsh)
+set_target_properties(lib PROPERTIES OUTPUT_NAME gmsh)
 if(MSVC)
   set_target_properties(lib PROPERTIES DEBUG_POSTFIX d) 
   if(ENABLE_MSVC_STATIC_RUNTIME)
@@ -1009,7 +1025,7 @@ endif(MSVC)
 
 # shared library target: we don't build it by default either
 add_library(shared SHARED EXCLUDE_FROM_ALL ${GMSH_SRC})
-set_target_properties(shared PROPERTIES OUTPUT_NAME Gmsh)
+set_target_properties(shared PROPERTIES OUTPUT_NAME gmsh1)
 if(HAVE_LAPACK AND LAPACK_FLAGS)
   set_target_properties(shared PROPERTIES LINK_FLAGS ${LAPACK_FLAGS})
 endif(HAVE_LAPACK AND LAPACK_FLAGS)
@@ -1017,7 +1033,7 @@ if(MSVC AND ENABLE_MSVC_STATIC_RUNTIME)
   message("WARNING: By enabling ENABLE_MSVC_STATIC_RUNTIME, shared library wont link. "
           "Change in msvc /MT flag to /MD in the shared project properties")
 endif(MSVC AND ENABLE_MSVC_STATIC_RUNTIME)		  
-target_link_libraries(shared ${LINK_LIBRARIES})
+target_link_libraries(shared ${LINK_LIBRARIES} -shared -lgl2ps -lGL -lglut)
 
 # binary targets
 if(HAVE_FLTK)
@@ -1032,7 +1048,7 @@ else(HAVE_FLTK)
   add_executable(gmsh_dynamic EXCLUDE_FROM_ALL Common/Main.cpp)
   target_link_libraries(gmsh_dynamic shared)
 endif(HAVE_FLTK)
-target_link_libraries(gmsh ${LINK_LIBRARIES})
+target_link_libraries(gmsh ${LINK_LIBRARIES} -lgl2ps -lGL -lglut)
 
 # increase stack to 16Mb on Windows to avoid overflows in recursive
 # tet classification for large 3D Delaunay grids + force static
@@ -1074,7 +1090,7 @@ if(UNIX)
 endif(UNIX)
 
 set(WELCOME_FILE ${CMAKE_CURRENT_SOURCE_DIR}/doc/WELCOME.txt)
-set(LICENSE_FILE ${CMAKE_CURRENT_SOURCE_DIR}/doc/LICENSE.txt)
+#set(LICENSE_FILE ${CMAKE_CURRENT_SOURCE_DIR}/doc/LICENSE.txt)
 set(CREDITS_FILE ${CMAKE_CURRENT_SOURCE_DIR}/doc/CREDITS.txt)
 file(GLOB TUTORIAL_FILES ${CMAKE_CURRENT_SOURCE_DIR}/tutorial/?*.*)
 file(GLOB DEMO_FILES ${CMAKE_CURRENT_SOURCE_DIR}/demos/?*.*)
@@ -1169,7 +1185,7 @@ endif(TEXI2PDF)
 if(MAKEINFO AND TEXI2PDF)
   add_custom_target(doc COMMAND ${CMAKE_COMMAND} -E tar zcf 
                     ${CMAKE_CURRENT_BINARY_DIR}/gmsh-${GMSH_VERSION}-doc.tgz
-                    doc/CREDITS.txt doc/LICENSE.txt doc/VERSIONS.txt
+                    doc/CREDITS.txt doc/VERSIONS.txt
                     doc/gmsh.1 doc/texinfo/gmsh.html doc/texinfo/gmsh.info 
                     doc/texinfo/gmsh.pdf doc/texinfo/gmsh.txt
                     COMMAND ${CMAKE_COMMAND} -E remove ${TEX_OBJ}
diff --git a/Graphics/CMakeLists.txt b/Graphics/CMakeLists.txt
index 1bf985a..3f3c08c 100644
--- a/Graphics/CMakeLists.txt
+++ b/Graphics/CMakeLists.txt
@@ -15,7 +15,6 @@ set(SRC
   drawScales.cpp 
   drawGraph2d.cpp 
   drawGlyph.cpp 
-  gl2ps.cpp
   gl2gif.cpp
   gl2jpeg.cpp
   gl2png.cpp
diff --git a/Plugin/Bubbles.cpp b/Plugin/Bubbles.cpp
index cc5170d..34285b8 100644
--- a/Plugin/Bubbles.cpp
+++ b/Plugin/Bubbles.cpp
@@ -30,7 +30,7 @@ std::string GMSH_BubblesPlugin::getHelp() const
 {
   return "Plugin(Bubbles) constructs a geometry consisting of "
     "`bubbles' inscribed in the Voronoi of an input triangulation. "
-    "`ShrinkFactor' allows to change the size of the bubbles. "
+    "`ShrinkFactor' allows one to change the size of the bubbles. "
     "The plugin expects a triangulation in the `z = 0' plane to exist "
     "in the current model.\n\n"
     "Plugin(Bubbles) creates one `.geo' file.";
diff --git a/contrib/lbfgs/alglibinternal.cpp b/contrib/lbfgs/alglibinternal.cpp
index e8a508e..34b2f70 100755
--- a/contrib/lbfgs/alglibinternal.cpp
+++ b/contrib/lbfgs/alglibinternal.cpp
@@ -3679,8 +3679,8 @@ void matrixvectormultiply(/* Real    */ ae_matrix* a,
         {
             return;
         }
-        ae_assert(j2-j1==ix2-ix1, "MatrixVectorMultiply: A and X dont match!", _state);
-        ae_assert(i2-i1==iy2-iy1, "MatrixVectorMultiply: A and Y dont match!", _state);
+        ae_assert(j2-j1==ix2-ix1, "MatrixVectorMultiply: A and X don't match!", _state);
+        ae_assert(i2-i1==iy2-iy1, "MatrixVectorMultiply: A and Y don't match!", _state);
         
         /*
          * beta*y
@@ -3716,8 +3716,8 @@ void matrixvectormultiply(/* Real    */ ae_matrix* a,
         {
             return;
         }
-        ae_assert(i2-i1==ix2-ix1, "MatrixVectorMultiply: A and X dont match!", _state);
-        ae_assert(j2-j1==iy2-iy1, "MatrixVectorMultiply: A and Y dont match!", _state);
+        ae_assert(i2-i1==ix2-ix1, "MatrixVectorMultiply: A and X don't match!", _state);
+        ae_assert(j2-j1==iy2-iy1, "MatrixVectorMultiply: A and Y don't match!", _state);
         
         /*
          * beta*y
diff --git a/debian/patches/fix_FTBFS_linking.patch b/debian/patches/fix_FTBFS_linking.patch
index a45a63b..68dc0ab 100644
--- a/debian/patches/fix_FTBFS_linking.patch
+++ b/debian/patches/fix_FTBFS_linking.patch
@@ -1,6 +1,6 @@
 Description: this linking causes a FTBFS 
 Author: Anton Gladky <gladky.anton at gmail.com>
-Last-Update: 2012-04-06
+Last-Update: 2012-04-08
 
 --- a/CMakeLists.txt
 +++ b/CMakeLists.txt
@@ -9,7 +9,7 @@ Last-Update: 2012-04-06
            "Change in msvc /MT flag to /MD in the shared project properties")
  endif(MSVC AND ENABLE_MSVC_STATIC_RUNTIME)		  
 -target_link_libraries(shared ${LINK_LIBRARIES})
-+
++target_link_libraries(shared ${LINK_LIBRARIES} -shared -lgl2ps -lGL -lglut)
  
  # binary targets
  if(HAVE_FLTK)
diff --git a/doc/texinfo/gmsh.texi b/doc/texinfo/gmsh.texi
index d938c02..3939391 100644
--- a/doc/texinfo/gmsh.texi
+++ b/doc/texinfo/gmsh.texi
@@ -1398,7 +1398,7 @@ contain floating point formatting characters: @code{%e}, @code{%g},
 etc.). The eigth case permits to use the value of a @var{char-option} as
 a @var{char-expression}. The ninth case gets the value of an environment
 variable from the operating system. The last case in the definition
-allows to ask the user for a value interactively. The various
+allows one to ask the user for a value interactively. The various
 @w{@var{char-option}s} are listed in @ref{Options}.
 
 Character expressions are mostly used to specify non-numeric options and
@@ -2921,7 +2921,7 @@ above.
 @item Extrude @{ Surface @{ @var{expression-list} @}; @var{layers} < Using Index[@var{expr}]; > < Using View[@var{expr}]; > @}
 Extrudes a boundary layer from the specified surfaces. If no view is
 specified, the boundary layer is created using gouraud-shaped (smoothed)
-normal field. Specifying a boundary layer index allows to extrude
+normal field. Specifying a boundary layer index allows one to extrude
 several independent boundary layers (with independent normal smoothing).
 
 @item Transfinite Line @{ @var{expression-list} @} | "*" = @var{expression} < Using Progression | Bump @var{expression} >;
diff --git a/utils/api_demos/CMakeLists.txt b/utils/api_demos/CMakeLists.txt
index e89693a..13637bc 100644
--- a/utils/api_demos/CMakeLists.txt
+++ b/utils/api_demos/CMakeLists.txt
@@ -9,45 +9,691 @@ else(DEFINED CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose build type")
 endif(DEFINED CMAKE_BUILD_TYPE)
 
-project(api_demos CXX)
+project(api_demos CXX C)
 
-add_subdirectory(../.. "${CMAKE_CURRENT_BINARY_DIR}/gmsh")
+# this variable controls the default value of the "ENABLE_XXX" options which are
+# normally set to ON (useful if you want to configure a minimal version of Gmsh:
+# e.g. "cmake -DDEFAULT=0 -DENABLE_POST=1 -DENABLE_PARSER=1")
+set(DEFAULT ON CACHE INTERNAL "Default value for options")
 
-include_directories(../../Common ../../Numeric ../../Geo ../../Mesh 
-   ../../Solver ../../Post ../../Plugin ../../Graphics ../../contrib/ANN/include
-   ../../contrib/DiscreteIntegration ${GMSH_EXTERNAL_INCLUDE_DIRS}
-   ${CMAKE_CURRENT_BINARY_DIR}/gmsh/Common)
+option(ENABLE_GMSH "Enable Gmsh" ${DEFAULT})
+option(ENABLE_ANN "Enable ANN to compute Approximate Nearest Neighbors" ${DEFAULT})
+option(ENABLE_KBIPACK "Enable Kbipack for homology solver" ${DEFAULT})
+option(ENABLE_MATHEX "Enable MathEx expression parser" ${DEFAULT})
+option(ENABLE_OCC "Enable Open CASCADE geometrical models" ${DEFAULT})
+option(ENABLE_PETSC "Enable PETSc linear algebra solvers" ${DEFAULT})
+option(ENABLE_SLEPC "Enable SLEPc eigensolvers" ${DEFAULT})
+option(ENABLE_FLTK "Build FLTK GUI" ${DEFAULT})
+option(ENABLE_FL_TREE "Enable FLTK tree browser widget" ${DEFAULT})
+option(ENABLE_MED "Enable MED mesh and post-processing file formats" ${DEFAULT})
+option(ENABLE_MMG3D "Enable 3D Mobile Mesh Generation" ${DEFAULT})
+option(ENABLE_TETGEN "Enable Tetgen mesh generator" ${DEFAULT})
+option(ENABLE_TETGEN_NEW "Enable experimental version of Tetgen" OFF)
+option(ENABLE_GRAPHICS "Compile-in OpenGL graphics even if there is no GUI" OFF)
+option(ENABLE_MESH "Build the mesh module" ${DEFAULT})
+option(ENABLE_POST "Build the post-processing module" ${DEFAULT})
+option(ENABLE_PLUGINS "Build the post-processing plugins" ${DEFAULT})
+option(ENABLE_DINTEGRATION "Enable discrete integration and levelsets" ${DEFAULT})
+option(ENABLE_BLAS_LAPACK "Use BLAS and Lapack for linear algebra" ON)
+
+include(CheckTypeSize)
+include(CheckFunctionExists)
+include(CheckIncludeFile)
+
+macro(find_all_libraries VARNAME LISTNAME PATH SUFFIX)
+  set(${VARNAME})
+  list(LENGTH ${LISTNAME} NUM_LIST)
+  foreach(LIB ${${LISTNAME}})
+    find_library(FOUND_LIB ${LIB} PATHS ${PATH} PATH_SUFFIXES ${SUFFIX})
+    if(FOUND_LIB)
+      list(APPEND ${VARNAME} ${FOUND_LIB})
+    endif(FOUND_LIB)
+    set(FOUND_LIB FOUND_LIB-NOTFOUND CACHE INTERNAL "")
+    # unset(FOUND_LIB CACHE) # cleaner, but only available in cmake >= 2.6.4
+  endforeach(LIB)
+  list(LENGTH ${VARNAME} NUM_FOUND_LIBRARIES)
+  if(NUM_FOUND_LIBRARIES LESS NUM_LIST)
+    set(${VARNAME})
+  endif(NUM_FOUND_LIBRARIES LESS NUM_LIST)
+endmacro(find_all_libraries)
+
+macro(set_config_option VARNAME STRING)
+  set(${VARNAME} TRUE)
+  list(APPEND CONFIG_OPTIONS ${STRING})
+  message(STATUS "Found " ${STRING})
+endmacro(set_config_option)
+
+# check if the machine is 64 bits (this is more reliable than using
+# CMAKE_SIZEOF_VOID_P, which does not seem to work e.g. on some Suse
+# machines)
+check_type_size("void*" SIZEOF_VOID_P)
+if(SIZEOF_VOID_P EQUAL 8)
+  set_config_option(HAVE_64BIT_SIZE_T "Have64BitSizeT")
+endif(SIZEOF_VOID_P EQUAL 8)
+
+if(ENABLE_BLAS_LAPACK)
+  if(MSVC)
+    # on Windows with Visual C++ try really hard to find blas/lapack
+    # *without* requiring a Fortran compiler: 1) try to find the Intel
+    # MKL libs using the standard search path; if not found 2) try to
+    # get the reference blas/lapack libs (useful for users with no
+    # Fortran compiler and no MKL license, who can just download our
+    # precompiled "gmsh-dep" package)
+    if(HAVE_64BIT_SIZE_T)
+      set(MKL_PATH em64t/lib)
+    else(HAVE_64BIT_SIZE_T)
+      set(MKL_PATH ia32/lib)
+    endif(HAVE_64BIT_SIZE_T)
+    set(MKL_LIBS_REQUIRED libguide40 mkl_intel_c mkl_intel_thread mkl_core)
+    find_all_libraries(LAPACK_LIBRARIES MKL_LIBS_REQUIRED "" ${MKL_PATH})
+    if(LAPACK_LIBRARIES)
+      set_config_option(HAVE_BLAS "Blas(IntelMKL)")
+      set_config_option(HAVE_LAPACK "Lapack(IntelMKL)")
+    else(LAPACK_LIBRARIES)
+      set(REFLAPACK_LIBS_REQUIRED lapack blas g2c gcc)
+      find_all_libraries(LAPACK_LIBRARIES REFLAPACK_LIBS_REQUIRED "" "")
+      if(LAPACK_LIBRARIES)
+        set_config_option(HAVE_BLAS "Blas(Ref)")
+        set_config_option(HAVE_LAPACK "Lapack(Ref)")
+      endif(LAPACK_LIBRARIES)
+    endif(LAPACK_LIBRARIES)
+  elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+    # on Linux try to find the Intel MKL without a Fortran compiler
+    if(HAVE_64BIT_SIZE_T)
+      set(MKL_PATH lib/em64t)
+    else(HAVE_64BIT_SIZE_T)
+      set(MKL_PATH lib/32)
+    endif(HAVE_64BIT_SIZE_T)
+    set(MKL_LIBS_REQUIRED mkl_gf_lp64 iomp5 mkl_gnu_thread mkl_core guide pthread)
+    find_all_libraries(LAPACK_LIBRARIES MKL_LIBS_REQUIRED "" ${MKL_PATH})
+    if(NOT LAPACK_LIBRARIES)
+      #match lapack 9.0 on 64bit
+      set(MKL_LIBS_REQUIRED mkl_lapack mkl_em64t guide)
+      find_all_libraries(LAPACK_LIBRARIES MKL_LIBS_REQUIRED "" ${MKL_PATH})
+    endif(NOT LAPACK_LIBRARIES)
+    if(LAPACK_LIBRARIES)
+      set_config_option(HAVE_BLAS "Blas(IntelMKL)")
+      set_config_option(HAVE_LAPACK "Lapack(IntelMKL)")
+    else(LAPACK_LIBRARIES)
+      # on Linux also try to find ATLAS without a Fortran compiler,
+      # because cmake ships with a buggy FindBLAS e.g. on Ubuntu Lucid
+      # Lynx
+      set(ATLAS_LIBS_REQUIRED lapack f77blas cblas atlas)
+      find_all_libraries(LAPACK_LIBRARIES ATLAS_LIBS_REQUIRED "" "")
+      if(LAPACK_LIBRARIES)
+        set_config_option(HAVE_BLAS "Blas(ATLAS)")
+        set_config_option(HAVE_LAPACK "Lapack(ATLAS)")
+      endif(LAPACK_LIBRARIES)
+    endif(LAPACK_LIBRARIES)
+  elseif(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
+    # on SunOS we know blas and lapack are available in sunperf
+    set(LAPACK_FLAGS -library=sunperf)
+    set_config_option(HAVE_BLAS "Blas(SubPerf)")
+    set_config_option(HAVE_LAPACK "Lapack(SunPerf)")
+  elseif(APPLE)
+    # on Mac we also know that blas and lapack are available
+    set(LAPACK_LIBRARIES "-framework vecLib")
+    set_config_option(HAVE_BLAS "Blas(VecLib)")
+    set_config_option(HAVE_LAPACK "Lapack(VecLib)")
+  endif(MSVC)
+  if(NOT HAVE_BLAS OR NOT HAVE_LAPACK)
+    # if we haven't found blas and lapack without using the standard
+    # cmake tests, do it (this requires a working Fortran compiler)
+    enable_language(Fortran)
+    find_package(BLAS)
+    if(BLAS_FOUND)
+      set_config_option(HAVE_BLAS "Blas")
+      find_package(LAPACK)
+      if(LAPACK_FOUND)
+        set_config_option(HAVE_LAPACK "Lapack")
+      else(LAPACK_FOUND)
+        set(LAPACK_LIBRARIES ${BLAS_LIBRARIES})
+      endif(LAPACK_FOUND)
+      if(CMAKE_Fortran_COMPILER_ID MATCHES "GNU")
+        if(CMAKE_Fortran_COMPILER MATCHES "gfortran")
+          list(APPEND LAPACK_LIBRARIES gfortran)
+        elseif(CMAKE_Fortran_COMPILER MATCHES "f95")
+          list(APPEND LAPACK_LIBRARIES gfortran)
+        elseif(CMAKE_Fortran_COMPILER MATCHES "g77")
+          list(APPEND LAPACK_LIBRARIES g2c)
+        endif(CMAKE_Fortran_COMPILER MATCHES "gfortran")
+      endif(CMAKE_Fortran_COMPILER_ID MATCHES "GNU")
+    endif(BLAS_FOUND)
+  endif(NOT HAVE_BLAS OR NOT HAVE_LAPACK)
+  if(NOT HAVE_BLAS OR NOT HAVE_LAPACK)
+    message("WARNING: Could not find Blas or Lapack: most meshing algorithms "
+            "will not be functional")
+  endif(NOT HAVE_BLAS OR NOT HAVE_LAPACK)
+endif(ENABLE_BLAS_LAPACK)
+
+if(ENABLE_KBIPACK)
+  find_library(GMP_LIB gmp)
+  if(GMP_LIB)
+    find_path(GMP_INC "gmp.h" PATH_SUFFIXES src include)
+    if(GMP_INC)
+      set_config_option(HAVE_GMP "GMP")
+      list(APPEND EXTERNAL_LIBRARIES ${GMP_LIB})
+      list(APPEND EXTERNAL_INCLUDES ${GMP_INC})
+      include_directories(../../contrib/kbipack)
+      set_config_option(HAVE_KBIPACK "Kbipack")
+    endif(GMP_INC)
+  endif(GMP_LIB)
+endif(ENABLE_KBIPACK)
+
+if(ENABLE_MATHEX)
+  include_directories(../../contrib/MathEx)
+  set_config_option(HAVE_MATHEX "MathEx")
+endif(ENABLE_MATHEX)
+
+if(ENABLE_PETSC)
+    set(ENV_PETSC_DIR $ENV{PETSC_DIR})
+    set(ENV_PETSC_ARCH $ENV{PETSC_ARCH})
+    if(EXISTS ${ENV_PETSC_DIR}/${ENV_PETSC_ARCH}/conf/petscvariables)
+      # old-style PETSc installations (using PETSC_DIR and PETSC_ARCH)
+      set_config_option(HAVE_PETSC "PETSc")
+      file(STRINGS ${ENV_PETSC_DIR}/${ENV_PETSC_ARCH}/conf/petscvariables 
+           PETSC_VARIABLES NEWLINE_CONSUME)
+      # find include directories
+      list(APPEND EXTERNAL_INCLUDES ${ENV_PETSC_DIR}/include)
+      list(APPEND EXTERNAL_INCLUDES ${ENV_PETSC_DIR}/${ENV_PETSC_ARCH}/include)
+      string(REGEX MATCH "PACKAGES_INCLUDES = [^\n\r]*" PETSC_PACKAGES_INCLUDES
+             ${PETSC_VARIABLES})
+      if(PETSC_PACKAGES_INCLUDES)
+        string(REPLACE "PACKAGES_INCLUDES = " "" PETSC_PACKAGES_INCLUDES
+               ${PETSC_PACKAGES_INCLUDES})
+        if(PETSC_PACKAGES_INCLUDES)
+          string(REPLACE "-I" "" PETSC_PACKAGES_INCLUDES ${PETSC_PACKAGES_INCLUDES})
+          string(REPLACE " " ";" PETSC_PACKAGES_INCLUDES ${PETSC_PACKAGES_INCLUDES})
+          foreach(VAR ${PETSC_PACKAGES_INCLUDES})
+            list(APPEND EXTERNAL_INCLUDES ${VAR})
+          endforeach(VAR)
+        endif(PETSC_PACKAGES_INCLUDES)
+      endif(PETSC_PACKAGES_INCLUDES)
+      # find libraries (<= 3.0)
+      set(PETSC_LIBS_REQUIRED petscksp petscdm petscmat petscvec petsc)
+      find_all_libraries(PETSC_LIBS PETSC_LIBS_REQUIRED 
+                         ${ENV_PETSC_DIR}/${ENV_PETSC_ARCH}/lib "")
+      # petsc 3.1 creates only one library (libpetsc)
+      if(NOT PETSC_LIBS)
+        find_library(PETSC_LIBS petsc PATHS ${ENV_PETSC_DIR}/${ENV_PETSC_ARCH}/lib)
+      endif(NOT PETSC_LIBS)
+      # find slepc (needs to be linked in before petsc)
+      if(ENABLE_SLEPC)
+        set(ENV_SLEPC_DIR $ENV{SLEPC_DIR})
+        find_library(SLEPC_LIB slepc PATHS ${ENV_SLEPC_DIR}/${ENV_PETSC_ARCH}/lib)
+        if(SLEPC_LIB)
+          find_path(SLEPC_INC "slepc.h" PATHS ${ENV_SLEPC_DIR} PATH_SUFFIXES include 
+                    ${ENV_PETSC_ARCH}/include include/slepc)
+          if(SLEPC_INC)
+            set_config_option(HAVE_SLEPC "SLEPc")
+            list(APPEND EXTERNAL_LIBRARIES ${SLEPC_LIB})
+            list(APPEND EXTERNAL_INCLUDES ${SLEPC_INC}) 
+            find_path(SLEPC_INC2 "slepcconf.h" PATHS ${ENV_SLEPC_DIR} 
+                      PATH_SUFFIXES ${ENV_PETSC_ARCH}/include)
+            if(SLEPC_INC2)
+              list(APPEND EXTERNAL_INCLUDES ${SLEPC_INC2}) 
+            endif(SLEPC_INC2)
+          endif(SLEPC_INC)
+        endif(SLEPC_LIB)
+        if(NOT HAVE_SLEPC AND NOT ENV_SLEPC_DIR)
+           message("WARNING: Export SLEPC_DIR before calling cmake")
+        endif(NOT HAVE_SLEPC AND NOT ENV_SLEPC_DIR)
+      endif(ENABLE_SLEPC)
+      list(APPEND EXTERNAL_LIBRARIES ${PETSC_LIBS})
+      # find additional libraries to link with
+      string(REGEX MATCH "PACKAGES_LIBS = [^\n\r]*" PLIBS ${PETSC_VARIABLES})
+      if(PLIBS)
+        string(REPLACE "PACKAGES_LIBS = " "" PLIBS ${PLIBS})
+        string(STRIP ${PLIBS} PLIBS)
+        list(APPEND EXTERNAL_LIBRARIES "${PLIBS}")
+      endif(PLIBS)
+      string(REGEX MATCH "PETSC_EXTERNAL_LIB_BASIC = [^\n\r]*" PLIBS_BASIC ${PETSC_VARIABLES})
+      if(PLIBS_BASIC)
+        string(REPLACE "PETSC_EXTERNAL_LIB_BASIC = " "" PLIBS_BASIC ${PLIBS_BASIC})
+        string(STRIP ${PLIBS_BASIC} PLIBS_BASIC)
+        list(APPEND EXTERNAL_LIBRARIES "${PLIBS_BASIC}")
+      endif(PLIBS_BASIC)
+      string(REGEX MATCH "PCC_LINKER_LIBS = [^\n\r]*" LLIBS ${PETSC_VARIABLES})
+      if(LLIBS)
+        string(REPLACE "PCC_LINKER_LIBS = " "" LLIBS ${LLIBS})
+        string(STRIP ${LLIBS} LLIBS)
+        list(APPEND EXTERNAL_LIBRARIES "${LLIBS}")
+      endif(LLIBS)
+    else(EXISTS ${ENV_PETSC_DIR}/${ENV_PETSC_ARCH}/conf/petscvariables)
+      # new-style PETSc installations (in standard system directories)
+      find_library(PETSC_LIBS petsc)
+      find_path(PETSC_INC "petsc.h" PATH_SUFFIXES include/petsc)
+      if(PETSC_LIBS AND PETSC_INC)
+        set_config_option(HAVE_PETSC "PETSc")
+        if(ENABLE_SLEPC)
+          find_library(SLEPC_LIB slepc)
+          find_path(SLEPC_INC "slepc.h" PATH_SUFFIXES include/slepc)
+          if(SLEPC_LIB AND SLEPC_INC)
+            set_config_option(HAVE_SLEPC "SLEPc")
+            list(APPEND EXTERNAL_LIBRARIES ${SLEPC_LIB})
+            list(APPEND EXTERNAL_INCLUDES ${SLEPC_INC}) 
+          endif(SLEPC_LIB AND SLEPC_INC)
+        endif(ENABLE_SLEPC)
+        list(APPEND EXTERNAL_LIBRARIES ${PETSC_LIBS})
+        list(APPEND EXTERNAL_INCLUDES ${PETSC_INC}) 
+      endif(PETSC_LIBS AND PETSC_INC)
+    endif(EXISTS ${ENV_PETSC_DIR}/${ENV_PETSC_ARCH}/conf/petscvariables)
+    if(NOT HAVE_PETSC AND NOT ENV_PETSC_DIR)
+       message("WARNING: Export PETSC_DIR before calling cmake")
+    endif(NOT HAVE_PETSC AND NOT ENV_PETSC_DIR)
+    if(NOT HAVE_PETSC AND NOT ENV_PETSC_ARCH)
+       message("WARNING: Export PETSC_ARCH before calling cmake")
+    endif(NOT HAVE_PETSC AND NOT ENV_PETSC_ARCH)
+  endif(ENABLE_PETSC)
+
+if(ENABLE_OCC)
+  if(WIN32 OR CYGWIN)
+    if(HAVE_64BIT_SIZE_T)
+      set(OCC_SYS_NAME win64)
+    else(HAVE_64BIT_SIZE_T)
+      set(OCC_SYS_NAME win32)
+    endif(HAVE_64BIT_SIZE_T)
+  else(WIN32 OR CYGWIN)
+    set(OCC_SYS_NAME ${CMAKE_SYSTEM_NAME})
+  endif(WIN32 OR CYGWIN)
+  set(OCC_LIBS_REQUIRED
+      # subset of DataExchange
+      TKSTEP TKSTEP209 TKSTEPAttr TKSTEPBase TKIGES TKXSBase
+      # ModelingAlgorithms
+      TKOffset TKFeat TKFillet TKBool TKShHealing TKMesh TKHLR TKBO TKPrim
+      TKTopAlgo TKGeomAlgo
+      # ModelingData
+      TKBRep TKGeomBase TKG3d TKG2d
+      # FoundationClasses
+      TKAdvTools TKMath TKernel)
+  list(LENGTH OCC_LIBS_REQUIRED NUM_OCC_LIBS_REQUIRED)
+  set(OCC_LIBS)
+  foreach(OCC ${OCC_LIBS_REQUIRED})
+    find_library(OCC_LIB ${OCC} HINTS ENV CASROOT PATH_SUFFIXES lib 
+                 ${OCC_SYS_NAME}/lib ${OCC_SYS_NAME}/vc8/lib)
+    if(OCC_LIB)
+      list(APPEND OCC_LIBS ${OCC_LIB})
+    else(OCC_LIB)
+      message(STATUS "OCC lib " ${OCC} " not Found")
+    endif(OCC_LIB)
+    set(OCC_LIB OCC_LIB-NOTFOUND CACHE INTERNAL "")
+    # unset(OCC_LIB CACHE) # cleaner, but only available in cmake >= 2.6.4
+  endforeach(OCC)
+  list(LENGTH OCC_LIBS NUM_OCC_LIBS)
+  if(NUM_OCC_LIBS EQUAL NUM_OCC_LIBS_REQUIRED)
+    find_path(OCC_INC "BRep_Tool.hxx" PATHS ENV CASROOT PATH_SUFFIXES inc 
+              include include/oce opencascade)
+    if(OCC_INC)
+      set_config_option(HAVE_OCC "OpenCascade")
+      list(APPEND EXTERNAL_LIBRARIES ${OCC_LIBS})
+      list(APPEND EXTERNAL_INCLUDES ${OCC_INC})
+      if(HAVE_64BIT_SIZE_T)
+        add_definitions(-D_OCC64)
+      endif(HAVE_64BIT_SIZE_T)
+      if(CYGWIN)
+        list(APPEND EXTERNAL_LIBRARIES "winspool")
+      elseif(MSVC)
+        add_definitions(-DWNT)
+      endif(CYGWIN)
+      find_path(OCC_CONFIG_H "config.h" PATHS ${OCC_INC} ${OCC_CONFIG_H_PATH}
+                NO_DEFAULT_PATH)
+      if(NOT OCC_CONFIG_H)
+        add_definitions(-DHAVE_NO_OCC_CONFIG_H)
+      endif(NOT OCC_CONFIG_H)
+    endif(OCC_INC)
+  endif(NUM_OCC_LIBS EQUAL NUM_OCC_LIBS_REQUIRED)
+endif(ENABLE_OCC)
+
+if(ENABLE_ANN)
+  find_library(ANN_LIB ann PATH_SUFFIXES lib)
+  find_path(ANN_INC "ANN.h" PATH_SUFFIXES src include ANN)
+  if(ANN_LIB AND ANN_INC)
+    list(APPEND EXTERNAL_LIBRARIES ${ANN_LIB})
+    list(APPEND EXTERNAL_INCLUDES ${ANN_INC})
+    set_config_option(HAVE_ANN "Ann")
+  else(ANN_LIB AND ANN_INC)
+    message(STATUS "System ANN not found - using contrib/ANN instead")
+    add_subdirectory(../contrib/ANN)
+    include_directories(../contrib/ANN/include)
+  endif(ANN_LIB AND ANN_INC)
+endif(ENABLE_ANN)
+
+find_library(GMSH_LIB gmsh PATH_SUFFIXES lib)
+find_path(GMSH_INC "Gmsh.h" PATH_SUFFIXES src include gmsh)
+if(GMSH_LIB AND GMSH_INC)
+  list(APPEND EXTERNAL_LIBRARIES ${GMSH_LIB})
+  list(APPEND EXTERNAL_INCLUDES ${GMSH_INC})
+  set_config_option(HAVE_GMSH "Gmsh")
+else(GMSH_LIB AND GMSH_INC)
+  message(STATUS "Gmsh.h not found")
+endif(GMSH_LIB AND GMSH_INC)
+
+find_library(ANTTWEAKBAR_LIB AntTweakBar PATH_SUFFIXES lib)
+find_path(ANTTWEAKBAR_INC "AntTweakBar.h" PATH_SUFFIXES src include AntTweakBar)
+if(ANTTWEAKBAR_LIB AND ANTTWEAKBAR_INC)
+  list(APPEND EXTERNAL_LIBRARIES ${ANTTWEAKBAR_LIB})
+  list(APPEND EXTERNAL_INCLUDES ${ANTTWEAKBAR_INC})
+  set_config_option(HAVE_ANTTWEAKBAR "AntTweakBar")
+else(ANTTWEAKBAR_LIB AND ANTTWEAKBAR_INC)
+  message(STATUS "ANTTWEAKBAR not found")
+endif(ANTTWEAKBAR_LIB AND ANTTWEAKBAR_INC)
+
+if(ENABLE_FLTK)
+  # first, try to use fltk-config for fltk >= 1.3 (FindFLTK is buggy
+  # on Unix, where e.g. xft and xinerama options are not dealt with)
+  find_program(FLTK_CONFIG_SCRIPT fltk-config)
+  if(FLTK_CONFIG_SCRIPT)
+    execute_process(COMMAND ${FLTK_CONFIG_SCRIPT} --api-version
+                    OUTPUT_VARIABLE FLTK_VERSION)
+    string(STRIP ${FLTK_VERSION} FLTK_VERSION)
+    if(FLTK_VERSION GREATER 1.1)
+      set_config_option(HAVE_FLTK "Fltk")
+      message(STATUS "Using fltk-config script for Fltk " ${FLTK_VERSION})
+      execute_process(COMMAND ${FLTK_CONFIG_SCRIPT} --use-gl --use-images --includedir
+                      OUTPUT_VARIABLE FLTK_INCLUDE_DIR)
+      string(STRIP ${FLTK_INCLUDE_DIR} FLTK_INCLUDE_DIR)
+      list(APPEND EXTERNAL_INCLUDES ${FLTK_INCLUDE_DIR} ${FLTK_INCLUDE_DIR}/FL/images
+           ${FLTK_INCLUDE_DIR}/jpeg ${FLTK_INCLUDE_DIR}/zlib ${FLTK_INCLUDE_DIR}/png)
+      execute_process(COMMAND ${FLTK_CONFIG_SCRIPT} --use-gl --use-images --ldflags
+                      OUTPUT_VARIABLE FLTK_LIBRARIES)
+      string(STRIP ${FLTK_LIBRARIES} FLTK_LIBRARIES)
+      string(REGEX MATCH "fltk[_ ]jpeg" FLTK_JPEG ${FLTK_LIBRARIES})
+      string(REGEX MATCH "fltk[_ ]z" FLTK_Z ${FLTK_LIBRARIES})
+      string(REGEX MATCH "fltk[_ ]png" FLTK_PNG ${FLTK_LIBRARIES})
+    endif(FLTK_VERSION GREATER 1.1)
+  endif(FLTK_CONFIG_SCRIPT)
+  # then try the built-in FindFLTK module
+  if(NOT HAVE_FLTK)
+    set(FLTK_SKIP_FORMS TRUE)
+    set(FLTK_SKIP_FLUID TRUE)
+    find_package(FLTK)
+    if(FLTK_FOUND)
+      add_subdirectory(Fltk)
+      set_config_option(HAVE_FLTK "Fltk")
+      list(APPEND EXTERNAL_INCLUDES ${FLTK_INCLUDE_DIR})
+      # find fltk jpeg
+      find_library(FLTK_JPEG NAMES fltk_jpeg fltkjpeg)
+      if(FLTK_JPEG)
+        list(APPEND EXTERNAL_LIBRARIES ${FLTK_JPEG})
+        foreach(DIR ${FLTK_INCLUDE_DIR})
+          list(APPEND EXTERNAL_INCLUDES ${DIR}/FL/images ${DIR}/jpeg)
+        endforeach(DIR)
+      endif(FLTK_JPEG)
+      # find fltk zlib
+      find_library(FLTK_Z NAMES fltk_z fltkz)
+      if(FLTK_Z)
+        list(APPEND EXTERNAL_LIBRARIES ${FLTK_Z})
+        foreach(DIR ${FLTK_INCLUDE_DIR})
+          list(APPEND EXTERNAL_INCLUDES ${DIR}/FL/images ${DIR}/zlib)
+        endforeach(DIR)
+      endif(FLTK_Z)
+      # find fltk png
+      find_library(FLTK_PNG NAMES fltk_png fltkpng)
+      if(FLTK_PNG)
+        list(APPEND EXTERNAL_LIBRARIES ${FLTK_PNG})
+        foreach(DIR ${FLTK_INCLUDE_DIR})
+          list(APPEND EXTERNAL_INCLUDES ${DIR}/FL/images ${DIR}/png)
+        endforeach(DIR)
+      endif(FLTK_PNG)   
+    endif(FLTK_FOUND)
+  endif(NOT HAVE_FLTK)
+  if(HAVE_FLTK)
+    if(ENABLE_NATIVE_FILE_CHOOSER)
+      if(NOT FLTK_VERSION OR FLTK_VERSION EQUAL 1.1)
+        add_subdirectory(contrib/NativeFileChooser)
+        include_directories(contrib/NativeFileChooser)
+        add_definitions(-DFLTK1)
+      endif(NOT FLTK_VERSION OR FLTK_VERSION EQUAL 1.1)
+      set_config_option(HAVE_NATIVE_FILE_CHOOSER "NativeFileChooser")
+    endif(ENABLE_NATIVE_FILE_CHOOSER)
+    if(ENABLE_FL_TREE)
+      if(NOT FLTK_VERSION OR FLTK_VERSION EQUAL 1.1)
+        add_subdirectory(contrib/Fl_Tree)
+        include_directories(contrib/Fl_Tree)
+      endif(NOT FLTK_VERSION OR FLTK_VERSION EQUAL 1.1)
+      set_config_option(HAVE_FL_TREE "FlTree")
+    endif(ENABLE_FL_TREE)
+  endif(HAVE_FLTK)
+elseif(ENABLE_QT)
+  find_package(Qt4)
+  set(QT_USE_QTOPENGL TRUE)
+  include(${QT_USE_FILE})
+  if(QT_FOUND)
+    add_subdirectory(Qt)
+    set_config_option(HAVE_QT "Qt")
+    list(APPEND EXTERNAL_INCLUDES ${QT_INCLUDE_DIR})
+  endif(QT_FOUND)
+endif(ENABLE_FLTK)
 
 if(APPLE)
   set(glut "-framework GLUT")
 else(APPLE)
-  set(glut "glut")
+  list(APPEND EXTERNAL_LIBRARIES "glut")
 endif(APPLE)
 
+  if(ENABLE_MMG3D)
+    find_library(MMG3D_LIB mmg3dlib4.0 PATH_SUFFIXES lib)
+    find_path(MMG3D_INC "libmmg3d.h" PATH_SUFFIXES src include)
+    if(MMG3D_LIB AND MMG3D_INC)
+       list(APPEND EXTERNAL_LIBRARIES ${MMG3D_LIB})
+       list(APPEND EXTERNAL_INCLUDES ${MMG3D_INC})
+    else(MMG3D_LIB AND MMG3D_INC)
+       message(STATUS "System MMG3D not found - using contrib/mmg3d instead")
+       add_subdirectory(contrib/mmg3d)
+       include_directories(contrib/mmg3d/build/sources)
+    endif(MMG3D_LIB AND MMG3D_INC)
+    set_config_option(HAVE_MMG3D "Mmg3d")
+  endif(ENABLE_MMG3D)
+
+  if(ENABLE_TETGEN_NEW AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/contrib/TetgenNew/tetgen.h)
+    add_subdirectory(contrib/TetgenNew)
+    include_directories(contrib/TetgenNew)
+    set_config_option(HAVE_TETGEN "Tetgen(New)")
+    add_definitions(-DTETLIBRARY)
+    message("WARNING: You are including an experimental version of Tetgen "
+            "that is KNOWN TO BE BUGGY on 64 bits archs and on WIN32/MSVC.")
+  elseif(ENABLE_TETGEN AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/contrib/Tetgen/tetgen.h)
+    add_subdirectory(contrib/Tetgen)
+    include_directories(contrib/Tetgen)
+    set_config_option(HAVE_TETGEN "Tetgen")
+    add_definitions(-DTETLIBRARY)
+  elseif(ENABLE_TETGEN)
+    find_library(TETGEN_LIB tet PATH_SUFFIXES lib)
+    find_path(TETGEN_INC "tetgen.h" PATH_SUFFIXES src include tetgen)
+    if(TETGEN_LIB AND TETGEN_INC)
+      list(APPEND EXTERNAL_LIBRARIES ${TETGEN_LIB})
+      list(APPEND EXTERNAL_INCLUDES ${TETGEN_INC})
+      set_config_option(HAVE_TETGEN "Tetgen")
+    endif(TETGEN_LIB AND TETGEN_INC)
+  endif(ENABLE_TETGEN_NEW AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/contrib/TetgenNew/tetgen.h)
+  if(HAVE_TETGEN)
+    message("WARNING: By including Tetgen you have to comply with Tetgen's "
+            "special licensing requirements stated in contrib/Tetgen/LICENSE.")
+  endif(HAVE_TETGEN)
+
+if(ENABLE_MED OR ENABLE_CGNS)
+  find_library(HDF5_LIB hdf5)
+  if(HDF5_LIB)
+    if(ENABLE_MED)
+      find_library(MED_LIB med)
+      if(MED_LIB)
+        set_config_option(HAVE_MED "Med")
+        list(APPEND EXTERNAL_LIBRARIES ${MED_LIB})
+      endif(MED_LIB)
+    endif(ENABLE_MED)    
+    if(ENABLE_CGNS)
+      find_library(CGNS_LIB cgns PATHS ENV CGNS_ROOT PATH_SUFFIXES lib)
+      find_path(CGNS_INC "cgnslib.h" PATHS ENV CGNS_ROOT PATH_SUFFIXES include)
+      if(CGNS_LIB)
+        set_config_option(HAVE_LIBCGNS "Cgns")
+        list(APPEND EXTERNAL_LIBRARIES ${CGNS_LIB})
+        list(APPEND EXTERNAL_INCLUDES ${CGNS_INC})
+      endif(CGNS_LIB)
+    endif(ENABLE_CGNS)    
+    if(MED_LIB OR CGNS_LIB)
+      list(APPEND EXTERNAL_LIBRARIES ${HDF5_LIB})
+      find_library(SZ_LIB NAMES szlib sz)
+      if(SZ_LIB)
+        list(APPEND EXTERNAL_LIBRARIES ${SZ_LIB})
+      endif(SZ_LIB)
+      if(NOT HAVE_LIBZ) # necessary for non-GUI builds
+        find_package(ZLIB)
+        if(ZLIB_FOUND)
+          set_config_option(HAVE_LIBZ "Zlib")
+          list(APPEND EXTERNAL_LIBRARIES ${ZLIB_LIBRARIES})
+        endif(ZLIB_FOUND)
+      endif(NOT HAVE_LIBZ)
+    endif(MED_LIB OR CGNS_LIB)
+  endif(HDF5_LIB)
+endif(ENABLE_MED OR ENABLE_CGNS)
+
+if(ENABLE_MESH)
+  set_config_option(HAVE_MESH "Mesh")
+endif(ENABLE_MESH)
+
+if(ENABLE_POST)
+  set_config_option(HAVE_POST "Post")
+  if(ENABLE_PLUGINS)
+    set_config_option(HAVE_PLUGINS "Plugins")
+  endif(ENABLE_PLUGINS)
+endif(ENABLE_POST)
+
+if(HAVE_FLTK OR HAVE_QT OR ENABLE_GRAPHICS)
+  if(NOT HAVE_MESH OR NOT HAVE_POST OR NOT HAVE_PLUGINS)
+    message(SEND_ERROR "Cannot compile GUI without Mesh, Post or Plugin modules")
+  endif(NOT HAVE_MESH OR NOT HAVE_POST OR NOT HAVE_PLUGINS)
+
+  if(FLTK_JPEG)
+    set_config_option(HAVE_LIBJPEG "Jpeg(Fltk)")
+  else(FLTK_JPEG)
+    find_package(JPEG)
+    if(JPEG_FOUND)
+      set_config_option(HAVE_LIBJPEG "Jpeg")
+      list(APPEND EXTERNAL_LIBRARIES ${JPEG_LIBRARIES})
+      list(APPEND EXTERNAL_INCLUDES ${JPEG_INCLUDE_DIR})
+    endif(JPEG_FOUND)
+  endif(FLTK_JPEG)
+
+  if(FLTK_Z)
+    set_config_option(HAVE_LIBZ "Zlib(Fltk)")
+  else(FLTK_Z)
+    find_package(ZLIB)
+    if(ZLIB_FOUND)
+      set_config_option(HAVE_LIBZ "Zlib")
+      list(APPEND EXTERNAL_LIBRARIES ${ZLIB_LIBRARIES})
+      list(APPEND EXTERNAL_INCLUDES ${ZLIB_INCLUDE_DIR})
+    endif(ZLIB_FOUND)
+  endif(FLTK_Z)
+
+  if(HAVE_LIBZ)
+    if(FLTK_PNG)
+      set_config_option(HAVE_LIBPNG "Png(Fltk)")
+    else(FLTK_PNG)
+      find_package(PNG)
+      if(PNG_FOUND)
+        set_config_option(HAVE_LIBPNG "Png")
+        list(APPEND EXTERNAL_LIBRARIES ${PNG_LIBRARIES})
+        list(APPEND EXTERNAL_INCLUDES ${PNG_INCLUDE_DIR})
+      endif(PNG_FOUND)
+    endif(FLTK_PNG)
+  endif(HAVE_LIBZ)
+
+  if(ENABLE_MPEG_ENCODE)
+    add_subdirectory(contrib/mpeg_encode)
+    include_directories(contrib/mpeg_encode/headers)
+    set_config_option(HAVE_MPEG_ENCODE "Mpeg")
+  endif(ENABLE_MPEG_ENCODE)
+
+  if(ENABLE_OSMESA)
+    find_library(OSMESA_LIB OSMesa)
+    if(OSMESA_LIB)
+      set_config_option(HAVE_OSMESA "OSMesa")
+      list(APPEND EXTERNAL_LIBRARIES ${OSMESA_LIB})
+    endif(OSMESA_LIB)
+  endif(ENABLE_OSMESA)
+
+  find_package(OpenGL REQUIRED)
+  if(OPENGL_GLU_FOUND)
+    set_config_option(HAVE_OPENGL "OpenGL")
+  else(OPENGL_GLU_FOUND)
+    message(SEND_ERROR "Could not find GLU: disabling OpenGL support")
+  endif(OPENGL_GLU_FOUND)
+endif(HAVE_FLTK OR HAVE_QT OR ENABLE_GRAPHICS)
+
+if(ENABLE_DINTEGRATION)
+  include_directories(../contrib/DiscreteIntegration)
+  set_config_option(HAVE_DINTEGRATION "DIntegration")
+endif(ENABLE_DINTEGRATION)
+
+# process cmake environment variables so we can append them to the -I
+# include commands. This is not recommended (we should only use the
+# cache variables) but it is very convenient: otherwise we have to
+# remember providing the -D... options to cmake for each new build.
+set(ENV_CMAKE_PREFIX_PATH $ENV{CMAKE_PREFIX_PATH})
+set(ENV_CMAKE_INCLUDE_PATH $ENV{CMAKE_INCLUDE_PATH})
+if(UNIX)
+  if(ENV_CMAKE_PREFIX_PATH)
+    string(REPLACE ":" ";" ENV_CMAKE_PREFIX_PATH ${ENV_CMAKE_PREFIX_PATH})
+  endif(ENV_CMAKE_PREFIX_PATH)
+  if(ENV_CMAKE_INCLUDE_PATH)
+    string(REPLACE ":" ";" ENV_CMAKE_INCLUDE_PATH ${ENV_CMAKE_INCLUDE_PATH})
+  endif(ENV_CMAKE_INCLUDE_PATH)
+endif(UNIX)
+list(APPEND EXTERNAL_INCLUDES ${CMAKE_INCLUDE_PATH} ${ENV_CMAKE_INCLUDE_PATH})
+list(APPEND EXTERNAL_INCLUDES ${CMAKE_PREFIX_PATH} ${ENV_CMAKE_PREFIX_PATH})
+foreach(DIR ${CMAKE_PREFIX_PATH} ${ENV_CMAKE_PREFIX_PATH})
+  list(APPEND EXTERNAL_INCLUDES ${DIR}/include)
+endforeach(DIR)
+
+if(EXTERNAL_INCLUDES)
+  list(REMOVE_DUPLICATES EXTERNAL_INCLUDES)
+endif(EXTERNAL_INCLUDES)
+
+if(HAVE_FLTK)
+  set(LINK_LIBRARIES ${FLTK_LIBRARIES} ${EXTERNAL_LIBRARIES} 
+                     ${OPENGL_LIBRARIES} ${LAPACK_LIBRARIES})
+elseif(HAVE_QT)
+  set(LINK_LIBRARIES ${QT_LIBRARIES} ${EXTERNAL_LIBRARIES}
+                     ${OPENGL_LIBRARIES} ${LAPACK_LIBRARIES})
+elseif(HAVE_OPENGL)
+  set(LINK_LIBRARIES ${EXTERNAL_LIBRARIES} ${OPENGL_LIBRARIES}
+                     ${LAPACK_LIBRARIES})
+else(HAVE_FLTK)
+  set(LINK_LIBRARIES ${EXTERNAL_LIBRARIES} ${LAPACK_LIBRARIES})
+endif(HAVE_FLTK)
+
+# set this for external codes that might include this CMakeList file
+set(GMSH_EXTERNAL_INCLUDE_DIRS ${EXTERNAL_INCLUDES} CACHE 
+    STRING "External include directories" FORCE)
+set(GMSH_EXTERNAL_LIBRARIES ${EXTERNAL_LIBRARIES} CACHE 
+    STRING "External libraries" FORCE)
+
+include_directories(${GMSH_EXTERNAL_INCLUDE_DIRS})
+
 add_executable(mainAntTweakBar mainAntTweakBar.cpp)
-target_link_libraries(mainAntTweakBar shared AntTweakBar ${glut})
+target_link_libraries(mainAntTweakBar ${LINK_LIBRARIES})
 
 add_executable(mainCartesian mainCartesian.cpp)
-target_link_libraries(mainCartesian shared)
+target_link_libraries(mainCartesian ${LINK_LIBRARIES})
 
 add_executable(mainElasticity mainElasticity.cpp)
-target_link_libraries(mainElasticity shared)
+target_link_libraries(mainElasticity ${LINK_LIBRARIES})
 
 add_executable(mainGlut mainGlut.cpp)
-target_link_libraries(mainGlut lib ${GMSH_EXTERNAL_LIBRARIES} ${glut})
+target_link_libraries(mainGlut ${glut} ${LINK_LIBRARIES})
 
 add_executable(mainHomology mainHomology.cpp)
-target_link_libraries(mainHomology shared)
+target_link_libraries(mainHomology ${LINK_LIBRARIES})
 
 add_executable(mainLevelset mainLevelset.cpp)
-target_link_libraries(mainLevelset shared)
+target_link_libraries(mainLevelset ${LINK_LIBRARIES})
 
 add_executable(mainOcc mainOcc.cpp)
-target_link_libraries(mainOcc shared)
+target_link_libraries(mainOcc ${LINK_LIBRARIES})
 
 add_executable(mainPost mainPost.cpp)
-target_link_libraries(mainPost shared)
+target_link_libraries(mainPost ${LINK_LIBRARIES})
 
 add_executable(mainSimple mainSimple.cpp)
-target_link_libraries(mainSimple shared)
+target_link_libraries(mainSimple ${LINK_LIBRARIES})
 
diff --git a/utils/api_demos/mainAntTweakBar.cpp b/utils/api_demos/mainAntTweakBar.cpp
index 2b248bd..b1a5d5b 100644
--- a/utils/api_demos/mainAntTweakBar.cpp
+++ b/utils/api_demos/mainAntTweakBar.cpp
@@ -14,6 +14,7 @@
 #include "GModel.h"
 #include "MElement.h"
 #include "drawContext.h"
+#include <cstring>
 
 static drawContext *ctx = 0;
 static mousePosition clickPos, prevPos;
diff --git a/utils/api_demos/mainCartesian.cpp b/utils/api_demos/mainCartesian.cpp
index 24a1037..6f21954 100644
--- a/utils/api_demos/mainCartesian.cpp
+++ b/utils/api_demos/mainCartesian.cpp
@@ -12,7 +12,7 @@
 #include "GmshMessage.h"
 #include "cartesian.h"
 
-static void insertActiveCells(double x, double y, double z, double rmax,
+static void my_insertActiveCells(double x, double y, double z, double rmax,
                               cartesianBox<double> &box)
 {
   int id1 = box.getCellContainingPoint(x - rmax, y - rmax, z - rmax);
@@ -27,7 +27,7 @@ static void insertActiveCells(double x, double y, double z, double rmax,
         box.insertActiveCell(box.getCellIndex(i, j, k));
 }
 
-static void computeLevelset(GModel *gm, cartesianBox<double> &box)
+static void my_computeLevelset(GModel *gm, cartesianBox<double> &box)
 {
   // tolerance for desambiguation
   const double tol = box.getLC() * 1.e-12;
@@ -82,10 +82,10 @@ static void computeLevelset(GModel *gm, cartesianBox<double> &box)
   for (unsigned int j = 0; j < dist.size(); j++)
     box.setNodalValue(indices[j], dist[j]);
 
-  if(box.getChildBox()) computeLevelset(gm, *box.getChildBox());
+  if(box.getChildBox()) my_computeLevelset(gm, *box.getChildBox());
 }
 
-static void fillPointCloud(GEdge *ge, double sampling, std::vector<SPoint3> &points)
+static void my_fillPointCloud(GEdge *ge, double sampling, std::vector<SPoint3> &points)
 {
   Range<double> t_bounds = ge->parBounds(0);
   double t_min = t_bounds.low();
@@ -99,7 +99,7 @@ static void fillPointCloud(GEdge *ge, double sampling, std::vector<SPoint3> &poi
   }
 }
 
-static int removeBadChildCells(cartesianBox<double> *parent)
+static int my_removeBadChildCells(cartesianBox<double> *parent)
 {
   cartesianBox<double> *child = parent->getChildBox();
   if(!child) return 0;
@@ -135,10 +135,10 @@ static int removeBadChildCells(cartesianBox<double> *parent)
             (k != K - 1 && !parent->activeCellExists(parent->getCellIndex(i, j, k + 1)))))
             for(int ii = 0; ii < 8; ii++) child->eraseActiveCell(idx[ii]);
       }
-  return removeBadChildCells(child);
+  return my_removeBadChildCells(child);
 }
 
-static void removeParentCellsWithChildren(cartesianBox<double> *box)
+static void my_removeParentCellsWithChildren(cartesianBox<double> *box)
 {
   if(!box->getChildBox()) return;
   for(int i = 0; i < box->getNxi(); i++)
@@ -157,7 +157,7 @@ static void removeParentCellsWithChildren(cartesianBox<double> *box)
           }
         }
       }
-  removeParentCellsWithChildren(box->getChildBox());
+  my_removeParentCellsWithChildren(box->getChildBox());
 }
 
 static void removeOutsideCells(cartesianBox<double> *box)
@@ -226,7 +226,7 @@ int main(int argc,char *argv[])
     double s = sampling / pow(2., levels - 1);
     Msg::Info("Filling refined point cloud on curves and curved surfaces");
     for (GModel::eiter eit = gm->firstEdge(); eit != gm->lastEdge(); eit++)
-      fillPointCloud(*eit, s, refinePoints);
+      my_fillPointCloud(*eit, s, refinePoints);
 
     // FIXME: refine this by computing e.g. "mean" curvature
     if(refineCurvedSurfaces){
@@ -263,13 +263,13 @@ int main(int argc,char *argv[])
   Msg::Info("Inserting active cells in the cartesian grid");
   Msg::Info("  level %d", box.getLevel());
   for (unsigned int i = 0; i < points.size(); i++)
-    insertActiveCells(points[i].x(), points[i].y(), points[i].z(), rmax, box);
+    my_insertActiveCells(points[i].x(), points[i].y(), points[i].z(), rmax, box);
 
   cartesianBox<double> *parent = &box, *child;
   while((child = parent->getChildBox())){
     Msg::Info("  level %d", child->getLevel());
     for(unsigned int i = 0; i < refinePoints.size(); i++)
-      insertActiveCells(refinePoints[i].x(), refinePoints[i].y(), refinePoints[i].z(),
+      my_insertActiveCells(refinePoints[i].x(), refinePoints[i].y(), refinePoints[i].z(),
                         rtube / pow(2., (levels - child->getLevel())), *child);
     parent = child;
   }
@@ -278,8 +278,8 @@ int main(int argc,char *argv[])
   // which there is no parent neighbor; then remove parent cells that
   // have children
   Msg::Info("Removing cells to match X-FEM mesh topology constraints");
-  removeBadChildCells(&box);
-  removeParentCellsWithChildren(&box);
+  my_removeBadChildCells(&box);
+  my_removeParentCellsWithChildren(&box);
 
   // we generate duplicate nodes at this point so we can easily access
   // cell values at each level; we will clean up by renumbering after
@@ -288,7 +288,7 @@ int main(int argc,char *argv[])
   box.createNodalValues();
 
   Msg::Info("Computing levelset on the cartesian grid");
-  computeLevelset(gm, box);
+  my_computeLevelset(gm, box);
 
   Msg::Info("Removing cells outside the structure");
   removeOutsideCells(&box);
diff --git a/utils/api_demos/mainElasticity.cpp b/utils/api_demos/mainElasticity.cpp
index 802c1fe..7268ca2 100644
--- a/utils/api_demos/mainElasticity.cpp
+++ b/utils/api_demos/mainElasticity.cpp
@@ -3,6 +3,7 @@
 #include "elasticitySolver.h"
 #include "PView.h"
 #include "PViewData.h"
+#include <cstring>
 
 void Info (int i, char* c){
   printf("%d %s\n",i,c);

-- 
Gmsh packaging. Gmsh is an automatic 3D finite element mesh generator. 



More information about the debian-science-commits mailing list