Test for 0026088: Exception in pipe algorithm

Method RWStl::Read() is improved to support reading multi-domain STL files.

Test added: bugs stlvrml bug28680

.gitattributes

@@ -18,6 +18,7 @@
 *.yacc      eol=lf
 *.lex       eol=lf
 *.mm        eol=lf
+*.i         eol=lf
 *.el        eol=lf
 *.sh        eol=lf
 *.csh       eol=lf
@@ -37,6 +38,9 @@
 *.vrml      eol=lf
 *.md        eol=lf
 *.natvis    eol=lf
+*.fs        eol=lf
+*.vs        eol=lf
+*.glsl      eol=lf
 FILES       eol=lf
 PACKAGES    eol=lf
 EXTERNLIB   eol=lf

.tgitconfig

@@ -0,0 +1,3 @@
+[bugtraq]
+	url = https://tracker.dev.opencascade.org/view.php?id=%BUGID%
+	logregex = "(\\s)(00|#)\\d+(?!\\w)\n(\\d+)"

CMakeLists.txt

@@ -1,5 +1,7 @@
 cmake_minimum_required (VERSION 2.8.12 FATAL_ERROR)
 
+set (CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/adm/cmake")
+
 set (CMAKE_SUPPRESS_REGENERATION TRUE)
 
 set (CMAKE_CONFIGURATION_TYPES Release Debug RelWithDebInfo CACHE INTERNAL "" FORCE)
@@ -37,6 +39,11 @@ endif()
 # the name of the project
 project (OCCT)
 
+if (WIN32)
+  add_definitions(-DUNICODE)
+  add_definitions(-D_UNICODE)
+endif()
+
 # include occt macros
 OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/occt_macros")
 
@@ -52,6 +59,9 @@ set_property (GLOBAL PROPERTY OCC_VERSION_MAINTENANCE ${OCC_VERSION_MAINTENANCE}
 
 set (INSTALL_TEST_CASES OFF CACHE BOOL "${INSTALL_TEST_CASES_DESCR}")
 
+# Regeneration of OCCT resource files
+set (BUILD_RESOURCES OFF CACHE BOOL "${BUILD_RESOURCES_DESCR}")
+
 # single-configuration generator
 set (SINGLE_GENERATOR OFF)
 if (CMAKE_BUILD_TYPE)
@@ -77,6 +87,31 @@ if (BUILD_WITH_DEBUG)
   set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS $<$<CONFIG:DEBUG>:OCCT_DEBUG>)
 endif()
 
+# option to enable or disable use of precompiled headers
+if (NOT DEFINED BUILD_USE_PCH)
+  set (BUILD_USE_PCH OFF CACHE BOOL "${BUILD_USE_PCH_DESCR}")
+endif()
+
+if (BUILD_USE_PCH)
+
+  # Load Cotire tool for accelerating build procedure
+  include(cotire)
+
+  # Set Cotire to ignore lxx, pxx, gxx 
+  set (COTIRE_ADDITIONAL_PREFIX_HEADER_IGNORE_EXTENSIONS "lxx;pxx;gxx" CACHE STRING "Set Cotire to ignore OCCT specific files that can be #included" FORCE)
+
+  # Set priority for inclusion of system headers in PCH to reduce problems
+  # due to incomplete inclusion or wrong order.
+  if (WIN32)
+    # on Windows, assume that SDK (windows.h) is in default location
+    set(ProgramFilesX86 "ProgramFiles(x86)")
+    file(TO_CMAKE_PATH "$ENV{${ProgramFilesX86}}" ProgramFilesX86)
+    set_property (DIRECTORY PROPERTY COTIRE_PREFIX_HEADER_INCLUDE_PRIORITY_PATH "${ProgramFilesX86}")
+    unset(ProgramFilesX86)
+  endif()
+
+endif()
+
 # copy samples to install directory
 set (INSTALL_SAMPLES OFF CACHE BOOL "${INSTALL_SAMPLES_DESCR}")
 
@@ -285,13 +320,16 @@ if (NOT DEFINED INSTALL_DIR_CMAKE)
   endif()
 endif()
 
+# include occt macros
+OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/occt_resources")
+
 # install LICENSE_LGPL_21.txt and OCCT_LGPL_EXCEPTION.txt files
 if ("${INSTALL_DIR_LAYOUT}" STREQUAL "Unix")
-  OCCT_INSTALL_FILE_OR_DIR ("LICENSE_LGPL_21.txt" "${INSTALL_DIR}/${INSTALL_DIR_DOC}")
-  OCCT_INSTALL_FILE_OR_DIR ("OCCT_LGPL_EXCEPTION.txt" "${INSTALL_DIR}/${INSTALL_DIR_DOC}")
+  OCCT_INSTALL_FILE_OR_DIR ("LICENSE_LGPL_21.txt" "${INSTALL_DIR_DOC}")
+  OCCT_INSTALL_FILE_OR_DIR ("OCCT_LGPL_EXCEPTION.txt" "${INSTALL_DIR_DOC}")
 else()
-  OCCT_INSTALL_FILE_OR_DIR ("LICENSE_LGPL_21.txt" "${INSTALL_DIR}")
-  OCCT_INSTALL_FILE_OR_DIR ("OCCT_LGPL_EXCEPTION.txt" "${INSTALL_DIR}")
+  OCCT_INSTALL_FILE_OR_DIR ("LICENSE_LGPL_21.txt" ".")
+  OCCT_INSTALL_FILE_OR_DIR ("OCCT_LGPL_EXCEPTION.txt" ".")
 endif()
 
 if(APPLE)
@@ -327,6 +365,20 @@ if (WIN32)
   set (USE_D3D OFF CACHE BOOL "${USE_D3D_DESCR}")
 endif()
 
+set (USE_QT_TOOLS OFF CACHE BOOL "${USE_QT_TOOLS_DESCR}")
+set (USE_QT4 ON CACHE BOOL "${USE_QT4}")
+
+# Enable/Disable the floating point exceptions (FPE) during runtime.
+if (NOT BUILD_ENABLE_FPE_SIGNAL_HANDLER)
+  set (BUILD_ENABLE_FPE_SIGNAL_HANDLER OFF CACHE BOOL "${BUILD_ENABLE_FPE_SIGNAL_HANDLER_DESCR}" FORCE)
+endif()
+
+if (BUILD_ENABLE_FPE_SIGNAL_HANDLER)
+  set (BUILD_ENABLE_FPE_SIGNAL_HANDLER 1)
+else()
+  set (BUILD_ENABLE_FPE_SIGNAL_HANDLER 0)
+endif()
+
 # include the patched or original list of modules
 # list <MODULENAME>_TOOLKITS is created foreach module and contains its toolkits
 # list <OCCT_MODULES> will contain all modules
@@ -425,8 +477,17 @@ else()
   set (3RDPARTY_DIR "${3RDPARTY_DIR}" CACHE PATH "${3RDPARTY_DIR_DESCR}" FORCE)
 endif()
 
-# search for CSF_TclLibs variable in EXTERNLIB of each being used toolkit
+# search for CSF variable in EXTERNLIB of each being used toolkit
+OCCT_IS_PRODUCT_REQUIRED (CSF_FreeImagePlus CAN_USE_FREEIMAGE)
 OCCT_IS_PRODUCT_REQUIRED (CSF_TclLibs USE_TCL)
+OCCT_IS_PRODUCT_REQUIRED (CSF_FREETYPE USE_FREETYPE)
+OCCT_IS_PRODUCT_REQUIRED (CSF_OpenGlLibs CAN_USE_GLES2)
+OCCT_IS_PRODUCT_REQUIRED (CSF_GL2PS CAN_USE_GL2PS)
+OCCT_IS_PRODUCT_REQUIRED (CSF_TBB CAN_USE_TBB)
+OCCT_IS_PRODUCT_REQUIRED (CSF_EIGEN CAN_USE_EIGEN)
+
+# define CSF variable
+OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/occt_csf")
 
 if (USE_TCL)
   message (STATUS "Info: TCL is used by OCCT")
@@ -442,9 +503,6 @@ else()
   OCCT_CHECK_AND_UNSET ("INSTALL_TK")
 endif()
 
-# search for CSF_FREETYPE variable in EXTERNLIB of each being used toolkit
-OCCT_IS_PRODUCT_REQUIRED (CSF_FREETYPE USE_FREETYPE)
-
 if (USE_FREETYPE)
   message (STATUS "Info: Freetype is used by OCCT")
   OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/freetype")
@@ -485,8 +543,6 @@ if (USE_GLX)
 endif()
 
 # FREEIMAGE
-# search for CSF_FREEIMAGE variable in EXTERNLIB of each being used toolkit
-OCCT_IS_PRODUCT_REQUIRED (CSF_FreeImagePlus CAN_USE_FREEIMAGE)
 
 if (CAN_USE_FREEIMAGE)
   set (USE_FREEIMAGE OFF CACHE BOOL "${USE_FREEIMAGE_DESCR}")
@@ -505,8 +561,28 @@ else()
   OCCT_CHECK_AND_UNSET ("INSTALL_FREEIMAGE")
 endif()
 
+# FFmpeg
+# search for CSF_FFmpeg variable in EXTERNLIB of each being used toolkit
+OCCT_IS_PRODUCT_REQUIRED (CSF_FFmpeg CAN_USE_FFMPEG)
+
+if (CAN_USE_FFMPEG)
+  set (USE_FFMPEG OFF CACHE BOOL "${USE_FFMPEG_DESCR}")
+
+  if (USE_FFMPEG)
+    add_definitions (-DHAVE_FFMPEG)
+    OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/ffmpeg")
+  else()
+    OCCT_CHECK_AND_UNSET_GROUP ("3RDPARTY_FFMPEG")
+    OCCT_CHECK_AND_UNSET ("INSTALL_FFMPEG")
+  endif()
+else()
+  OCCT_CHECK_AND_UNSET ("USE_FFMPEG")
+
+  OCCT_CHECK_AND_UNSET_GROUP ("3RDPARTY_FFMPEG")
+  OCCT_CHECK_AND_UNSET ("INSTALL_FFMPEG")
+endif()
+
 # OpenGL ES 2.0
-OCCT_IS_PRODUCT_REQUIRED (CSF_OpenGlLibs CAN_USE_GLES2)
 if (WIN32 AND CAN_USE_GLES2)
   if ("${CMAKE_SYSTEM_NAME}" STREQUAL "WindowsStore")
     set (USE_GLES2 ON)
@@ -534,9 +610,6 @@ else()
 endif()
 
 # GL2PS
-# search for CSF_GL2PS variable in EXTERNLIB of each being used toolkit
-OCCT_IS_PRODUCT_REQUIRED (CSF_GL2PS CAN_USE_GL2PS)
-
 if (NOT DEFINED ANDROID AND CAN_USE_GL2PS)
   set (USE_GL2PS OFF CACHE BOOL "${USE_GL2PS_DESCR}")
 
@@ -555,9 +628,6 @@ else()
 endif()
 
 # TBB
-# search for CSF_TBB variable in EXTERNLIB of each being used toolkit
-OCCT_IS_PRODUCT_REQUIRED (CSF_TBB CAN_USE_TBB)
-
 if (NOT DEFINED ANDROID AND CAN_USE_TBB)
   set (USE_TBB OFF CACHE BOOL "${USE_TBB_DESCR}")
 
@@ -577,6 +647,22 @@ else()
   OCCT_CHECK_AND_UNSET ("INSTALL_TBB")
 endif()
 
+# EIGEN
+if (CAN_USE_EIGEN)
+  set (USE_EIGEN OFF CACHE BOOL "${USE_EIGEN_DESCR}")
+
+  if (USE_EIGEN)
+    add_definitions (-DHAVE_EIGEN)
+    OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/eigen")
+  else()
+    OCCT_CHECK_AND_UNSET_GROUP ("3RDPARTY_EIGEN")
+  endif()
+else()
+  OCCT_CHECK_AND_UNSET ("USE_EIGEN")
+
+  OCCT_CHECK_AND_UNSET_GROUP ("3RDPARTY_EIGEN")
+endif()
+
 # Doxygen
 if (BUILD_DOC_Overview)
   if (NOT DEFINED INSTALL_DOC_Overview)
@@ -584,11 +670,11 @@ if (BUILD_DOC_Overview)
   endif()
 
   if (INSTALL_DOC_Overview)
-    install (DIRECTORY "${CMAKE_BINARY_DIR}/doc/overview" DESTINATION  "${INSTALL_DIR}/${INSTALL_DIR_DOC}")
+    install (DIRECTORY "${CMAKE_BINARY_DIR}/doc/overview" DESTINATION  "${INSTALL_DIR_DOC}")
 
     # create overview.html only for windows
     if (WIN32 AND "${INSTALL_DIR_LAYOUT}" STREQUAL "Windows")
-      OCCT_INSTALL_FILE_OR_DIR ("dox/resources/overview.html" "${INSTALL_DIR}/${INSTALL_DIR_DOC}/..")
+      OCCT_INSTALL_FILE_OR_DIR ("dox/resources/overview.html" "${INSTALL_DIR_DOC}/..")
     endif()
   endif()
 
@@ -629,7 +715,7 @@ if (3RDPARTY_INCLUDE_DIRS)
 endif()
 
 # include <cmake binary folder>/inc
-include_directories (${CMAKE_BINARY_DIR}/inc)
+include_directories (${CMAKE_BINARY_DIR}/${INSTALL_DIR_INCLUDE})
 
 if (3RDPARTY_LIBRARY_DIRS AND BUILD_SHARED_LIBS)
   list (REMOVE_DUPLICATES 3RDPARTY_LIBRARY_DIRS)
@@ -670,57 +756,96 @@ string(TIMESTAMP CURRENT_TIME "%H:%M:%S")
 message (STATUS "\nInfo: \(${CURRENT_TIME}\) Start collecting all OCCT header files into ${CMAKE_BINARY_DIR}/inc ...")
 
 # collect all the headers to <binary dir>/inc folder
-COLLECT_AND_INSTALL_OCCT_HEADER_FILES ("${CMAKE_BINARY_DIR}" "${BUILD_TOOLKITS}")
+COLLECT_AND_INSTALL_OCCT_HEADER_FILES ("${CMAKE_BINARY_DIR}" "${BUILD_TOOLKITS}" "${CMAKE_SOURCE_DIR}/src" "${INSTALL_DIR_INCLUDE}")
 
 string(TIMESTAMP CURRENT_TIME "%H:%M:%S")
 message (STATUS "Info: \(${CURRENT_TIME}\) End the collecting")
 
+list (FIND BUILD_TOOLKITS DRAWEXE DRAWEXE_INDEX)
+if (${DRAWEXE_INDEX} GREATER -1)
+  OCCT_INSTALL_FILE_OR_DIR ("data/" "${INSTALL_DIR_DATA}")
+  OCCT_INSTALL_FILE_OR_DIR ("samples/tcl" "${INSTALL_DIR_SAMPLES}")
+endif()
+
 if (WIN32)
   set (SCRIPT_EXT bat)
 else()
   set (SCRIPT_EXT sh)
 endif()
 
+# OCCT tools
+# include the patched or original list of tools
+# list <TOOLNAME>_TOOLKITS is created foreach tool and contains its toolkits
+# list <OCCT_TOOLS> will contain all tools
+if (NOT USE_QT_TOOLS)
+  OCCT_CHECK_AND_UNSET_GROUP ("3RDPARTY_QT")
+  OCCT_CHECK_AND_UNSET_GROUP ("3RDPARTY_TQTMALLOC")
+  OCCT_CHECK_AND_UNSET ("INSTALL_QT")
+else()
+  OCCT_TOOLS_AND_TOOLKITS (OCCT_TOOLS)
+  foreach (OCCT_TOOL ${OCCT_TOOLS})
+    list (APPEND BUILD_TOOL_TOOLKITS ${${OCCT_TOOL}_TOOL_TOOLKITS})
+  endforeach()
+
+  # collect all the headers to <binary dir>/inc folder
+  string(TIMESTAMP CURRENT_TIME "%H:%M:%S")
+  message (STATUS "\nInfo: \(${CURRENT_TIME}\) Start collecting all OCCT tool header files into ${CMAKE_BINARY_DIR}/tools/inc ...")
+  COLLECT_AND_INSTALL_OCCT_HEADER_FILES ("${CMAKE_BINARY_DIR}/${INSTALL_DIR_INCLUDE}" "${BUILD_TOOL_TOOLKITS}" "${CMAKE_SOURCE_DIR}/tools" "tools")
+  include_directories (${CMAKE_BINARY_DIR}/${INSTALL_DIR_INCLUDE}/tools)
+
+
+  # check qt 3rdparty path
+  add_definitions (-DHAVE_QT)
+  OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/qt5")
+  message (STATUS "Info: Qt is used by OCCT")
+endif()
+
 # OCCT samples
+# get absolute path from INSTALL_DIR
+set (INSTALL_DIR_ABSOLUTE "${INSTALL_DIR}")
+if(NOT IS_ABSOLUTE "${INSTALL_DIR_ABSOLUTE}")
+  get_filename_component(INSTALL_DIR_ABSOLUTE "${CMAKE_BINARY_DIR}/${INSTALL_DIR}" ABSOLUTE)
+endif()
+
 if (INSTALL_SAMPLES)
   OCCT_CONFIGURE ("adm/templates/env.samples.${SCRIPT_EXT}.in" "env.samples.${SCRIPT_EXT}")
   if (WIN32)
-    OCCT_INSTALL_FILE_OR_DIR ("samples/CSharp" "${INSTALL_DIR}/${INSTALL_DIR_SAMPLES}")
-    OCCT_INSTALL_FILE_OR_DIR ("samples/mfc" "${INSTALL_DIR}/${INSTALL_DIR_SAMPLES}")
+    OCCT_INSTALL_FILE_OR_DIR ("samples/CSharp" "${INSTALL_DIR_SAMPLES}")
+    OCCT_INSTALL_FILE_OR_DIR ("samples/mfc" "${INSTALL_DIR_SAMPLES}")
 
     if ("${CMAKE_SYSTEM_NAME}" STREQUAL "WindowsStore")
-      OCCT_INSTALL_FILE_OR_DIR ("samples/xaml" "${INSTALL_DIR}/${INSTALL_DIR_SAMPLES}")
+      OCCT_INSTALL_FILE_OR_DIR ("samples/xaml" "${INSTALL_DIR_SAMPLES}")
     endif()
 
-    install (FILES "${CMAKE_BINARY_DIR}/env.samples.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_SAMPLES}/CSharp" RENAME "env.${SCRIPT_EXT}")
-    install (FILES "${CMAKE_BINARY_DIR}/env.samples.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_SAMPLES}/mfc/standard" RENAME "env.${SCRIPT_EXT}")
+    install (FILES "${CMAKE_BINARY_DIR}/env.samples.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR_SAMPLES}/CSharp" RENAME "env.${SCRIPT_EXT}")
+    install (FILES "${CMAKE_BINARY_DIR}/env.samples.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR_SAMPLES}/mfc/standard" RENAME "env.${SCRIPT_EXT}")
   endif()
 
-  OCCT_INSTALL_FILE_OR_DIR ("samples/java" "${INSTALL_DIR}/${INSTALL_DIR_SAMPLES}")
-  OCCT_INSTALL_FILE_OR_DIR ("samples/ocafsamples" "${INSTALL_DIR}/${INSTALL_DIR_SAMPLES}")
-  OCCT_INSTALL_FILE_OR_DIR ("samples/qt" "${INSTALL_DIR}/${INSTALL_DIR_SAMPLES}")
+  OCCT_INSTALL_FILE_OR_DIR ("samples/java" "${INSTALL_DIR_SAMPLES}")
+  OCCT_INSTALL_FILE_OR_DIR ("samples/ocafsamples" "${INSTALL_DIR_SAMPLES}")
+  OCCT_INSTALL_FILE_OR_DIR ("samples/qt" "${INSTALL_DIR_SAMPLES}")
 
-  install (FILES "${CMAKE_BINARY_DIR}/env.samples.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_SAMPLES}/qt/FuncDemo" RENAME "env.${SCRIPT_EXT}")
-  install (FILES "${CMAKE_BINARY_DIR}/env.samples.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_SAMPLES}/qt/IESample" RENAME "env.${SCRIPT_EXT}")
-  install (FILES "${CMAKE_BINARY_DIR}/env.samples.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_SAMPLES}/qt/Tutorial" RENAME "env.${SCRIPT_EXT}")
+  install (FILES "${CMAKE_BINARY_DIR}/env.samples.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR_SAMPLES}/qt/FuncDemo" RENAME "env.${SCRIPT_EXT}")
+  install (FILES "${CMAKE_BINARY_DIR}/env.samples.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR_SAMPLES}/qt/IESample" RENAME "env.${SCRIPT_EXT}")
+  install (FILES "${CMAKE_BINARY_DIR}/env.samples.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR_SAMPLES}/qt/Tutorial" RENAME "env.${SCRIPT_EXT}")
 endif()
 
 if (INSTALL_TEST_CASES)
-  OCCT_INSTALL_FILE_OR_DIR ("tests/" "${INSTALL_DIR}/${INSTALL_DIR_TESTS}")
+  OCCT_INSTALL_FILE_OR_DIR ("tests/" "${INSTALL_DIR_TESTS}")
 endif()
 
 list (FIND BUILD_TOOLKITS DRAWEXE DRAWEXE_INDEX)
 if (${DRAWEXE_INDEX} GREATER -1)
   # copy data and samples/tcl folders to install script folder
-  OCCT_INSTALL_FILE_OR_DIR ("data/" "${INSTALL_DIR}/${INSTALL_DIR_DATA}")
-  OCCT_INSTALL_FILE_OR_DIR ("samples/tcl" "${INSTALL_DIR}/${INSTALL_DIR_SAMPLES}")
+  OCCT_INSTALL_FILE_OR_DIR ("data/" "${INSTALL_DIR_DATA}")
+  OCCT_INSTALL_FILE_OR_DIR ("samples/tcl" "${INSTALL_DIR_SAMPLES}")
 
   # copy draw script to install script folder
   if (BUILD_PATCH AND EXISTS "${BUILD_PATCH}/adm/templates/draw.${SCRIPT_EXT}")
-    install (FILES "${BUILD_PATCH}/adm/templates/draw.${SCRIPT_EXT}" DESTINATION  "${INSTALL_DIR}/${INSTALL_DIR_SCRIPT}"
+    install (FILES "${BUILD_PATCH}/adm/templates/draw.${SCRIPT_EXT}" DESTINATION  "${INSTALL_DIR_SCRIPT}"
             PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_WRITE GROUP_EXECUTE WORLD_READ WORLD_WRITE WORLD_EXECUTE)
   else()
-    install (FILES "${CMAKE_SOURCE_DIR}/adm/templates/draw.${SCRIPT_EXT}" DESTINATION  "${INSTALL_DIR}/${INSTALL_DIR_SCRIPT}"
+    install (FILES "${CMAKE_SOURCE_DIR}/adm/templates/draw.${SCRIPT_EXT}" DESTINATION  "${INSTALL_DIR_SCRIPT}"
             PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_WRITE GROUP_EXECUTE WORLD_READ WORLD_WRITE WORLD_EXECUTE)
   endif()
 
@@ -744,18 +869,18 @@ if (EXISTS "${INSTALL_DIR}/${INSTALL_DIR_SCRIPT}/custom.${SCRIPT_EXT}")
 
   file (WRITE "${INSTALL_DIR}/${INSTALL_DIR_SCRIPT}/custom.${SCRIPT_EXT}" "${CUSTOM_CONTENT}")
 else()
-  OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.${SCRIPT_EXT}.main" "custom.${SCRIPT_EXT}" "custom.${SCRIPT_EXT}" "${INSTALL_DIR}/${INSTALL_DIR_SCRIPT}")
+  OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.${SCRIPT_EXT}.main" "custom.${SCRIPT_EXT}" "custom.${SCRIPT_EXT}" "${INSTALL_DIR_SCRIPT}")
 endif()
 
 # write current custom.bat/sh (for install directory)
 set (SUB_CUSTOM_BUILD_NAME "custom_${COMPILER}_${COMPILER_BITNESS}.install.${SCRIPT_EXT}")
-OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.install.${SCRIPT_EXT}.in" "${SUB_CUSTOM_BUILD_NAME}" "${SUB_CUSTOM_NAME}" "${INSTALL_DIR}/${INSTALL_DIR_SCRIPT}")
+OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.install.${SCRIPT_EXT}.in" "${SUB_CUSTOM_BUILD_NAME}" "${SUB_CUSTOM_NAME}" "${INSTALL_DIR_SCRIPT}")
 
 # write current custom.bat/sh (for build directory)
 OCCT_CONFIGURE ("adm/templates/custom.build.${SCRIPT_EXT}.in" "${SUB_CUSTOM_NAME}")
 
 if (BUILD_MODULE_MfcSamples)
-  OCCT_INSTALL_FILE_OR_DIR ("adm/templates/sample.bat" "${INSTALL_DIR}/${INSTALL_DIR_SCRIPT}")
+  OCCT_INSTALL_FILE_OR_DIR ("adm/templates/sample.bat" "${INSTALL_DIR_SCRIPT}")
   OCCT_COPY_FILE_OR_DIR    ("adm/templates/sample.bat" "${CMAKE_BINARY_DIR}")
 endif()
 
@@ -763,7 +888,7 @@ endif()
 OCCT_CONFIGURE ("adm/templates/env.${SCRIPT_EXT}.in" "env.${SCRIPT_EXT}")
 
 # install env script
-install (FILES "${CMAKE_BINARY_DIR}/env.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_SCRIPT}")
+install (FILES "${CMAKE_BINARY_DIR}/env.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR_SCRIPT}")
 
 # copy DrawAppliInit from OCCT source to build directory
 if (NOT EXISTS "${CMAKE_BINARY_DIR}/DrawAppliInit")
@@ -776,9 +901,9 @@ foreach(RESOURCE ${RESOURCES})
   get_filename_component(RESOURCE_FOLDER ${RESOURCE} DIRECTORY)
   if(NOT "${RESOURCE_FOLDER}" STREQUAL "")
     get_filename_component(RESOURCE_FOLDER ${RESOURCE_FOLDER} NAME)
-    OCCT_INSTALL_FILE_OR_DIR ("src/${RESOURCE}" "${INSTALL_DIR}/${INSTALL_DIR_RESOURCE}/${RESOURCE_FOLDER}")
+    OCCT_INSTALL_FILE_OR_DIR ("src/${RESOURCE}" "${INSTALL_DIR_RESOURCE}/${RESOURCE_FOLDER}")
   else()
-    OCCT_INSTALL_FILE_OR_DIR ("src/${RESOURCE}" "${INSTALL_DIR}/${INSTALL_DIR_RESOURCE}")
+    OCCT_INSTALL_FILE_OR_DIR ("src/${RESOURCE}" "${INSTALL_DIR_RESOURCE}")
   endif()
 endforeach()
 
@@ -787,9 +912,6 @@ if (NOT "${BUILD_SHARED_LIBRARY_NAME_POSTFIX}" STREQUAL "")
   OCCT_UPDATE_DRAW_DEFAULT_FILE()
 endif()
 
-# define CSF variable
-OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/occt_csf")
-
 # include patched toolkit projects or original ones
 foreach (BUILD_TOOLKIT ${BUILD_TOOLKITS})
   OCCT_ADD_SUBDIRECTORY ("src/${BUILD_TOOLKIT}")
@@ -820,6 +942,14 @@ if (MSVC AND 3RDPARTY_DLL_DIRS)
   endif()
 endif()
 
+# include patched toolkit projects or original ones
+if (BUILD_TOOL_TOOLKITS)
+  foreach (BUILD_TOOL_TOOLKIT ${BUILD_TOOL_TOOLKITS})
+    OCCT_ADD_SUBDIRECTORY ("tools/${BUILD_TOOL_TOOLKIT}")
+  endforeach()
+endif()
+
+message (STATUS "Info: \(${CURRENT_TIME}\) OCCT toolkits processed")
 # samples do not support patch usage
 if (BUILD_MODULE_MfcSamples)
   set (OCCT_ROOT ${CMAKE_SOURCE_DIR})
@@ -838,12 +968,30 @@ if (BUILD_MODULE_MfcSamples)
   add_subdirectory(samples/mfc/standard/08_HLR)
   add_subdirectory(samples/mfc/standard/09_Animation)
   add_subdirectory(samples/mfc/standard/10_Convert)
+
+  message (STATUS "Info: \(${CURRENT_TIME}\) MFC Sample projects added")
 endif()
 
 if (BUILD_MODULE_UwpSample)
   add_subdirectory(samples/xaml)
 endif()
 
+if (BUILD_TOOL_TOOLKITS)
+  # copy tinspector script to install script folder
+  if (BUILD_PATCH AND EXISTS "${BUILD_PATCH}/adm/templates/dfbrowser.${SCRIPT_EXT}")
+    install (FILES "${BUILD_PATCH}/adm/templates/dfbrowser.${SCRIPT_EXT}" DESTINATION  "${INSTALL_DIR_SCRIPT}"
+            PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_WRITE GROUP_EXECUTE WORLD_READ WORLD_WRITE WORLD_EXECUTE)
+  else()
+    install (FILES "${CMAKE_SOURCE_DIR}/adm/templates/dfbrowser.${SCRIPT_EXT}" DESTINATION  "${INSTALL_DIR_SCRIPT}"
+            PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_WRITE GROUP_EXECUTE WORLD_READ WORLD_WRITE WORLD_EXECUTE)
+  endif()
+
+  set (BUILD_SAMPLE_TOOLKITS TInspectorEXE)
+  foreach (BUILD_SAMPLE_TOOL_TOOLKIT ${BUILD_SAMPLE_TOOLKITS})
+    OCCT_ADD_SUBDIRECTORY ("samples/tools/${BUILD_SAMPLE_TOOL_TOOLKIT}")
+  endforeach()
+endif()
+
 # Prepare variables for configuration of OpenCASCADE cmake config file
 set (OCCT_MODULES_ENABLED)
 set (OCCT_LIBRARIES)
@@ -933,7 +1081,7 @@ endif()
 
 # Configure and install cmake config file
 configure_file("${CMAKE_SOURCE_DIR}/adm/templates/OpenCASCADEConfig.cmake.in" "OpenCASCADEConfig.cmake" @ONLY)
-install(FILES "${CMAKE_BINARY_DIR}/OpenCASCADEConfig.cmake" DESTINATION  "${INSTALL_DIR}/${INSTALL_DIR_CMAKE}")
+install(FILES "${CMAKE_BINARY_DIR}/OpenCASCADEConfig.cmake" DESTINATION  "${INSTALL_DIR_CMAKE}")
 
 # Configure cmake version file
 include(CMakePackageConfigHelpers)
@@ -942,7 +1090,7 @@ write_basic_package_version_file( ${CMAKE_BINARY_DIR}/OpenCASCADEConfigVersion.c
                                   COMPATIBILITY ExactVersion )
 
 # Install cmake version file
-install (FILES "${CMAKE_BINARY_DIR}/OpenCASCADEConfigVersion.cmake" DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_CMAKE}")
+install (FILES "${CMAKE_BINARY_DIR}/OpenCASCADEConfigVersion.cmake" DESTINATION "${INSTALL_DIR_CMAKE}")
 
 # Install the export set for use with the install-tree for each configuration
 foreach (OCCT_MODULE ${OCCT_MODULES_ENABLED})
@@ -952,3 +1100,5 @@ endforeach()
 # Update generated OpenCASCADETargets-*.cmake files 
 # to have correct paths to libraries depending on the configuration
 OCCT_UPDATE_TARGET_FILE ()
+
+message (STATUS "Info: \(${CURRENT_TIME}\) OCCT configuration files prepared")

adm/RESOURCES

@@ -6,6 +6,6 @@ Shaders
 XSMessage
 XSTEPResource
 XmlOcafResource
-UnitsAPI/Lexi_Expr.dat
 UnitsAPI/Units.dat
-TObj/TObj.msg
+TObj/TObj.msg
+BOPAlgo/BOPAlgo.msg

adm/TOOLS

@@ -0,0 +1,4 @@
+TModelingData TKShapeView
+TVisualization TKView TKVInspector
+TApplicationFramework TKTreeModel TKTInspectorAPI TKDFBrowser
+TTool TKTInspector TKToolsDraw

adm/UDLIST

@@ -5,7 +5,6 @@ n Bnd
 n BVH
 n CSLib
 n Convert
-n Dico
 n ElCLib
 n ElSLib
 n Expr
@@ -248,6 +247,7 @@ n StdObjMgt
 n StdDrivers
 n StdObject
 n StdPersistent
+n StdStorage
 n ShapePersistent
 n TDF
 n TDataStd
@@ -347,8 +347,6 @@ n StepToGeom
 n StepToTopoDS
 n StepVisual
 n StlAPI
-n StlMesh
-n StlTransfer
 n TopoDSToStep
 n Transfer
 n TransferBRep
@@ -399,9 +397,6 @@ n HLRTest
 n MeshTest
 n SWDRAW
 n TObjDRAW
-n TestTopOpe
-n TestTopOpeDraw
-n TestTopOpeTools
 n ViewerTest
 n XDEDRAW
 n XSDRAW
@@ -438,3 +433,4 @@ n IVtkDraw
 t TKIVtkDraw
 n Geom2dEvaluator
 t TKVCAF
+n XCAFView

adm/cmake/3rdparty_macro.cmake

@@ -6,7 +6,7 @@ endif()
 set(3RDPARTY_MACRO_ALREADY_INCLUDED 1)
 
 
-macro (THIRDPARTY_PRODUCT PRODUCT_NAME HEADER_NAME LIBRARY_NAME LIBRARY_NAME_DEBUG)
+macro (THIRDPARTY_PRODUCT PRODUCT_NAME HEADER_NAME LIBRARY_CSF_NAME LIBRARY_NAME_DEBUG_SUFFIX)
 
   if (NOT DEFINED INSTALL_${PRODUCT_NAME} AND BUILD_SHARED_LIBS)
     set (INSTALL_${PRODUCT_NAME} OFF CACHE BOOL "${INSTALL_${PRODUCT_NAME}_DESCR}")
@@ -37,54 +37,57 @@ macro (THIRDPARTY_PRODUCT PRODUCT_NAME HEADER_NAME LIBRARY_NAME LIBRARY_NAME_DEB
     set (3RDPARTY_${PRODUCT_NAME}_INCLUDE_DIR           "" CACHE PATH "the path of ${HEADER_NAME}")
   endif()
 
-  if (BUILD_SHARED_LIBS)
-    if (NOT DEFINED 3RDPARTY_${PRODUCT_NAME}_LIBRARY OR NOT 3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR OR NOT EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR}")
-      set (3RDPARTY_${PRODUCT_NAME}_LIBRARY               "" CACHE FILEPATH "${PRODUCT_NAME} library" FORCE)
-    endif()
-
-    if (NOT DEFINED 3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR)
-      set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR           "" CACHE PATH "The directory containing ${PRODUCT_NAME} library")
-    endif()
-
-    if (WIN32)
-      if (NOT DEFINED 3RDPARTY_${PRODUCT_NAME}_DLL OR NOT 3RDPARTY_${PRODUCT_NAME}_DLL_DIR OR NOT EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR}")
-        set (3RDPARTY_${PRODUCT_NAME}_DLL                 "" CACHE FILEPATH "${PRODUCT_NAME} shared library" FORCE)
-      endif()
-    endif()
-
-    if (WIN32)
-      if (NOT DEFINED 3RDPARTY_${PRODUCT_NAME}_DLL_DIR)
-        set (3RDPARTY_${PRODUCT_NAME}_DLL_DIR             "" CACHE PATH "The directory containing ${PRODUCT_NAME} shared library")
-      endif()
-    endif()
-  endif()
-
-  # check 3RDPARTY_${PRODUCT_NAME}_ paths for consistency with specified 3RDPARTY_${PRODUCT_NAME}_DIR
-  if (3RDPARTY_${PRODUCT_NAME}_DIR AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_DIR}")
-    CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_${PRODUCT_NAME}_DIR 3RDPARTY_${PRODUCT_NAME}_INCLUDE_DIR PATH "the path to ${PRODUCT_NAME}")
+  separate_arguments (${LIBRARY_CSF_NAME})
+  foreach (LIBRARY_NAME ${${LIBRARY_CSF_NAME}})
+    string (REPLACE "." "" LIBRARY_NAME "${LIBRARY_NAME}")
     if (BUILD_SHARED_LIBS)
-      CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_${PRODUCT_NAME}_DIR 3RDPARTY_${PRODUCT_NAME}_LIBRARY FILEPATH "the path to ${PRODUCT_NAME} library")
+      if (NOT DEFINED 3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME} OR NOT 3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME} OR NOT EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME}}")
+        set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME}               "" CACHE FILEPATH "${PRODUCT_NAME} library \"${LIBRARY_NAME}\"" FORCE)
+      endif()
 
-      if (3RDPARTY_${PRODUCT_NAME}_LIBRARY AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY}")
-        get_filename_component (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR "${3RDPARTY_${PRODUCT_NAME}_LIBRARY}" PATH)
-        set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR}" CACHE PATH "The directory containing ${PRODUCT_NAME} library" FORCE)
-      else()
-        CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_${PRODUCT_NAME}_DIR 3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR PATH "The directory containing ${PRODUCT_NAME} library")
+      if (NOT DEFINED 3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME})
+        set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME}           "" CACHE PATH "The directory containing ${PRODUCT_NAME} library \"${LIBRARY_NAME}\"")
       endif()
 
       if (WIN32)
-        CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_${PRODUCT_NAME}_DIR 3RDPARTY_${PRODUCT_NAME}_DLL FILEPATH "the path to ${PRODUCT_NAME} shared library")
+        if (NOT DEFINED 3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME} OR NOT 3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME} OR NOT EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME}}")
+          set (3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME}                 "" CACHE FILEPATH "${PRODUCT_NAME} shared library \"${LIBRARY_NAME}\"" FORCE)
+        endif()
+      endif()
 
-        if (3RDPARTY_${PRODUCT_NAME}_DLL AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL}")
-          get_filename_component (3RDPARTY_${PRODUCT_NAME}_DLL_DIR "${3RDPARTY_${PRODUCT_NAME}_DLL}" PATH)
-          set (3RDPARTY_${PRODUCT_NAME}_DLL_DIR "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR}" CACHE PATH "The directory containing ${PRODUCT_NAME} shared library" FORCE)
-        else()
-          CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_${PRODUCT_NAME}_DIR 3RDPARTY_${PRODUCT_NAME}_DLL_DIR PATH "The directory containing ${PRODUCT_NAME} shared library")
+      if (WIN32)
+        if (NOT DEFINED 3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME})
+          set (3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME}             "" CACHE PATH "The directory containing ${PRODUCT_NAME} shared library \"${LIBRARY_NAME}\"")
         endif()
       endif()
     endif()
-  endif()
 
+    # check 3RDPARTY_${PRODUCT_NAME}_ paths for consistency with specified 3RDPARTY_${PRODUCT_NAME}_DIR
+    if (3RDPARTY_${PRODUCT_NAME}_DIR AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_DIR}")
+      CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_${PRODUCT_NAME}_DIR 3RDPARTY_${PRODUCT_NAME}_INCLUDE_DIR PATH "the path to ${PRODUCT_NAME}")
+      if (BUILD_SHARED_LIBS)
+        CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_${PRODUCT_NAME}_DIR 3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME} FILEPATH "the path to ${PRODUCT_NAME} library \"${LIBRARY_NAME}\"")
+
+        if (3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME} AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME}}")
+          get_filename_component (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME} "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME}}" PATH)
+          set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME} "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME}}" CACHE PATH "The directory containing ${PRODUCT_NAME} library \"${LIBRARY_NAME}\"" FORCE)
+        else()
+          CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_${PRODUCT_NAME}_DIR 3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME} PATH "The directory containing ${PRODUCT_NAME} library \"${LIBRARY_NAME}\"")
+        endif()
+
+        if (WIN32)
+          CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_${PRODUCT_NAME}_DIR 3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME} FILEPATH "the path to ${PRODUCT_NAME} shared library \"${LIBRARY_NAME}\"")
+
+          if (3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME} AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME}}")
+            get_filename_component (3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME} "${3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME}}" PATH)
+            set (3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME} "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME}}" CACHE PATH "The directory containing ${PRODUCT_NAME} shared library \"${LIBRARY_NAME}\"" FORCE)
+          else()
+            CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_${PRODUCT_NAME}_DIR 3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME} PATH "The directory containing ${PRODUCT_NAME} shared library \"${LIBRARY_NAME}\"")
+          endif()
+        endif()
+      endif()
+    endif()
+  endforeach()
   # header
   if (NOT 3RDPARTY_${PRODUCT_NAME}_INCLUDE_DIR OR NOT EXISTS "${3RDPARTY_${PRODUCT_NAME}_INCLUDE_DIR}")
 
@@ -94,12 +97,12 @@ macro (THIRDPARTY_PRODUCT PRODUCT_NAME HEADER_NAME LIBRARY_NAME LIBRARY_NAME_DEB
     if (3RDPARTY_${PRODUCT_NAME}_DIR AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_DIR}")
       find_path (3RDPARTY_${PRODUCT_NAME}_INCLUDE_DIR NAMES ${HEADER_NAME}
                                                       PATHS ${3RDPARTY_${PRODUCT_NAME}_DIR}
-                                                      PATH_SUFFIXES include
+                                                      PATH_SUFFIXES include inc
                                                       CMAKE_FIND_ROOT_PATH_BOTH
                                                       NO_DEFAULT_PATH)
     else()
       find_path (3RDPARTY_${PRODUCT_NAME}_INCLUDE_DIR NAMES ${HEADER_NAME}
-                                                      PATH_SUFFIXES include
+                                                      PATH_SUFFIXES include inc
                                                       CMAKE_FIND_ROOT_PATH_BOTH)
     endif()
   endif()
@@ -112,158 +115,204 @@ macro (THIRDPARTY_PRODUCT PRODUCT_NAME HEADER_NAME LIBRARY_NAME LIBRARY_NAME_DEB
     set (3RDPARTY_${PRODUCT_NAME}_INCLUDE_DIR "" CACHE FILEPATH "The path to ${HEADER_NAME}" FORCE)
   endif()
 
-  if (BUILD_SHARED_LIBS)
-    # library
-    if (NOT 3RDPARTY_${PRODUCT_NAME}_LIBRARY OR NOT EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY}")
-      set (CMAKE_FIND_LIBRARY_SUFFIXES .lib .so .dylib .a)
+  foreach (LIBRARY_NAME ${${LIBRARY_CSF_NAME}})
+    string (REPLACE "." "" LIBRARY_NAME_SUFFIX "${LIBRARY_NAME}")
+    if (BUILD_SHARED_LIBS)
+      # library
+      if (NOT 3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX} OR NOT EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX}}")
+        set (CMAKE_FIND_LIBRARY_SUFFIXES .lib .so .dylib .a)
 
-      set (${PRODUCT_NAME}_PATH_SUFFIXES lib)
-      if (ANDROID)
-        set (${PRODUCT_NAME}_PATH_SUFFIXES ${${PRODUCT_NAME}_PATH_SUFFIXES} libs/${ANDROID_ABI})
-      endif()
+        set (${PRODUCT_NAME}_PATH_SUFFIXES lib)
+        if (WIN32)
+          set (${PRODUCT_NAME}_PATH_SUFFIXES ${${PRODUCT_NAME}_PATH_SUFFIXES} win${COMPILER_BITNESS}/${COMPILER}/lib)
+        endif()
+        if (ANDROID)
+          set (${PRODUCT_NAME}_PATH_SUFFIXES ${${PRODUCT_NAME}_PATH_SUFFIXES} libs/${ANDROID_ABI})
+        endif()
 
-      # set 3RDPARTY_${PRODUCT_NAME}_LIBRARY as notfound, otherwise find_library can't assign a new value to 3RDPARTY_${PRODUCT_NAME}_LIBRARY
-      set (3RDPARTY_${PRODUCT_NAME}_LIBRARY "3RDPARTY_${PRODUCT_NAME}_LIBRARY-NOTFOUND" CACHE FILEPATH "The path to ${PRODUCT_NAME} library" FORCE)
-
-      if (3RDPARTY_${PRODUCT_NAME}_DIR AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_DIR}")
-        find_library (3RDPARTY_${PRODUCT_NAME}_LIBRARY NAMES ${LIBRARY_NAME}
-                                                       PATHS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR}" "${3RDPARTY_${PRODUCT_NAME}_DIR}"
-                                                       PATH_SUFFIXES ${${PRODUCT_NAME}_PATH_SUFFIXES}
-                                                       CMAKE_FIND_ROOT_PATH_BOTH
-                                                       NO_DEFAULT_PATH)
-      else()
-        find_library (3RDPARTY_${PRODUCT_NAME}_LIBRARY NAMES ${LIBRARY_NAME} 
-                                                       PATH_SUFFIXES ${${PRODUCT_NAME}_PATH_SUFFIXES}
-                                                       CMAKE_FIND_ROOT_PATH_BOTH)
-      endif()
-
-      if (3RDPARTY_${PRODUCT_NAME}_LIBRARY AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY}")
-        get_filename_component (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR "${3RDPARTY_${PRODUCT_NAME}_LIBRARY}" PATH)
-        set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR}" CACHE PATH "The directory containing ${PRODUCT_NAME} library" FORCE)
-      else()
-        set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR "" CACHE PATH "The directory containing ${PRODUCT_NAME} library" FORCE)
-      endif()
-    endif()
-
-    if (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR}")
-      list (APPEND 3RDPARTY_LIBRARY_DIRS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR}")
-    else()
-      list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR)
-
-      set (3RDPARTY_${PRODUCT_NAME}_LIBRARY "" CACHE FILEPATH "The path to ${PRODUCT_NAME} library" FORCE)
-    endif()
-
-    # shared library
-    if (WIN32)
-      if (NOT 3RDPARTY_${PRODUCT_NAME}_DLL OR NOT EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL}")
-
-        set (CMAKE_FIND_LIBRARY_SUFFIXES .dll)
-
-        # set 3RDPARTY_${PRODUCT_NAME}_DLL as notfound, otherwise find_library can't assign a new value to 3RDPARTY_${PRODUCT_NAME}_DLL
-        set (3RDPARTY_${PRODUCT_NAME}_DLL "3RDPARTY_${PRODUCT_NAME}_DLL-NOTFOUND" CACHE FILEPATH "The path to ${PRODUCT_NAME} shared library" FORCE)
+        # set 3RDPARTY_${PRODUCT_NAME}_LIBRARY as notfound, otherwise find_library can't assign a new value to 3RDPARTY_${PRODUCT_NAME}_LIBRARY
+        set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX} "3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX}-NOTFOUND" CACHE FILEPATH "The path to ${PRODUCT_NAME} library \"${LIBRARY_NAME}\"" FORCE)
 
         if (3RDPARTY_${PRODUCT_NAME}_DIR AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_DIR}")
-          find_library (3RDPARTY_${PRODUCT_NAME}_DLL  NAMES ${LIBRARY_NAME}
-                                                      PATHS "${3RDPARTY_${PRODUCT_NAME}_DIR}"
-                                                      PATH_SUFFIXES bin
-                                                      NO_DEFAULT_PATH)
+          find_library (3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX} NAMES ${LIBRARY_NAME}
+                                                                                PATHS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME}}" "${3RDPARTY_${PRODUCT_NAME}_DIR}"
+                                                                                PATH_SUFFIXES ${${PRODUCT_NAME}_PATH_SUFFIXES}
+                                                                                CMAKE_FIND_ROOT_PATH_BOTH
+                                                                                NO_DEFAULT_PATH)
+          if ("${3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX}}" STREQUAL "3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX}-NOTFOUND")
+            # find directory recursive
+            FIND_SUBDIRECTORY (${3RDPARTY_${PRODUCT_NAME}_DIR} "${${PRODUCT_NAME}_PATH_SUFFIXES}" SUBDIR_NAME)
+            if (NOT "${SUBDIR_NAME}" STREQUAL "")
+              find_library (3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX} NAMES ${LIBRARY_NAME_SUFFIX}
+                                                           PATHS "${SUBDIR_NAME}"
+                                                           PATH_SUFFIXES ${${PRODUCT_NAME}_PATH_SUFFIXES}
+                                                           CMAKE_FIND_ROOT_PATH_BOTH
+                                                           NO_DEFAULT_PATH)
+            endif()
+          endif()
         else()
-          find_library (3RDPARTY_${PRODUCT_NAME}_DLL NAMES ${LIBRARY_NAME} PATH_SUFFIXES bin)
+          find_library (3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX} NAMES ${LIBRARY_NAME}
+                                                                                PATH_SUFFIXES ${${PRODUCT_NAME}_PATH_SUFFIXES}
+                                                                                CMAKE_FIND_ROOT_PATH_BOTH)
         endif()
 
-        if (3RDPARTY_${PRODUCT_NAME}_DLL AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL}")
-          get_filename_component (3RDPARTY_${PRODUCT_NAME}_DLL_DIR "${3RDPARTY_${PRODUCT_NAME}_DLL}" PATH)
-          set (3RDPARTY_${PRODUCT_NAME}_DLL_DIR "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR}" CACHE PATH "The directory containing ${PRODUCT_NAME} library" FORCE)
+        if (3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX} AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX}}")
+          get_filename_component (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME_SUFFIX} "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX}}" PATH)
+          set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME_SUFFIX} "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME_SUFFIX}}" CACHE PATH "The directory containing ${PRODUCT_NAME} library \"${LIBRARY_NAME}\"" FORCE)
         else()
-          set (3RDPARTY_${PRODUCT_NAME}_DLL_DIR "" CACHE PATH "The directory containing ${PRODUCT_NAME} shared library" FORCE)
-
-          set (3RDPARTY_${PRODUCT_NAME}_DLL "" CACHE FILEPATH "${PRODUCT_NAME} shared library" FORCE)
+          set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME_SUFFIX} "" CACHE PATH "The directory containing ${PRODUCT_NAME} library \"${LIBRARY_NAME}\"" FORCE)
         endif()
       endif()
 
-      if (3RDPARTY_${PRODUCT_NAME}_DLL_DIR OR EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR}")
-        list (APPEND 3RDPARTY_DLL_DIRS "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR}")
+      if (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME_SUFFIX} AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME_SUFFIX}}")
+        list (APPEND 3RDPARTY_LIBRARY_DIRS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME_SUFFIX}}")
       else()
-        list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_${PRODUCT_NAME}_DLL_DIR)
+        list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME_SUFFIX})
+
+        set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX} "" CACHE FILEPATH "The path to ${PRODUCT_NAME} library \"${LIBRARY_NAME}\"" FORCE)
       endif()
-    endif()
-
-    set (USED_3RDPARTY_${PRODUCT_NAME}_DIR "")
-
-    if (INSTALL_${PRODUCT_NAME})
-      OCCT_MAKE_OS_WITH_BITNESS()
-      OCCT_MAKE_COMPILER_SHORT_NAME()
 
+      # shared library
       if (WIN32)
-        if (SINGLE_GENERATOR)
-          install (FILES "${3RDPARTY_${PRODUCT_NAME}_DLL}" DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}")
-        else()
-          install (FILES "${3RDPARTY_${PRODUCT_NAME}_DLL}"
-                   CONFIGURATIONS Release
-                   DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}")
-          install (FILES "${3RDPARTY_${PRODUCT_NAME}_DLL}"
-                   CONFIGURATIONS RelWithDebInfo
-                   DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}i")
-          install (FILES "${3RDPARTY_${PRODUCT_NAME}_DLL}"
-                   CONFIGURATIONS Debug
-                   DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}d")
-        endif()
-      else()
-        get_filename_component(ABS_PATH ${3RDPARTY_${PRODUCT_NAME}_LIBRARY} REALPATH)
+        if (NOT 3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX} OR NOT EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX}}")
 
-        if ("${PRODUCT_NAME}" STREQUAL "FREEIMAGE")
-          get_filename_component(FREEIMLIB ${3RDPARTY_${PRODUCT_NAME}_LIBRARY} NAME)
+          set (CMAKE_FIND_LIBRARY_SUFFIXES .dll)
 
-          if (SINGLE_GENERATOR)
-            install (FILES "${ABS_PATH}" DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}" RENAME ${FREEIMLIB}.3)
+          # set 3RDPARTY_${PRODUCT_NAME}_DLL as notfound, otherwise find_library can't assign a new value to 3RDPARTY_${PRODUCT_NAME}_DLL
+          set (3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX} "3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX}-NOTFOUND" CACHE FILEPATH "The path to ${PRODUCT_NAME} shared library \"${LIBRARY_NAME}\"" FORCE)
+
+          if (3RDPARTY_${PRODUCT_NAME}_DIR AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_DIR}")
+            find_library (3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX}  NAMES ${LIBRARY_NAME}
+                                                                               PATHS "${3RDPARTY_${PRODUCT_NAME}_DIR}"
+                                                                               PATH_SUFFIXES bin  win${COMPILER_BITNESS}/${COMPILER}/bin
+                                                                               NO_DEFAULT_PATH)
+            if (3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX} STREQUAL "3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX}-NOTFOUND")
+              # find directory recursive
+              FIND_SUBDIRECTORY (${3RDPARTY_${PRODUCT_NAME}_DIR} bin SUBDIR_NAME)
+              if (NOT "${SUBDIR_NAME}" STREQUAL "")
+                find_library (3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX} NAMES ${LIBRARY_NAME_SUFFIX}
+                                                             PATHS "${SUBDIR_NAME}"
+                                                             PATH_SUFFIXES bin
+                                                             NO_DEFAULT_PATH)
+              endif()
+            endif()
           else()
-            install (FILES "${ABS_PATH}"
-                     CONFIGURATIONS Release
-                     DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}"
-                     RENAME ${FREEIMLIB}.3)
-            install (FILES "${ABS_PATH}"
-                     CONFIGURATIONS RelWithDebInfo
-                     DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}i"
-                     RENAME ${FREEIMLIB}.3)
-            install (FILES "${ABS_PATH}"
-                     CONFIGURATIONS Debug
-                     DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}d"
-                     RENAME ${FREEIMLIB}.3)
+            find_library (3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX} NAMES ${LIBRARY_NAME} PATH_SUFFIXES bin)
+          endif()
+
+          if (3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX} AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX}}")
+            get_filename_component (3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME_SUFFIX} "${3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX}}" PATH)
+            set (3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME_SUFFIX} "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME_SUFFIX}}" CACHE PATH "The directory containing ${PRODUCT_NAME} library \"${LIBRARY_NAME}\"" FORCE)
+          else()
+            set (3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME_SUFFIX} "" CACHE PATH "The directory containing ${PRODUCT_NAME} shared library \"${LIBRARY_NAME}\"" FORCE)
+
+            set (3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX} "" CACHE FILEPATH "${PRODUCT_NAME} shared library \"${LIBRARY_NAME}\"" FORCE)
           endif()
         endif()
 
-        if("${PRODUCT_NAME}" STREQUAL "GL2PS")
-          get_filename_component(GL2PSLIB ${3RDPARTY_${PRODUCT_NAME}_LIBRARY} NAME)
-
-          if (SINGLE_GENERATOR)
-            install (FILES "${ABS_PATH}" DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}" RENAME ${GL2PSLIB}.1)
-          else()
-            install (FILES "${ABS_PATH}"
-                     CONFIGURATIONS Release
-                     DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}"
-                     RENAME ${GL2PSLIB}.1)
-            install (FILES "${ABS_PATH}"
-                     CONFIGURATIONS RelWithDebInfo
-                     DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}i"
-                     RENAME ${GL2PSLIB}.1)
-            install (FILES "${ABS_PATH}"
-                     CONFIGURATIONS Debug
-                     DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}d"
-                     RENAME ${GL2PSLIB}.1)
-          endif()
+        if (3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME_SUFFIX} OR EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME_SUFFIX}}")
+          list (APPEND 3RDPARTY_DLL_DIRS "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME_SUFFIX}}")
+        else()
+          list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME_SUFFIX})
         endif()
       endif()
-    else()
-      # the library directory for using by the executable
-      if (WIN32)
-        set (USED_3RDPARTY_${PRODUCT_NAME}_DIR "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR}")
-      else()
-        set (USED_3RDPARTY_${PRODUCT_NAME}_DIR "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR}")
-      endif()
-    endif()
 
-    mark_as_advanced (3RDPARTY_${PRODUCT_NAME}_LIBRARY 3RDPARTY_${PRODUCT_NAME}_DLL)
-  endif()
+      if (WIN32)
+        set (3RDPARTY_${PRODUCT_NAME}_DLL_DIRS "")
+      else()
+        set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIRS "")
+      endif()
+
+      foreach (LIBRARY_NAME ${${LIBRARY_CSF_NAME}})
+        string (REPLACE "." "" LIBRARY_NAME_SUFFIX "${LIBRARY_NAME}")
+        if (WIN32)
+          set (3RDPARTY_${PRODUCT_NAME}_DLL_DIRS "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME_SUFFIX}};${3RDPARTY_${PRODUCT_NAME}_DLL_DIRS}")
+          set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIRS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME_SUFFIX}}")
+        else()
+          set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIRS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME_SUFFIX}}:${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIRS}")
+        endif()
+      endforeach()
+
+      set (USED_3RDPARTY_${PRODUCT_NAME}_DIRS "")
+
+      if (INSTALL_${PRODUCT_NAME})
+        OCCT_MAKE_OS_WITH_BITNESS()
+        OCCT_MAKE_COMPILER_SHORT_NAME()
+
+        if (WIN32)
+          if (SINGLE_GENERATOR)
+            install (FILES "${3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX}}" DESTINATION "${INSTALL_DIR_BIN}")
+          else()
+            install (FILES "${3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX}}"
+                     CONFIGURATIONS Release
+                     DESTINATION "${INSTALL_DIR_BIN}")
+            install (FILES "${3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX}}"
+                     CONFIGURATIONS RelWithDebInfo
+                     DESTINATION "${INSTALL_DIR_BIN}i")
+            install (FILES "${3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX}}"
+                     CONFIGURATIONS Debug
+                     DESTINATION "${INSTALL_DIR_BIN}d")
+          endif()
+        else()
+          get_filename_component(ABS_PATH ${3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX}} REALPATH)
+
+          if ("${PRODUCT_NAME}" STREQUAL "FREEIMAGE")
+            get_filename_component(FREEIMLIB ${3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX}} NAME)
+
+            if (SINGLE_GENERATOR)
+              install (FILES "${ABS_PATH}" DESTINATION "${INSTALL_DIR_LIB}" RENAME ${FREEIMLIB}.3)
+            else()
+              install (FILES "${ABS_PATH}"
+                       CONFIGURATIONS Release
+                       DESTINATION "${INSTALL_DIR_LIB}"
+                       RENAME ${FREEIMLIB}.3)
+              install (FILES "${ABS_PATH}"
+                       CONFIGURATIONS RelWithDebInfo
+                       DESTINATION "${INSTALL_DIR_LIB}i"
+                       RENAME ${FREEIMLIB}.3)
+              install (FILES "${ABS_PATH}"
+                       CONFIGURATIONS Debug
+                       DESTINATION "${INSTALL_DIR_LIB}d"
+                       RENAME ${FREEIMLIB}.3)
+            endif()
+          endif()
+
+          if("${PRODUCT_NAME}" STREQUAL "GL2PS")
+            get_filename_component(GL2PSLIB ${3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX}} NAME)
+
+            if (SINGLE_GENERATOR)
+              install (FILES "${ABS_PATH}" DESTINATION "${INSTALL_DIR_LIB}" RENAME ${GL2PSLIB}.1)
+            else()
+              install (FILES "${ABS_PATH}"
+                       CONFIGURATIONS Release
+                       DESTINATION "${INSTALL_DIR_LIB}"
+                       RENAME ${GL2PSLIB}.1)
+              install (FILES "${ABS_PATH}"
+                       CONFIGURATIONS RelWithDebInfo
+                       DESTINATION "${INSTALL_DIR_LIB}i"
+                       RENAME ${GL2PSLIB}.1)
+              install (FILES "${ABS_PATH}"
+                       CONFIGURATIONS Debug
+                       DESTINATION "${INSTALL_DIR_LIB}d"
+                       RENAME ${GL2PSLIB}.1)
+            endif()
+          endif()
+        endif()
+      else()
+        # the library directory for using by the executable
+      foreach (LIBRARY_NAME ${${LIBRARY_CSF_NAME}})
+        string (REPLACE "." "" LIBRARY_NAME_SUFFIX "${LIBRARY_NAME}")
+          if (WIN32)
+            set (USED_3RDPARTY_${PRODUCT_NAME}_DIRS "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR_${LIBRARY_NAME_SUFFIX}};${USED_3RDPARTY_${PRODUCT_NAME}_DIRS}")
+          else()
+            set (USED_3RDPARTY_${PRODUCT_NAME}_DIRS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR_${LIBRARY_NAME_SUFFIX}}:${USED_3RDPARTY_${PRODUCT_NAME}_DIRS}")
+          endif()
+        endforeach()
+      endif()
+
+      mark_as_advanced (3RDPARTY_${PRODUCT_NAME}_LIBRARY_${LIBRARY_NAME_SUFFIX} 3RDPARTY_${PRODUCT_NAME}_DLL_${LIBRARY_NAME_SUFFIX})
+    endif()
+  endforeach()
 endmacro()
 
 macro (COMPLIANCE_PRODUCT_CONSISTENCY LIBNAME)

adm/cmake/doxygen.cmake

@@ -1,9 +1,10 @@
 # doxygen
+set (DOXYGEN_MINIMUM_VERSION 1.8.4)
 
 if (DO_ONLY_CHECK_FOR_DOXYGEN)
   message (STATUS "Info. Detecting doxygen")
   set (DOXYGEN_SKIP_DOT ON)
-  find_package (Doxygen)
+  find_package (Doxygen ${DOXYGEN_MINIMUM_VERSION})
 
   set (CAN_DOXYGEN_BE_USED OFF)
   if (DOXYGEN_EXECUTABLE)
@@ -33,7 +34,7 @@ else()
   if (NOT 3RDPARTY_DOXYGEN_EXECUTABLE OR (NOT 3RDPARTY_SKIP_DOT_EXECUTABLE AND NOT 3RDPARTY_DOT_EXECUTABLE))
 
     set (DOXYGEN_SKIP_DOT ${3RDPARTY_SKIP_DOT_EXECUTABLE})
-    find_package (Doxygen)
+    find_package (Doxygen ${DOXYGEN_MINIMUM_VERSION})
     
     if (NOT 3RDPARTY_DOXYGEN_EXECUTABLE AND DOXYGEN_EXECUTABLE)
       set (3RDPARTY_DOXYGEN_EXECUTABLE "${DOXYGEN_EXECUTABLE}" CACHE FILEPATH "${3RDPARTY_DOXYGEN_EXECUTABLE_DESCR}" FORCE)

adm/cmake/egl.cmake

@@ -1,6 +1,3 @@
 # EGL
-if (WIN32)
-  THIRDPARTY_PRODUCT("EGL" "EGL/egl.h" "libEGL" "libEGL")
-else()
-  THIRDPARTY_PRODUCT("EGL" "EGL/egl.h" "EGL" "EGL")
-endif()
+
+THIRDPARTY_PRODUCT("EGL" "EGL/egl.h" "CSF_OpenGlLibs" "")

adm/cmake/eigen.cmake

@@ -0,0 +1,71 @@
+# eigen
+
+# eigen directory
+if (NOT DEFINED 3RDPARTY_EIGEN_DIR)
+  set (3RDPARTY_EIGEN_DIR "" CACHE PATH "The directory containing eigen")
+endif()
+
+# search for eigen in user defined directory
+if (3RDPARTY_DIR AND EXISTS "${3RDPARTY_DIR}")
+  if (NOT 3RDPARTY_EIGEN_DIR OR NOT EXISTS "${3RDPARTY_EIGEN_DIR}")
+    FIND_PRODUCT_DIR("${3RDPARTY_DIR}" Eigen EIGEN_DIR_NAME)
+    if (EIGEN_DIR_NAME)
+      set (3RDPARTY_EIGEN_DIR "${3RDPARTY_DIR}/${EIGEN_DIR_NAME}" CACHE PATH "The directory containing eigen" FORCE)
+    endif()
+  endif()
+endif()
+
+if (NOT DEFINED 3RDPARTY_EIGEN_INCLUDE_DIR)
+  set (3RDPARTY_EIGEN_INCLUDE_DIR  "" CACHE FILEPATH "The directory containing headers of the EIGEN")
+endif()
+
+if (NOT 3RDPARTY_EIGEN_INCLUDE_DIR OR NOT EXISTS "${3RDPARTY_EIGEN_INCLUDE_DIR}")
+
+  set (HEADER_NAMES Eigen)
+
+  set (3RDPARTY_EIGEN_INCLUDE_DIR "3RDPARTY_EIGEN_INCLUDE_DIR-NOTFOUND" CACHE PATH "the path to Eigen header file" FORCE)
+
+  if (3RDPARTY_EIGEN_DIR AND EXISTS "${3RDPARTY_EIGEN_DIR}")
+    find_path (3RDPARTY_EIGEN_INCLUDE_DIR NAMES ${HEADER_NAMES}
+                                              PATHS ${3RDPARTY_EIGEN_DIR}
+                                              PATH_SUFFIXES include eigen3 include/eigen3
+                                              CMAKE_FIND_ROOT_PATH_BOTH
+                                              NO_DEFAULT_PATH)
+  else()
+    find_path (3RDPARTY_EIGEN_INCLUDE_DIR NAMES ${HEADER_NAMES}
+                                              PATH_SUFFIXES include eigen3 include/eigen3
+                                              CMAKE_FIND_ROOT_PATH_BOTH)
+  endif()
+
+  # use default (CMake) EIGEN search
+  if (NOT 3RDPARTY_EIGEN_INCLUDE_DIR OR NOT EXISTS "${3RDPARTY_EIGEN_INCLUDE_DIR}")
+    # use 3RDPARTY_EIGEN_DIR if it is specified for eigen search
+    if (3RDPARTY_EIGEN_DIR AND EXISTS "${3RDPARTY_EIGEN_DIR}")
+      set (CACHED_EIGEN_DIR $ENV{Eigen3_DIR})
+      set (ENV{Eigen3_DIR} "${3RDPARTY_EIGEN_DIR}")
+    endif()
+
+    find_package(Eigen3 QUIET)
+
+    # restore ENV{Eigen3_DIR}
+    if (3RDPARTY_EIGEN_DIR AND EXISTS "${3RDPARTY_EIGEN_DIR}")
+      set (ENV{Eigen3_DIR} ${CACHED_EIGEN_DIR})
+    endif()
+
+    if (${EIGEN3_FOUND})
+      set (3RDPARTY_EIGEN_INCLUDE_DIR "${EIGEN3_INCLUDE_DIR}" CACHE PATH "the path to Eigen header file" FORCE)
+      set (3RDPARTY_EIGEN_DIR "${EIGEN3_ROOT_DIR}"    CACHE PATH "The directory containing eigen" FORCE)
+    endif()
+  endif()
+endif()
+
+if (3RDPARTY_EIGEN_INCLUDE_DIR AND EXISTS "${3RDPARTY_EIGEN_INCLUDE_DIR}")
+  list (APPEND 3RDPARTY_INCLUDE_DIRS "${3RDPARTY_EIGEN_INCLUDE_DIR}")
+else()
+  list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_EIGEN_INCLUDE_DIR)
+
+  set (3RDPARTY_EIGEN_INCLUDE_DIR "" CACHE PATH "the path to Eigen header file" FORCE)
+endif()
+
+# unset all redundant variables
+OCCT_CHECK_AND_UNSET(Eigen3_DIR)

adm/cmake/ffmpeg.cmake

@@ -0,0 +1,228 @@
+# FFmpeg
+
+if (NOT DEFINED INSTALL_FFMPEG)
+  set (INSTALL_FFMPEG OFF CACHE BOOL "${INSTALL_FFMPEG_DESCR}")
+endif()
+
+if (NOT DEFINED 3RDPARTY_FFMPEG_DIR)
+  set (3RDPARTY_FFMPEG_DIR "" CACHE PATH "The directory containing FFmpeg")
+endif()
+
+# include occt macros. compiler_bitness, os_wiht_bit, compiler
+OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/occt_macros")
+
+# specify FFMPEG folder in connection with 3RDPARTY_DIR
+if (3RDPARTY_DIR AND EXISTS "${3RDPARTY_DIR}")
+  if (NOT 3RDPARTY_FFMPEG_DIR OR NOT EXISTS "${3RDPARTY_FFMPEG_DIR}")
+    FIND_PRODUCT_DIR ("${3RDPARTY_DIR}" FFMPEG FFMPEG_DIR_NAME)
+    if (FFMPEG_DIR_NAME)
+      set (3RDPARTY_FFMPEG_DIR "${3RDPARTY_DIR}/${FFMPEG_DIR_NAME}" CACHE PATH "The directory containing FFmpeg" FORCE)
+    endif()
+  endif()
+else()
+endif()
+
+# define required FFMPEG variables
+if (NOT DEFINED 3RDPARTY_FFMPEG_INCLUDE_DIR)
+  set (3RDPARTY_FFMPEG_INCLUDE_DIR  "" CACHE PATH "the path of headers directory")
+endif()
+
+if (NOT DEFINED 3RDPARTY_FFMPEG_LIBRARY OR NOT 3RDPARTY_FFMPEG_LIBRARY_DIR OR NOT EXISTS "${3RDPARTY_FFMPEG_LIBRARY_DIR}")
+  set (3RDPARTY_FFMPEG_LIBRARY               "" CACHE FILEPATH "FFmpeg framework" FORCE)
+endif()
+
+if (NOT DEFINED 3RDPARTY_FFMPEG_LIBRARY_DIR)
+  set (3RDPARTY_FFMPEG_LIBRARY_DIR           "" CACHE PATH "The directory containing FFmpeg framework")
+endif()
+
+if (WIN32)
+  if (NOT DEFINED 3RDPARTY_FFMPEG_DLL OR NOT 3RDPARTY_FFMPEG_DLL_DIR OR NOT EXISTS "${3RDPARTY_FFMPEG_DLL_DIR}")
+    set (3RDPARTY_FFMPEG_DLL                 "" CACHE FILEPATH "FFmpeg shared libraries" FORCE)
+  endif()
+endif()
+
+if (WIN32)
+  if (NOT DEFINED 3RDPARTY_FFMPEG_DLL_DIR)
+    set (3RDPARTY_FFMPEG_DLL_DIR               "" CACHE PATH "The directory containing FFmpeg shared libraries")
+  endif()
+endif()
+
+# check 3RDPARTY_${PRODUCT_NAME}_ paths for consistency with specified 3RDPARTY_${PRODUCT_NAME}_DIR
+if (3RDPARTY_FFMPEG_DIR AND EXISTS "${3RDPARTY_FFMPEG_DIR}")
+  CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_FFMPEG_DIR 3RDPARTY_FFMPEG_INCLUDE_DIR PATH "the path to FFmpeg")
+  CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_FFMPEG_DIR 3RDPARTY_FFMPEG_LIBRARY FILEPATH "the path to FFmpeg framework")
+
+  if (3RDPARTY_FFMPEG_LIBRARY AND EXISTS "${3RDPARTY_FFMPEG_LIBRARY}")
+    get_filename_component (3RDPARTY_FFMPEG_LIBRARY_DIR "${3RDPARTY_FFMPEG_LIBRARY}" PATH)
+    set (3RDPARTY_FFMPEG_LIBRARY_DIR "${3RDPARTY_FFMPEG_LIBRARY_DIR}" CACHE PATH "The directory containing FFmpeg libraries" FORCE)
+  else()
+    CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_FFMPEG_DIR 3RDPARTY_FFMPEG_LIBRARY_DIR PATH "The directory containing FFmpeg libraries")
+  endif()
+
+  if (WIN32)
+    CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_FFMPEG_DIR 3RDPARTY_FFMPEG_DLL FILEPATH "the path to FFmpeg shared libraries")
+
+    if (3RDPARTY_FFMPEG_DLL AND EXISTS "${3RDPARTY_FFMPEG_DLL}")
+      get_filename_component (3RDPARTY_FFMPEG_DLL_DIR "${3RDPARTY_FFMPEG_DLL}" PATH)
+      set (3RDPARTY_FFMPEG_DLL_DIR "${3RDPARTY_FFMPEG_DLL_DIR}" CACHE PATH "The directory containing FFmpeg shared libraries" FORCE)
+    else()
+      CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_FFMPEG_DIR 3RDPARTY_FFMPEG_DLL_DIR PATH "The directory containing FFmpeg shared libraries")
+    endif()
+  endif()
+endif()
+
+# header
+if (NOT 3RDPARTY_FFMPEG_INCLUDE_DIR OR NOT EXISTS "${3RDPARTY_FFMPEG_INCLUDE_DIR}")
+  set (HEADER_NAMES avutil.h libavutil/avutil.h)
+
+  # set 3RDPARTY_FFMPEG_INCLUDE_DIR as notfound, otherwise find_library can't assign a new value to 3RDPARTY_FFMPEG_INCLUDE_DIR
+  set (3RDPARTY_FFMPEG_INCLUDE_DIR "3RDPARTY_FFMPEG_INCLUDE_DIR-NOTFOUND" CACHE FILEPATH "the path to header directory" FORCE)
+
+  if (3RDPARTY_FFMPEG_DIR AND EXISTS "${3RDPARTY_FFMPEG_DIR}")
+    find_path (3RDPARTY_FFMPEG_INCLUDE_DIR NAMES ${HEADER_NAMES}
+                                                 PATHS ${3RDPARTY_FFMPEG_DIR}
+                                                 PATH_SUFFIXES include
+                                                 CMAKE_FIND_ROOT_PATH_BOTH
+                                                 NO_DEFAULT_PATH)
+  else()
+    find_path (3RDPARTY_FFMPEG_INCLUDE_DIR NAMES ${HEADER_NAMES}
+                                                 PATH_SUFFIXES include
+                                                 CMAKE_FIND_ROOT_PATH_BOTH)
+  endif()
+endif()
+
+if (3RDPARTY_FFMPEG_INCLUDE_DIR AND EXISTS "${3RDPARTY_FFMPEG_INCLUDE_DIR}")
+  list (APPEND 3RDPARTY_INCLUDE_DIRS "${3RDPARTY_FFMPEG_INCLUDE_DIR}")
+else()
+  list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_FFMPEG_INCLUDE_DIR)
+
+  set (3RDPARTY_FFMPEG_INCLUDE_DIR "" CACHE FILEPATH "the path to avutil.h" FORCE)
+endif()
+
+# library
+if (NOT 3RDPARTY_FFMPEG_LIBRARY OR NOT EXISTS "${3RDPARTY_FFMPEG_LIBRARY}")
+  set (CMAKE_FIND_LIBRARY_SUFFIXES .lib .so .dylib .a)
+
+  set (FFMPEG_PATH_SUFFIXES lib)
+  if (ANDROID)
+    set (FFMPEG_PATH_SUFFIXES ${FFMPEG_PATH_SUFFIXES} libs/${ANDROID_ABI})
+  elseif(APPLE)
+    set (FFMPEG_PATH_SUFFIXES ${FFMPEG_PATH_SUFFIXES} Frameworks)
+  endif()
+
+  # set 3RDPARTY_FFMPEG_LIBRARY as notfound, otherwise find_library can't assign a new value to 3RDPARTY_FFMPEG_LIBRARY
+  set (3RDPARTY_FFMPEG_LIBRARY "3RDPARTY_FFMPEG_LIBRARY-NOTFOUND" CACHE FILEPATH "The path to FFmpeg library" FORCE)
+
+  if (3RDPARTY_FFMPEG_DIR AND EXISTS "${3RDPARTY_FFMPEG_DIR}")
+    find_library (3RDPARTY_FFMPEG_LIBRARY NAMES avutil
+                  PATHS "${3RDPARTY_FFMPEG_LIBRARY_DIR}" "${3RDPARTY_FFMPEG_DIR}"
+                  PATH_SUFFIXES ${FFMPEG_PATH_SUFFIXES}
+                  CMAKE_FIND_ROOT_PATH_BOTH
+                  NO_DEFAULT_PATH)
+  else()
+    find_library (3RDPARTY_FFMPEG_LIBRARY NAMES avutil
+                  PATH_SUFFIXES ${FFMPEG_PATH_SUFFIXES}
+                  CMAKE_FIND_ROOT_PATH_BOTH)
+  endif()
+
+  if (3RDPARTY_FFMPEG_LIBRARY AND EXISTS "${3RDPARTY_FFMPEG_LIBRARY}")
+    get_filename_component (3RDPARTY_FFMPEG_LIBRARY_DIR "${3RDPARTY_FFMPEG_LIBRARY}" PATH)
+    set (3RDPARTY_FFMPEG_LIBRARY_DIR "${3RDPARTY_FFMPEG_LIBRARY_DIR}" CACHE PATH "The directory containing FFmpeg library" FORCE)
+  else()
+    set (3RDPARTY_FFMPEG_LIBRARY_DIR "" CACHE PATH "The directory containing FFmpeg library" FORCE)
+  endif()
+endif()
+
+if (3RDPARTY_FFMPEG_LIBRARY_DIR AND EXISTS "${3RDPARTY_FFMPEG_LIBRARY_DIR}")
+  list (APPEND 3RDPARTY_LIBRARY_DIRS "${3RDPARTY_FFMPEG_LIBRARY_DIR}")
+else()
+  list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_FFMPEG_LIBRARY_DIR)
+
+  set (3RDPARTY_FFMPEG_LIBRARY "" CACHE FILEPATH "The path to FFmpeg library" FORCE)
+endif()
+
+# shared library
+if (WIN32)
+  if (NOT 3RDPARTY_FFMPEG_DLL OR NOT EXISTS "${3RDPARTY_FFMPEG_DLL}")
+
+    set (CMAKE_FIND_LIBRARY_SUFFIXES .dll)
+    set (3RDPARTY_FFMPEG_DLL "3RDPARTY_FFMPEG_DLL-NOTFOUND" CACHE FILEPATH "The path to FFmpeg shared library" FORCE)
+
+    # find FFmpeg shared library
+    file (GLOB 3RDPARTY_FFMPEG_DLL "${3RDPARTY_FFMPEG_DIR}/bin/avutil[-][0-9]*")
+
+    if (3RDPARTY_FFMPEG_DLL AND EXISTS "${3RDPARTY_FFMPEG_DLL}")
+      set (3RDPARTY_FFMPEG_DLL "${3RDPARTY_FFMPEG_DLL}" CACHE FILEPATH "FFmpeg shared library" FORCE)
+      get_filename_component (3RDPARTY_FFMPEG_DLL_DIR "${3RDPARTY_FFMPEG_DLL}" PATH)
+      set (3RDPARTY_FFMPEG_DLL_DIR "${3RDPARTY_FFMPEG_DLL_DIR}" CACHE PATH "The directory containing FFmpeg library" FORCE)
+    else()
+      set (3RDPARTY_FFMPEG_DLL_DIR "" CACHE PATH "The directory containing FFmpeg shared library" FORCE)
+    endif()
+  endif()
+
+  if (3RDPARTY_FFMPEG_DLL_DIR OR EXISTS "${3RDPARTY_FFMPEG_DLL_DIR}")
+    list (APPEND 3RDPARTY_DLL_DIRS "${3RDPARTY_FFMPEG_DLL_DIR}")
+  else()
+    list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_FFMPEG_DLL_DIR)
+  endif()
+endif()
+
+# install instructions
+if (INSTALL_FFMPEG)
+  OCCT_MAKE_OS_WITH_BITNESS()
+  OCCT_MAKE_COMPILER_SHORT_NAME()
+
+  if (WIN32)
+    if (DEFINED INSTALL_BIN_DIR)
+      install (FILES "${3RDPARTY_FFMPEG_DLL}" DESTINATION "${INSTALL_BIN_DIR}")
+    else()
+      install (FILES "${3RDPARTY_FFMPEG_DLL}"
+               CONFIGURATIONS Release
+               DESTINATION "${INSTALL_DIR}/${OS_WITH_BIT}/${COMPILER}/bin")
+      install (FILES "${3RDPARTY_FFMPEG_DLL}"
+               CONFIGURATIONS RelWithDebInfo
+               DESTINATION "${INSTALL_DIR}/${OS_WITH_BIT}/${COMPILER}/bini")
+      install (FILES "${3RDPARTY_FFMPEG_DLL}"
+               CONFIGURATIONS Debug
+               DESTINATION "${INSTALL_DIR}/${OS_WITH_BIT}/${COMPILER}/bind")
+    endif()
+  else()
+    get_filename_component(3RDPARTY_FFMPEG_LIBRARY_ABS ${3RDPARTY_FFMPEG_LIBRARY} REALPATH)
+    get_filename_component(3RDPARTY_FFMPEG_LIBRARY_NAME ${3RDPARTY_FFMPEG_LIBRARY} NAME)
+
+    if (DEFINED INSTALL_LIB_DIR)
+      install (FILES "${3RDPARTY_FFMPEG_LIBRARY_ABS}"
+               DESTINATION "${INSTALL_LIB_DIR}"
+               RENAME ${3RDPARTY_FFMPEG_LIBRARY_NAME}.6)
+    else()
+      install (FILES "${3RDPARTY_FFMPEG_LIBRARY_ABS}"
+               CONFIGURATIONS Release
+               DESTINATION "${INSTALL_DIR}/${OS_WITH_BIT}/${COMPILER}/lib"
+               RENAME ${3RDPARTY_FFMPEG_LIBRARY_NAME}.6)
+      install (FILES "${3RDPARTY_FFMPEG_LIBRARY_ABS}"
+               CONFIGURATIONS RelWithDebInfo
+               DESTINATION "${INSTALL_DIR}/${OS_WITH_BIT}/${COMPILER}/libi"
+               RENAME ${3RDPARTY_FFMPEG_LIBRARY_NAME}.6)
+      install (FILES "${3RDPARTY_FFMPEG_LIBRARY_ABS}"
+               CONFIGURATIONS Debug
+               DESTINATION "${INSTALL_DIR}/${OS_WITH_BIT}/${COMPILER}/libd"
+               RENAME ${3RDPARTY_FFMPEG_LIBRARY_NAME}.6)
+    endif()
+  endif()
+
+  set (USED_3RDPARTY_FFMPEG_DIR "")
+else()
+  # the library directory for using by the executable
+  if (WIN32)
+    set (USED_3RDPARTY_FFMPEG_DIR ${3RDPARTY_FFMPEG_DLL_DIR})
+  else()
+    set (USED_3RDPARTY_FFMPEG_DIR ${3RDPARTY_FFMPEG_LIBRARY_DIR})
+  endif()
+endif()
+
+# unset all redundant variables
+OCCT_CHECK_AND_UNSET (FFMPEG_INCLUDE_DIRS)
+OCCT_CHECK_AND_UNSET (FFMPEG_LIBRARY_DIRS)
+OCCT_CHECK_AND_UNSET (FFMPEG_DIR)
+
+mark_as_advanced (3RDPARTY_FFMPEG_LIBRARY 3RDPARTY_FFMPEG_DLL)

adm/cmake/freeimage.cmake

@@ -1,3 +1,3 @@
 #freeimage
 
-THIRDPARTY_PRODUCT("FREEIMAGE" "FreeImage.h" "freeimage" "freeimaged")
+THIRDPARTY_PRODUCT("FREEIMAGE" "FreeImage.h" "CSF_FreeImagePlus" "d")

adm/cmake/freetype.cmake

@@ -231,13 +231,13 @@ if (BUILD_SHARED_LIBS)
     set (3RDPARTY_FREETYPE_LIBRARY "3RDPARTY_FREETYPE_LIBRARY-NOTFOUND" CACHE FILEPATH "The path to freetype library" FORCE)
 
     if (3RDPARTY_FREETYPE_DIR AND EXISTS "${3RDPARTY_FREETYPE_DIR}")
-      find_library (3RDPARTY_FREETYPE_LIBRARY freetype
+      find_library (3RDPARTY_FREETYPE_LIBRARY ${CSF_FREETYPE}
                                               PATHS "${3RDPARTY_FREETYPE_LIBRARY_DIR}" "${3RDPARTY_FREETYPE_DIR}"
                                               PATH_SUFFIXES ${FREETYPE_PATH_SUFFIXES}
                                               CMAKE_FIND_ROOT_PATH_BOTH
                                               NO_DEFAULT_PATH)
     else()
-      find_library (3RDPARTY_FREETYPE_LIBRARY freetype 
+      find_library (3RDPARTY_FREETYPE_LIBRARY ${CSF_FREETYPE}
                                               PATH_SUFFIXES ${FREETYPE_PATH_SUFFIXES}
                                               CMAKE_FIND_ROOT_PATH_BOTH)
     endif()
@@ -268,12 +268,12 @@ if (BUILD_SHARED_LIBS)
       set (3RDPARTY_FREETYPE_DLL "3RDPARTY_FREETYPE_DLL-NOTFOUND" CACHE FILEPATH "The path to freetype shared library" FORCE)
 
       if (3RDPARTY_FREETYPE_DIR AND EXISTS "${3RDPARTY_FREETYPE_DIR}")
-        find_library (3RDPARTY_FREETYPE_DLL freetype
+        find_library (3RDPARTY_FREETYPE_DLL ${CSF_FREETYPE}
                                             PATHS "${3RDPARTY_FREETYPE_DIR}"
                                             PATH_SUFFIXES bin
                                             NO_DEFAULT_PATH)
       else()
-        find_library (3RDPARTY_FREETYPE_DLL freetype
+        find_library (3RDPARTY_FREETYPE_DLL ${CSF_FREETYPE}
                                             PATH_SUFFIXES bin)
       endif()
 
@@ -300,17 +300,17 @@ if (BUILD_SHARED_LIBS)
 
     if (WIN32)
       if (SINGLE_GENERATOR)
-        install (FILES "${3RDPARTY_FREETYPE_DLL}" DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}")
+        install (FILES "${3RDPARTY_FREETYPE_DLL}" DESTINATION "${INSTALL_DIR_BIN}")
       else()
         install (FILES "${3RDPARTY_FREETYPE_DLL}"
                  CONFIGURATIONS Release
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}")
+                 DESTINATION "${INSTALL_DIR_BIN}")
         install (FILES "${3RDPARTY_FREETYPE_DLL}"
                  CONFIGURATIONS RelWithDebInfo
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}i")
+                 DESTINATION "${INSTALL_DIR_BIN}i")
         install (FILES "${3RDPARTY_FREETYPE_DLL}"
                  CONFIGURATIONS Debug
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}d")
+                 DESTINATION "${INSTALL_DIR_BIN}d")
       endif()
     else()
       get_filename_component(3RDPARTY_FREETYPE_LIBRARY_ABS ${3RDPARTY_FREETYPE_LIBRARY} REALPATH)
@@ -318,20 +318,20 @@ if (BUILD_SHARED_LIBS)
 
       if (SINGLE_GENERATOR)
         install (FILES "${3RDPARTY_FREETYPE_LIBRARY_ABS}"
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}"
+                 DESTINATION "${INSTALL_DIR_LIB}"
                  RENAME ${3RDPARTY_FREETYPE_LIBRARY_NAME}.6)
       else()
         install (FILES "${3RDPARTY_FREETYPE_LIBRARY_ABS}"
                  CONFIGURATIONS Release
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}"
+                 DESTINATION "${INSTALL_DIR_LIB}"
                  RENAME ${3RDPARTY_FREETYPE_LIBRARY_NAME}.6)
         install (FILES "${3RDPARTY_FREETYPE_LIBRARY_ABS}"
                  CONFIGURATIONS RelWithDebInfo
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}i"
+                 DESTINATION "${INSTALL_DIR_LIB}i"
                  RENAME ${3RDPARTY_FREETYPE_LIBRARY_NAME}.6)
         install (FILES "${3RDPARTY_FREETYPE_LIBRARY_ABS}"
                  CONFIGURATIONS Debug
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}d"
+                 DESTINATION "${INSTALL_DIR_LIB}d"
                  RENAME ${3RDPARTY_FREETYPE_LIBRARY_NAME}.6)
       endif()
     endif()

adm/cmake/gl2ps.cmake

@@ -1,3 +1,3 @@
 #GL2PS
 
-THIRDPARTY_PRODUCT("GL2PS" "gl2ps.h" "gl2ps" "gl2psd")
+THIRDPARTY_PRODUCT("GL2PS" "gl2ps.h" "CSF_GL2PS" "d")

adm/cmake/gles2.cmake

@@ -1,6 +1,3 @@
 # OpenGL ES 2.0
-if (WIN32)
-  THIRDPARTY_PRODUCT("GLES2" "GLES2/gl2.h" "libGLESv2" "libGLESv2")
-else()
-  THIRDPARTY_PRODUCT("GLES2" "GLES2/gl2.h" "GLESv2" "GLESv2")
-endif()
+
+THIRDPARTY_PRODUCT("GLES2" "GLES2/gl2.h" "CSF_OpenGlLibs" "")

adm/cmake/glx.cmake

@@ -1,3 +1,4 @@
 # glx
 
-THIRDPARTY_PRODUCT("GLX" "GL/glx.h" "GL" "GLd")
+separate_arguments (CSF_OpenGlLibs)
+THIRDPARTY_PRODUCT("GLX" "GL/glx.h" "CSF_OpenGlLibs" "d")

adm/cmake/occt_csf.cmake

@@ -10,61 +10,72 @@ if (NOT DEFINED USE_TCL)
   OCCT_IS_PRODUCT_REQUIRED (CSF_TclLibs USE_TCL)
 endif()
 
-if (USE_TCL AND BUILD_SHARED_LIBS)
-  if ("${3RDPARTY_TCL_LIBRARY_VERSION}" STREQUAL "")
-    message (STATUS "Warning: TCL version has not been specified by CSF_TclLibs defining thus it will be used as 8.6")
-    set (3RDPARTY_TCL_LIBRARY_VERSION "8.6")
-  endif()
-
-  if ("${3RDPARTY_TK_LIBRARY_VERSION}" STREQUAL "")
-    message (STATUS "Warning: TK version has not been specified by CSF_TclTkLibs defining thus it will be used as 8.6")
-    set (3RDPARTY_TK_LIBRARY_VERSION "8.6")
-  endif()
-endif()
-
+# TBB
 if (USE_TBB)
   set (CSF_TBB "tbb tbbmalloc")
 else()
   set (CSF_TBB)
 endif()
 
+# FREETYPE
+if (USE_FREETYPE)
+  set (CSF_FREETYPE "freetype")
+else()
+  set (CSF_FREETYPE)
+endif()
+
+# FFmpeg
+if (USE_FFMPEG)
+  set (CSF_FFmpeg "avcodec avformat swscale avutil")
+else()
+  set (CSF_FFmpeg)
+endif()
+
+# FREEIMAGE
+if (USE_FREEIMAGE)
+  set (CSF_FreeImagePlus "freeimage")
+else()
+  set (CSF_FreeImagePlus)
+endif()
+
+# TCL/TK
+if (USE_TCL)
+  if (WIN32)
+    set (CSF_TclLibs     "tcl86")
+    set (CSF_TclTkLibs   "tk86")
+  else()
+    if(APPLE)
+      set (CSF_TclTkLibs Tk)
+      set (CSF_TclLibs   Tcl)
+    elseif(UNIX)
+      set (CSF_TclLibs     "tcl8.6")
+      set (CSF_TclTkLibs   "tk8.6")
+    endif()
+  endif()
+endif()
+
+# GL2PS
+if (NOT DEFINED ANDROID)
+  if (USE_GL2PS)
+    set (CSF_GL2PS "gl2ps")
+  else()
+    set (CSF_GL2PS)
+  endif()
+endif()
+
 if (WIN32)
   set (CSF_advapi32      "advapi32.lib")
   set (CSF_gdi32         "gdi32.lib")
   set (CSF_user32        "user32.lib")
   set (CSF_wsock32       "wsock32.lib")
   set (CSF_psapi         "Psapi.lib")
-  set (CSF_AviLibs       "ws2_32.lib vfw32.lib")
   if ("${CMAKE_SYSTEM_NAME}" STREQUAL "WindowsStore" OR USE_GLES2)
-    set (CSF_OpenGlLibs  "libEGL.lib libGLESv2.lib")
+    set (CSF_OpenGlLibs  "libEGL libGLESv2")
   else()
     set (CSF_OpenGlLibs  "opengl32.lib")
   endif()
 
-  if (USE_FREETYPE)
-    set (CSF_FREETYPE "freetype.lib")
   else()
-    set (CSF_FREETYPE)
-  endif()
-
-  if (USE_GL2PS)
-    set (CSF_GL2PS "gl2ps.lib")
-  else()
-    set (CSF_GL2PS)
-  endif()
-
-  if (USE_FREEIMAGE)
-    set (CSF_FreeImagePlus "freeimage.lib")
-  else()
-    set (CSF_FreeImagePlus)
-  endif()
-
-  if (USE_TCL)
-    set (CSF_TclLibs     "tcl${3RDPARTY_TCL_LIBRARY_VERSION}.lib")
-    set (CSF_TclTkLibs   "tk${3RDPARTY_TK_LIBRARY_VERSION}.lib")
-  endif()
-
-else()
 
   if (APPLE)
     set (CSF_objc        "objc")
@@ -89,10 +100,6 @@ else()
       OCCT_CHECK_AND_UNSET (OpenGlLibs_LIB)
     endif()
     
-    if (USE_TCL)
-      set (CSF_TclTkLibs Tk)
-      set (CSF_TclLibs   Tcl)
-    endif()
   elseif (ANDROID)
     set (CSF_ThreadLibs  "c")
     set (CSF_OpenGlLibs  "EGL GLESv2")
@@ -101,30 +108,5 @@ else()
     set (CSF_OpenGlLibs  "GL")
     set (CSF_XwLibs      "X11 Xext Xmu Xi")
     set (CSF_dl          "dl")
-
-    if (USE_TCL)
-      set (CSF_TclLibs     "tcl${3RDPARTY_TCL_LIBRARY_VERSION}")
-      set (CSF_TclTkLibs   "tk${3RDPARTY_TK_LIBRARY_VERSION}")
-    endif()
   endif()
-
-  if (USE_FREETYPE)
-    set (CSF_FREETYPE "freetype")
-  else()
-    set (CSF_FREETYPE)
-  endif()
-
-  if (USE_FREEIMAGE)
-    set (CSF_FreeImagePlus "freeimage")
-  else()
-    set (CSF_FreeImagePlus)
-  endif()
-
-  if (NOT DEFINED ANDROID)
-    if (USE_GL2PS)
-      set (CSF_GL2PS "gl2ps")
-    else()
-      set (CSF_GL2PS)
-    endif()
-  endif()
-endif()
+endif()

adm/cmake/occt_defs_flags.cmake

@@ -122,7 +122,14 @@ if(MINGW)
   add_definitions(-D_WIN32_WINNT=0x0501)
   # workaround bugs in mingw with vtable export
   set (CMAKE_SHARED_LINKER_FLAGS "-Wl,--export-all-symbols")
-elseif (DEFINED CMAKE_COMPILER_IS_GNUCXX OR "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xClang")
+elseif ("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xClang")
+  if (APPLE)
+    # CLang can be used with both libstdc++ and libc++, however on OS X libstdc++ is outdated.
+    set (CMAKE_CXX_FLAGS "-std=c++0x -stdlib=libc++ ${CMAKE_CXX_FLAGS}")
+  else()
+    set (CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS}")
+  endif()
+elseif (DEFINED CMAKE_COMPILER_IS_GNUCXX)
   set (CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS}")
 endif()
 

adm/cmake/occt_macros.cmake

@@ -74,6 +74,11 @@ macro (OCCT_MAKE_COMPILER_SHORT_NAME)
       set (COMPILER vc12)
     elseif (MSVC14)
       set (COMPILER vc14)
+    elseif (MSVC15)
+      # Since Visual Studio 15 (2017), its version diverged from version of
+      # compiler which is 14.1; as that compiler uses the same run-time as 14.0,
+      # we keep its id as "vc14" to be compatibille
+      set (COMPILER vc14)
     endif()
   elseif (DEFINED CMAKE_COMPILER_IS_GNUCC)
     set (COMPILER gcc)
@@ -101,6 +106,34 @@ function (SUBDIRECTORY_NAMES MAIN_DIRECTORY RESULT)
   set (${RESULT} ${LOCAL_RESULT} PARENT_SCOPE)
 endfunction()
 
+function (FIND_SUBDIRECTORY ROOT_DIRECTORY DIRECTORY_SUFFIX SUBDIRECTORY_NAME)
+  #message("Trying to find directory with suffix ${DIRECTORY_SUFFIX} in ${ROOT_DIRECTORY}")
+  SUBDIRECTORY_NAMES ("${ROOT_DIRECTORY}" SUBDIR_NAME_LIST)
+  #message("Subdirectories: ${SUBDIR_NAME_LIST}")
+
+  #set(${SUBDIRECTORY_NAME} "${SUBDIR_NAME_LIST}" PARENT_SCOPE)
+
+  foreach (SUBDIR_NAME ${SUBDIR_NAME_LIST})
+    #message("Subdir: ${SUBDIR_NAME}, ${DIRECTORY_SUFFIX}")
+    # REGEX failed if the directory name contains '++' combination, so we replace it
+    string(REPLACE "++" "\\+\\+" SUBDIR_NAME_ESCAPED ${SUBDIR_NAME})
+    string (REGEX MATCH "${SUBDIR_NAME_ESCAPED}" DOES_PATH_CONTAIN "${DIRECTORY_SUFFIX}")
+    if (DOES_PATH_CONTAIN)
+      set(${SUBDIRECTORY_NAME} "${ROOT_DIRECTORY}/${SUBDIR_NAME}" PARENT_SCOPE)
+      #message("Subdirectory is found: ${SUBDIRECTORY_NAME}")
+      BREAK()
+    else()
+      #message("Check directory: ${ROOT_DIRECTORY}/${SUBDIR_NAME}")
+      FIND_SUBDIRECTORY ("${ROOT_DIRECTORY}/${SUBDIR_NAME}" "${DIRECTORY_SUFFIX}" SUBDIR_REC_NAME)
+      if (NOT "${SUBDIR_REC_NAME}" STREQUAL "")
+        set(${SUBDIRECTORY_NAME} "${SUBDIR_REC_NAME}" PARENT_SCOPE)
+        #message("Subdirectory is found: ${SUBDIRECTORY_NAME}")
+        BREAK()
+      endif()
+    endif()
+  endforeach()
+endfunction()
+
 function (OCCT_ORIGIN_AND_PATCHED_FILES RELATIVE_PATH SEARCH_TEMPLATE RESULT)
 
   if (BUILD_PATCH AND EXISTS "${BUILD_PATCH}/${RELATIVE_PATH}")
@@ -189,7 +222,7 @@ macro (OCCT_CONFIGURE_AND_INSTALL BEING_CONGIRUGED_FILE BUILD_NAME INSTALL_NAME
   install(FILES "${OCCT_BINARY_DIR}/${BUILD_NAME}" DESTINATION  "${DESTINATION_PATH}" RENAME ${INSTALL_NAME})
 endmacro()
 
-macro (COLLECT_AND_INSTALL_OCCT_HEADER_FILES ROOT_TARGET_OCCT_DIR OCCT_BUILD_TOOLKITS)
+macro (COLLECT_AND_INSTALL_OCCT_HEADER_FILES ROOT_TARGET_OCCT_DIR OCCT_BUILD_TOOLKITS OCCT_COLLECT_SOURCE_DIR OCCT_INSTALL_DIR_PREFIX)
   set (OCCT_USED_PACKAGES)
 
   # consider patched header.in template
@@ -205,8 +238,8 @@ macro (COLLECT_AND_INSTALL_OCCT_HEADER_FILES ROOT_TARGET_OCCT_DIR OCCT_BUILD_TOO
     set (OCCT_TOOLKIT_PACKAGES)
     if (BUILD_PATCH AND EXISTS "${BUILD_PATCH}/src/${OCCT_USED_TOOLKIT}/PACKAGES")
       file (STRINGS "${BUILD_PATCH}/src/${OCCT_USED_TOOLKIT}/PACKAGES" OCCT_TOOLKIT_PACKAGES)
-    elseif (EXISTS "${CMAKE_SOURCE_DIR}/src/${OCCT_USED_TOOLKIT}/PACKAGES")
-      file (STRINGS "${CMAKE_SOURCE_DIR}/src/${OCCT_USED_TOOLKIT}/PACKAGES" OCCT_TOOLKIT_PACKAGES)
+    elseif (EXISTS "${OCCT_COLLECT_SOURCE_DIR}/${OCCT_USED_TOOLKIT}/PACKAGES")
+      file (STRINGS "${OCCT_COLLECT_SOURCE_DIR}/${OCCT_USED_TOOLKIT}/PACKAGES" OCCT_TOOLKIT_PACKAGES)
     endif()
 
     list (APPEND OCCT_USED_PACKAGES ${OCCT_TOOLKIT_PACKAGES})
@@ -224,10 +257,10 @@ macro (COLLECT_AND_INSTALL_OCCT_HEADER_FILES ROOT_TARGET_OCCT_DIR OCCT_BUILD_TOO
   foreach (OCCT_PACKAGE ${OCCT_USED_PACKAGES})
     if (BUILD_PATCH AND EXISTS "${BUILD_PATCH}/src/${OCCT_PACKAGE}/FILES")
       file (STRINGS "${BUILD_PATCH}/src/${OCCT_PACKAGE}/FILES" OCCT_ALL_FILE_NAMES)
-    elseif (EXISTS "${CMAKE_SOURCE_DIR}/src/${OCCT_PACKAGE}/FILES")
-      file (STRINGS "${CMAKE_SOURCE_DIR}/src/${OCCT_PACKAGE}/FILES" OCCT_ALL_FILE_NAMES)
+    elseif (EXISTS "${OCCT_COLLECT_SOURCE_DIR}/${OCCT_PACKAGE}/FILES")
+      file (STRINGS "${OCCT_COLLECT_SOURCE_DIR}/${OCCT_PACKAGE}/FILES" OCCT_ALL_FILE_NAMES)
     else()
-      message (WARNING "FILES has not been found in ${CMAKE_SOURCE_DIR}/src/${OCCT_PACKAGE}")
+      message (WARNING "FILES has not been found in ${OCCT_COLLECT_SOURCE_DIR}/${OCCT_PACKAGE}")
       continue()
     endif()
 
@@ -235,13 +268,13 @@ macro (COLLECT_AND_INSTALL_OCCT_HEADER_FILES ROOT_TARGET_OCCT_DIR OCCT_BUILD_TOO
     math (EXPR ALL_FILES_NB "${ALL_FILES_NB} - 1" )
 
     # emit warnings if there is unprocessed headers
-    file (GLOB OCCT_ALL_FILES_IN_DIR "${CMAKE_SOURCE_DIR}/src/${OCCT_PACKAGE}/*.*")
+    file (GLOB OCCT_ALL_FILES_IN_DIR "${OCCT_COLLECT_SOURCE_DIR}/${OCCT_PACKAGE}/*.*")
     file (GLOB OCCT_ALL_FILES_IN_PATCH_DIR "${BUILD_PATCH}/src/${OCCT_PACKAGE}/*.*")
 
     # use patched header files
     foreach (OCCT_FILE_IN_PATCH_DIR ${OCCT_ALL_FILES_IN_PATCH_DIR})
       get_filename_component (OCCT_FILE_IN_PATCH_DIR_NAME ${OCCT_FILE_IN_PATCH_DIR} NAME)
-      list (REMOVE_ITEM OCCT_ALL_FILES_IN_DIR "${CMAKE_SOURCE_DIR}/src/${OCCT_PACKAGE}/${OCCT_FILE_IN_PATCH_DIR_NAME}")
+      list (REMOVE_ITEM OCCT_ALL_FILES_IN_DIR "${OCCT_COLLECT_SOURCE_DIR}/${OCCT_PACKAGE}/${OCCT_FILE_IN_PATCH_DIR_NAME}")
       list (APPEND OCCT_ALL_FILES_IN_DIR "${OCCT_FILE_IN_PATCH_DIR}")
     endforeach()
 
@@ -257,6 +290,8 @@ macro (COLLECT_AND_INSTALL_OCCT_HEADER_FILES ROOT_TARGET_OCCT_DIR OCCT_BUILD_TOO
       foreach (FILE_INDEX RANGE ${ALL_FILES_NB})
         list (GET OCCT_ALL_FILE_NAMES ${FILE_INDEX} OCCT_FILE_NAME)
 
+        string (REGEX REPLACE "[^:]+:+" "" OCCT_FILE_NAME "${OCCT_FILE_NAME}")
+
         if ("${OCCT_FILE_IN_DIR_NAME}" STREQUAL "${OCCT_FILE_NAME}")
           set (OCCT_FILE_IN_DIR_STATUS ON)
 
@@ -280,7 +315,7 @@ macro (COLLECT_AND_INSTALL_OCCT_HEADER_FILES ROOT_TARGET_OCCT_DIR OCCT_BUILD_TOO
       endforeach()
 
       if (NOT OCCT_FILE_IN_DIR_STATUS)
-        message (STATUS "Warning. File ${OCCT_FILE_IN_DIR} is not listed in ${CMAKE_SOURCE_DIR}/src/${OCCT_PACKAGE}/FILES")
+        message (STATUS "Warning. File ${OCCT_FILE_IN_DIR} is not listed in ${OCCT_COLLECT_SOURCE_DIR}/${OCCT_PACKAGE}/FILES")
 
         string (REGEX MATCH ".+\\.[hlg]xx|.+\\.h$" IS_HEADER_FOUND "${OCCT_FILE_NAME}")
         if (IS_HEADER_FOUND)
@@ -296,10 +331,11 @@ macro (COLLECT_AND_INSTALL_OCCT_HEADER_FILES ROOT_TARGET_OCCT_DIR OCCT_BUILD_TOO
 
   foreach (OCCT_HEADER_FILE ${OCCT_HEADER_FILES_COMPLETE})
     get_filename_component (HEADER_FILE_NAME ${OCCT_HEADER_FILE} NAME)
-    configure_file ("${TEMPLATE_HEADER_PATH}" "${ROOT_TARGET_OCCT_DIR}/inc/${HEADER_FILE_NAME}" @ONLY)
+    set (OCCT_HEADER_FILE_CONTENT "#include \"${OCCT_HEADER_FILE}\"")
+    configure_file ("${TEMPLATE_HEADER_PATH}" "${ROOT_TARGET_OCCT_DIR}/${OCCT_INSTALL_DIR_PREFIX}/${HEADER_FILE_NAME}" @ONLY)
   endforeach()
   
-  install (FILES ${OCCT_HEADER_FILES_COMPLETE} DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_INCLUDE}")
+  install (FILES ${OCCT_HEADER_FILES_COMPLETE} DESTINATION "${INSTALL_DIR}/${OCCT_INSTALL_DIR_PREFIX}")
   
   string(TIMESTAMP CURRENT_TIME "%H:%M:%S")
   message (STATUS "Info: \(${CURRENT_TIME}\) Checking headers in inc folder...")
@@ -311,7 +347,7 @@ macro (COLLECT_AND_INSTALL_OCCT_HEADER_FILES ROOT_TARGET_OCCT_DIR OCCT_BUILD_TOO
     
     list (FIND OCCT_USED_PACKAGES ${PACKAGE_NAME} IS_HEADER_FOUND)
     if (NOT ${IS_HEADER_FOUND} EQUAL -1)
-      if (NOT EXISTS "${CMAKE_SOURCE_DIR}/src/${PACKAGE_NAME}/${HEADER_FILE_NAME}")
+      if (NOT EXISTS "${OCCT_COLLECT_SOURCE_DIR}/${PACKAGE_NAME}/${HEADER_FILE_NAME}")
         message (STATUS "Warning. ${OCCT_HEADER_FILE_OLD} is not presented in the sources and will be removed from ${ROOT_TARGET_OCCT_DIR}/inc")
         file (REMOVE "${OCCT_HEADER_FILE_OLD}")
       else()
@@ -421,7 +457,7 @@ function (OCCT_TOOLKIT_DEP TOOLKIT_NAME TOOLKIT_DEPS)
   set (LOCAL_TOOLKIT_DEPS)
   foreach (FILE_CONTENT_LINE ${FILE_CONTENT})
     string (REGEX MATCH "^TK" TK_FOUND ${FILE_CONTENT_LINE})
-    if ("${FILE_CONTENT_LINE}" STREQUAL "DRAWEXE" OR NOT "${TK_FOUND}" STREQUAL "")
+    if ("x${FILE_CONTENT_LINE}" STREQUAL "xDRAWEXE" OR NOT "${TK_FOUND}" STREQUAL "")
       list (APPEND LOCAL_TOOLKIT_DEPS ${FILE_CONTENT_LINE})
     endif()
   endforeach()
@@ -482,6 +518,24 @@ function (OCCT_MODULES_AND_TOOLKITS MODULE_LIST)
   set (${MODULE_LIST} ${${MODULE_LIST}} PARENT_SCOPE)
 endfunction()
 
+# Function to get list of tools and toolkits from file adm/TOOLS.
+# Creates list <$TOOL_LIST> to store list of TOOLS and
+# <NAME_OF_TOOL>_TOOLKITS foreach tool to store its toolkits.
+function (OCCT_TOOLS_AND_TOOLKITS TOOL_LIST)
+  FILE_TO_LIST ("adm/TOOLS" FILE_CONTENT)
+
+  foreach (CONTENT_LINE ${FILE_CONTENT})
+    string (REPLACE " " ";" CONTENT_LINE ${CONTENT_LINE})
+    list (GET CONTENT_LINE 0 TOOL_NAME)
+    list (REMOVE_AT CONTENT_LINE 0)
+    list (APPEND ${TOOL_LIST} ${TOOL_NAME})
+    # (!) REMOVE THE LINE BELOW (implicit variables)
+    set (${TOOL_NAME}_TOOL_TOOLKITS ${CONTENT_LINE} PARENT_SCOPE)
+  endforeach()
+
+  set (${TOOL_LIST} ${${TOOL_LIST}} PARENT_SCOPE)
+endfunction()
+
 # Returns OCC version string from file Standard_Version.hxx (if available)
 function (OCC_VERSION OCC_VERSION_MAJOR OCC_VERSION_MINOR OCC_VERSION_MAINTENANCE OCC_VERSION_DEVELOPMENT OCC_VERSION_STRING_EXT)
 

adm/cmake/occt_resources.cmake

@@ -0,0 +1,77 @@
+# OCCT resource files generation
+
+macro (OCCT_GENERATE_CONTENT_ONLY CurrentResource)
+  set (RESOURCE_FILES)
+  set (isResDirectory FALSE)
+  if (IS_DIRECTORY "${CMAKE_SOURCE_DIR}/src/${CurrentResource}")
+    file (STRINGS "${CMAKE_SOURCE_DIR}/src/${CurrentResource}/FILES" RESOURCE_FILES)
+    set (CurrentResource_Directory "${CurrentResource}")
+    set (isResDirectory TRUE)
+  else()
+    get_filename_component (CurrentResource_Name "${CurrentResource}" NAME)
+    list (APPEND RESOURCE_FILES "res:::${CurrentResource_Name}")
+    get_filename_component (CurrentResource_Directory "${CurrentResource}" DIRECTORY)
+  endif()
+
+  # Add current toolkit into RESOURCE_TOOLKITS array to copy it to the BUILD directory
+  list (APPEND RESOURCE_TOOLKITS "${CurrentResource_Directory}")
+  list (REMOVE_DUPLICATES RESOURCE_TOOLKITS)
+
+  if (BUILD_RESOURCES)
+    foreach (RESOURCE_FILE ${RESOURCE_FILES})
+      string (REGEX MATCH "^[^:]+:::" IS_RESOURCE "${RESOURCE_FILE}")
+      if (IS_RESOURCE)
+        string (REGEX REPLACE "[^:]+:+" "" RESOURCE_FILE "${RESOURCE_FILE}")
+
+        get_filename_component (CurrentResource_FileName "${RESOURCE_FILE}" NAME)
+        string (REPLACE "." "_" CurrentResource_FileName "${CurrentResource_FileName}")
+        set (HEADER_FILE_NAME "${CurrentResource_Directory}_${CurrentResource_FileName}.pxx")
+
+        set (toProcessResFile TRUE)
+        if (isResDirectory)
+          list (FIND RESOURCE_FILES "${HEADER_FILE_NAME}" aResIndex)
+          if ("${aResIndex}" STREQUAL "-1")
+            set (toProcessResFile FALSE)
+          endif()
+        endif()
+
+        if (toProcessResFile)
+          message(STATUS "Info. Generating header file from resource file: ${CMAKE_SOURCE_DIR}/src/${CurrentResource_Directory}/${RESOURCE_FILE}")
+
+          # generate content for header file
+          set (OCCT_HEADER_FILE_CONTENT "// This file has been automatically generated from resource file src/${CurrentResource_Directory}/${RESOURCE_FILE}\n\n")
+
+          # read resource file
+          file (STRINGS "${CMAKE_SOURCE_DIR}/src/${CurrentResource_Directory}/${RESOURCE_FILE}" RESOURCE_FILE_LINES_LIST)
+
+          set (OCCT_HEADER_FILE_CONTENT "${OCCT_HEADER_FILE_CONTENT}static const char ${CurrentResource_Directory}_${CurrentResource_FileName}[] =")
+          foreach (line IN LISTS RESOURCE_FILE_LINES_LIST)
+            string (REPLACE "\"" "\\\"" line "${line}")
+            set (OCCT_HEADER_FILE_CONTENT "${OCCT_HEADER_FILE_CONTENT}\n  \"${line}\\n\"")
+          endforeach()
+          set (OCCT_HEADER_FILE_CONTENT "${OCCT_HEADER_FILE_CONTENT};")
+
+          # Save generated content to header file
+          set (HEADER_FILE "${CMAKE_SOURCE_DIR}/src/${CurrentResource_Directory}/${HEADER_FILE_NAME}")
+          if (EXISTS "${HEADER_FILE}")
+            file (REMOVE "${HEADER_FILE}")
+          endif()
+          configure_file ("${CMAKE_SOURCE_DIR}/adm/templates/header.in" "${HEADER_FILE}" @ONLY NEWLINE_STYLE LF)
+        endif()
+      endif()
+    endforeach()
+  endif()
+endmacro()
+
+
+FILE_TO_LIST ("adm/RESOURCES" RESOURCES)
+foreach (CurrentResource ${RESOURCES})
+  get_filename_component (CurrentResource_FileName "${CurrentResource}" NAME)
+  if ("${CurrentResource_FileName}" STREQUAL TObj.msg OR
+      "${CurrentResource_FileName}" STREQUAL Units.dat OR
+      "${CurrentResource}" STREQUAL XSMessage OR
+      "${CurrentResource}" STREQUAL SHMessage OR
+      "${CurrentResource}" STREQUAL Shaders)
+    OCCT_GENERATE_CONTENT_ONLY ("${CurrentResource}")
+  endif()
+endforeach()

adm/cmake/occt_toolkit.cmake

@@ -147,14 +147,14 @@ if ("${PROJECT_NAME}" STREQUAL "DRAWEXE")
   add_executable (${PROJECT_NAME} ${USED_SRCFILES} ${USED_INCFILES} ${USED_RCFILE})
 
   install (TARGETS ${PROJECT_NAME}
-           DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}\${OCCT_INSTALL_BIN_LETTER}")
+           DESTINATION "${INSTALL_DIR_BIN}\${OCCT_INSTALL_BIN_LETTER}")
 else()
   add_library (${PROJECT_NAME} ${USED_SRCFILES} ${USED_INCFILES} ${USED_RCFILE})
 
   if (MSVC)
     install (FILES  ${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bind/${PROJECT_NAME}.pdb
              CONFIGURATIONS Debug
-             DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}\${OCCT_INSTALL_BIN_LETTER}")
+             DESTINATION "${INSTALL_DIR_BIN}\${OCCT_INSTALL_BIN_LETTER}")
   endif()
 
   if (BUILD_SHARED_LIBS AND NOT "${BUILD_SHARED_LIBRARY_NAME_POSTFIX}" STREQUAL "")
@@ -219,10 +219,39 @@ foreach (USED_ITEM ${USED_EXTERNLIB_AND_TOOLKITS})
         message (STATUS "Info: ${USED_ITEM} from ${PROJECT_NAME} skipped due to it is empty")
       else() # get CSF_ value
         set (CURRENT_CSF ${${USED_ITEM}})
-        if (NOT "${CURRENT_CSF}" STREQUAL "")
-          # prepare a list from a string with whitespaces
+        if (NOT "x${CURRENT_CSF}" STREQUAL "x")
+          set (LIBRARY_FROM_CACHE 0)
           separate_arguments (CURRENT_CSF)
-          list (APPEND USED_EXTERNAL_LIBS_BY_CURRENT_PROJECT ${CURRENT_CSF})
+          foreach (CSF_LIBRARY ${CURRENT_CSF})
+            string (TOLOWER "${CSF_LIBRARY}" CSF_LIBRARY)
+            string (REPLACE "+" "[+]" CSF_LIBRARY "${CSF_LIBRARY}")
+            string (REPLACE "." "" CSF_LIBRARY "${CSF_LIBRARY}")
+            get_cmake_property(ALL_CACHE_VARIABLES CACHE_VARIABLES)
+            string (REGEX MATCHALL "(^|;)3RDPARTY_[^;]+_LIBRARY[^;]*" ALL_CACHE_VARIABLES "${ALL_CACHE_VARIABLES}")
+            foreach (CACHE_VARIABLE ${ALL_CACHE_VARIABLES})
+              set (CURRENT_CACHE_LIBRARY ${${CACHE_VARIABLE}})
+              string (TOLOWER "${CACHE_VARIABLE}" CACHE_VARIABLE)
+
+              if (EXISTS "${CURRENT_CACHE_LIBRARY}" AND NOT IS_DIRECTORY "${CURRENT_CACHE_LIBRARY}")
+                string (REGEX MATCH "_${CSF_LIBRARY}$" IS_ENDING "${CACHE_VARIABLE}")
+                string (REGEX MATCH "^([a-z]+)" CSF_WO_VERSION "${CSF_LIBRARY}")
+                string (REGEX MATCH "_${CSF_WO_VERSION}$" IS_ENDING_WO_VERSION "${CACHE_VARIABLE}")
+                if ("3rdparty_${CSF_LIBRARY}_library" STREQUAL "${CACHE_VARIABLE}" OR
+                    "3rdparty_${CSF_WO_VERSION}_library" STREQUAL "${CACHE_VARIABLE}" OR
+                    NOT "x${IS_ENDING}" STREQUAL "x" OR
+                    NOT "x${IS_ENDING_WO_VERSION}" STREQUAL "x")
+                  list (APPEND USED_EXTERNAL_LIBS_BY_CURRENT_PROJECT "${CURRENT_CACHE_LIBRARY}")
+                  set (LIBRARY_FROM_CACHE 1)
+                endif()
+              endif()
+            endforeach()
+          endforeach()
+
+          if (NOT ${LIBRARY_FROM_CACHE})
+            # prepare a list from a string with whitespaces
+            separate_arguments (CURRENT_CSF)
+            list (APPEND USED_EXTERNAL_LIBS_BY_CURRENT_PROJECT ${CURRENT_CSF})
+          endif()
         endif()
       endif()
     endif()
@@ -257,3 +286,43 @@ endif()
 if (BUILD_SHARED_LIBS)
   target_link_libraries (${PROJECT_NAME} ${USED_TOOLKITS_BY_CURRENT_PROJECT} ${USED_EXTERNAL_LIBS_BY_CURRENT_PROJECT})
 endif()
+
+# suppress deprecation warnings inside OCCT itself for old gcc versions with unavailable Standard_DISABLE_DEPRECATION_WARNINGS
+if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
+  if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6.0)
+    add_definitions("-DOCCT_NO_DEPRECATED")
+    message (STATUS "Warning: internal deprecation warnings by Standard_DEPRECATED have been disabled due to old gcc version being used")
+  endif()
+endif()
+
+# use Cotire to accelerate build via usage of precompiled headers
+if (BUILD_USE_PCH)
+  if (WIN32)
+    # prevent definition of min and max macros through inclusion of Windows.h
+    # (for cotire builds)
+    add_definitions("-DNOMINMAX")
+    # avoid warnings on deprecated names from standard C library (see strsafe.h)
+    add_definitions("-DSTRSAFE_NO_DEPRECATE")
+    # avoid "std::Equal1" warning in QANCollection_Stl.cxx in debug mode
+    # suggesting using msvc "Checked Iterators"
+    add_definitions("-D_SCL_SECURE_NO_WARNINGS")
+  endif()
+
+  # Exclude system-provided glext.h.
+  # These macros are already defined within OpenGl_GlFunctions.hxx,
+  # however we have to duplicate them here for building TKOpenGl with PCH.
+  add_definitions("-DGL_GLEXT_LEGACY")
+  add_definitions("-DGLX_GLXEXT_LEGACY")
+
+  # workaround for old gcc
+  if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
+    add_definitions("-D__STDC_CONSTANT_MACROS")
+    add_definitions("-D__STDC_FORMAT_MACROS")
+  endif()
+
+  # unity builds are not used since they do not add speed but cause conflicts
+  # in TKV3d
+  set_target_properties(${PROJECT_NAME} PROPERTIES COTIRE_ADD_UNITY_BUILD FALSE)
+
+  cotire(${PROJECT_NAME})
+endif()

adm/cmake/occt_toolkit_tool.cmake

@@ -0,0 +1,298 @@
+# script for each OCCT tool toolkit
+
+# Qt dependencies
+OCCT_INCLUDE_CMAKE_FILE (adm/cmake/qt5_macro)
+
+FIND_QT5_PACKAGE(PROJECT_LIBRARIES_DEBUG PROJECT_LIBRARIES_RELEASE PROJECT_INCLUDES)
+include_directories("${PROJECT_INCLUDES}"
+                    "${CMAKE_BINARY_DIR}/${INSTALL_DIR_INCLUDE}/tools")
+
+FILE_TO_LIST ("tools/${PROJECT_NAME}/PACKAGES" USED_PACKAGES)
+# parce PACKAGES file
+
+if ("${PROJECT_NAME}" STREQUAL TInspectorEXE)
+  set (USED_PACKAGES ${PROJECT_NAME})
+  set (PACKAGE_PREFIX_DIR "samples/tools")
+  include_directories("${PROJECT_INCLUDES}"
+                      "${CMAKE_SOURCE_DIR}/${PACKAGE_PREFIX_DIR}/${PROJECT_NAME}")
+else()
+  FILE_TO_LIST ("tools/${PROJECT_NAME}/PACKAGES" USED_PACKAGES)
+  set (PACKAGE_PREFIX_DIR "tools")
+endif()
+
+
+SET (RCC_FILES)
+foreach (OCCT_PACKAGE ${USED_PACKAGES})
+  file (STRINGS "${CMAKE_SOURCE_DIR}/${PACKAGE_PREFIX_DIR}/${OCCT_PACKAGE}/FILES" SOURCE_FILES_C REGEX ".+[.]c")
+
+  #message("Sources are ${SOURCE_FILES_C}")
+  FIND_AND_WRAP_MOC_FILES("${SOURCE_FILES_C}")
+
+  #message("Dir is ${CMAKE_SOURCE_DIR}/${PACKAGE_PREFIX_DIR}/${OCCT_PACKAGE}/${OCCT_PACKAGE}.qrc")
+  FIND_AND_WRAP_RESOURCE_FILE("${CMAKE_SOURCE_DIR}/${PACKAGE_PREFIX_DIR}/${OCCT_PACKAGE}/${OCCT_PACKAGE}.qrc" RCC_FILES)
+endforeach()
+#message("RCC_FILES for ${PROJECT_NAME} are ${RCC_FILES}")
+
+set (PRECOMPILED_DEFS)
+
+if (NOT BUILD_SHARED_LIBS)
+  list (APPEND PRECOMPILED_DEFS "-DOCCT_NO_PLUGINS")
+endif()
+
+# Get all used packages from toolkit
+foreach (OCCT_PACKAGE ${USED_PACKAGES})
+
+  ADD_DEFINITIONS(-D${OCCT_PACKAGE}_EXPORTS)
+  
+  # TKService contains platform-dependent packages: Xw and WNT
+  if ((WIN32 AND "${OCCT_PACKAGE}" STREQUAL "Xw") OR (NOT WIN32 AND "${OCCT_PACKAGE}" STREQUAL "WNT"))
+    # do nothing
+  else()
+
+    if (WIN32)
+      list (APPEND PRECOMPILED_DEFS "-D__${OCCT_PACKAGE}_DLL")
+    endif()
+
+    set (SOURCE_FILES)
+    set (HEADER_FILES)
+
+    # Generate Flex and Bison files
+    if (${BUILD_YACCLEX})
+
+      # flex files
+      OCCT_ORIGIN_AND_PATCHED_FILES ("tools/${OCCT_PACKAGE}" "*[.]lex" SOURCE_FILES_FLEX)
+      list (LENGTH SOURCE_FILES_FLEX SOURCE_FILES_FLEX_LEN)
+
+      # bison files
+      OCCT_ORIGIN_AND_PATCHED_FILES ("tools/${OCCT_PACKAGE}" "*[.]yacc" SOURCE_FILES_BISON)
+      list (LENGTH SOURCE_FILES_BISON SOURCE_FILES_BISON_LEN)
+
+      if (${SOURCE_FILES_FLEX_LEN} EQUAL ${SOURCE_FILES_BISON_LEN} AND NOT ${SOURCE_FILES_FLEX_LEN} EQUAL 0)
+      
+        list (SORT SOURCE_FILES_FLEX)
+        list (SORT SOURCE_FILES_BISON)
+
+        math (EXPR SOURCE_FILES_FLEX_LEN "${SOURCE_FILES_FLEX_LEN} - 1")
+        foreach (FLEX_FILE_INDEX RANGE ${SOURCE_FILES_FLEX_LEN})
+
+          list (GET SOURCE_FILES_FLEX ${FLEX_FILE_INDEX} CURRENT_FLEX_FILE)
+          get_filename_component (CURRENT_FLEX_FILE_NAME ${CURRENT_FLEX_FILE} NAME_WE)
+
+          list (GET SOURCE_FILES_BISON ${FLEX_FILE_INDEX} CURRENT_BISON_FILE)
+          get_filename_component (CURRENT_BISON_FILE_NAME ${CURRENT_BISON_FILE} NAME_WE)
+          
+          string (COMPARE EQUAL ${CURRENT_FLEX_FILE_NAME} ${CURRENT_BISON_FILE_NAME} ARE_FILES_EQUAL)
+
+          if (EXISTS "${CURRENT_FLEX_FILE}" AND EXISTS "${CURRENT_BISON_FILE}" AND ${ARE_FILES_EQUAL})
+            set (BISON_OUTPUT_FILE ${CURRENT_BISON_FILE_NAME}.tab.c)
+            set (FLEX_OUTPUT_FILE lex.${CURRENT_FLEX_FILE_NAME}.c)
+            BISON_TARGET (Parser_${CURRENT_BISON_FILE_NAME} ${CURRENT_BISON_FILE} ${CMAKE_SOURCE_DIR}/tools/${OCCT_PACKAGE}/${BISON_OUTPUT_FILE} COMPILE_FLAGS "-p ${CURRENT_BISON_FILE_NAME}")
+            FLEX_TARGET  (Scanner_${CURRENT_FLEX_FILE_NAME} ${CURRENT_FLEX_FILE} ${CMAKE_SOURCE_DIR}/tools/${OCCT_PACKAGE}/${FLEX_OUTPUT_FILE} COMPILE_FLAGS "-P${CURRENT_FLEX_FILE_NAME}")
+            ADD_FLEX_BISON_DEPENDENCY (Scanner_${CURRENT_FLEX_FILE_NAME} Parser_${CURRENT_BISON_FILE_NAME})
+           
+            list (APPEND SOURCE_FILES ${BISON_OUTPUT_FILE} ${FLEX_OUTPUT_FILE})
+          endif()
+        endforeach()
+      endif()
+    endif()
+
+    # header files
+    if (BUILD_PATCH AND EXISTS "${BUILD_PATCH}/tools/${OCCT_PACKAGE}/FILES")
+      file (STRINGS "${BUILD_PATCH}/tools/${OCCT_PACKAGE}/FILES" HEADER_FILES_M   REGEX ".+[.]h")
+      file (STRINGS "${BUILD_PATCH}/tools/${OCCT_PACKAGE}/FILES" HEADER_FILES_LXX REGEX ".+[.]lxx")
+      file (STRINGS "${BUILD_PATCH}/tools/${OCCT_PACKAGE}/FILES" HEADER_FILES_GXX REGEX ".+[.]gxx")
+
+      file (STRINGS "${BUILD_PATCH}/tools/${OCCT_PACKAGE}/FILES" SOURCE_FILES_C REGEX ".+[.]c")
+      if(APPLE)
+        file (STRINGS "${BUILD_PATCH}/tools/${OCCT_PACKAGE}/FILES" SOURCE_FILES_M REGEX ".+[.]mm")
+      endif()
+    else()
+      file (STRINGS "${CMAKE_SOURCE_DIR}/${PACKAGE_PREFIX_DIR}/${OCCT_PACKAGE}/FILES"     HEADER_FILES_M   REGEX ".+[.]h")
+      file (STRINGS "${CMAKE_SOURCE_DIR}/${PACKAGE_PREFIX_DIR}/${OCCT_PACKAGE}/FILES"     HEADER_FILES_LXX REGEX ".+[.]lxx")
+      file (STRINGS "${CMAKE_SOURCE_DIR}/${PACKAGE_PREFIX_DIR}/${OCCT_PACKAGE}/FILES"     HEADER_FILES_GXX REGEX ".+[.]gxx")
+
+      file (STRINGS "${CMAKE_SOURCE_DIR}/${PACKAGE_PREFIX_DIR}/${OCCT_PACKAGE}/FILES"     SOURCE_FILES_C REGEX ".+[.]c")
+      if(APPLE)
+        file (STRINGS "${CMAKE_SOURCE_DIR}/${PACKAGE_PREFIX_DIR}/${OCCT_PACKAGE}/FILES"   SOURCE_FILES_M REGEX ".+[.]mm")
+      endif()
+    endif()
+
+
+    
+    list (APPEND HEADER_FILES ${HEADER_FILES_M} ${HEADER_FILES_LXX} ${SOURCE_FILES_GXX})
+    list (APPEND SOURCE_FILES ${SOURCE_FILES_C})
+    if(APPLE)
+      list (APPEND SOURCE_FILES ${SOURCE_FILES_M})
+    endif()
+
+    foreach(HEADER_FILE ${HEADER_FILES})
+      if (BUILD_PATCH AND EXISTS "${BUILD_PATCH}/tools/${OCCT_PACKAGE}/${HEADER_FILE}")
+        message (STATUS "Info: consider patched file: ${BUILD_PATCH}/tools/${OCCT_PACKAGE}/${HEADER_FILE}")
+        list (APPEND USED_INCFILES "${BUILD_PATCH}/tools/${OCCT_PACKAGE}/${HEADER_FILE}")
+        SOURCE_GROUP ("Header Files\\${OCCT_PACKAGE}" FILES "${BUILD_PATCH}/tools/${OCCT_PACKAGE}/${HEADER_FILE}")
+      else()
+        list (APPEND USED_INCFILES "${CMAKE_SOURCE_DIR}/${PACKAGE_PREFIX_DIR}/${OCCT_PACKAGE}/${HEADER_FILE}")
+        SOURCE_GROUP ("Header Files\\${OCCT_PACKAGE}" FILES "${CMAKE_SOURCE_DIR}/${PACKAGE_PREFIX_DIR}/${OCCT_PACKAGE}/${HEADER_FILE}")
+      endif()
+    endforeach()
+
+
+    foreach(SOURCE_FILE ${SOURCE_FILES})
+      if (BUILD_PATCH AND EXISTS "${BUILD_PATCH}/tools/${OCCT_PACKAGE}/${SOURCE_FILE}")
+        message (STATUS "Info: consider patched file: ${BUILD_PATCH}/tools/${OCCT_PACKAGE}/${SOURCE_FILE}")
+        list (APPEND USED_SRCFILES "${BUILD_PATCH}/tools/${OCCT_PACKAGE}/${SOURCE_FILE}")
+        SOURCE_GROUP ("Source Files\\${OCCT_PACKAGE}" FILES "${BUILD_PATCH}/tools/${OCCT_PACKAGE}/${SOURCE_FILE}")
+      else()
+        list (APPEND USED_SRCFILES "${CMAKE_SOURCE_DIR}/${PACKAGE_PREFIX_DIR}/${OCCT_PACKAGE}/${SOURCE_FILE}")
+        SOURCE_GROUP ("Source Files\\${OCCT_PACKAGE}" FILES "${CMAKE_SOURCE_DIR}/${PACKAGE_PREFIX_DIR}/${OCCT_PACKAGE}/${SOURCE_FILE}")
+      endif()
+    endforeach()
+  endif()
+endforeach()
+string (REGEX REPLACE ";" " " PRECOMPILED_DEFS "${PRECOMPILED_DEFS}")
+
+set (USED_RCFILE "")
+if (MSVC)
+  set (USED_RCFILE "${CMAKE_BINARY_DIR}/resources/${PROJECT_NAME}.rc")
+
+  if (APPLY_OCCT_PATCH_DIR AND EXISTS "${APPLY_OCCT_PATCH_DIR}/adm/templates/occt_toolkit.rc.in")
+    configure_file("${APPLY_OCCT_PATCH_DIR}/adm/templates/occt_toolkit.rc.in" "${USED_RCFILE}" @ONLY)
+  else()
+    configure_file("${CMAKE_SOURCE_DIR}/adm/templates/occt_toolkit.rc.in" "${USED_RCFILE}" @ONLY)
+  endif()
+endif()
+
+set (CURRENT_MODULE)
+foreach (OCCT_MODULE ${OCCT_TOOLS})
+  list (FIND ${OCCT_MODULE}_TOOL_TOOLKITS ${PROJECT_NAME} CURRENT_PROJECT_IS_BUILT)
+  if (NOT ${CURRENT_PROJECT_IS_BUILT} EQUAL -1)
+    set (CURRENT_MODULE ${OCCT_MODULE})
+  endif()
+endforeach()
+
+if (NOT SINGLE_GENERATOR)
+  OCCT_INSERT_CODE_FOR_TARGET ()
+endif()
+
+if ("${PROJECT_NAME}" STREQUAL TInspectorEXE)
+  add_executable (${PROJECT_NAME} ${USED_SRCFILES} ${USED_INCFILES} ${USED_RCFILE} ${RCC_FILES})
+
+  install (TARGETS ${PROJECT_NAME}
+           DESTINATION "${INSTALL_DIR_BIN}\${OCCT_INSTALL_BIN_LETTER}")
+else()
+  add_library (${PROJECT_NAME} ${USED_SRCFILES} ${USED_INCFILES} ${USED_RCFILE} ${RCC_FILES})
+
+  if (MSVC)
+    install (FILES  ${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bind/${PROJECT_NAME}.pdb
+             CONFIGURATIONS Debug
+             DESTINATION "${INSTALL_DIR_BIN}\${OCCT_INSTALL_BIN_LETTER}")
+  endif()
+
+  if (BUILD_SHARED_LIBS AND NOT "${BUILD_SHARED_LIBRARY_NAME_POSTFIX}" STREQUAL "")
+    set (CMAKE_SHARED_LIBRARY_SUFFIX_DEFAULT ${CMAKE_SHARED_LIBRARY_SUFFIX})
+    set (CMAKE_SHARED_LIBRARY_SUFFIX "${BUILD_SHARED_LIBRARY_NAME_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+  endif()
+
+  install (TARGETS ${PROJECT_NAME}
+           EXPORT OpenCASCADE${CURRENT_MODULE}Targets
+           RUNTIME DESTINATION "${INSTALL_DIR_BIN}\${OCCT_INSTALL_BIN_LETTER}"
+           ARCHIVE DESTINATION "${INSTALL_DIR_LIB}\${OCCT_INSTALL_BIN_LETTER}"
+           LIBRARY DESTINATION "${INSTALL_DIR_LIB}\${OCCT_INSTALL_BIN_LETTER}")
+
+
+  if (NOT WIN32)
+    if (BUILD_SHARED_LIBS AND NOT "${BUILD_SHARED_LIBRARY_NAME_POSTFIX}" STREQUAL "")
+      set (LINK_NAME    "${INSTALL_DIR}/${INSTALL_DIR_LIB}\${OCCT_INSTALL_BIN_LETTER}/lib${PROJECT_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX_DEFAULT}/tools")
+      set (LIBRARY_NAME "${INSTALL_DIR}/${INSTALL_DIR_LIB}\${OCCT_INSTALL_BIN_LETTER}/lib${PROJECT_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}/tools")
+      OCCT_CREATE_SYMLINK_TO_FILE (${LIBRARY_NAME} ${LINK_NAME})
+    endif()
+  endif()
+endif()
+
+if (CURRENT_MODULE)
+  set_target_properties (${PROJECT_NAME} PROPERTIES FOLDER "Tools/${CURRENT_MODULE}")
+  set_target_properties (${PROJECT_NAME} PROPERTIES MODULE "${CURRENT_MODULE}")
+  if (APPLE)
+    if (NOT "${INSTALL_NAME_DIR}" STREQUAL "")
+      set_target_properties (${PROJECT_NAME} PROPERTIES BUILD_WITH_INSTALL_RPATH 1 INSTALL_NAME_DIR "${INSTALL_NAME_DIR}")
+    endif()
+  endif()
+endif()
+
+get_property (OCC_VERSION_MAJOR GLOBAL PROPERTY OCC_VERSION_MAJOR)
+get_property (OCC_VERSION_MINOR GLOBAL PROPERTY OCC_VERSION_MINOR)
+get_property (OCC_VERSION_MAINTENANCE GLOBAL PROPERTY OCC_VERSION_MAINTENANCE)
+
+if (ANDROID)
+  # do not append version to the filename
+  set_target_properties (${PROJECT_NAME} PROPERTIES COMPILE_FLAGS "${PRECOMPILED_DEFS}")
+else()
+  set_target_properties (${PROJECT_NAME} PROPERTIES COMPILE_FLAGS "${PRECOMPILED_DEFS}"
+                                                    SOVERSION     "${OCC_VERSION_MAJOR}"
+                                                    VERSION       "${OCC_VERSION_MAJOR}.${OCC_VERSION_MINOR}.${OCC_VERSION_MAINTENANCE}")
+endif()
+
+set (USED_TOOLKITS_BY_CURRENT_PROJECT)
+set (USED_EXTERNAL_LIBS_BY_CURRENT_PROJECT)
+
+# parce EXTERNLIB file
+FILE_TO_LIST ("${PACKAGE_PREFIX_DIR}/${PROJECT_NAME}/EXTERNLIB" USED_EXTERNLIB_AND_TOOLKITS)
+foreach (USED_ITEM ${USED_EXTERNLIB_AND_TOOLKITS})
+  string (REGEX MATCH "^ *#" COMMENT_FOUND ${USED_ITEM})
+  if (NOT COMMENT_FOUND)
+    string (REGEX MATCH "^TK" TK_FOUND ${USED_ITEM})
+    string (REGEX MATCH "^vtk" VTK_FOUND ${USED_ITEM})
+    
+    if (NOT "${TK_FOUND}" STREQUAL "" OR NOT "${VTK_FOUND}" STREQUAL "")
+      list (APPEND USED_TOOLKITS_BY_CURRENT_PROJECT ${USED_ITEM})
+    else()
+      string (REGEX MATCH "^CSF_" CSF_FOUND ${USED_ITEM})
+      if ("${CSF_FOUND}" STREQUAL "")
+        message (STATUS "Info: ${USED_ITEM} from ${PROJECT_NAME} skipped due to it is empty")
+      else() # get CSF_ value
+        set (CURRENT_CSF ${${USED_ITEM}})
+        if (NOT "x${CURRENT_CSF}" STREQUAL "x")
+          # prepare a list from a string with whitespaces
+          separate_arguments (CURRENT_CSF)
+          list (APPEND USED_EXTERNAL_LIBS_BY_CURRENT_PROJECT ${CURRENT_CSF})
+        endif()
+      endif()
+    endif()
+  endif()
+endforeach()
+
+if (APPLE)
+  list (FIND USED_EXTERNAL_LIBS_BY_CURRENT_PROJECT X11 IS_X11_FOUND)
+  if (NOT ${IS_X11_FOUND} EQUAL -1)
+    find_package (X11 COMPONENTS X11 Xext Xmu Xi)
+    if (NOT X11_FOUND)
+      message (STATUS "Warning: X11 is not found. It's required to install The XQuartz project: http://www.xquartz.org")
+    endif()
+  endif()
+endif()
+
+# Update list of used VTK libraries if OpenGL2 Rendering BackEnd is used.
+# Add VTK_OPENGL2_BACKEND definition.
+if("${VTK_RENDERING_BACKEND}" STREQUAL "OpenGL2")
+  add_definitions(-DVTK_OPENGL2_BACKEND)
+  foreach (VTK_EXCLUDE_LIBRARY vtkRenderingOpenGL vtkRenderingFreeTypeOpenGL)
+    list (FIND USED_TOOLKITS_BY_CURRENT_PROJECT "${VTK_EXCLUDE_LIBRARY}" IS_VTK_OPENGL_FOUND)
+    if (NOT ${IS_VTK_OPENGL_FOUND} EQUAL -1)
+      list (REMOVE_ITEM USED_TOOLKITS_BY_CURRENT_PROJECT ${VTK_EXCLUDE_LIBRARY})
+      if (${VTK_EXCLUDE_LIBRARY} STREQUAL vtkRenderingOpenGL)
+        list (APPEND USED_TOOLKITS_BY_CURRENT_PROJECT vtkRenderingOpenGL2)
+      endif()
+    endif()
+  endforeach()
+endif()
+
+if (BUILD_SHARED_LIBS)
+  target_link_libraries (${PROJECT_NAME} ${USED_TOOLKITS_BY_CURRENT_PROJECT} ${USED_EXTERNAL_LIBS_BY_CURRENT_PROJECT})
+endif()
+
+# Set Qt dependencies
+target_link_libraries(${PROJECT_NAME} "${PROJECT_LIBRARIES}")
+
+target_link_libraries(${PROJECT_NAME} debug "${PROJECT_LIBRARIES_DEBUG}")
+target_link_libraries(${PROJECT_NAME} optimized "${PROJECT_LIBRARIES_RELEASE}")
+

adm/cmake/qt5.cmake

@@ -0,0 +1,22 @@
+#qt
+
+#looking for 3RDPARTY_QT_DIR variable used later in qt5_macro.cmake
+if (${USE_QT4})
+  SET(CSF_QtCore "QtCore")
+  THIRDPARTY_PRODUCT("QT" "" "CSF_QtCore" "d")
+else()
+  SET(CSF_Qt5Core "Qt5Core")
+  THIRDPARTY_PRODUCT("QT" "" "CSF_Qt5Core" "d")
+endif()
+
+list (REMOVE_ITEM 3RDPARTY_NOT_INCLUDED "3RDPARTY_QT_INCLUDE_DIR")
+list (REMOVE_ITEM 3RDPARTY_NOT_INCLUDED "3RDPARTY_QT_LIBRARY_DIR")
+list (REMOVE_ITEM 3RDPARTY_NOT_INCLUDED "3RDPARTY_QT_DLL_DIR")
+
+UNSET (${3RDPARTY_QT_DLL} CACHE)
+UNSET (${3RDPARTY_QT_DLL_DIR} CACHE)
+UNSET (${3RDPARTY_QT_INCLUDE_DIR} CACHE)
+UNSET (${3RDPARTY_QT_LIBRARY} CACHE)
+UNSET (${3RDPARTY_QT_LIBRARY_DIR} CACHE)
+
+set (USED_3RDPARTY_QT_DIR "${3RDPARTY_QT_DIR}")

adm/cmake/qt5_macro.cmake

@@ -0,0 +1,68 @@
+#qt
+
+macro (FIND_QT5_PACKAGE PROJECT_LIBRARIES_DEBUG PROJECT_LIBRARIES_RELEASE PROJECT_INCLUDES)
+
+  if ("${3RDPARTY_QT_DIR}" STREQUAL "")
+    message (FATAL_ERROR "Empty Qt dir")
+  endif()
+
+  # Now set CMAKE_PREFIX_PATH to point to local Qt installation.
+  # Without this setting find_package() will not work
+  set(CMAKE_PREFIX_PATH ${3RDPARTY_QT_DIR})
+  if (USE_QT4)
+    # Now we can apply standard CMake finder for Qt. We do this mostly
+    # to have qt5_wrap_cpp() function available
+    find_package(Qt4)
+    #message (STATUS "Qt cmake configuration at directory ${Qt4DIR}")
+
+    set(PROJECT_INCLUDES ${QT_INCLUDES})
+    if (WIN32)
+      set(PROJECT_LIBRARIES_DEBUG "${3RDPARTY_QT_DIR}/lib/QtCored4.lib;${3RDPARTY_QT_DIR}/lib/QtGuid4.lib")
+      set(PROJECT_LIBRARIES_RELEASE "${3RDPARTY_QT_DIR}/lib/QtCore4.lib;${3RDPARTY_QT_DIR}/lib/QtGui4.lib")
+    else()
+      set(PROJECT_LIBRARIES_DEBUG "${3RDPARTY_QT_DIR}/lib/libQtCore.so;${3RDPARTY_QT_DIR}/lib/libQtGui.so")
+      set(PROJECT_LIBRARIES_RELEASE "${3RDPARTY_QT_DIR}/lib/libQtCore.so;${3RDPARTY_QT_DIR}/lib/libQtGui.so")
+    endif(WIN32)
+  else()
+    # Now we can apply standard CMake finder for Qt4. We do this mostly
+    # to have qt5_wrap_cpp() function available
+    find_package(Qt5 REQUIRED COMPONENTS Widgets)
+    #message (STATUS "Qt cmake configuration at directory ${Qt5DIR}")
+
+    set(PROJECT_INCLUDES "${Qt5Widgets_INCLUDE_DIRS}")
+    set(PROJECT_LIBRARIES_DEBUG "${Qt5Widgets_LIBRARIES}")
+    set(PROJECT_LIBRARIES_RELEASE "${Qt5Widgets_LIBRARIES}")
+  endif()
+endmacro()
+
+
+macro (FIND_AND_WRAP_MOC_FILES SOURCE_FILES)
+  SET(CMAKE_AUTOMOC ON)
+
+  foreach (FILE ${SOURCE_FILES})
+    set (src_files ${src_files} ${FILE})
+    unset (MOC_FILE)
+    if (USE_QT4)
+      qt4_wrap_cpp(MOC_FILE ${FILE})
+    else()
+      qt5_wrap_cpp(MOC_FILE ${FILE})
+    endif()
+    #message (STATUS "... Info: next MOC file ${MOC_FILE}")
+
+  endforeach (FILE)
+
+endmacro()
+
+macro (FIND_AND_WRAP_RESOURCE_FILE RESOURCE_FILE_NAME RCC_FILES)
+  if(EXISTS "${RESOURCE_FILE_NAME}")
+    if (USE_QT4)
+      qt4_add_resources(RCC_FILES "${RESOURCE_FILE_NAME}")
+      # suppress some GCC warnings coming from source files generated from .qrc resources
+      if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-variable")
+      endif()
+    else()
+      qt5_add_resources(RCC_FILES "${RESOURCE_FILE_NAME}")
+    endif()
+  endif()
+endmacro()

adm/cmake/tbb.cmake

@@ -70,49 +70,49 @@ else()
 endif()
 
 # common steps for tbb and tbbmalloc
-macro (TBB_PRODUCT_SEARCH PRODUCT_NAME)
+macro (TBB_PRODUCT_SEARCH PRODUCT_LIBRARY_NAME)
 
-  string (TOLOWER ${PRODUCT_NAME} lower_PRODUCT_NAME)
+  string (TOUPPER ${PRODUCT_LIBRARY_NAME} upper_PRODUCT_LIBRARY_NAME)
 
   # define required tbb/tbbmalloc variables
-  if (NOT DEFINED 3RDPARTY_${PRODUCT_NAME}_LIBRARY OR NOT 3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR OR NOT EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR}")
-    set (3RDPARTY_${PRODUCT_NAME}_LIBRARY "" CACHE FILEPATH "${PRODUCT_NAME} library" FORCE)
+  if (NOT DEFINED 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY OR NOT 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR OR NOT EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR}")
+    set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY "" CACHE FILEPATH "${upper_PRODUCT_LIBRARY_NAME} library" FORCE)
   endif()
 
-  if (NOT DEFINED 3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR)
-    set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR "" CACHE PATH "The directory containing ${PRODUCT_NAME} library")
+  if (NOT DEFINED 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR)
+    set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR "" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} library")
   endif()
 
   if (WIN32)
-    if (NOT DEFINED 3RDPARTY_${PRODUCT_NAME}_DLL OR NOT 3RDPARTY_${PRODUCT_NAME}_DLL_DIR OR NOT EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR}")
-      set (3RDPARTY_${PRODUCT_NAME}_DLL "" CACHE FILEPATH "${PRODUCT_NAME} shared library" FORCE)
+    if (NOT DEFINED 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL OR NOT 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR OR NOT EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR}")
+      set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL "" CACHE FILEPATH "${upper_PRODUCT_LIBRARY_NAME} shared library" FORCE)
     endif()
   endif()
 
-  if (WIN32 AND NOT DEFINED 3RDPARTY_${PRODUCT_NAME}_DLL_DIR)
-    set (3RDPARTY_${PRODUCT_NAME}_DLL_DIR "" CACHE PATH "The directory containing ${PRODUCT_NAME} shared library")
+  if (WIN32 AND NOT DEFINED 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR)
+    set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR "" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} shared library")
   endif()
 
-  # check 3RDPARTY_${PRODUCT_NAME}_ paths for consistency with specified 3RDPARTY_TBB_DIR
+  # check 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_ paths for consistency with specified 3RDPARTY_TBB_DIR
   if (3RDPARTY_TBB_DIR AND EXISTS "${3RDPARTY_TBB_DIR}")
-    CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_TBB_DIR 3RDPARTY_${PRODUCT_NAME}_LIBRARY FILEPATH "the path to ${PRODUCT_NAME} library")
+    CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_TBB_DIR 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY FILEPATH "the path to ${upper_PRODUCT_LIBRARY_NAME} library")
 
-    if (3RDPARTY_${PRODUCT_NAME}_LIBRARY AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY}")
-      get_filename_component (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR "${3RDPARTY_${PRODUCT_NAME}_LIBRARY}" PATH)
-      set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR}" CACHE PATH "The directory containing ${PRODUCT_NAME} library" FORCE)
+    if (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY AND EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}")
+      get_filename_component (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}" PATH)
+      set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR}" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} library" FORCE)
     else()
-      CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_TBB_DIR 3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR PATH "The directory containing ${PRODUCT_NAME} library")
+      CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_TBB_DIR 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} library")
     endif()
 
     if (WIN32)
-      CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_TBB_DIR 3RDPARTY_${PRODUCT_NAME}_DLL FILEPATH "the path to ${PRODUCT_NAME} shared library")
+      CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_TBB_DIR 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL FILEPATH "the path to ${upper_PRODUCT_LIBRARY_NAME} shared library")
 
-      if (3RDPARTY_${PRODUCT_NAME}_DLL AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL}")
-        get_filename_component (3RDPARTY_${PRODUCT_NAME}_DLL_DIR "${3RDPARTY_${PRODUCT_NAME}_DLL}" PATH)
-        set (3RDPARTY_${PRODUCT_NAME}_DLL_DIR "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR}" CACHE PATH "The directory containing ${PRODUCT_NAME} shared library" FORCE)
+      if (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL AND EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}")
+        get_filename_component (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}" PATH)
+        set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR}" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} shared library" FORCE)
       else()
 
-      CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_TBB_DIR 3RDPARTY_${PRODUCT_NAME}_DLL_DIR PATH "The directory containing ${PRODUCT_NAME} shared library")
+      CHECK_PATH_FOR_CONSISTENCY (3RDPARTY_TBB_DIR 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} shared library")
       endif()
     endif()
   endif()
@@ -121,112 +121,112 @@ macro (TBB_PRODUCT_SEARCH PRODUCT_NAME)
   OCCT_MAKE_COMPILER_BITNESS()
 
   if (${COMPILER_BITNESS} EQUAL 32)
-    set (${PRODUCT_NAME}_ARCH_NAME ia32)
+    set (${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME ia32)
   else()
-    set (${PRODUCT_NAME}_ARCH_NAME intel64)
+    set (${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME intel64)
   endif()
 
   # tbb/tbbmalloc library
-  if (NOT 3RDPARTY_${PRODUCT_NAME}_LIBRARY OR NOT EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY}")
+  if (NOT 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY OR NOT EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}")
     
     set (CMAKE_FIND_LIBRARY_SUFFIXES .lib .so .dylib .a)
-    set (PRODUCT_PATH_SUFFIXES lib ${lower_PRODUCT_NAME})
+    set (PRODUCT_PATH_SUFFIXES lib ${PRODUCT_LIBRARY_NAME})
 
-    # set 3RDPARTY_${PRODUCT_NAME}_LIBRARY as notfound, otherwise find_library can't assign a new value to 3RDPARTY_${PRODUCT_NAME}_LIBRARY
-    set (3RDPARTY_${PRODUCT_NAME}_LIBRARY "3RDPARTY_${PRODUCT_NAME}_LIBRARY-NOTFOUND" CACHE FILEPATH "The path to ${PRODUCT_NAME} library" FORCE)
+    # set 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY as notfound, otherwise find_library can't assign a new value to 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY
+    set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY "3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY-NOTFOUND" CACHE FILEPATH "The path to ${upper_PRODUCT_LIBRARY_NAME} library" FORCE)
 
     if (3RDPARTY_TBB_DIR AND EXISTS "${3RDPARTY_TBB_DIR}")
-      if (NOT EXISTS "${3RDPARTY_TBB_DIR}/lib/${${PRODUCT_NAME}_ARCH_NAME}/${COMPILER}")
-        if (EXISTS "${3RDPARTY_TBB_DIR}/lib/${${PRODUCT_NAME}_ARCH_NAME}")
-          file (GLOB ${PRODUCT_NAME}_COMPILER_LIST "${3RDPARTY_TBB_DIR}/lib/${${PRODUCT_NAME}_ARCH_NAME}/*")
-          if (${PRODUCT_NAME}_COMPILER_LIST)
-            list (GET ${PRODUCT_NAME}_COMPILER_LIST -1 THE_MOST_FRESH_COMPILER_VERSION)
+      if (NOT EXISTS "${3RDPARTY_TBB_DIR}/lib/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/${COMPILER}")
+        if (EXISTS "${3RDPARTY_TBB_DIR}/lib/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}")
+          file (GLOB ${upper_PRODUCT_LIBRARY_NAME}_COMPILER_LIST "${3RDPARTY_TBB_DIR}/lib/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/*")
+          if (${upper_PRODUCT_LIBRARY_NAME}_COMPILER_LIST)
+            list (GET ${upper_PRODUCT_LIBRARY_NAME}_COMPILER_LIST -1 THE_MOST_FRESH_COMPILER_VERSION)
             if (THE_MOST_FRESH_COMPILER_VERSION)
               get_filename_component (THE_MOST_FRESH_COMPILER_VERSION_NAME "${THE_MOST_FRESH_COMPILER_VERSION}" NAME)
-              set (PRODUCT_PATH_SUFFIXES lib ${lower_PRODUCT_NAME} lib/${${PRODUCT_NAME}_ARCH_NAME}/${THE_MOST_FRESH_COMPILER_VERSION_NAME})
+              set (PRODUCT_PATH_SUFFIXES lib ${PRODUCT_LIBRARY_NAME} lib/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/${THE_MOST_FRESH_COMPILER_VERSION_NAME})
             endif()
           endif()
         endif()
       else()
-        set (PRODUCT_PATH_SUFFIXES lib ${lower_PRODUCT_NAME} lib/${${PRODUCT_NAME}_ARCH_NAME}/${COMPILER})
+        set (PRODUCT_PATH_SUFFIXES lib ${PRODUCT_LIBRARY_NAME} lib/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/${COMPILER})
       endif()
 
-      find_library (3RDPARTY_${PRODUCT_NAME}_LIBRARY ${lower_PRODUCT_NAME}
-                                         PATHS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR}" "${3RDPARTY_TBB_DIR}"
+      find_library (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY ${PRODUCT_LIBRARY_NAME}
+                                         PATHS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR}" "${3RDPARTY_TBB_DIR}"
                                          PATH_SUFFIXES ${PRODUCT_PATH_SUFFIXES}
                                          CMAKE_FIND_ROOT_PATH_BOTH
                                          NO_DEFAULT_PATH)
     else()
-      find_library (3RDPARTY_${PRODUCT_NAME}_LIBRARY ${lower_PRODUCT_NAME} 
+      find_library (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY ${PRODUCT_LIBRARY_NAME}
                                          PATH_SUFFIXES ${PRODUCT_PATH_SUFFIXES}
                                          CMAKE_FIND_ROOT_PATH_BOTH)
     endif()
 
-    if (3RDPARTY_${PRODUCT_NAME}_LIBRARY AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY}")
-      get_filename_component (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR "${3RDPARTY_${PRODUCT_NAME}_LIBRARY}" PATH)
-      set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR}" CACHE PATH "The directory containing ${PRODUCT_NAME} library" FORCE)
+    if (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY AND EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}")
+      get_filename_component (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}" PATH)
+      set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR}" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} library" FORCE)
     else()
-      set (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR "" CACHE PATH "The directory containing ${PRODUCT_NAME} library" FORCE)
+      set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR "" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} library" FORCE)
     endif()
   endif()
 
-  if (3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR}")
-    list (APPEND 3RDPARTY_LIBRARY_DIRS "${3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR}")
+  if (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR AND EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR}")
+    list (APPEND 3RDPARTY_LIBRARY_DIRS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR}")
   else()
-    list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_${PRODUCT_NAME}_LIBRARY_DIR)
+    list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY_DIR)
 
-    set (3RDPARTY_${PRODUCT_NAME}_LIBRARY "" CACHE FILEPATH "The path to ${PRODUCT_NAME} library" FORCE)
+    set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY "" CACHE FILEPATH "The path to ${upper_PRODUCT_LIBRARY_NAME} library" FORCE)
   endif()
 
   # tbb/tbbmalloc shared library
   if (WIN32)
-    if (NOT 3RDPARTY_${PRODUCT_NAME}_DLL OR NOT EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL}")
+    if (NOT 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL OR NOT EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}")
       set (CMAKE_FIND_LIBRARY_SUFFIXES .dll)
       set (PRODUCT_PATH_SUFFIXES bin)
 
-      # set 3RDPARTY_${PRODUCT_NAME}_DLL as notfound, otherwise find_library can't assign a new value to 3RDPARTY_${PRODUCT_NAME}_DLL
-      set (3RDPARTY_${PRODUCT_NAME}_DLL "3RDPARTY_${PRODUCT_NAME}_DLL-NOTFOUND" CACHE FILEPATH "${PRODUCT_NAME} shared library" FORCE)
+      # set 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL as notfound, otherwise find_library can't assign a new value to 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL
+      set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL "3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL-NOTFOUND" CACHE FILEPATH "${upper_PRODUCT_LIBRARY_NAME} shared library" FORCE)
 
       if (3RDPARTY_TBB_DIR AND EXISTS "${3RDPARTY_TBB_DIR}")
-        if (NOT EXISTS "${3RDPARTY_TBB_DIR}/bin/${${PRODUCT_NAME}_ARCH_NAME}/${COMPILER}")
-          if (EXISTS "${3RDPARTY_TBB_DIR}/bin/${${PRODUCT_NAME}_ARCH_NAME}")
-            file (GLOB ${PRODUCT_NAME}_COMPILER_LIST "${3RDPARTY_TBB_DIR}/bin/${${PRODUCT_NAME}_ARCH_NAME}/*")
-            if (${PRODUCT_NAME}_COMPILER_LIST)
-              list (GET ${PRODUCT_NAME}_COMPILER_LIST -1 THE_MOST_FRESH_COMPILER_VERSION)
+        if (NOT EXISTS "${3RDPARTY_TBB_DIR}/bin/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/${COMPILER}")
+          if (EXISTS "${3RDPARTY_TBB_DIR}/bin/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}")
+            file (GLOB ${upper_PRODUCT_LIBRARY_NAME}_COMPILER_LIST "${3RDPARTY_TBB_DIR}/bin/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/*")
+            if (${upper_PRODUCT_LIBRARY_NAME}_COMPILER_LIST)
+              list (GET ${upper_PRODUCT_LIBRARY_NAME}_COMPILER_LIST -1 THE_MOST_FRESH_COMPILER_VERSION)
               if (THE_MOST_FRESH_COMPILER_VERSION)
                 get_filename_component (THE_MOST_FRESH_COMPILER_VERSION_NAME "${THE_MOST_FRESH_COMPILER_VERSION}" NAME)
-                set (PRODUCT_PATH_SUFFIXES bin bin/${${PRODUCT_NAME}_ARCH_NAME}/${THE_MOST_FRESH_COMPILER_VERSION_NAME})
+                set (PRODUCT_PATH_SUFFIXES bin bin/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/${THE_MOST_FRESH_COMPILER_VERSION_NAME})
               endif()
             endif()
           endif()
         else()
-          set (PRODUCT_PATH_SUFFIXES bin bin/${${PRODUCT_NAME}_ARCH_NAME}/${COMPILER})
+          set (PRODUCT_PATH_SUFFIXES bin bin/${${upper_PRODUCT_LIBRARY_NAME}_ARCH_NAME}/${COMPILER})
         endif()
 
         if (3RDPARTY_TBB_DIR AND EXISTS "${3RDPARTY_TBB_DIR}")
-          find_library (3RDPARTY_${PRODUCT_NAME}_DLL ${lower_PRODUCT_NAME}
+          find_library (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL ${PRODUCT_LIBRARY_NAME}
                                          PATHS "${3RDPARTY_TBB_DIR}"
                                          PATH_SUFFIXES ${PRODUCT_PATH_SUFFIXES}
                                          NO_DEFAULT_PATH)
         else()
-          find_library (3RDPARTY_${PRODUCT_NAME}_DLL ${lower_PRODUCT_NAME} PATH_SUFFIXES ${PRODUCT_PATH_SUFFIXES})
+          find_library (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL ${PRODUCT_LIBRARY_NAME} PATH_SUFFIXES ${PRODUCT_PATH_SUFFIXES})
         endif()
 
-        if (3RDPARTY_${PRODUCT_NAME}_DLL AND EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL}")
-          get_filename_component (3RDPARTY_${PRODUCT_NAME}_DLL_DIR "${3RDPARTY_${PRODUCT_NAME}_DLL}" PATH)
-          set (3RDPARTY_${PRODUCT_NAME}_DLL_DIR "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR}" CACHE PATH "The directory containing ${PRODUCT_NAME} library" FORCE)
+        if (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL AND EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}")
+          get_filename_component (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}" PATH)
+          set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR}" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} library" FORCE)
         else()
-          set (3RDPARTY_${PRODUCT_NAME}_DLL_DIR "" CACHE PATH "The directory containing ${PRODUCT_NAME} shared library" FORCE)
+          set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR "" CACHE PATH "The directory containing ${upper_PRODUCT_LIBRARY_NAME} shared library" FORCE)
 
-          set (3RDPARTY_${PRODUCT_NAME}_DLL "" CACHE FILEPATH "${PRODUCT_NAME} shared library" FORCE)
+          set (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL "" CACHE FILEPATH "${upper_PRODUCT_LIBRARY_NAME} shared library" FORCE)
         endif()
       endif()
     endif()
 
-    if (3RDPARTY_${PRODUCT_NAME}_DLL_DIR OR EXISTS "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR}")
-      list (APPEND 3RDPARTY_DLL_DIRS "${3RDPARTY_${PRODUCT_NAME}_DLL_DIR}")
+    if (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR OR EXISTS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR}")
+      list (APPEND 3RDPARTY_DLL_DIRS "${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR}")
     else()
-      list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_${PRODUCT_NAME}_DLL_DIR)
+      list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL_DIR)
     endif()
   endif()
 
@@ -237,47 +237,49 @@ macro (TBB_PRODUCT_SEARCH PRODUCT_NAME)
 
     if (WIN32)
       if (SINGLE_GENERATOR)
-        install (FILES ${3RDPARTY_${PRODUCT_NAME}_DLL} DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}")
+        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL} DESTINATION "${INSTALL_DIR_BIN}")
       else()
-        install (FILES ${3RDPARTY_${PRODUCT_NAME}_DLL}
+        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}
                  CONFIGURATIONS Release
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}")
-        install (FILES ${3RDPARTY_${PRODUCT_NAME}_DLL}
+                 DESTINATION "${INSTALL_DIR_BIN}")
+        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}
                  CONFIGURATIONS RelWithDebInfo
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}i")
-        install (FILES ${3RDPARTY_${PRODUCT_NAME}_DLL}
+                 DESTINATION "${INSTALL_DIR_BIN}i")
+        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL}
                  CONFIGURATIONS Debug
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}d")
+                 DESTINATION "${INSTALL_DIR_BIN}d")
       endif()
     else()
-      get_filename_component (PRODUCT_LIBRARY_NAME ${3RDPARTY_${PRODUCT_NAME}_LIBRARY} NAME)
+      get_filename_component (PRODUCT_LIBRARY_NAME ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY} NAME)
 
       if (SINGLE_GENERATOR)
-        install (FILES ${3RDPARTY_${PRODUCT_NAME}_LIBRARY}.2
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}"
+        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}.2
+                 DESTINATION "${INSTALL_DIR_LIB}"
                  RENAME ${PRODUCT_LIBRARY_NAME}.2)
       else()
-        install (FILES ${3RDPARTY_${PRODUCT_NAME}_LIBRARY}.2
+        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}.2
                  CONFIGURATIONS Release
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}"
+                 DESTINATION "${INSTALL_DIR_LIB}"
                  RENAME ${PRODUCT_LIBRARY_NAME}.2)
-        install (FILES ${3RDPARTY_${PRODUCT_NAME}_LIBRARY}.2
+        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}.2
                  CONFIGURATIONS RelWithDebInfo
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}i"
+                 DESTINATION "${INSTALL_DIR_LIB}i"
                  RENAME ${PRODUCT_LIBRARY_NAME}.2)
-        install (FILES ${3RDPARTY_${PRODUCT_NAME}_LIBRARY}.2
+        install (FILES ${3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY}.2
                  CONFIGURATIONS Debug
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}d"
+                 DESTINATION "${INSTALL_DIR_LIB}d"
                  RENAME ${PRODUCT_LIBRARY_NAME}.2)
       endif()
     endif()
   endif()
-  mark_as_advanced (3RDPARTY_${PRODUCT_NAME}_LIBRARY 3RDPARTY_${PRODUCT_NAME}_DLL)
+  mark_as_advanced (3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_LIBRARY 3RDPARTY_${upper_PRODUCT_LIBRARY_NAME}_DLL)
 endmacro()
 
 if (BUILD_SHARED_LIBS)
-  TBB_PRODUCT_SEARCH (TBB)
-  TBB_PRODUCT_SEARCH (TBBMALLOC)
+  separate_arguments (CSF_TBB)
+  foreach (LIB IN LISTS CSF_TBB)
+    TBB_PRODUCT_SEARCH (${LIB})
+  endforeach()
 
   if (INSTALL_TBB)
     set (USED_3RDPARTY_TBB_DIR "")

adm/cmake/tcl.cmake

@@ -93,9 +93,9 @@ if (BUILD_SHARED_LIBS)
       endif()
 
       set (3RDPARTY_TCL_DLL "3RDPARTY_TCL_DLL-NOTFOUND" CACHE FILEPATH "TCL shared library" FORCE)
-      find_library (3RDPARTY_TCL_DLL NAMES tcl86 tcl85
-                                            PATHS "${DLL_FOLDER_FOR_SEARCH}"
-                                            NO_DEFAULT_PATH)
+      find_library (3RDPARTY_TCL_DLL NAMES ${CSF_TclLibs}
+                                           PATHS "${DLL_FOLDER_FOR_SEARCH}"
+                                           NO_DEFAULT_PATH)
     endif()
   endif()
 endif()
@@ -106,14 +106,14 @@ if (BUILD_SHARED_LIBS)
   # tcl dir and library
   if (NOT 3RDPARTY_TCL_LIBRARY)
     set (3RDPARTY_TCL_LIBRARY "3RDPARTY_TCL_LIBRARY-NOTFOUND" CACHE FILEPATH "TCL library" FORCE)
-    find_library (3RDPARTY_TCL_LIBRARY NAMES tcl8.6 tcl86 tcl8.5 tcl85
-                                              PATHS "${3RDPARTY_TCL_LIBRARY_DIR}"
-                                              NO_DEFAULT_PATH)
+    find_library (3RDPARTY_TCL_LIBRARY NAMES ${CSF_TclLibs}
+                                             PATHS "${3RDPARTY_TCL_LIBRARY_DIR}"
+                                             NO_DEFAULT_PATH)
 
     # search in another place if previous search doesn't find anything
-    find_library (3RDPARTY_TCL_LIBRARY NAMES tcl8.6 tcl86 tcl8.5 tcl85
-                                              PATHS "${3RDPARTY_TCL_DIR}/lib"
-                                              NO_DEFAULT_PATH)
+    find_library (3RDPARTY_TCL_LIBRARY NAMES ${CSF_TclLibs}
+                                             PATHS "${3RDPARTY_TCL_DIR}/lib"
+                                             NO_DEFAULT_PATH)
 
 
     if (NOT 3RDPARTY_TCL_LIBRARY OR NOT EXISTS "${3RDPARTY_TCL_LIBRARY}")
@@ -161,8 +161,8 @@ if (BUILD_SHARED_LIBS)
 
       set (3RDPARTY_TCL_DLL "3RDPARTY_TCL_DLL-NOTFOUND" CACHE FILEPATH "TCL shared library" FORCE)
       find_library (3RDPARTY_TCL_DLL NAMES tcl${3RDPARTY_TCL_LIBRARY_VERSION}
-                                            PATHS "${DLL_FOLDER_FOR_SEARCH}"
-                                            NO_DEFAULT_PATH)
+                                           PATHS "${DLL_FOLDER_FOR_SEARCH}"
+                                           NO_DEFAULT_PATH)
 
       if (NOT 3RDPARTY_TCL_DLL OR NOT EXISTS "${3RDPARTY_TCL_DLL}")
         set (3RDPARTY_TCL_DLL "" CACHE FILEPATH "TCL shared library" FORCE)
@@ -184,7 +184,7 @@ if (BUILD_SHARED_LIBS)
   if (3RDPARTY_TCL_LIBRARY AND EXISTS "${3RDPARTY_TCL_LIBRARY}")
     list (APPEND 3RDPARTY_LIBRARY_DIRS "${3RDPARTY_TCL_LIBRARY_DIR}")
   else()
-    list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_TCL_LIBRARY_DIR})
+    list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_TCL_LIBRARY_DIR)
   endif()
 
   if (WIN32)
@@ -210,40 +210,40 @@ if (BUILD_SHARED_LIBS)
       file (GLOB TCL_DLLS "${3RDPARTY_TCL_DLL_DIR}/*.dll")
 
       if (SINGLE_GENERATOR)
-        install (FILES ${TCL_DLLS} DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}")
+        install (FILES ${TCL_DLLS} DESTINATION "${INSTALL_DIR_BIN}")
       else()
         install (FILES ${TCL_DLLS}
                  CONFIGURATIONS Release
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}")
+                 DESTINATION "${INSTALL_DIR_BIN}")
         install (FILES ${TCL_DLLS}
                  CONFIGURATIONS RelWithDebInfo
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}i")
+                 DESTINATION "${INSTALL_DIR_BIN}i")
         install (FILES ${TCL_DLLS}
                  CONFIGURATIONS Debug
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}d")
+                 DESTINATION "${INSTALL_DIR_BIN}d")
       endif()
     else()
       get_filename_component(3RDPARTY_TCL_LIBRARY_REALPATH ${3RDPARTY_TCL_LIBRARY} REALPATH)
 
       if (SINGLE_GENERATOR)
-        install (FILES ${3RDPARTY_TCL_LIBRARY_REALPATH} DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}")
+        install (FILES ${3RDPARTY_TCL_LIBRARY_REALPATH} DESTINATION "${INSTALL_DIR_LIB}")
       else()
         install (FILES ${3RDPARTY_TCL_LIBRARY_REALPATH}
                  CONFIGURATIONS Release
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}")
+                 DESTINATION "${INSTALL_DIR_LIB}")
         install (FILES ${3RDPARTY_TCL_LIBRARY_REALPATH}
                  CONFIGURATIONS RelWithDebInfo
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}i")
+                 DESTINATION "${INSTALL_DIR_LIB}i")
         install (FILES ${3RDPARTY_TCL_LIBRARY_REALPATH}
                  CONFIGURATIONS Debug
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}d")
+                 DESTINATION "${INSTALL_DIR_LIB}d")
       endif()
     endif()
 
     if (TCL_TCLSH_VERSION)
       # tcl is required to install in lib folder (without)
-      install (DIRECTORY "${3RDPARTY_TCL_LIBRARY_DIR}/tcl8"                    DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}")
-      install (DIRECTORY "${3RDPARTY_TCL_LIBRARY_DIR}/tcl${TCL_TCLSH_VERSION}" DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}")
+      install (DIRECTORY "${3RDPARTY_TCL_LIBRARY_DIR}/tcl8"                    DESTINATION "${INSTALL_DIR_LIB}")
+      install (DIRECTORY "${3RDPARTY_TCL_LIBRARY_DIR}/tcl${TCL_TCLSH_VERSION}" DESTINATION "${INSTALL_DIR_LIB}")
     else()
       message (STATUS "\nWarning: tclX.X subdir won't be copyied during the installation process.")
       message (STATUS "Try seeking tcl within another folder by changing 3RDPARTY_TCL_DIR variable.")

adm/cmake/tk.cmake

@@ -97,9 +97,9 @@ if (BUILD_SHARED_LIBS)
         endif()
 
         set (3RDPARTY_TK_DLL "3RDPARTY_TK_DLL-NOTFOUND" CACHE FILEPATH "TK shared library" FORCE)
-        find_library (3RDPARTY_TK_DLL NAMES tk86 tk85
-                                              PATHS "${DLL_FOLDER_FOR_SEARCH}"
-                                              NO_DEFAULT_PATH)
+        find_library (3RDPARTY_TK_DLL NAMES ${CSF_TclTkLibs}
+                                            PATHS "${DLL_FOLDER_FOR_SEARCH}"
+                                            NO_DEFAULT_PATH)
     endif()
   endif()
 endif()
@@ -110,14 +110,14 @@ if (BUILD_SHARED_LIBS)
   # tk dir and library
   if (NOT 3RDPARTY_TK_LIBRARY)
     set (3RDPARTY_TK_LIBRARY "3RDPARTY_TK_LIBRARY-NOTFOUND" CACHE FILEPATH "TK library" FORCE)
-    find_library (3RDPARTY_TK_LIBRARY NAMES tk8.6 tk86 tk8.5 tk85
-                                              PATHS "${3RDPARTY_TK_LIBRARY_DIR}"
-                                              NO_DEFAULT_PATH)
+    find_library (3RDPARTY_TK_LIBRARY NAMES ${CSF_TclTkLibs}
+                                            PATHS "${3RDPARTY_TK_LIBRARY_DIR}"
+                                            NO_DEFAULT_PATH)
 
     # search in another place if previous search doesn't find anything
-    find_library (3RDPARTY_TK_LIBRARY NAMES tk8.6 tk86 tk8.5 tk85
-                                              PATHS "${3RDPARTY_TK_DIR}/lib"
-                                              NO_DEFAULT_PATH)
+    find_library (3RDPARTY_TK_LIBRARY NAMES ${CSF_TclTkLibs}
+                                            PATHS "${3RDPARTY_TK_DIR}/lib"
+                                            NO_DEFAULT_PATH)
 
 
     if (NOT 3RDPARTY_TK_LIBRARY OR NOT EXISTS "${3RDPARTY_TK_LIBRARY}")
@@ -165,8 +165,8 @@ if (BUILD_SHARED_LIBS)
 
       set (3RDPARTY_TK_DLL "3RDPARTY_TK_DLL-NOTFOUND" CACHE FILEPATH "TK shared library" FORCE)
       find_library (3RDPARTY_TK_DLL NAMES tk${3RDPARTY_TK_LIBRARY_VERSION}
-                                            PATHS "${DLL_FOLDER_FOR_SEARCH}"
-                                            NO_DEFAULT_PATH)
+                                          PATHS "${DLL_FOLDER_FOR_SEARCH}"
+                                          NO_DEFAULT_PATH)
 
       if (NOT 3RDPARTY_TK_DLL OR NOT EXISTS "${3RDPARTY_TK_DLL}")
         set (3RDPARTY_TK_DLL "" CACHE FILEPATH "TK shared library" FORCE)
@@ -190,7 +190,7 @@ if (BUILD_SHARED_LIBS)
   if (3RDPARTY_TK_LIBRARY AND EXISTS "${3RDPARTY_TK_LIBRARY}")
     list (APPEND 3RDPARTY_LIBRARY_DIRS "${3RDPARTY_TK_LIBRARY_DIR}")
   else()
-    list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_TK_LIBRARY_DIR})
+    list (APPEND 3RDPARTY_NOT_INCLUDED 3RDPARTY_TK_LIBRARY_DIR)
   endif()
 
   if (WIN32)
@@ -216,39 +216,39 @@ if (BUILD_SHARED_LIBS)
       file (GLOB TK_DLLS  "${3RDPARTY_TK_DLL_DIR}/*.dll")
 
       if (SINGLE_GENERATOR)
-        install (FILES ${TK_DLLS} DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}")
+        install (FILES ${TK_DLLS} DESTINATION "${INSTALL_DIR_BIN}")
       else()
         install (FILES ${TK_DLLS}
                  CONFIGURATIONS Release
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}")
+                 DESTINATION "${INSTALL_DIR_BIN}")
         install (FILES ${TK_DLLS}
                  CONFIGURATIONS RelWithDebInfo
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}i")
+                 DESTINATION "${INSTALL_DIR_BIN}i")
         install (FILES ${TK_DLLS}
                  CONFIGURATIONS Debug
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_BIN}d")
+                 DESTINATION "${INSTALL_DIR_BIN}d")
       endif()
     else()
       get_filename_component(3RDPARTY_TK_LIBRARY_REALPATH ${3RDPARTY_TK_LIBRARY} REALPATH)
 
       if (SINGLE_GENERATOR)
-        install (FILES ${3RDPARTY_TK_LIBRARY_REALPATH} DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}")
+        install (FILES ${3RDPARTY_TK_LIBRARY_REALPATH} DESTINATION "${INSTALL_DIR_LIB}")
       else()
         install (FILES ${3RDPARTY_TK_LIBRARY_REALPATH}
                  CONFIGURATIONS Release
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}/")
+                 DESTINATION "${INSTALL_DIR_LIB}/")
         install (FILES ${3RDPARTY_TK_LIBRARY_REALPATH}
                  CONFIGURATIONS RelWithDebInfo
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}/i")
+                 DESTINATION "${INSTALL_DIR_LIB}/i")
         install (FILES ${3RDPARTY_TK_LIBRARY_REALPATH}
                  CONFIGURATIONS Debug
-                 DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}d")
+                 DESTINATION "${INSTALL_DIR_LIB}d")
       endif()
     endif()
 
     if (TCL_TCLSH_VERSION)
       # tk is required to install in lib folder (without)
-      install (DIRECTORY "${3RDPARTY_TK_LIBRARY_DIR}/tk${TCL_TCLSH_VERSION}"  DESTINATION "${INSTALL_DIR}/${INSTALL_DIR_LIB}")
+      install (DIRECTORY "${3RDPARTY_TK_LIBRARY_DIR}/tk${TCL_TCLSH_VERSION}"  DESTINATION "${INSTALL_DIR_LIB}")
     else()
       message (STATUS "\nWarning: tkX.X subdir won't be copyied during the installation process.")
       message (STATUS "Try seeking tk within another folder by changing 3RDPARTY_TK_DIR variable.")

adm/cmake/vardescr.cmake

@@ -18,6 +18,8 @@ set (BUILD_YACCLEX_DESCR
 ExprIntrp functionality are generated automatically with Flex/Bison. Checking this options
 leads to automatic search of Flex/Bison binaries and regeneration of the mentioned files")
 
+set (BUILD_RESOURCES_DESCR "Enables regeneration of OCCT resource files")
+
 set (BUILD_WITH_DEBUG_DESCR
 "Enables extended messages of many OCCT algorithms, usually printed to cout.
 These include messages on internal errors and special cases encountered, timing etc.
@@ -26,6 +28,15 @@ Applies only for Debug configuration.")
 set (BUILD_SHARED_LIBRARY_NAME_POSTFIX_DESCR
 "Append the postfix to names of output libraries")
 
+set (BUILD_ENABLE_FPE_SIGNAL_HANDLER_DESCR
+"Enable/Disable the floating point exceptions (FPE) during DRAW execution only.
+Corresponding environment variable (CSF_FPE) can be changed manually
+in custom.bat/sh scripts without regeneration by CMake.")
+
+set (BUILD_USE_PCH_DESCR
+"Use precompiled headers to accelerate the build.
+Precompiled headers are generated automatically by Cotire tool.")
+
 # install variables
 set (INSTALL_DIR_DESCR 
 "The place where built OCCT libraries, headers, test cases (INSTALL_TEST_CASES variable),
@@ -71,6 +82,7 @@ endmacro()
 INSTALL_MESSAGE (INSTALL_SAMPLES          "OCCT samples")
 INSTALL_MESSAGE (INSTALL_TEST_CASES       "non-regression OCCT test scripts")
 INSTALL_MESSAGE (INSTALL_DOC_Overview     "OCCT overview documentation (HTML format)")
+INSTALL_MESSAGE (INSTALL_FFMPEG           "FFmpeg binaries")
 INSTALL_MESSAGE (INSTALL_FREEIMAGE        "FreeImage binaries")
 INSTALL_MESSAGE (INSTALL_EGL              "EGL binaries")
 INSTALL_MESSAGE (INSTALL_GLES2            "OpenGL ES 2.0 binaries")
@@ -125,6 +137,10 @@ set (3RDPARTY_DIR_DESCR
 third-party product have been found - corresponding CMake variables will be specified
 (VTK: 3RDPARTY_VTK_DIR, 3RDPARTY_VTK_INCLUDE_DIR, 3RDPARTY_VTK_LIBRARY_DIR)")
 
+set (USE_FFMPEG_DESCR
+"Indicates whether FFmpeg framework is used or not. FFmpeg stands for
+multimedia data handling, open-source software libraries used for video encoding and decoding.")
+
 set (USE_FREEIMAGE_DESCR
 "Indicates whether Freeimage product should be used in OCCT visualization
 module for support of popular graphics image formats (PNG, BMP etc)")
@@ -156,6 +172,11 @@ set (USE_GLX_DESCR "Indicates whether X11 OpenGl on OSX is used or not")
 
 set (USE_D3D_DESCR "Indicates whether optional Direct3D wrapper in OCCT visualization module should be build or not")
 
+set (BUILD_QT_TOOLS_DESCR "Indicates whether OCCT tools should be build or not")
+
+set (USE_QT_TOOLS_DESCR "Indicates whether OCCT tools should be used or not
+The tools will be searched in third-party directory or may be set manually")
+
 macro (BUILD_MODULE MODULE_NAME)
   set (ENABLE_MODULE TRUE)
   set (BUILD_MODULE_${MODULE_NAME} ${ENABLE_MODULE} CACHE BOOL "${BUILD_MODULE_${MODULE_NAME}_DESCR}")

adm/genconf.tcl

@@ -38,39 +38,50 @@ set SYS_VS_LIST {}
 set SYS_VC_LIST {}
 set SYS_VCVARS_LIST {}
 
-# detect installed Visual Studio instances from global environment
-if { [info exists ::env(VS150COMNTOOLS)] } {
-  lappend ::SYS_VS_LIST "Visual Studio 201x (vc15)"
-  lappend ::SYS_VC_LIST "vc15"
-  lappend ::SYS_VCVARS_LIST "%VS150COMNTOOLS%..\\..\\VC\\vcvarsall.bat"
+# detect installed Visual Studio 2017 instances by running vswhere.exe
+if { ! [catch {exec vswhere.exe -version "\[15.0,15.99\]" -latest -requires Microsoft.VisualStudio.Workload.NativeDesktop -property installationPath} res] } {
+  lappend ::SYS_VS_LIST "Visual Studio 2017 (15, toolset v141)"
+  lappend ::SYS_VC_LIST "vc141"
+  lappend ::SYS_VCVARS_LIST "$res\\VC\\vcvarsall.bat"
 }
+if { ! [catch {exec vswhere.exe -version "\[15.0,15.99\]" -latest -requires Microsoft.VisualStudio.Workload.Universal -property installationPath} res] } {
+  lappend ::SYS_VS_LIST "Visual Studio 2017 (15, toolset v141) UWP"
+  lappend ::SYS_VC_LIST "vc141-uwp"
+  lappend ::SYS_VCVARS_LIST "$res\\VC\\vcvarsall.bat"
+}
+
+# detect installed Visual Studio instances from global environment
 if { [info exists ::env(VS140COMNTOOLS)] } {
-  lappend ::SYS_VS_LIST "Visual Studio 2015 (vc14)"
+  lappend ::SYS_VS_LIST "Visual Studio 2015 (14, toolset v140)"
   lappend ::SYS_VC_LIST "vc14"
   lappend ::SYS_VCVARS_LIST "%VS140COMNTOOLS%..\\..\\VC\\vcvarsall.bat"
+
+  lappend ::SYS_VS_LIST "Visual Studio 2015 (14, toolset v140) UWP"
+  lappend ::SYS_VC_LIST "vc14-uwp"
+  lappend ::SYS_VCVARS_LIST "%VS140COMNTOOLS%..\\..\\VC\\vcvarsall.bat"
 }
 if { [info exists ::env(VS120COMNTOOLS)] } {
-  lappend ::SYS_VS_LIST "Visual Studio 2013 (vc12)"
+  lappend ::SYS_VS_LIST "Visual Studio 2013 (12, toolset v120)"
   lappend ::SYS_VC_LIST "vc12"
   lappend ::SYS_VCVARS_LIST "%VS120COMNTOOLS%..\\..\\VC\\vcvarsall.bat"
 }
 if { [info exists ::env(VS110COMNTOOLS)] } {
-  lappend ::SYS_VS_LIST "Visual Studio 2012 (vc11)"
+  lappend ::SYS_VS_LIST "Visual Studio 2012 (11, toolset v110)"
   lappend ::SYS_VC_LIST "vc11"
   lappend ::SYS_VCVARS_LIST "%VS110COMNTOOLS%..\\..\\VC\\vcvarsall.bat"
 }
 if { [info exists ::env(VS100COMNTOOLS)] } {
-  lappend ::SYS_VS_LIST "Visual Studio 2010 (vc10)"
+  lappend ::SYS_VS_LIST "Visual Studio 2010 (10, toolset v100)"
   lappend ::SYS_VC_LIST "vc10"
   lappend ::SYS_VCVARS_LIST "%VS100COMNTOOLS%..\\..\\VC\\vcvarsall.bat"
 }
 if { [info exists ::env(VS90COMNTOOLS)] } {
-  lappend ::SYS_VS_LIST "Visual Studio 2008 (vc9)"
+  lappend ::SYS_VS_LIST "Visual Studio 2008 (9, toolset v90)"
   lappend ::SYS_VC_LIST "vc9"
   lappend ::SYS_VCVARS_LIST "%VS90COMNTOOLS%..\\..\\VC\\vcvarsall.bat"
 }
 if { [info exists ::env(VS80COMNTOOLS)] } {
-  lappend ::SYS_VS_LIST "Visual Studio 2005 (vc8)"
+  lappend ::SYS_VS_LIST "Visual Studio 2005 (8, toolset v80)"
   lappend ::SYS_VC_LIST "vc8"
   lappend ::SYS_VCVARS_LIST "%VS80COMNTOOLS%..\\..\\VC\\vcvarsall.bat"
 }
@@ -129,10 +140,10 @@ proc wokdep:gui:UpdateList {} {
   wokdep:SearchX11       anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
   if { "$::HAVE_GLES2" == "true" } {
     if { "$::HAVE_GL2PS" == "true" } {
-      lappend anIncErrs "Error: gl2ps can not be used within OpenGL ES"
+      lappend anIncErrs "Error: gl2ps can not be used with OpenGL ES"
     }
     if { "$::HAVE_D3D" == "true" } {
-      lappend anIncErrs "Error: Direct3D can not be used within OpenGL ES"
+      lappend anIncErrs "Error: Direct3D can not be used with OpenGL ES"
     }
     wokdep:SearchEGL     anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
     wokdep:SearchGLES    anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
@@ -140,8 +151,11 @@ proc wokdep:gui:UpdateList {} {
   if { "$::HAVE_FREEIMAGE" == "true" } {
     wokdep:SearchFreeImage anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
   }
+  if { "$::HAVE_FFMPEG" == "true" } {
+    wokdep:SearchFFmpeg  anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
+  }
   if { "$::HAVE_GL2PS" == "true" } {
-    wokdep:SearchGL2PS   anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
+    wokdep:SearchStandardLibrary  anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs "gl2ps" "gl2ps.h" "gl2ps" {"gl2ps"}
   }
   if { "$::HAVE_TBB" == "true" } {
     wokdep:SearchTBB     anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
@@ -152,6 +166,18 @@ proc wokdep:gui:UpdateList {} {
   if { "$::HAVE_VTK" == "true" } {
     wokdep:SearchVTK  anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
   }
+
+  if { "$::HAVE_ZLIB" == "true" } {
+    wokdep:SearchStandardLibrary  anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs "zlib" "zlib.h" "zlib" {"zlib"}
+  }
+  if { "$::HAVE_LIBLZMA" == "true" } {
+    set aCheckLib "lzma"
+    if { "$::tcl_platform(platform)" == "windows" } {
+      set aCheckLib "liblzma"
+    }
+    wokdep:SearchStandardLibrary  anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs "liblzma" "lzma.h" "$aCheckLib" {"lzma" "xz"}
+  }
+
   if { "$::CHECK_QT4" == "true" } {
     wokdep:SearchQt4     anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
   }
@@ -373,12 +399,14 @@ proc wokdep:gui:Show64Bitness { theRowIter } {
 }
 
 # Header
-ttk::label    .myFrame.myVsFrame.myVsLbl       -text "Visual Studio configuration:" -padding {5 5 80 5}
-ttk::combobox .myFrame.myVsFrame.myVsCombo     -values $SYS_VS_LIST -state readonly -textvariable VSVER -width 30
+ttk::label    .myFrame.myVsFrame.myVsLbl       -text "Visual Studio configuration:" -padding {5 5 20 5}
+ttk::combobox .myFrame.myVsFrame.myVsCombo     -values $SYS_VS_LIST -state readonly -textvariable VSVER -width 40
 ttk::combobox .myFrame.myVsFrame.myArchCombo   -values { {32} {64} } -textvariable ARCH -state readonly -width 6
-entry         .myFrame.myVcEntry     -textvariable VCVER  -width 6
+entry         .myFrame.myVcEntry     -textvariable VCVER  -width 10
 entry         .myFrame.myVcVarsEntry -textvariable VCVARS -width 70
 ttk::button   .myFrame.myVcBrowseBtn -text "Browse" -command wokdep:gui:BrowseVcVars
+ttk::label    .myFrame.myHxxChecks.myRelDebInfoLbl   -text "Release with Debug info"
+checkbutton   .myFrame.myHxxChecks.myRelDebInfoCheck -offvalue "false" -onvalue "true" -variable HAVE_RelWithDebInfo
 
 #
 ttk::combobox .myFrame.myHxxChecks.myScutsCombo   -values { {ShortCut} {Copy} {HardLink} } -textvariable SHORTCUT_HEADERS -state readonly -width 12
@@ -402,12 +430,20 @@ if { "$::tcl_platform(platform)" == "windows" } {
   checkbutton .myFrame.myChecks.myD3dCheck      -offvalue "false" -onvalue "true" -variable HAVE_D3D       -command wokdep:gui:UpdateList
   ttk::label  .myFrame.myChecks.myD3dLbl        -text "Use Direct3D"
 }
+checkbutton   .myFrame.myChecks.myFFmpegCheck   -offvalue "false" -onvalue "true" -variable HAVE_FFMPEG    -command wokdep:gui:UpdateList
+ttk::label    .myFrame.myChecks.myFFmpegLbl     -text "Use FFmpeg"
 #checkbutton   .myFrame.myChecks.myOpenClCheck   -offvalue "false" -onvalue "true" -variable HAVE_OPENCL    -command wokdep:gui:UpdateList
 #ttk::label    .myFrame.myChecks.myOpenClLbl     -text "Use OpenCL"
 checkbutton   .myFrame.myChecks.myMacGLXCheck   -offvalue "false" -onvalue "true" -variable MACOSX_USE_GLX
 ttk::label    .myFrame.myChecks.myMacGLXLbl     -text "Use X11 for windows drawing"
 ttk::label    .myFrame.myChecks.myVtkLbl        -text "Use VTK"
 checkbutton   .myFrame.myChecks.myVtkCheck      -offvalue "false" -onvalue "true" -variable HAVE_VTK       -command wokdep:gui:UpdateList
+
+checkbutton   .myFrame.myChecks.myZLibCheck     -offvalue "false" -onvalue "true" -variable HAVE_ZLIB      -command wokdep:gui:UpdateList
+ttk::label    .myFrame.myChecks.myZLibLbl       -text "Use zlib"
+checkbutton   .myFrame.myChecks.myLzmaCheck     -offvalue "false" -onvalue "true" -variable HAVE_LIBLZMA   -command wokdep:gui:UpdateList
+ttk::label    .myFrame.myChecks.myLzmaLbl       -text "Use liblzma"
+
 checkbutton   .myFrame.myChecks.myQt4Check      -offvalue "false" -onvalue "true" -variable CHECK_QT4      -command wokdep:gui:UpdateList
 ttk::label    .myFrame.myChecks.myQt4Lbl        -text "Search Qt4"
 checkbutton   .myFrame.myChecks.myJDKCheck      -offvalue "false" -onvalue "true" -variable CHECK_JDK      -command wokdep:gui:UpdateList
@@ -485,6 +521,10 @@ if { "$tcl_platform(platform)" == "windows" } {
 grid .myFrame.myHxxChecks -row $aRowIter -column 0 -columnspan 10 -sticky w
 grid .myFrame.myHxxChecks.myScutsLbl     -row 0 -column 0
 grid .myFrame.myHxxChecks.myScutsCombo   -row 0 -column 1
+if { "$tcl_platform(platform)" == "windows" } {
+  grid .myFrame.myHxxChecks.myRelDebInfoCheck -row 0 -column 2
+  grid .myFrame.myHxxChecks.myRelDebInfoLbl   -row 0 -column 3
+}
 incr aRowIter
 #
 grid .myFrame.mySrchLbl       -row $aRowIter -column 0 -columnspan 10 -sticky w
@@ -499,23 +539,35 @@ grid .myFrame.myChecks.myFImageCheck   -row $aCheckRowIter -column 0 -sticky e
 grid .myFrame.myChecks.myFImageLbl     -row $aCheckRowIter -column 1 -sticky w
 grid .myFrame.myChecks.myTbbCheck      -row $aCheckRowIter -column 2 -sticky e
 grid .myFrame.myChecks.myTbbLbl        -row $aCheckRowIter -column 3 -sticky w
-grid .myFrame.myChecks.myQt4Check      -row $aCheckRowIter -column 4 -sticky e
-grid .myFrame.myChecks.myQt4Lbl        -row $aCheckRowIter -column 5 -sticky w
-grid .myFrame.myChecks.myGlesCheck     -row $aCheckRowIter -column 6 -sticky e
-grid .myFrame.myChecks.myGlesLbl       -row $aCheckRowIter -column 7 -sticky w
+if { "$::tcl_platform(os)" != "Darwin" } {
+  grid .myFrame.myChecks.myGlesCheck     -row $aCheckRowIter -column 4 -sticky e
+  grid .myFrame.myChecks.myGlesLbl       -row $aCheckRowIter -column 5 -sticky w
+}
 #grid .myFrame.myChecks.myOpenClCheck   -row $aCheckRowIter -column 6 -sticky e
 #grid .myFrame.myChecks.myOpenClLbl     -row $aCheckRowIter -column 7 -sticky w
+grid .myFrame.myChecks.myZLibCheck     -row $aCheckRowIter -column 6 -sticky e
+grid .myFrame.myChecks.myZLibLbl       -row $aCheckRowIter -column 7 -sticky w
+
+grid .myFrame.myChecks.myGl2psCheck    -row $aCheckRowIter -column 8 -sticky e
+grid .myFrame.myChecks.myGl2psLbl      -row $aCheckRowIter -column 9 -sticky w
+
+grid .myFrame.myChecks.myQt4Check      -row $aCheckRowIter -column 10 -sticky e
+grid .myFrame.myChecks.myQt4Lbl        -row $aCheckRowIter -column 11 -sticky w
+
 incr aCheckRowIter
-grid .myFrame.myChecks.myGl2psCheck    -row $aCheckRowIter -column 0 -sticky e
-grid .myFrame.myChecks.myGl2psLbl      -row $aCheckRowIter -column 1 -sticky w
+grid .myFrame.myChecks.myFFmpegCheck   -row $aCheckRowIter -column 0 -sticky e
+grid .myFrame.myChecks.myFFmpegLbl     -row $aCheckRowIter -column 1 -sticky w
 grid .myFrame.myChecks.myVtkCheck      -row $aCheckRowIter -column 2 -sticky e
 grid .myFrame.myChecks.myVtkLbl        -row $aCheckRowIter -column 3 -sticky w
-grid .myFrame.myChecks.myJDKCheck      -row $aCheckRowIter -column 4 -sticky e
-grid .myFrame.myChecks.myJDKLbl        -row $aCheckRowIter -column 5 -sticky w
 if { "$::tcl_platform(platform)" == "windows" } {
-  grid .myFrame.myChecks.myD3dCheck    -row $aCheckRowIter -column 6 -sticky e
-  grid .myFrame.myChecks.myD3dLbl      -row $aCheckRowIter -column 7 -sticky w
+  grid .myFrame.myChecks.myD3dCheck    -row $aCheckRowIter -column 4 -sticky e
+  grid .myFrame.myChecks.myD3dLbl      -row $aCheckRowIter -column 5 -sticky w
 }
+grid .myFrame.myChecks.myLzmaCheck     -row $aCheckRowIter -column 6 -sticky e
+grid .myFrame.myChecks.myLzmaLbl       -row $aCheckRowIter -column 7 -sticky w
+grid .myFrame.myChecks.myJDKCheck      -row $aCheckRowIter -column 10 -sticky e
+grid .myFrame.myChecks.myJDKLbl        -row $aCheckRowIter -column 11 -sticky w
+
 incr aCheckRowIter
 if { "$::tcl_platform(os)" == "Darwin" } {
   grid .myFrame.myChecks.myMacGLXCheck -row $aCheckRowIter -column 0 -sticky e

adm/genconfdeps.tcl

@@ -43,16 +43,6 @@ if { "$tcl_platform(platform)" == "unix" } {
 
 set SHORTCUT_HEADERS "ShortCut"
 
-set HAVE_FREEIMAGE "false"
-set HAVE_GL2PS     "false"
-set HAVE_TBB       "false"
-set HAVE_D3D       "false"
-set HAVE_GLES2     "false"
-set HAVE_OPENCL    "false"
-set HAVE_VTK       "false"
-set MACOSX_USE_GLX "false"
-set CHECK_QT4      "false"
-set CHECK_JDK      "false"
 set PRODUCTS_PATH ""
 set CSF_OPT_INC   [list]
 set CSF_OPT_LIB32 [list]
@@ -66,51 +56,38 @@ if { "$tcl_platform(pointerSize)" == "4" } {
 if { [info exists ::env(ARCH)] } {
   set ARCH "$::env(ARCH)"
 }
-if { [info exists ::env(VCVER)] } {
-  set VCVER "$::env(VCVER)"
-}
-if { [info exists ::env(VCVARS)] } {
-  set VCVARS "$::env(VCVARS)"
-}
+
 if { [info exists ::env(SHORTCUT_HEADERS)] } {
   set SHORTCUT_HEADERS "$::env(SHORTCUT_HEADERS)"
   if { $SHORTCUT_HEADERS == "true" } {
     set SHORTCUT_HEADERS "ShortCut"
   }
 }
-if { [info exists ::env(HAVE_FREEIMAGE)] } {
-  set HAVE_FREEIMAGE "$::env(HAVE_FREEIMAGE)"
+
+# fetch environment variables (e.g. set by custom.sh or custom.bat) and set them as tcl variables with the same name
+set THE_ENV_VARIABLES {HAVE_FREEIMAGE HAVE_FFMPEG HAVE_TBB HAVE_GLES2 HAVE_D3D HAVE_VTK HAVE_GL2PS HAVE_ZLIB HAVE_LIBLZMA HAVE_OPENCL CHECK_QT4 CHECK_JDK MACOSX_USE_GLX HAVE_RelWithDebInfo}
+foreach anEnvIter $THE_ENV_VARIABLES {
+  set ${anEnvIter} "false"
+  if { [info exists ::env(${anEnvIter})] } {
+    set ${anEnvIter} "$::env(${anEnvIter})"
+  }
 }
-if { [info exists ::env(HAVE_GL2PS)] } {
-  set HAVE_GL2PS "$::env(HAVE_GL2PS)"
+# do not export platform-specific variables
+if { "$::tcl_platform(os)" == "Darwin" } {
+  set HAVE_GLES2 ""
+} else {
+  set MACOSX_USE_GLX ""
 }
-if { [info exists ::env(HAVE_TBB)] } {
-  set HAVE_TBB "$::env(HAVE_TBB)"
+if { "$tcl_platform(platform)" != "windows" } {
+  set HAVE_D3D ""
+  set HAVE_RelWithDebInfo ""
 }
-if { [info exists ::env(HAVE_D3D)] } {
-  set HAVE_D3D "$::env(HAVE_D3D)"
-}
-if { [info exists ::env(HAVE_GLES2)] } {
-  set HAVE_GLES2 "$::env(HAVE_GLES2)"
-}
-if { [info exists ::env(HAVE_OPENCL)] } {
-  set HAVE_OPENCL "$::env(HAVE_OPENCL)"
-}
-if { [info exists ::env(HAVE_VTK)] } {
-  set HAVE_VTK "$::env(HAVE_VTK)"
-}
-if { [info exists ::env(MACOSX_USE_GLX)] } {
-  set MACOSX_USE_GLX "$::env(MACOSX_USE_GLX)"
-}
-if { [info exists ::env(CHECK_QT4)] } {
-  set CHECK_QT4 "$::env(CHECK_QT4)"
-}
-if { [info exists ::env(CHECK_JDK)] } {
-  set CHECK_JDK "$::env(CHECK_JDK)"
-}
-if { [info exists ::env(PRODUCTS_PATH)] } {
-  set PRODUCTS_PATH "$::env(PRODUCTS_PATH)"
+foreach anEnvIter {ARCH VCVER VCVARS PRODUCTS_PATH} {
+  if { [info exists ::env(${anEnvIter})] } {
+    set ${anEnvIter} "$::env(${anEnvIter})"
+  }
 }
+
 if { [info exists ::env(CSF_OPT_INC)] } {
   set CSF_OPT_INC [split "$::env(CSF_OPT_INC)" $::SYS_PATH_SPLITTER]
 }
@@ -142,6 +119,21 @@ proc wokdep:SearchHeader {theHeader} {
   if { [file exists "$aPath"] } {
     return "$aPath"
   }
+
+  if { "$::tcl_platform(os)" == "Linux" } {
+    if { "$::ARCH" == "64" } {
+      set aPath "/usr/include/x86_64-linux-gnu/${theHeader}"
+      if { [file exists "$aPath"] } {
+        return "$aPath"
+      }
+    } else {
+      set aPath "/usr/include/i386-linux-gnu/${theHeader}"
+      if { [file exists "$aPath"] } {
+        return "$aPath"
+      }
+    }
+  }
+
   return ""
 }
 
@@ -227,9 +219,14 @@ proc wokdep:Preferred {theList theCmpl theArch} {
     return ""
   }
 
+  # keep only two first digits in "vc141"
+  if { ! [regexp {^vc[0-9][0-9]} $theCmpl aCmpl] } {
+    set aCmpl $theCmpl
+  }
+
   set aShortList {}
   foreach aPath $theList {
-    if { [string first "$theCmpl" "$aPath"] != "-1" } {
+    if { [string first "$aCmpl" "$aPath"] != "-1" } {
       lappend aShortList "$aPath"
     }
   }
@@ -252,6 +249,83 @@ proc wokdep:Preferred {theList theCmpl theArch} {
   return [lindex [lsort -decreasing $aVeryShortList] 0]
 }
 
+# Search library placement
+proc wokdep:SearchStandardLibrary {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64 theName theCheckHeader theCheckLib theCheckFolders} {
+  upvar $theErrInc   anErrInc
+  upvar $theErrLib32 anErrLib32
+  upvar $theErrLib64 anErrLib64
+  upvar $theErrBin32 anErrBin32
+  upvar $theErrBin64 anErrBin64
+
+  set isFound "true"
+  set aHeaderPath [wokdep:SearchHeader "$theCheckHeader"]
+  if { "$aHeaderPath"  == "" } {
+    set hasHeader false
+    foreach aFolderIter $theCheckFolders {
+      set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{$aFolderIter}*] "$::VCVER" "$::ARCH" ]
+      if { "$aPath" != "" && [file exists "$aPath/include/$theCheckHeader"] } {
+        lappend ::CSF_OPT_INC "$aPath/include"
+        set hasHeader true
+        break
+      }
+    }
+    if { !$hasHeader } {
+      lappend anErrInc "Error: '$theCheckHeader' not found ($theName)"
+      set isFound "false"
+    }
+  }
+
+  foreach anArchIter {64 32} {
+    set aLibPath [wokdep:SearchLib "$theCheckLib" "$anArchIter"]
+    if { "$aLibPath" == "" } {
+      set hasLib false
+      foreach aFolderIter $theCheckFolders {
+        set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{$aFolderIter}*] "$::VCVER" "$anArchIter" ]
+        set aLibPath [wokdep:SearchLib "$theCheckLib" "$anArchIter" "$aPath/lib"]
+        if { "$aLibPath" != "" } {
+          lappend ::CSF_OPT_LIB$anArchIter "$aPath/lib"
+          lappend ::CSF_OPT_BIN$anArchIter "$aPath/bin"
+          set hasLib true
+          break
+        }
+      }
+      if { !$hasLib } {
+        lappend anErrLib$anArchIter "Error: '${::SYS_LIB_PREFIX}$theCheckLib.${::SYS_LIB_SUFFIX}' not found ($theName)"
+        if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
+      }
+    }
+
+    if { "$::tcl_platform(platform)" == "windows" } {
+      set aDllPath [wokdep:SearchBin "$theCheckLib.dll" "$anArchIter"]
+      if { "$aDllPath" == "" } {
+        set hasDll false
+        foreach aFolderIter $theCheckFolders {
+          set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{$aFolderIter}*] "$::VCVER" "$anArchIter" ]
+          set aDllPath [wokdep:SearchBin "$theCheckLib.dll" "$anArchIter" "$aPath/bin"]
+          if { "$aDllPath" != "" } {
+            lappend ::CSF_OPT_BIN$anArchIter "$aPath/bin"
+            set hasDll true
+            break
+          } else {
+            set aDllPath [wokdep:SearchBin "$theCheckLib.dll" "$anArchIter" "$aPath/lib"]
+            if { "$aDllPath" != "" } {
+              lappend ::CSF_OPT_BIN$anArchIter "$aPath/lib"
+              set hasDll true
+              break
+            }
+          }
+        }
+        if { !$hasDll } {
+          lappend anErrBin$anArchIter "Error: '$theCheckLib.dll' not found ($theName)"
+          if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
+        }
+      }
+    }
+  }
+
+  return "$isFound"
+}
+
 # Search Tcl/Tk libraries placement
 proc wokdep:SearchTclTk {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64} {
   upvar $theErrInc   anErrInc
@@ -489,8 +563,8 @@ proc wokdep:SearchFreeImage {theErrInc theErrLib32 theErrLib64 theErrBin32 theEr
   return "$isFound"
 }
 
-# Search GL2PS library placement
-proc wokdep:SearchGL2PS {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64} {
+# Search FFmpeg framework placement
+proc wokdep:SearchFFmpeg {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64} {
   upvar $theErrInc   anErrInc
   upvar $theErrLib32 anErrLib32
   upvar $theErrLib64 anErrLib64
@@ -498,47 +572,30 @@ proc wokdep:SearchGL2PS {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin
   upvar $theErrBin64 anErrBin64
 
   set isFound "true"
-  set aGl2psHPath [wokdep:SearchHeader "gl2ps.h"]
-  if { "$aGl2psHPath"  == "" } {
-    set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{gl2ps}*] "$::VCVER" "$::ARCH" ]
-    if { "$aPath" != "" && [file exists "$aPath/include/gl2ps.h"] } {
+  set aFFmpegHPath [wokdep:SearchHeader "libavutil/avutil.h"]
+  if { "$aFFmpegHPath"  == "" } {
+    set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{ffmpeg}*] "$::VCVER" "$::ARCH" ]
+    if { "$aPath" != "" && [file exists "$aPath/include/libavutil/avutil.h"] } {
       lappend ::CSF_OPT_INC "$aPath/include"
     } else {
-      lappend anErrInc "Error: 'gl2ps.h' not found (GL2PS)"
+      lappend anErrInc "Error: 'libavutil/avutil.h' not found (FFmpeg)"
       set isFound "false"
     }
   }
 
   foreach anArchIter {64 32} {
-    set aGl2psLibPath [wokdep:SearchLib "gl2ps" "$anArchIter"]
-    if { "$aGl2psLibPath" == "" } {
-      set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{gl2ps}*] "$::VCVER" "$anArchIter" ]
-      set aGl2psLibPath [wokdep:SearchLib "gl2ps" "$anArchIter" "$aPath/lib"]
-      if { "$aGl2psLibPath" != "" } {
+    set aFFmpegLibPath [wokdep:SearchLib "avutil" "$anArchIter"]
+    if { "$aFFmpegLibPath" == "" } {
+      set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{ffmpeg}*] "$::VCVER" "$anArchIter" ]
+      set aFFmpegLibPath [wokdep:SearchLib "avutil" "$anArchIter" "$aPath/lib"]
+      if { "$aFFmpegLibPath" != "" } {
         lappend ::CSF_OPT_LIB$anArchIter "$aPath/lib"
+        lappend ::CSF_OPT_BIN$anArchIter "$aPath/bin"
       } else {
-        lappend anErrLib$anArchIter "Error: '${::SYS_LIB_PREFIX}gl2ps.${::SYS_LIB_SUFFIX}' not found (GL2PS)"
+        lappend anErrLib$anArchIter "Error: '${::SYS_LIB_PREFIX}avutil.${::SYS_LIB_SUFFIX}' not found (FFmpeg)"
         if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
       }
     }
-    if { "$::tcl_platform(platform)" == "windows" } {
-      set aGl2psDllPath [wokdep:SearchBin "gl2ps.dll" "$anArchIter"]
-      if { "$aGl2psDllPath" == "" } {
-        set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{gl2ps}*] "$::VCVER" "$anArchIter" ]
-        set aGl2psDllPath [wokdep:SearchBin "gl2ps.dll" "$anArchIter" "$aPath/bin"]
-        if { "$aGl2psDllPath" != "" } {
-          lappend ::CSF_OPT_BIN$anArchIter "$aPath/bin"
-        } else {
-          set aGl2psDllPath [wokdep:SearchBin "gl2ps.dll" "$anArchIter" "$aPath/lib"]
-          if { "$aGl2psDllPath" != "" } {
-            lappend ::CSF_OPT_BIN$anArchIter "$aPath/lib"
-          } else {
-            lappend anErrBin$anArchIter "Error: 'gl2ps.dll' not found (GL2PS)"
-            if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
-          }
-        }
-      }
-    }
   }
 
   return "$isFound"
@@ -552,6 +609,11 @@ proc wokdep:SearchTBB {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64
   upvar $theErrBin32 anErrBin32
   upvar $theErrBin64 anErrBin64
 
+  # keep only two first digits in "vc141"
+  if { ! [regexp {^vc[0-9][0-9]} ${::VCVER} aVcLib] } {
+    set aVcLib ${::VCVER}
+  }
+
   set isFound "true"
   set aTbbHPath [wokdep:SearchHeader "tbb/scalable_allocator.h"]
   if { "$aTbbHPath"  == "" } {
@@ -572,8 +634,8 @@ proc wokdep:SearchTBB {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64
 
     set aTbbLibPath [wokdep:SearchLib "tbb" "$anArchIter"]
     if { "$aTbbLibPath" == "" } {
-      set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{tbb}*] "$::VCVER" "$anArchIter" ]
-      set aTbbLibPath [wokdep:SearchLib "tbb" "$anArchIter" "$aPath/lib/$aSubDir/${::VCVER}"]
+      set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{tbb}*] $aVcLib "$anArchIter" ]
+      set aTbbLibPath [wokdep:SearchLib "tbb" "$anArchIter" "$aPath/lib/$aSubDir/$aVcLib"]
       if { "$aTbbLibPath" == "" } {
         # Set the path to the TBB library for Linux
         if { "$::tcl_platform(platform)" != "windows" } {
@@ -584,7 +646,7 @@ proc wokdep:SearchTBB {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64
           lappend ::CSF_OPT_LIB$anArchIter "$aPath/lib/$aSubDir"
         }
       } else {
-        lappend ::CSF_OPT_LIB$anArchIter "$aPath/lib/$aSubDir/${::VCVER}"
+        lappend ::CSF_OPT_LIB$anArchIter "$aPath/lib/$aSubDir/$aVcLib"
       }
       if { "$aTbbLibPath" == "" } {
         lappend anErrLib$anArchIter "Error: '${::SYS_LIB_PREFIX}tbb.${::SYS_LIB_SUFFIX}' not found (Intel TBB)"
@@ -594,10 +656,10 @@ proc wokdep:SearchTBB {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64
     if { "$::tcl_platform(platform)" == "windows" } {
       set aTbbDllPath [wokdep:SearchBin "tbb.dll" "$anArchIter"]
       if { "$aTbbDllPath" == "" } {
-        set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{tbb}*] "$::VCVER" "$anArchIter" ]
-        set aTbbDllPath [wokdep:SearchBin "tbb.dll" "$anArchIter" "$aPath/bin/$aSubDir/${::VCVER}"]
+        set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{tbb}*] $aVcLib "$anArchIter" ]
+        set aTbbDllPath [wokdep:SearchBin "tbb.dll" "$anArchIter" "$aPath/bin/$aSubDir/$aVcLib"]
         if { "$aTbbDllPath" != "" } {
-          lappend ::CSF_OPT_BIN$anArchIter "$aPath/bin/$aSubDir/${::VCVER}"
+          lappend ::CSF_OPT_BIN$anArchIter "$aPath/bin/$aSubDir/$aVcLib"
         } else {
           lappend anErrBin$anArchIter "Error: 'tbb.dll' not found (Intel TBB)"
           if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
@@ -1075,15 +1137,13 @@ proc wokdep:SaveCustom {} {
 
     puts $aFile ""
     puts $aFile "rem Optional 3rd-parties switches"
-    puts $aFile "set HAVE_FREEIMAGE=$::HAVE_FREEIMAGE"
-    puts $aFile "set HAVE_GL2PS=$::HAVE_GL2PS"
-    puts $aFile "set HAVE_TBB=$::HAVE_TBB"
-    puts $aFile "set HAVE_GLES2=$::HAVE_GLES2"
-    puts $aFile "set HAVE_D3D=$::HAVE_D3D"
-    puts $aFile "set HAVE_OPENCL=$::HAVE_OPENCL"
-    puts $aFile "set HAVE_VTK=$::HAVE_VTK"
-    puts $aFile "set CHECK_QT4=$::CHECK_QT4"
-    puts $aFile "set CHECK_JDK=$::CHECK_JDK"
+    foreach anEnvIter $::THE_ENV_VARIABLES {
+      set aName ${anEnvIter}
+      set aValue [set ::${anEnvIter}]
+      if { "$aValue" != "" } {
+        puts $aFile "set ${aName}=$aValue"
+      }
+    }
 
     set aStringInc [join $::CSF_OPT_INC $::SYS_PATH_SPLITTER]
     puts $aFile ""
@@ -1126,17 +1186,13 @@ proc wokdep:SaveCustom {} {
 
     puts $aFile ""
     puts $aFile "# Optional 3rd-parties switches"
-    puts $aFile "export HAVE_FREEIMAGE=$::HAVE_FREEIMAGE"
-    puts $aFile "export HAVE_GL2PS=$::HAVE_GL2PS"
-    puts $aFile "export HAVE_TBB=$::HAVE_TBB"
-    puts $aFile "export HAVE_GLES2=$::HAVE_GLES2"
-    puts $aFile "export HAVE_OPENCL=$::HAVE_OPENCL"
-    puts $aFile "export HAVE_VTK=$::HAVE_VTK"
-    if { "$::tcl_platform(os)" == "Darwin" } {
-      puts $aFile "export MACOSX_USE_GLX=$::MACOSX_USE_GLX"
+    foreach anEnvIter $::THE_ENV_VARIABLES {
+      set aName ${anEnvIter}
+      set aValue [set ::${anEnvIter}]
+      if { "$aValue" != "" } {
+        puts $aFile "export ${aName}=${aValue}"
+      }
     }
-    puts $aFile "export CHECK_QT4=$::CHECK_QT4"
-    puts $aFile "export CHECK_JDK=$::CHECK_JDK"
 
     set aStringInc [join $::CSF_OPT_INC $::SYS_PATH_SPLITTER]
     puts $aFile ""

adm/gendoc.tcl

@@ -56,7 +56,7 @@ proc OCCDoc_PrintHelpMessage {} {
     puts "  -s=<search_mode>   : Specifies the Search mode of HTML documents"
     puts "                       Can be: none | local | server | external"
     puts "  -h                 : Prints this help message"
-    puts "  -v                 : Enables more verbose output"    
+    puts "  -v                 : Enables more verbose output"
 }
 
 # A command for User Documentation compilation
@@ -70,7 +70,7 @@ proc gendoc {args} {
   set DOCLABEL                  ""
   set VERB_MODE                 "NO"
   set SEARCH_MODE               "none"
-  set MATHJAX_LOCATION          "http://cdn.mathjax.org/mathjax/latest"
+  set MATHJAX_LOCATION          "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1"
   set mathjax_js_name           "MathJax.js"
   set DOCTYPE_COMBO_FLAG        0
   set GENMODE_COMBO_FLAG        0
@@ -171,7 +171,7 @@ proc gendoc {args} {
       if { $DOCTYPE_COMBO_FLAG != 1 } { 
         set DOC_TYPE "REFMAN"
         set DOCTYPE_COMBO_FLAG 1
-        if { [info exists env(PRODROOT)] && [file exists $::env(PRODROOT)/src/VAS/Products.tcl] } {
+        if { [file exists [OCCDoc_GetProdRootDir]/src/VAS/Products.tcl] } {
           set GENERATE_PRODUCTS_REFMAN "YES"
         }
       } else {
@@ -303,27 +303,35 @@ proc gendoc {args} {
 
   puts ""
 
-  # Clean logfiles
-  set DOXYLOG [OCCDoc_GetRootDir]/doc/doxygen_warnings_and_errors.log
-  set PDFLOG  [OCCDoc_GetRootDir]/doc/pdflatex_warnings_and_errors.log
-
-  file delete -force $PDFLOG
-  file delete -force $DOXYLOG
-  
   # Start main activities
   if { $GEN_MODE != "PDF_ONLY" } {
-    OCCDoc_Main $DOC_TYPE $DOCFILES $MODULES $GEN_MODE $VERB_MODE $SEARCH_MODE $MATHJAX_LOCATION $GENERATE_PRODUCTS_REFMAN $DOXYGEN_PATH $GRAPHVIZ_PATH $INKSCAPE_PATH $HHC_PATH
+    if { [OCCDoc_GetProdRootDir] == ""} {
+      OCCDoc_Main $DOC_TYPE $DOCFILES $MODULES $GEN_MODE $VERB_MODE $SEARCH_MODE $MATHJAX_LOCATION $GENERATE_PRODUCTS_REFMAN $DOXYGEN_PATH $GRAPHVIZ_PATH $INKSCAPE_PATH $HHC_PATH
+    } else {
+      if { $DOC_TYPE == "REFMAN" } {
+        if { $MODULES != "" } {
+          foreach module $MODULES {
+            OCCDoc_Main $DOC_TYPE $DOCFILES $module $GEN_MODE $VERB_MODE $SEARCH_MODE $MATHJAX_LOCATION $GENERATE_PRODUCTS_REFMAN $DOXYGEN_PATH $GRAPHVIZ_PATH $INKSCAPE_PATH $HHC_PATH
+          }
+        } else {
+          OCCDoc_Main $DOC_TYPE $DOCFILES $MODULES $GEN_MODE $VERB_MODE $SEARCH_MODE $MATHJAX_LOCATION $GENERATE_PRODUCTS_REFMAN $DOXYGEN_PATH $GRAPHVIZ_PATH $INKSCAPE_PATH $HHC_PATH
+        }
+      } else {
+        foreach md $DOCFILES {
+          OCCDoc_Main $DOC_TYPE $md $MODULES $GEN_MODE $VERB_MODE $SEARCH_MODE $MATHJAX_LOCATION $GENERATE_PRODUCTS_REFMAN $DOXYGEN_PATH $GRAPHVIZ_PATH $INKSCAPE_PATH $HHC_PATH
+        }
+      }
+    }
   } else {
-    puts "Generating OCCT User Guides in PDF format...\n"
+    puts "Generating OCCT User Guides in PDF format..."
     foreach pdf $DOCFILES {
 
-      puts "Info: Processing file $pdf\n"
+      puts "\nInfo: Processing file $pdf"
 
       # Some values are hardcoded because they are related only to PDF generation
       OCCDoc_Main "OVERVIEW" [list $pdf] {} "PDF_ONLY" $VERB_MODE "none" $MATHJAX_LOCATION "NO" $DOXYGEN_PATH $GRAPHVIZ_PATH $INKSCAPE_PATH $HHC_PATH
     }
-    puts "[clock format [clock seconds] -format {%Y-%m-%d %H:%M}] Generation completed."
-    puts "\nPDF files are generated in \n[file normalize [OCCDoc_GetRootDir]/doc/pdf]"
+    puts "\n[clock format [clock seconds] -format {%Y-%m-%d %H:%M}] Generation completed."
   }
 }
 
@@ -333,12 +341,7 @@ proc OCCDoc_Main {docType {docfiles {}} {modules {}} generatorMode verboseMode s
   global available_docfiles
   global available_pdf
 
-  set PRODPATH   ""
-  if { [string compare -nocase $generateProductsRefman "YES"] == 0 } {
-    set PRODPATH "$::env(PRODROOT)"
-  }
-
-  set ROOTDIR    [OCCDoc_GetRootDir $PRODPATH]
+  set ROOTDIR    [OCCDoc_GetRootDir [OCCDoc_GetProdRootDir]]
   set INDIR      [OCCDoc_GetDoxDir]
   set OUTDIR     $ROOTDIR/doc
   set PDFDIR     $OUTDIR/pdf
@@ -348,7 +351,29 @@ proc OCCDoc_Main {docType {docfiles {}} {modules {}} generatorMode verboseMode s
   set HTMLDIR    $OUTDIR/overview/html
   set LATEXDIR   $OUTDIR/overview/latex
   set DOXYFILE   $OUTDIR/OCCT.cfg
- 
+
+  # OUTDIR for products documentation should be separate directories for each components
+  if { [OCCDoc_GetProdRootDir] != ""} {
+    if { $docType == "REFMAN" } {
+      if { "$modules" != "" } {
+        source "[OCCDoc_GetSourceDir [OCCDoc_GetProdRootDir]]/VAS/${modules}.tcl"
+        set doc_component_name [${modules}:documentation_name]
+        set OUTDIR     $OUTDIR/$doc_component_name
+      }
+    } else {
+      if {[regexp {([^/]+)/([^/]+)/([^/]+)} $docfiles dump doc_type doc_component doc_name]} {
+        set PDFNAME [file rootname $doc_name]
+        set OUTDIR     $OUTDIR/$doc_component
+      } else {
+        error "Could not parse input path to *.md file: \"${docfiles}\""
+      }
+    }
+    set HTMLDIR    $OUTDIR/html
+    set LATEXDIR   $OUTDIR/latex
+    set DOXYFILE   $OUTDIR/OCCT.cfg
+    set TAGFILEDIR $OUTDIR/refman
+  }
+
   # Create or cleanup the output folders
   if { [string compare -nocase $generateProductsRefman "YES"] != 0 } {
     if { ![file exists $OUTDIR] } {
@@ -357,19 +382,24 @@ proc OCCDoc_Main {docType {docfiles {}} {modules {}} generatorMode verboseMode s
     if { ![file exists $HTMLDIR] } {
       file mkdir $HTMLDIR
     }
-    if { ![file exists $PDFDIR] } {
-      file mkdir $PDFDIR
+    if { [OCCDoc_GetProdRootDir] == ""} {
+      if { ![file exists $PDFDIR] } {
+        file mkdir $PDFDIR
+      }
+      if { ![file exists $UGDIR] } {
+        file mkdir $UGDIR
+      }
+      if { ![file exists $DGDIR] } {
+        file mkdir $DGDIR
+      }
     }
-    if { ![file exists $UGDIR] } {
-      file mkdir $UGDIR
+
+    if { $generatorMode == "PDF_ONLY" } {
+      if { [file exists $LATEXDIR] } {
+        file delete -force $LATEXDIR
+      }
+      file mkdir $LATEXDIR
     }
-    if { ![file exists $DGDIR] } {
-      file mkdir $DGDIR
-    }
-    if { [file exists $LATEXDIR] } {
-      file delete -force $LATEXDIR
-    }
-    file mkdir $LATEXDIR
   }
   if { $docType == "REFMAN" } {
     if { ![file exists $TAGFILEDIR] } {
@@ -397,7 +427,11 @@ proc OCCDoc_Main {docType {docfiles {}} {modules {}} generatorMode verboseMode s
       set DOCDIR "$OUTDIR/refman"
       puts "\nGenerating Open CASCADE Reference Manual\n"
     } elseif { $docType == "OVERVIEW" } {
-      set DOCDIR "$OUTDIR/overview"
+      if { [OCCDoc_GetProdRootDir] == ""} {
+        set DOCDIR "$OUTDIR/overview"
+      } else {
+        set DOCDIR "$OUTDIR"
+      }
       set FORMAT ""
       if { ($generatorMode == "HTML_ONLY") || ($generatorMode == "CHM_ONLY") } {
         if { $generatorMode == "HTML_ONLY" } { 
@@ -416,7 +450,7 @@ proc OCCDoc_Main {docType {docfiles {}} {modules {}} generatorMode verboseMode s
   # Generate Doxyfile
   puts "[clock format [clock seconds] -format {%Y-%m-%d %H:%M}] Generating Doxyfile..."
 
-  if { [OCCDoc_MakeDoxyfile $docType $DOCDIR $TAGFILEDIR $DOXYFILE $generatorMode $docfiles $modules $verboseMode $searchMode $HHC_PATH $mathjax_relative_location $GRAPHVIZ_PATH $PRODPATH] == -1 } {
+  if { [OCCDoc_MakeDoxyfile $docType $DOCDIR $TAGFILEDIR $DOXYFILE $generatorMode $docfiles $modules $verboseMode $searchMode $HHC_PATH $mathjax_relative_location $GRAPHVIZ_PATH [OCCDoc_GetProdRootDir]] == -1 } {
     return -1
   }
 
@@ -424,23 +458,31 @@ proc OCCDoc_Main {docType {docfiles {}} {modules {}} generatorMode verboseMode s
   set starttimestamp [clock format [clock seconds] -format {%Y-%m-%d %H:%M}]
 
   if { ($generatorMode == "HTML_ONLY") || ($docType == "REFMAN") } {
+    set LOGPREFIX "html_"
     puts "$starttimestamp Generating HTML files..."
 
     # Copy index file to provide fast access to HTML documentation
     file copy -force $INDIR/resources/index.html $DOCDIR/index.html
   } elseif { $generatorMode == "CHM_ONLY" } {
+    set LOGPREFIX "chm_"
     puts "$starttimestamp Generating CHM file..."
   } elseif { $generatorMode == "PDF_ONLY" } {
+    set LOGPREFIX "[file rootname [file tail [lindex $docfiles 0]]]_"
     puts "$starttimestamp Generating PDF file..."
   }
 
-  set DOXYLOG $OUTDIR/doxygen_warnings_and_errors.log
-  set RESULT [catch {exec $DOXYGEN_PATH $DOXYFILE >> $OUTDIR/doxygen_out.log} DOX_ERROR] 
+  # Clean logfiles  
+  set DOXYLOG $OUTDIR/${LOGPREFIX}doxygen_err.log
+  set DOXYOUT $OUTDIR/${LOGPREFIX}doxygen_out.log
+  file delete -force $DOXYLOG
+  file delete -force $DOXYOUT
+
+  set RESULT [catch {exec $DOXYGEN_PATH $DOXYFILE >> $DOXYOUT} DOX_ERROR] 
   if {$RESULT != 0} {
     set NbErrors [regexp -all -line {^\s*[^\s]+} $DOX_ERROR]
     if {$NbErrors > 0} {
-      puts "\nWarning: Doxygen reported $NbErrors messages."
-      puts "See log in $DOXYLOG\n"
+      puts "Warning: Doxygen reported $NbErrors messages."
+      puts "See log in $DOXYLOG"
       set DOX_ERROR_FILE [open $DOXYLOG "a"]
       if {$generatorMode == "PDF_ONLY"} {
         puts $DOX_ERROR_FILE "\n===================================================="
@@ -462,7 +504,7 @@ proc OCCDoc_Main {docType {docfiles {}} {modules {}} generatorMode verboseMode s
     if {[OCCDoc_PostProcessor $DOCDIR] == 0} {
       puts "$curtime Generation completed."
       puts "\nInfo: doxygen log file is located in:"
-      puts "$OUTDIR/doxygen_out.log."
+      puts "${DOXYOUT}."
       puts "\nReference Manual is generated in \n$DOCDIR"
     }
   } elseif { $docType == "OVERVIEW" } {
@@ -529,25 +571,29 @@ proc OCCDoc_Main {docType {docfiles {}} {modules {}} generatorMode verboseMode s
             puts "Info: Executing $LATEXDIR/Makefile..."
           }
         }
-        set PDFLOG $OUTDIR/pdflatex_warnings_and_errors.log
+
+        set PDFLOG $OUTDIR/${LOGPREFIX}pdflatex_err.log
+        set PDFOUT $OUTDIR/${LOGPREFIX}pdflatex_out.log
+        file delete -force $PDFLOG
+        file delete -force $PDFOUT
 
         if {"$is_win" == "yes"} {
-          set RESULT [catch {eval exec [auto_execok $LATEXDIR/make.bat] >> "$OUTDIR/pdflatex_out.log"} LaTeX_ERROR]
+          set RESULT [catch {eval exec [auto_execok $LATEXDIR/make.bat] >> "$PDFOUT"} LaTeX_ERROR]
         } else {
-          set RESULT [catch {eval exec "make -f $LATEXDIR/Makefile" >> "$OUTDIR/pdflatex_out.log"} LaTeX_ERROR]
+          set RESULT [catch {eval exec "make -f $LATEXDIR/Makefile" >> "$PDFOUT"} LaTeX_ERROR]
 
           # Small workaround for *nix stations
           set prev_loc [pwd]
           cd $LATEXDIR
-          set RESULT [catch {eval exec "pdflatex refman.tex" >> "$OUTDIR/pdflatex_out.log"} LaTeX_ERROR]
+          set RESULT [catch {eval exec "pdflatex refman.tex" >> "$PDFOUT"} LaTeX_ERROR]
           cd $prev_loc
         }
 
         if {$RESULT != 0} {
           set NbErrors [regexp -all -line {^\s*[^\s]+} $LaTeX_ERROR]
           if {$NbErrors > 0} {
-            puts "\nWarning: PDFLaTeX reported $NbErrors messages.\nSee log in $PDFLOG\n"
-            set LaTeX_ERROR_FILE [open $PDFLOG "a"]
+            puts "Warning: PDFLaTeX reported $NbErrors messages.\nSee log in $PDFLOG"
+            set LaTeX_ERROR_FILE [open $PDFLOG "a+"]
             puts $LaTeX_ERROR_FILE "\n===================================================="
             puts $LaTeX_ERROR_FILE "Logfile of file $TEX:"
             puts $LaTeX_ERROR_FILE "====================================================\n"
@@ -564,32 +610,38 @@ proc OCCDoc_Main {docType {docfiles {}} {modules {}} generatorMode verboseMode s
 
         set destFolder $PDFDIR
         set parsed_string [split $TEX "_"]
-        if { [lsearch $parsed_string "tutorial"] != -1 } {
-          set TEX [string map [list occt__ occt_] $TEX]
-          set destFolder $PDFDIR
-        } elseif { [lsearch $parsed_string "user"] != -1 } {
-          set TEX [string map [list user_guides__ ""] $TEX]
-          set destFolder $UGDIR
-        } elseif { [lsearch $parsed_string "dev"]  != -1 } {
-          set TEX [string map [list dev_guides__ ""] $TEX]
-          set destFolder $DGDIR
+        if { [OCCDoc_GetProdRootDir] == ""} {
+          if { [lsearch $parsed_string "tutorial"] != -1 } {
+            set TEX [string map [list occt__ occt_] $TEX]
+            set destFolder $PDFDIR
+          } elseif { [lsearch $parsed_string "user"] != -1 } {
+            set TEX [string map [list user_guides__ ""] $TEX]
+            set destFolder $UGDIR
+          } elseif { [lsearch $parsed_string "dev"]  != -1 } {
+            set TEX [string map [list dev_guides__ ""] $TEX]
+            set destFolder $DGDIR
+          }
+        } else {
+          set destFolder $OUTDIR
+          set TEX "$PDFNAME"
         }
         file rename -force $LATEXDIR/refman.pdf "$destFolder/$TEX.pdf"
-
+        puts "Generated $destFolder/$TEX.pdf"
       }
     } elseif { $generatorMode == "CHM_ONLY" } {
-      file rename  $OUTDIR/overview.chm $OUTDIR/occt_overview.chm
+      if { [OCCDoc_GetProdRootDir] == ""} {
+        file rename $OUTDIR/overview.chm $OUTDIR/occt_overview.chm
+      } else {
+        file rename -force $ROOTDIR/doc/overview.chm $OUTDIR/occt_overview.chm
+      }
     }
     cd $INDIR
 
     if { $generatorMode == "HTML_ONLY" } {
-      puts "\nHTML documentation is generated in \n$DOCDIR"
+      puts "HTML documentation is generated in \n$DOCDIR"
+    } elseif { $generatorMode == "CHM_ONLY" } {
+      puts "Generated CHM documentation is in \n$OUTDIR/overview.chm"
     }
-    if { $generatorMode == "CHM_ONLY" } {
-      puts "\nGenerated CHM documentation is in \n$OUTDIR/overview.chm"
-    }
-
-    puts ""
   }
 
   # Remove temporary Doxygen files
@@ -597,14 +649,15 @@ proc OCCDoc_Main {docType {docfiles {}} {modules {}} generatorMode verboseMode s
   foreach file $deleteList {
     file delete $file
   }
+
   return 0
 }
 
 # Generates Doxygen configuration file for Overview documentation
 proc OCCDoc_MakeDoxyfile {docType outDir tagFileDir {doxyFileName} {generatorMode ""} {DocFilesList {}} {ModulesList {}} verboseMode searchMode hhcPath mathjaxLocation graphvizPath productsPath} {
+  set inputDir      [OCCDoc_GetDoxDir [OCCDoc_GetProdRootDir]]
 
-  set inputDir      [OCCDoc_GetDoxDir]
-  set TEMPLATES_DIR $inputDir/resources
+  set TEMPLATES_DIR [OCCDoc_GetDoxDir]/resources
   set occt_version  [OCCDoc_DetectCasVersion]
 
   # Delete existent doxyfile
@@ -751,10 +804,10 @@ proc OCCDoc_MakeDoxyfile {docType outDir tagFileDir {doxyFileName} {generatorMod
     # Add common options for generation of Overview and User Guides
     puts $doxyFile "PROJECT_NUMBER         = $occt_version"
     puts $doxyFile "OUTPUT_DIRECTORY       = $outDir/."
-    puts $doxyFile "PROJECT_LOGO           = $inputDir/resources/occ_logo.png"
+    puts $doxyFile "PROJECT_LOGO           = [OCCDoc_GetDoxDir]/resources/occ_logo.png"
 
     set PARAM_INPUT "INPUT                 ="
-    set PARAM_IMAGEPATH "IMAGE_PATH        = $inputDir/resources/ "
+    set PARAM_IMAGEPATH "IMAGE_PATH        = [OCCDoc_GetDoxDir]/resources/ "
     foreach docFile $DocFilesList {
       set NEW_IMG_PATH "$inputDir/$docFile"
       if { [string compare $NEW_IMG_PATH [OCCDoc_GetRootDir $productsPath]] != 0 } {

adm/genproj.tcl

@@ -108,17 +108,163 @@ proc osutils:findSrcSubPath {theSubPath} {
   return "$::THE_CASROOT/src/$theSubPath"
 }
 
+# Auxiliary tool comparing content of two files line-by-line.
+proc osutils:isEqualContent { theContent1 theContent2 } {
+  set aLen1 [llength $theContent1]
+  set aLen2 [llength $theContent2]
+  if { $aLen1 != $aLen2 } {
+    return false
+  }
+
+  for {set aLineIter 0} {$aLineIter < $aLen1} {incr aLineIter} {
+    set aLine1 [lindex $theContent1 $aLineIter]
+    set aLine2 [lindex $theContent2 $aLineIter]
+    if { $aLine1 != $aLine2 } {
+      return false
+    }
+  }
+  return true
+}
+
+# Auxiliary function for writing new file content only if it has been actually changed
+# (e.g. to preserve file timestamp on no change).
+# Useful for automatically (re)generated files.
+proc osutils:writeTextFile { theFile theContent {theEol lf} } {
+  if {[file exists "${theFile}"]} {
+    set aFileOld [open "${theFile}" rb]
+    fconfigure $aFileOld -translation crlf
+    set aLineListOld [split [read $aFileOld] "\n"]
+    close $aFileOld
+
+    # append empty line for proper comparison (which will be implicitly added by last puts below)
+    set aContent $theContent
+    lappend aContent ""
+    if { [osutils:isEqualContent $aLineListOld $aContent] == true } {
+      return false
+    }
+
+    file delete -force "${theFile}"
+  }
+
+  set anOutFile [open "$theFile" "w"]
+  fconfigure $anOutFile -translation $theEol
+  foreach aLine ${theContent} {
+    puts $anOutFile "${aLine}"
+  }
+  close $anOutFile
+  return true
+}
+
+# Function re-generating header files for specified text resource
+proc genResources { theResource } {
+  global path
+
+  set aResFileList {}
+  set aResourceAbsPath [file normalize "${path}/src/${theResource}"]
+  set aResourceDirectory ""
+  set isResDirectory false
+
+  if {[file isdirectory "${aResourceAbsPath}"]} {
+    if {[file exists "${aResourceAbsPath}/FILES"]} {
+      set aFilesFile [open "${aResourceAbsPath}/FILES" rb]
+      set aResFileList [split [read $aFilesFile] "\n"]
+      close $aFilesFile
+    }
+    set aResFileList [lsearch -inline -all -not -exact $aResFileList ""]
+    set aResourceDirectory "${theResource}"
+    set isResDirectory true
+  } else {
+    set aResourceName [file tail "${theResource}"]
+    lappend aResFileList "res:::${aResourceName}"
+    set aResourceDirectory [file dirname "${theResource}"]
+  }
+
+  foreach aResFileIter ${aResFileList} {
+    if {![regexp {^[^:]+:::(.+)} "${aResFileIter}" dump aResFileIter]} {
+	  continue
+	}
+
+    set aResFileName [file tail "${aResFileIter}"]
+    regsub -all {\.} "${aResFileName}" {_} aResFileName
+    set aHeaderFileName "${aResourceDirectory}_${aResFileName}.pxx"
+    if { $isResDirectory == true && [lsearch $aResFileList $aHeaderFileName] == -1 } {
+      continue
+    }
+
+    # generate
+    set aContent {}
+    lappend aContent "// This file has been automatically generated from resource file src/${aResourceDirectory}/${aResFileIter}"
+	lappend aContent ""
+
+    # generate necessary structures
+    set aLineList {}
+    if {[file exists "${path}/src/${aResourceDirectory}/${aResFileIter}"]} {
+      set anInputFile [open "${path}/src/${aResourceDirectory}/${aResFileIter}" rb]
+      fconfigure $anInputFile -translation crlf
+      set aLineList [split [read $anInputFile] "\n"]
+      close $anInputFile
+    }
+
+    # drop empty trailing line
+    set anEndOfFile ""
+    if { [lindex $aLineList end] == "" } {
+      set aLineList [lreplace $aLineList end end]
+      set anEndOfFile "\\n"
+    }
+
+    lappend aContent "static const char ${aResourceDirectory}_${aResFileName}\[\] ="
+    set aNbLines  [llength $aLineList]
+    set aLastLine [expr $aNbLines - 1]
+    for {set aLineIter 0} {$aLineIter < $aNbLines} {incr aLineIter} {
+      set aLine [lindex $aLineList $aLineIter]
+      regsub -all {\"} "${aLine}" {\\"} aLine
+      if { $aLineIter == $aLastLine } {
+        lappend aContent "  \"${aLine}${anEndOfFile}\";"
+      } else {
+        lappend aContent "  \"${aLine}\\n\""
+      }
+    }
+
+    # Save generated content to header file
+    set aHeaderFilePath "${path}/src/${aResourceDirectory}/${aHeaderFileName}"
+    if { [osutils:writeTextFile $aHeaderFilePath $aContent] == true } {
+      puts "Generating header file from resource file: ${path}/src/${aResourceDirectory}/${aResFileIter}"
+    } else {
+	  #puts "Header file from resource ${path}/src/${aResourceDirectory}/${aResFileIter} is up-to-date"
+    }
+  }
+}
+
+# Function re-generating header files for all text resources
+proc genAllResources {} {
+  global path
+  set aCasRoot [file normalize $path]
+  if {![file exists "$aCasRoot/adm/RESOURCES"]} {
+    puts "OCCT directory is not defined correctly: $aCasRoot"
+    return
+  }
+
+  set aFileResources [open "$aCasRoot/adm/RESOURCES" rb]
+  set anAdmResources [split [read $aFileResources] "\r\n"]
+  close $aFileResources
+  set anAdmResources [lsearch -inline -all -not -exact $anAdmResources ""]
+
+  foreach line $anAdmResources {
+    genResources "${line}"
+  }
+}
+
 # Wrapper-function to generate VS project files
-proc genproj {theIDE args} {
-  set aSupportedIDEs { "vc7" "vc8" "vc9" "vc10" "vc11" "vc12" "vc14" "cbp" "xcd" }
-  set aSupportedPlatforms { "wnt" "lin" "mac" "ios" "qnx" }
+proc genproj {theFormat args} {
+  set aSupportedFormats { "vc7" "vc8" "vc9" "vc10" "vc11" "vc12" "vc14" "vc141" "cbp" "xcd"}
+  set aSupportedPlatforms { "wnt" "uwp" "lin" "mac" "ios" "qnx" }
   set isHelpRequire false
 
-  # check IDE argument
-  if { $theIDE == "-h" || $theIDE == "-help" || $theIDE == "--help" } {
+  # check format argument
+  if { $theFormat == "-h" || $theFormat == "-help" || $theFormat == "--help" } {
     set isHelpRequire true
-  } elseif { [lsearch -exact $aSupportedIDEs $theIDE] < 0 } {
-    puts "Error: genproj: unrecognized IDE \"$theIDE\""
+  } elseif { [lsearch -exact $aSupportedFormats $theFormat] < 0 } {
+    puts "Error: genproj: unrecognized project format \"$theFormat\""
     set isHelpRequire true
   }
 
@@ -126,9 +272,9 @@ proc genproj {theIDE args} {
   set aCmpl "gcc"
 
   # Determine default platform: wnt for vc*, mac for xcd, current for cbp
-  if { [regexp "^vc" $theIDE] } {
+  if { [regexp "^vc" $theFormat] } {
     set aPlatform "wnt"
-  } elseif { $theIDE == "xcd" || $::tcl_platform(os) == "Darwin" } {
+  } elseif { $theFormat == "xcd" || $::tcl_platform(os) == "Darwin" } {
     set aPlatform "mac"
   } elseif { $::tcl_platform(platform) == "windows" } {
     set aPlatform "wnt"
@@ -156,20 +302,22 @@ proc genproj {theIDE args} {
   }
 
   if {  $isHelpRequire == true } {
-    puts "usage: genproj IDE \[Platform\] \[-static\] \[-h|-help|--help\]
+    puts "usage: genproj Format \[Platform\] \[-static\] \[-h|-help|--help\]
 
-    IDE must be one of:
-      vc8   -  Visual Studio 2005
-      vc9   -  Visual Studio 2008
-      vc10  -  Visual Studio 2010
-      vc11  -  Visual Studio 2012
-      vc12  -  Visual Studio 2013
-      vc14  -  Visual Studio 2015
-      cbp   -  CodeBlocks
-      xcd   -  XCode
+    Format must be one of:
+      vc8      -  Visual Studio 2005
+      vc9      -  Visual Studio 2008
+      vc10     -  Visual Studio 2010
+      vc11     -  Visual Studio 2012
+      vc12     -  Visual Studio 2013
+      vc14     -  Visual Studio 2015
+      vc141    -  Visual Studio 2017
+      cbp      -  CodeBlocks
+      xcd      -  XCode
 
-    Platform (optional, only for CodeBlocks and XCode):
-      wnt   -  Windows
+    Platform (optional):
+      wnt   -  Windows Desktop
+      uwp   -  Universal Windows Platform
       lin   -  Linux
       mac   -  OS X
       ios   -  iOS
@@ -185,23 +333,24 @@ proc genproj {theIDE args} {
     return
   }
 
-  puts "Preparing to generate $theIDE projects for $aPlatform platform..."
+  puts "Preparing to generate $theFormat projects for $aPlatform platform..."
 
-  # path to where to generate projects, hardcoded from current dir
+  # base path to where to generate projects, hardcoded from current dir
   set anAdmPath [file normalize "${::path}/adm"]
 
-  OS:MKPRC "$anAdmPath" "$theIDE" "$aLibType" "$aPlatform" "$aCmpl"
+  OS:MKPRC "$anAdmPath" "$theFormat" "$aLibType" "$aPlatform" "$aCmpl"
 
-  genprojbat "$theIDE" $aPlatform
+  genprojbat "$theFormat" "$aPlatform"
+  genAllResources
 }
 
-proc genprojbat {theIDE thePlatform} {
+proc genprojbat {theFormat thePlatform} {
   set aTargetPlatformExt sh
-  if { $thePlatform == "wnt" } {
+  if { $thePlatform == "wnt" || $thePlatform == "uwp" } {
     set aTargetPlatformExt bat
   }
 
-  if {"$theIDE" != "cmake"} {
+  if {"$theFormat" != "cmake"} {
     # copy env.bat/sh only if not yet present
     if { ! [file exists "$::path/env.${aTargetPlatformExt}"] } {
       set anEnvTmplFile [open "$::THE_CASROOT/adm/templates/env.${aTargetPlatformExt}" "r"]
@@ -223,10 +372,10 @@ proc genprojbat {theIDE thePlatform} {
     file copy -force -- "$::THE_CASROOT/adm/templates/draw.${aTargetPlatformExt}" "$::path/draw.${aTargetPlatformExt}"
   }
 
-  if {[regexp {(vc)[0-9]*$} $theIDE] == 1} {
+  if { [regexp {^vc} $theFormat] } {
     file copy -force -- "$::THE_CASROOT/adm/templates/msvc.bat" "$::path/msvc.bat"
   } else {
-    switch -exact -- "$theIDE" {
+    switch -exact -- "$theFormat" {
       "cbp"   {
         file copy -force -- "$::THE_CASROOT/adm/templates/codeblocks.sh"  "$::path/codeblocks.sh"
         file copy -force -- "$::THE_CASROOT/adm/templates/codeblocks.bat" "$::path/codeblocks.bat"
@@ -251,13 +400,13 @@ proc removeAllOccurrencesOf { theObject theList } {
 set aTKNullKey "TKNull"
 set THE_GUIDS_LIST($aTKNullKey) "{00000000-0000-0000-0000-000000000000}"
 
-# Entry function to generate project files and solutions for IDE
+# Entry function to generate project files
 # @param theOutDir   Root directory for project files
-# @param theIDE      IDE code name (vc10 for Visual Studio 2010, cbp for Code::Blocks, xcd for XCode)
+# @param theFormat   Project format name (vc.. for Visual Studio projects, cbp for Code::Blocks, xcd for XCode)
 # @param theLibType  Library type - dynamic or static
 # @param thePlatform Optional target platform for cross-compiling, e.g. ios for iOS
 # @param theCmpl     Compiler option (msvc or gcc)
-proc OS:MKPRC { theOutDir theIDE theLibType thePlatform theCmpl } {
+proc OS:MKPRC { theOutDir theFormat theLibType thePlatform theCmpl } {
   global path
   set anOutRoot $theOutDir
   if { $anOutRoot == "" } {
@@ -266,14 +415,19 @@ proc OS:MKPRC { theOutDir theIDE theLibType thePlatform theCmpl } {
 
   # Create output directory
   set aWokStation "$thePlatform"
-  if { [lsearch -exact {vc7 vc8 vc9 vc10 vc11 vc12 vc14} $theIDE] != -1 } {
+  if { [regexp {^vc} $theFormat] } {
     set aWokStation "msvc"
   }
-
-  set anOutDir "${anOutRoot}/${aWokStation}/${theIDE}"
+  set aSuffix ""
+  set isUWP 0
+  if { $thePlatform == "uwp" } {
+    set aSuffix "-uwp"
+    set isUWP 1
+  }
+  set anOutDir "${anOutRoot}/${aWokStation}/${theFormat}${aSuffix}"
 
   # read map of already generated GUIDs
-  set aGuidsFilePath [file join $anOutDir "wok_${theIDE}_guids.txt"]
+  set aGuidsFilePath [file join $anOutDir "wok_${theFormat}_guids.txt"]
   if [file exists "$aGuidsFilePath"] {
     set aFileIn [open "$aGuidsFilePath" r]
     set aFileDataRaw [read $aFileIn]
@@ -294,6 +448,14 @@ proc OS:MKPRC { theOutDir theIDE theLibType thePlatform theCmpl } {
     set aModules [osutils:juststation $goaway $aModules]
   }
 
+  # Draw module is turned off due to it is not supported on UWP
+  if { $isUWP } {
+    set aDrawIndex [lsearch -exact ${aModules} "Draw"]
+    if { ${aDrawIndex} != -1 } {
+      set aModules [lreplace ${aModules} ${aDrawIndex} ${aDrawIndex}]
+    }
+  }
+
   # generate one solution for all projects if complete OS or VAS is processed
   set anAllSolution "OCCT"
 
@@ -313,17 +475,18 @@ proc OS:MKPRC { theOutDir theIDE theLibType thePlatform theCmpl } {
   puts "Collecting required header files into $path/inc ..."
   osutils:collectinc $aModules $path/inc
 
-  # Generating project files for the selected IDE
-  switch -exact -- "$theIDE" {
+  # Generating project files for the selected format
+  switch -exact -- "$theFormat" {
     "vc7"   -
     "vc8"   -
     "vc9"   -
-    "vc10"   -
-    "vc11"   -
-    "vc12"   -
-    "vc14"  { OS:MKVC  $anOutDir $aModules $anAllSolution $theIDE }
-    "cbp"   { OS:MKCBP $anOutDir $aModules $anAllSolution $thePlatform $theCmpl }
-    "xcd"   {
+    "vc10"  -
+    "vc11"  -
+    "vc12"  -
+    "vc14"  -
+    "vc141"    { OS:MKVC  $anOutDir $aModules $anAllSolution $theFormat $isUWP}
+    "cbp"      { OS:MKCBP $anOutDir $aModules $anAllSolution $thePlatform $theCmpl }
+    "xcd"      {
       set ::THE_GUIDS_LIST($::aTKNullKey) "000000000000000000000000"
       OS:MKXCD $anOutDir $aModules $anAllSolution $theLibType $thePlatform
     }
@@ -340,14 +503,14 @@ proc OS:MKPRC { theOutDir theIDE theLibType thePlatform theCmpl } {
 }
 
 # Function to generate Visual Studio solution and project files
-proc OS:MKVC { theOutDir {theModules {}} {theAllSolution ""} {theVcVer "vc8"} } {
+proc OS:MKVC { theOutDir theModules theAllSolution theVcVer isUWP } {
 
   puts stderr "Generating VS project files for $theVcVer"
 
   # generate projects for toolkits and separate solution for each module
   foreach aModule $theModules {
     OS:vcsolution $theVcVer $aModule $aModule $theOutDir ::THE_GUIDS_LIST
-    OS:vcproj     $theVcVer $aModule          $theOutDir ::THE_GUIDS_LIST
+    OS:vcproj     $theVcVer $isUWP   $aModule $theOutDir ::THE_GUIDS_LIST
   }
 
   # generate single solution "OCCT" containing projects from all modules
@@ -592,8 +755,8 @@ proc LocateRecur {theName} {
   return ""
 }
 
-proc OS:genGUID { {theIDE "vc"} } {
-  if { "$theIDE" == "vc" } {
+proc OS:genGUID { {theFormat "vc"} } {
+  if { "$theFormat" == "vc" } {
     set p1 "[format %07X [expr { int(rand() * 268435456) }]][format %X [expr { int(rand() * 16) }]]"
     set p2 "[format %04X [expr { int(rand() * 6536) }]]"
     set p3 "[format %04X [expr { int(rand() * 6536) }]]"
@@ -659,6 +822,7 @@ proc osutils:collectinc {theModules theIncPath} {
     }
   }
 
+  set allHeaderFiles {}
   if { $aCopyType == "shortcut" } {
     # template preparation
     if { ![file exists $::THE_CASROOT/adm/templates/header.in] } {
@@ -672,11 +836,14 @@ proc osutils:collectinc {theModules theIncPath} {
 
     # create and copy short-cut header files
     foreach anUnit $anUnits {
-      set aHFiles [glob -nocomplain -dir $aCasRoot/src/$anUnit "*.h"]
-      foreach aHeaderFile [concat [glob -nocomplain -dir $aCasRoot/src/$anUnit "*.\[hgl\]xx"] $aHFiles] {
-        set aHeaderFileName [file tail $aHeaderFile]
+      osutils:checksrcfiles ${anUnit}
 
-        regsub -all -- {@OCCT_HEADER_FILE@} $aHeaderTmpl "$aFromBuildIncToSrcPath/$anUnit/$aHeaderFileName" aShortCutHeaderFileContent
+      set aHFiles [_get_used_files ${anUnit} true false]
+      foreach aHeaderFile ${aHFiles} {
+        set aHeaderFileName [lindex ${aHeaderFile} 1]
+        lappend allHeaderFiles "${aHeaderFileName}"
+
+        regsub -all -- {@OCCT_HEADER_FILE_CONTENT@} $aHeaderTmpl "#include \"$aFromBuildIncToSrcPath/$anUnit/$aHeaderFileName\"" aShortCutHeaderFileContent
 
         if {[file exists "$theIncPath/$aHeaderFileName"] && [file readable "$theIncPath/$aHeaderFileName"]} {
           set fp [open "$theIncPath/$aHeaderFileName" r]
@@ -706,12 +873,15 @@ proc osutils:collectinc {theModules theIncPath} {
   } else {
     set nbcopied 0
     foreach anUnit $anUnits {
-      set aHFiles [glob -nocomplain -dir $aCasRoot/src/$anUnit "*.h"]
-      foreach aHeaderFile [concat [glob -nocomplain -dir $aCasRoot/src/$anUnit "*.\[hgl\]xx"] $aHFiles] {
-        set aHeaderFileName [file tail $aHeaderFile]
+      osutils:checksrcfiles ${anUnit}
+
+      set aHFiles [_get_used_files ${anUnit} true false]
+      foreach aHeaderFile ${aHFiles} {
+        set aHeaderFileName [lindex ${aHeaderFile} 1]
+        lappend allHeaderFiles "${aHeaderFileName}"
 
         # copy file only if target does not exist or is older than original
-        set torig [file mtime $aHeaderFile]
+        set torig [file mtime $aCasRoot/src/$anUnit/$aHeaderFileName]
         set tcopy 0
         if { [file isfile $anIncPath/$aHeaderFileName] } {
           set tcopy [file mtime $anIncPath/$aHeaderFileName]
@@ -722,17 +892,26 @@ proc osutils:collectinc {theModules theIncPath} {
             if { $tcopy != 0 } {
               file delete -force "$theIncPath/$aHeaderFileName"
             }
-            file link -hard  $anIncPath/$aHeaderFileName $aHeaderFile
+            file link -hard  $anIncPath/$aHeaderFileName $aCasRoot/src/$anUnit/$aHeaderFileName
           } else {
-            file copy -force $aHeaderFile $anIncPath/$aHeaderFileName
+            file copy -force $aCasRoot/src/$anUnit/$aHeaderFileName $anIncPath/$aHeaderFileName
           }
         } elseif { $tcopy != $torig } {
-          puts "Warning: file $anIncPath/$aHeaderFileName is newer than $aHeaderFile, not changed!"
+          puts "Warning: file $anIncPath/$aHeaderFileName is newer than $aCasRoot/src/$anUnit/$aHeaderFileName, not changed!"
         }
       }
     }
     puts "Info: $nbcopied files updated"
   }
+
+  # remove header files not listed in FILES
+  set anIncFiles [glob -tails -nocomplain -dir ${anIncPath} "*"]
+  foreach anIncFile ${anIncFiles} {
+    if { [lsearch -exact ${allHeaderFiles} ${anIncFile}] == -1 } {
+      puts "Warning: file ${anIncPath}/${anIncFile} is not presented in the sources and will be removed from ${theIncPath}!"
+      file delete -force "${theIncPath}/${anIncFile}"
+    }
+  }
 }
 
 # Generate header for VS solution file
@@ -758,9 +937,9 @@ proc osutils:vcsolution:header { vcversion } {
       "# Visual Studio 2012\n"
   } elseif { "$vcversion" == "vc12" } {
     append var \
-      "Microsoft Visual Studio Solution File, Format Version 13.00\n" \
+      "Microsoft Visual Studio Solution File, Format Version 12.00\n" \
       "# Visual Studio 2013\n"
-  } elseif { "$vcversion" == "vc14" } {
+  } elseif { "$vcversion" == "vc14"  || "$vcversion" == "vc141"} {
     append var \
       "Microsoft Visual Studio Solution File, Format Version 12.00\n" \
       "# Visual Studio 14\n"
@@ -969,47 +1148,84 @@ proc OS:vcsolution { theVcVer theSolName theModules theOutDir theGuidsMap } {
 }
 # Generate Visual Studio projects for specified version
 
-proc OS:vcproj { theVcVer theModules theOutDir theGuidsMap } {
+proc OS:vcproj { theVcVer isUWP theModules theOutDir theGuidsMap } {
   upvar $theGuidsMap aGuidsMap
 
   set aProjectFiles {}
 
   foreach aModule $theModules {
     foreach aToolKit [${aModule}:toolkits] {
-      lappend aProjectFiles [osutils:vcproj  $theVcVer $theOutDir $aToolKit     aGuidsMap]
+      lappend aProjectFiles [osutils:vcproj  $theVcVer $isUWP $theOutDir $aToolKit     aGuidsMap]
     }
     foreach anExecutable [OS:executable ${aModule}] {
-      lappend aProjectFiles [osutils:vcprojx $theVcVer $theOutDir $anExecutable aGuidsMap]
+      lappend aProjectFiles [osutils:vcprojx $theVcVer $isUWP $theOutDir $anExecutable aGuidsMap]
     }
   }
   return $aProjectFiles
 }
 # generate template name and load it for given version of Visual Studio and platform
 
-proc osutils:vcproj:readtemplate {theVcVer isexec} {
+proc osutils:vcproj:readtemplate {theVcVer isUWP isExec} {
   set anExt $theVcVer
   if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
     set anExt vc10
   }
 
+  # determine versions of runtime and toolset
+  set aVCRTVer $theVcVer 
+  set aToolset "v[string range $theVcVer 2 3]0"
+  if { $theVcVer == "vc141" } {
+    set aVCRTVer "vc14"
+    set aToolset "v141"
+  }
+
   set what "$theVcVer"
-  set aVerExt [string range $theVcVer 2 end]
-  set aVerExt "v${aVerExt}0"
   set aCmpl32 ""
   set aCmpl64 ""
-  if { $isexec } {
+  set aCharSet "Unicode"
+  if { $isExec } {
     set anExt "${anExt}x"
     set what "$what executable"
   }
   if { "$theVcVer" == "vc10" } {
     # SSE2 is enabled by default in vc11+, but not in vc10 for 32-bit target
-    set aCmpl32 "\n      <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>"
+    set aCmpl32 "<EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>"
   }
   set aTmpl [osutils:readtemplate $anExt "MS VC++ project ($what)"]
-  regsub -all -- {__VCVER__}    $aTmpl $theVcVer aTmpl
-  regsub -all -- {__VCVEREXT__} $aTmpl $aVerExt  aTmpl
-  regsub -all -- {__VCMPL32__}  $aTmpl $aCmpl32  aTmpl
-  regsub -all -- {__VCMPL64__}  $aTmpl $aCmpl64  aTmpl
+
+  if { $isUWP } {
+    set UwpWinRt "<CompileAsWinRT>false</CompileAsWinRT>"
+    foreach bitness {32 64} {
+      set indent ""
+      if {"[set aCmpl${bitness}]" != ""} {
+        set indent "\n      "
+      }
+      set aCmpl${bitness} "[set aCmpl${bitness}]${indent}${UwpWinRt}"
+    }
+  }
+
+  set format_template "\[\\r\\n\\s\]*"
+  foreach bitness {32 64} {
+    set format_templateloc ""
+    if {"[set aCmpl${bitness}]" == ""} {
+      set format_templateloc "$format_template"
+    }
+    regsub -all -- "${format_templateloc}__VCMPL${bitness}__" $aTmpl "[set aCmpl${bitness}]" aTmpl
+  }
+
+  set aDebugInfo "no"
+  set aReleaseLnk ""
+  if { "$::HAVE_RelWithDebInfo" == "true" } {
+    set aDebugInfo "true"
+    set aReleaseLnk "\n      <OptimizeReferences>true</OptimizeReferences>\n      <EnableCOMDATFolding>true</EnableCOMDATFolding>"
+  }
+
+  regsub -all -- {__VCVER__}     $aTmpl $aVCRTVer aTmpl
+  regsub -all -- {__VCVEREXT__}  $aTmpl $aToolset aTmpl
+  regsub -all -- {__VCCHARSET__} $aTmpl $aCharSet aTmpl
+  regsub -all -- {__VCReleasePDB__} $aTmpl $aDebugInfo aTmpl
+  regsub -all -- "${format_template}__VCLNKREL__" $aTmpl "${aReleaseLnk}" aTmpl
+
   return $aTmpl
 }
 
@@ -1081,6 +1297,9 @@ proc osutils:csfList { theOS theCsfLibsMap theCsfFrmsMap } {
       set aLibsMap(CSF_FreeImagePlus) "freeimage"
     }
   }
+  if { "$::HAVE_FFMPEG" == "true" } {
+    set aLibsMap(CSF_FFmpeg) "avcodec avformat swscale avutil"
+  }
   if { "$::HAVE_GL2PS" == "true" } {
     set aLibsMap(CSF_GL2PS) "gl2ps"
   }
@@ -1094,6 +1313,12 @@ proc osutils:csfList { theOS theCsfLibsMap theCsfFrmsMap } {
       set aLibsMap(CSF_VTK) [osutils:vtkCsf "unix"]
     }
   }
+  if { "$::HAVE_ZLIB" == "true" } {
+    set aLibsMap(CSF_ZLIB) "zlib"
+  }
+  if { "$::HAVE_LIBLZMA" == "true" } {
+    set aLibsMap(CSF_LIBLZMA) "liblzma"
+  }
 
   if { "$theOS" == "wnt" } {
     #  WinAPI libraries
@@ -1104,7 +1329,6 @@ proc osutils:csfList { theOS theCsfLibsMap theCsfFrmsMap } {
     set aLibsMap(CSF_opengl32)     "opengl32"
     set aLibsMap(CSF_wsock32)      "wsock32"
     set aLibsMap(CSF_netapi32)     "netapi32"
-    set aLibsMap(CSF_AviLibs)      "ws2_32 vfw32"
     set aLibsMap(CSF_OpenGlLibs)   "opengl32"
     if { "$::HAVE_GLES2" == "true" } {
       set aLibsMap(CSF_OpenGlLibs) "libEGL libGLESv2"
@@ -1130,6 +1354,7 @@ proc osutils:csfList { theOS theCsfLibsMap theCsfFrmsMap } {
       set aLibsMap(CSF_TclLibs)    ""
       set aFrmsMap(CSF_TclTkLibs)  "Tk"
       set aLibsMap(CSF_TclTkLibs)  ""
+      set aLibsMap(CSF_QT)         "QtCore QtGui"
     } else {
       if { "$theOS" == "qnx" } {
         # CSF_ThreadLibs - pthread API is part of libc on QNX
@@ -1315,7 +1540,7 @@ proc wokUtils:FILES:wtail { f n } {
 }
 
 # Generate entry for one source file in Visual Studio 10 project file
-proc osutils:vcxproj:file { vcversion file params } {
+proc osutils:vcxproj:file { file params } {
   append text "    <ClCompile Include=\"..\\..\\..\\[wokUtils:EASY:bs1 [wokUtils:FILES:wtail $file 3]]\">\n"
   if { $params != "" } {
     append text "      <AdditionalOptions Condition=\"\'\$(Configuration)|\$(Platform)\'==\'Debug|Win32\'\">[string trim ${params}]  %(AdditionalOptions)</AdditionalOptions>\n"
@@ -1441,8 +1666,8 @@ proc osutils:readtemplate:rc {theOutDir theToolKit} {
 }
 
 # Generate Visual Studio project file for ToolKit
-proc osutils:vcproj { theVcVer theOutDir theToolKit theGuidsMap {theProjTmpl {} } } {
-  if { $theProjTmpl == {} } {set theProjTmpl [osutils:vcproj:readtemplate $theVcVer 0]}
+proc osutils:vcproj { theVcVer isUWP theOutDir theToolKit theGuidsMap } {
+  set theProjTmpl [osutils:vcproj:readtemplate $theVcVer $isUWP 0]
 
   set l_compilable [osutils:compilable wnt]
   regsub -all -- {__TKNAM__} $theProjTmpl $theToolKit theProjTmpl
@@ -1453,7 +1678,14 @@ proc osutils:vcproj { theVcVer theOutDir theToolKit theGuidsMap {theProjTmpl {}
   }
   regsub -all -- {__PROJECT_GUID__} $theProjTmpl $aGuidsMap($theToolKit) theProjTmpl
 
+  set theProjTmpl [osutils:uwp:proj $isUWP ${theProjTmpl}]
+
   set aUsedLibs [list]
+
+  if { $isUWP } {
+    lappend aUsedLibs "WindowsApp.lib"
+  }
+
   foreach tkx [osutils:commonUsedTK  $theToolKit] {
     lappend aUsedLibs "${tkx}.lib"
   }
@@ -1465,7 +1697,8 @@ proc osutils:vcproj { theVcVer theOutDir theToolKit theGuidsMap {theProjTmpl {}
 
   # correct names of referred third-party libraries that are named with suffix
   # depending on VC version
-  regsub -all -- {vc[0-9]+} $aUsedLibs $theVcVer aUsedLibs
+  set aVCRTVer [string range $theVcVer 0 3]
+  regsub -all -- {vc[0-9]+} $aUsedLibs $aVCRTVer aUsedLibs
 
   # and put this list to project file
   #puts "$theToolKit requires  $aUsedLibs"
@@ -1519,7 +1752,7 @@ proc osutils:vcproj { theVcVer theOutDir theToolKit theGuidsMap {theProjTmpl {}
       foreach aSrcFile [lsort $aSrcFiles] {
         if { ![info exists written([file tail $aSrcFile])] } {
           set written([file tail $aSrcFile]) 1
-          append aFilesSection [osutils:vcxproj:file $theVcVer $aSrcFile $needparam]
+          append aFilesSection [osutils:vcxproj:file $aSrcFile $needparam]
         } else {
           puts "Warning : in vcproj more than one occurences for [file tail $aSrcFile]"
         }
@@ -1638,14 +1871,11 @@ proc osutils:tk:files { tkloc thePlatform } {
 }
 
 # Generate Visual Studio project file for executable
-proc osutils:vcprojx { theVcVer theOutDir theToolKit theGuidsMap {theProjTmpl {} } } {
+proc osutils:vcprojx { theVcVer isUWP theOutDir theToolKit theGuidsMap } {
   set aVcFiles {}
   foreach f [osutils:tk:files $theToolKit wnt] {
-    if { $theProjTmpl == {} } {
-      set aProjTmpl [osutils:vcproj:readtemplate $theVcVer 1]
-    } else {
-      set aProjTmpl $theProjTmpl
-    }
+    set aProjTmpl [osutils:vcproj:readtemplate $theVcVer $isUWP 1]
+
     set aProjName [file rootname [file tail $f]]
     set l_compilable [osutils:compilable wnt]
     regsub -all -- {__XQTNAM__} $aProjTmpl $aProjName aProjTmpl
@@ -1668,7 +1898,8 @@ proc osutils:vcprojx { theVcVer theOutDir theToolKit theGuidsMap {theProjTmpl {}
 
     # correct names of referred third-party libraries that are named with suffix
     # depending on VC version
-    regsub -all -- {vc[0-9]+} $aUsedLibs $theVcVer aUsedLibs
+    set aVCRTVer [string range $theVcVer 0 3]
+    regsub -all -- {vc[0-9]+} $aUsedLibs $aVCRTVer aUsedLibs
 
 #    puts "$aProjName requires  $aUsedLibs"
     if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
@@ -1683,7 +1914,7 @@ proc osutils:vcprojx { theVcVer theOutDir theToolKit theGuidsMap {theProjTmpl {}
       set written([file tail $f]) 1
 
       if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
-        append aFilesSection [osutils:vcxproj:file $theVcVer $f ""]
+        append aFilesSection [osutils:vcxproj:file $f ""]
         if { ! [info exists aVcFilesX($theToolKit)] } { lappend aVcFilesX(units) $theToolKit }
         lappend aVcFilesX($theToolKit) $f
       } else {
@@ -1728,7 +1959,7 @@ proc osutils:vcprojx { theVcVer theOutDir theToolKit theGuidsMap {theProjTmpl {}
       set aCommonSettingsFileTmpl [wokUtils:FILES:FileToString "$::THE_CASROOT/adm/templates/vcxproj.user.vc10x"]
     }
     if { "$aCommonSettingsFileTmpl" != "" } {
-      regsub -all -- {__VCVER__} $aCommonSettingsFileTmpl $theVcVer aCommonSettingsFileTmpl
+      regsub -all -- {__VCVER__} $aCommonSettingsFileTmpl $aVCRTVer aCommonSettingsFileTmpl
 
       set aFile [open [set aVcFilePath "$aCommonSettingsFile"] w]
       fconfigure $aFile -translation crlf
@@ -1893,7 +2124,7 @@ proc osutils:cbptk { theCmpl theOutDir theToolKit thePlatform} {
     set listloc $theToolKit
   }
 
-  if { $thePlatform == "wnt" } {
+  if { $thePlatform == "wnt" || $thePlatform == "uwp" } {
     set resultloc [osutils:justwnt  $listloc]
   } else {
     set resultloc [osutils:justunix $listloc]
@@ -1912,7 +2143,7 @@ proc osutils:cbptk { theCmpl theOutDir theToolKit thePlatform} {
     }
 
     # macros for correct DLL exports
-    if { $thePlatform == "wnt" } {
+    if { $thePlatform == "wnt" || $thePlatform == "uwp" } {
       lappend aTKDefines "__${xlo}_DLL"
     }
   }
@@ -2031,7 +2262,7 @@ proc osutils:cbpx { theCmpl theOutDir theToolKit thePlatform } {
     }
 
     # macros for correct DLL exports
-    if { $thePlatform == "wnt" } {
+    if { $thePlatform == "wnt" || $thePlatform == "uwp" } {
       lappend aTKDefines "__${theToolKit}_DLL"
     }
 
@@ -2055,7 +2286,6 @@ proc osutils:cbpx { theCmpl theOutDir theToolKit thePlatform } {
 # @param theDefines    - compiler macro definitions
 # @param theIsExe      - flag to indicate executable / library target
 proc osutils:cbp { theCmpl theOutDir theProjName thePlatform theSrcFiles theLibsList theFrameworks theIncPaths theDefines {theIsExe "false"} } {
-  set aWokStation $thePlatform
   set aWokArch    "$::env(ARCH)"
 
   set aCmplCbp "gcc"
@@ -2064,7 +2294,7 @@ proc osutils:cbp { theCmpl theOutDir theProjName thePlatform theSrcFiles theLibs
   set aCmplFlagsDebug   [list]
   set toPassArgsByFile 0
   set aLibPrefix "lib"
-  if { "$aWokStation" == "wnt" || "$aWokStation" == "qnx" } {
+  if { "$thePlatform" == "wnt" || "$thePlatform" == "uwp" || "$thePlatform" == "qnx" } {
     set toPassArgsByFile 1
   }
   if { "$theCmpl" == "msvc" } {
@@ -2079,12 +2309,12 @@ proc osutils:cbp { theCmpl theOutDir theProjName thePlatform theSrcFiles theLibs
     lappend aCmplFlags    "-D_CRT_SECURE_NO_WARNINGS"
     lappend aCmplFlags    "-D_CRT_NONSTDC_NO_DEPRECATE"
   } elseif { "$theCmpl" == "gcc" } {
-    if { "$aWokStation" != "qnx" } {
+    if { "$thePlatform" != "qnx" } {
       set aCmplFlags      "-mmmx -msse -msse2 -mfpmath=sse"
     }
     set aCmplFlagsRelease "-O2"
     set aCmplFlagsDebug   "-O0 -g"
-    if { "$aWokStation" == "wnt" } {
+    if { "$thePlatform" == "wnt" || "$thePlatform" == "uwp" } {
       lappend aCmplFlags "-std=gnu++0x"
       lappend aCmplFlags "-D_WIN32_WINNT=0x0501"
     } else {
@@ -2098,7 +2328,7 @@ proc osutils:cbp { theCmpl theOutDir theProjName thePlatform theSrcFiles theLibs
   lappend aCmplFlagsRelease "-DNDEBUG"
   lappend aCmplFlagsRelease "-DNo_Exception"
   lappend aCmplFlagsDebug   "-D_DEBUG"
-  if { "$aWokStation" == "qnx" } {
+  if { "$thePlatform" == "qnx" } {
     lappend aCmplFlags "-D_QNX_SOURCE"
   }
 
@@ -2120,20 +2350,20 @@ proc osutils:cbp { theCmpl theOutDir theProjName thePlatform theSrcFiles theLibs
   # Release target configuration
   puts $aFile "\t\t\t<Target title=\"Release\">"
   if { "$theIsExe" == "true" } {
-    puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/bin/${theProjName}\" prefix_auto=\"0\" extension_auto=\"0\" />"
+    puts $aFile "\t\t\t\t<Option output=\"../../../${thePlatform}/cbp/bin/${theProjName}\" prefix_auto=\"0\" extension_auto=\"0\" />"
     puts $aFile "\t\t\t\t<Option type=\"1\" />"
   } else {
-    if { "$aWokStation" == "wnt" } {
-      puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/bin/${aLibPrefix}${theProjName}\" imp_lib=\"../../../${aWokStation}/cbp/lib/\$(TARGET_OUTPUT_BASENAME)\" prefix_auto=\"1\" extension_auto=\"1\" />"
+    if { "$thePlatform" == "wnt" || "$thePlatform" == "uwp" } {
+      puts $aFile "\t\t\t\t<Option output=\"../../../${thePlatform}/cbp/bin/${aLibPrefix}${theProjName}\" imp_lib=\"../../../${thePlatform}/cbp/lib/\$(TARGET_OUTPUT_BASENAME)\" prefix_auto=\"1\" extension_auto=\"1\" />"
     } else {
-      puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/lib/lib${theProjName}.so\" prefix_auto=\"0\" extension_auto=\"0\" />"
+      puts $aFile "\t\t\t\t<Option output=\"../../../${thePlatform}/cbp/lib/lib${theProjName}.so\" prefix_auto=\"0\" extension_auto=\"0\" />"
     }
     puts $aFile "\t\t\t\t<Option type=\"3\" />"
   }
-  puts $aFile "\t\t\t\t<Option object_output=\"../../../${aWokStation}/cbp/obj\" />"
+  puts $aFile "\t\t\t\t<Option object_output=\"../../../${thePlatform}/cbp/obj\" />"
   puts $aFile "\t\t\t\t<Option compiler=\"$aCmplCbp\" />"
   puts $aFile "\t\t\t\t<Option createDefFile=\"0\" />"
-  if { "$aWokStation" == "wnt" } {
+  if { "$thePlatform" == "wnt" || "$thePlatform" == "uwp" } {
     puts $aFile "\t\t\t\t<Option createStaticLib=\"1\" />"
   } else {
     puts $aFile "\t\t\t\t<Option createStaticLib=\"0\" />"
@@ -2153,15 +2383,15 @@ proc osutils:cbp { theCmpl theOutDir theProjName thePlatform theSrcFiles theLibs
   if { $toPassArgsByFile == 1 } {
     puts $aFile "\t\t\t\t\t<Add option=\"\@$aLnkFileName\" />"
   }
-  puts $aFile "\t\t\t\t\t<Add directory=\"../../../${aWokStation}/cbp/lib\" />"
-  if { "$aWokStation" == "mac" } {
+  puts $aFile "\t\t\t\t\t<Add directory=\"../../../${thePlatform}/cbp/lib\" />"
+  if { "$thePlatform" == "mac" } {
     if { [ lsearch $theLibsList X11 ] >= 0} {
       puts $aFile "\t\t\t\t\t<Add directory=\"/usr/X11/lib\" />"
     }
   }
   puts $aFile "\t\t\t\t\t<Add option=\"\$(CSF_OPT_LNK${aWokArch})\" />"
-  if { "$aWokStation" == "lin" } {
-    puts $aFile "\t\t\t\t\t<Add option=\"-Wl,-rpath-link=../../../${aWokStation}/cbp/lib\" />"
+  if { "$thePlatform" == "lin" } {
+    puts $aFile "\t\t\t\t\t<Add option=\"-Wl,-rpath-link=../../../${thePlatform}/cbp/lib\" />"
   }
   puts $aFile "\t\t\t\t</Linker>"
 
@@ -2170,20 +2400,20 @@ proc osutils:cbp { theCmpl theOutDir theProjName thePlatform theSrcFiles theLibs
   # Debug target configuration
   puts $aFile "\t\t\t<Target title=\"Debug\">"
   if { "$theIsExe" == "true" } {
-    puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/bind/${theProjName}\" prefix_auto=\"0\" extension_auto=\"0\" />"
+    puts $aFile "\t\t\t\t<Option output=\"../../../${thePlatform}/cbp/bind/${theProjName}\" prefix_auto=\"0\" extension_auto=\"0\" />"
     puts $aFile "\t\t\t\t<Option type=\"1\" />"
   } else {
-    if { "$aWokStation" == "wnt" } {
-      puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/bind/${aLibPrefix}${theProjName}\" imp_lib=\"../../../${aWokStation}/cbp/libd/\$(TARGET_OUTPUT_BASENAME)\" prefix_auto=\"1\" extension_auto=\"1\" />"
+    if { "$thePlatform" == "wnt" || "$thePlatform" == "uwp" } {
+      puts $aFile "\t\t\t\t<Option output=\"../../../${thePlatform}/cbp/bind/${aLibPrefix}${theProjName}\" imp_lib=\"../../../${thePlatform}/cbp/libd/\$(TARGET_OUTPUT_BASENAME)\" prefix_auto=\"1\" extension_auto=\"1\" />"
     } else {
-      puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/libd/lib${theProjName}.so\" prefix_auto=\"0\" extension_auto=\"0\" />"
+      puts $aFile "\t\t\t\t<Option output=\"../../../${thePlatform}/cbp/libd/lib${theProjName}.so\" prefix_auto=\"0\" extension_auto=\"0\" />"
     }
     puts $aFile "\t\t\t\t<Option type=\"3\" />"
   }
-  puts $aFile "\t\t\t\t<Option object_output=\"../../../${aWokStation}/cbp/objd\" />"
+  puts $aFile "\t\t\t\t<Option object_output=\"../../../${thePlatform}/cbp/objd\" />"
   puts $aFile "\t\t\t\t<Option compiler=\"$aCmplCbp\" />"
   puts $aFile "\t\t\t\t<Option createDefFile=\"0\" />"
-  if { "$aWokStation" == "wnt" } {
+  if { "$thePlatform" == "wnt" || "$thePlatform" == "uwp" } {
     puts $aFile "\t\t\t\t<Option createStaticLib=\"1\" />"
   } else {
     puts $aFile "\t\t\t\t<Option createStaticLib=\"0\" />"
@@ -2203,15 +2433,15 @@ proc osutils:cbp { theCmpl theOutDir theProjName thePlatform theSrcFiles theLibs
   if { $toPassArgsByFile == 1 } {
     puts $aFile "\t\t\t\t\t<Add option=\"\@$aLnkDebFileName\" />"
   }
-  puts $aFile "\t\t\t\t\t<Add directory=\"../../../${aWokStation}/cbp/libd\" />"
-  if { "$aWokStation" == "mac" } {
+  puts $aFile "\t\t\t\t\t<Add directory=\"../../../${thePlatform}/cbp/libd\" />"
+  if { "$thePlatform" == "mac" } {
     if { [ lsearch $theLibsList X11 ] >= 0} {
       puts $aFile "\t\t\t\t\t<Add directory=\"/usr/X11/lib\" />"
     }
   }
   puts $aFile "\t\t\t\t\t<Add option=\"\$(CSF_OPT_LNK${aWokArch}D)\" />"
-  if { "$aWokStation" == "lin" } {
-    puts $aFile "\t\t\t\t\t<Add option=\"-Wl,-rpath-link=../../../${aWokStation}/cbp/libd\" />"
+  if { "$thePlatform" == "lin" } {
+    puts $aFile "\t\t\t\t\t<Add option=\"-Wl,-rpath-link=../../../${thePlatform}/cbp/libd\" />"
   }
   puts $aFile "\t\t\t\t</Linker>"
 
@@ -2232,7 +2462,7 @@ proc osutils:cbp { theCmpl theOutDir theProjName thePlatform theSrcFiles theLibs
 
   # COMMON linker options
   puts $aFile "\t\t<Linker>"
-  if { "$aWokStation" == "wnt" && "$theCmpl" == "gcc" } {
+  if { "$thePlatform" == "wnt" && "$theCmpl" == "gcc" } {
     puts $aFile "\t\t\t<Add option=\"-Wl,--export-all-symbols\" />"
   }
   foreach aFrameworkName $theFrameworks {
@@ -2278,8 +2508,8 @@ proc osutils:cbp { theCmpl theOutDir theProjName thePlatform theSrcFiles theLibs
       puts $aFile "\t\t\t<Option link=\"0\" />"
       puts $aFile "\t\t</Unit>"
 
-      set aFileObj  [string map {.cxx .o} [string map [list "/src/" "/$aWokStation/cbp/obj/src/"]  $aSrcFile]]
-      set aFileObjd [string map {.cxx .o} [string map [list "/src/" "/$aWokStation/cbp/objd/src/"] $aSrcFile]]
+      set aFileObj  [string map {.cxx .o} [string map [list "/src/" "/$thePlatform/cbp/obj/src/"]  $aSrcFile]]
+      set aFileObjd [string map {.cxx .o} [string map [list "/src/" "/$thePlatform/cbp/objd/src/"] $aSrcFile]]
       puts -nonewline $aFileLnkObj  "$aFileObj "
       puts -nonewline $aFileLnkObjd "$aFileObjd "
     } else {
@@ -2288,7 +2518,7 @@ proc osutils:cbp { theCmpl theOutDir theProjName thePlatform theSrcFiles theLibs
     }
   }
 
-  if { "$aWokStation" == "wnt" } {
+  if { "$thePlatform" == "wnt" || "$thePlatform" == "uwp" } {
     close $aFileLnkObj
     close $aFileLnkObjd
   }
@@ -2852,12 +3082,12 @@ proc osutils:xcdtk { theOutDir theToolKit theGuidsMap theIsStatic thePlatform {t
   if { "$thePlatform" == "ios" } {
     puts $aPbxprojFile "\t\t\t\t\"ARCHS\[sdk=iphoneos\*\]\" = \"\$(ARCHS_STANDARD)\";";
     puts $aPbxprojFile "\t\t\t\t\"ARCHS\[sdk=iphonesimulator\*\]\" = \"x86_64\";";
-    puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LIBRARY = \"libc++\";"
     puts $aPbxprojFile "\t\t\t\tCLANG_ENABLE_MODULES = YES;"
     puts $aPbxprojFile "\t\t\t\tCLANG_ENABLE_OBJC_ARC = YES;"
   }
   puts $aPbxprojFile "\t\t\t\tARCHS = \"\$(ARCHS_STANDARD_64_BIT)\";"
-  puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LANGUAGE_STANDARD = \"gnu++0x\";"
+  puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LIBRARY = \"libc++\";"
+  puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LANGUAGE_STANDARD = \"c++0x\";"
   puts $aPbxprojFile "\t\t\t\tCOPY_PHASE_STRIP = NO;"
   puts $aPbxprojFile "\t\t\t\tGCC_C_LANGUAGE_STANDARD = gnu99;"
   puts $aPbxprojFile "\t\t\t\tGCC_DYNAMIC_NO_PIC = NO;"
@@ -2895,12 +3125,12 @@ proc osutils:xcdtk { theOutDir theToolKit theGuidsMap theIsStatic thePlatform {t
   if { "$thePlatform" == "ios" } {
     puts $aPbxprojFile "\t\t\t\t\"ARCHS\[sdk=iphoneos\*\]\" = \"\$(ARCHS_STANDARD)\";";
     puts $aPbxprojFile "\t\t\t\t\"ARCHS\[sdk=iphonesimulator\*\]\" = \"x86_64\";";
-    puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LIBRARY = \"libc++\";"
     puts $aPbxprojFile "\t\t\t\tCLANG_ENABLE_MODULES = YES;"
     puts $aPbxprojFile "\t\t\t\tCLANG_ENABLE_OBJC_ARC = YES;"
   }
   puts $aPbxprojFile "\t\t\t\tARCHS = \"\$(ARCHS_STANDARD_64_BIT)\";"
-  puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LANGUAGE_STANDARD = \"gnu++0x\";"
+  puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LIBRARY = \"libc++\";"
+  puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LANGUAGE_STANDARD = \"c++0x\";"
   puts $aPbxprojFile "\t\t\t\tCOPY_PHASE_STRIP = YES;"
   puts $aPbxprojFile "\t\t\t\tGCC_C_LANGUAGE_STANDARD = gnu99;"
   puts $aPbxprojFile "\t\t\t\tGCC_ENABLE_OBJC_EXCEPTIONS = YES;"
@@ -3080,3 +3310,93 @@ proc osutils:xcdx { theOutDir theExecutable theGuidsMap } {
   puts $aPlistFile $aPlistTmpl
   close $aPlistFile
 }
+
+# Returns available Windows SDKs versions
+proc osutils:sdk { theSdkMajorVer {isQuietMode false} {theSdkDirectories {}} } {
+  if { ![llength ${theSdkDirectories}] } {
+    foreach anEnvVar { "ProgramFiles" "ProgramFiles\(x86\)" "ProgramW6432" } {
+      if {[ info exists ::env(${anEnvVar}) ]} {
+        lappend theSdkDirectories "$::env(${anEnvVar})/Windows Kits/${theSdkMajorVer}/Include"
+      }
+    }
+  }
+
+  set sdk_versions {}
+  foreach sdk_dir ${theSdkDirectories} {
+    if { [file isdirectory ${sdk_dir}] } {
+      lappend sdk_versions [glob -tails -directory "${sdk_dir}" -type d *]
+    }
+  }
+
+  if {![llength ${sdk_versions}] && !${isQuietMode}} {
+    error "Error : Could not find Windows SDK ${theSdkMajorVer}"
+  }
+
+  return [join [lsort -unique ${sdk_versions}] " "]
+}
+
+# Generate global properties to Visual Studio project file for UWP solution
+proc osutils:uwp:proj { isUWP theProjTmpl } {
+
+  set uwp_properties ""
+  set uwp_generate_metadata ""
+  set uwp_app_container ""
+
+  set format_template ""
+
+  if { $isUWP } {
+    set sdk_versions [osutils:sdk 10]
+    set sdk_max_ver [lindex ${sdk_versions} end]
+
+    set uwp_properties "<DefaultLanguage>en-US</DefaultLanguage>\n   \
+<ApplicationType>Windows Store</ApplicationType>\n   \
+<ApplicationTypeRevision>10.0</ApplicationTypeRevision>\n   \
+<MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>\n   \
+<AppContainerApplication>true</AppContainerApplication>\n   \
+<WindowsTargetPlatformVersion>${sdk_max_ver}</WindowsTargetPlatformVersion>\n   \
+<WindowsTargetPlatformMinVersion>${sdk_max_ver}</WindowsTargetPlatformMinVersion>"
+
+    set uwp_generate_metadata        "<GenerateWindowsMetadata>false</GenerateWindowsMetadata>"
+
+    regsub -all -- {[\r\n\s]*<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>} ${theProjTmpl} "" theProjTmpl
+  } else {
+    set format_template "\[\\r\\n\\s\]*"
+  }
+
+  regsub -all -- "${format_template}__UWP_PROPERTIES__"        ${theProjTmpl} "${uwp_properties}" theProjTmpl
+  regsub -all -- "${format_template}__UWP_GENERATE_METADATA__" ${theProjTmpl} "${uwp_generate_metadata}" theProjTmpl
+
+  return ${theProjTmpl}
+}
+
+# Report all files found in package directory but not listed in FILES
+proc osutils:checksrcfiles { theUnit } {
+  global path
+  set aCasRoot [file normalize ${path}]
+
+  if {![file isdirectory ${aCasRoot}]} {
+    puts "OCCT directory is not defined correctly: ${aCasRoot}"
+    return
+  }
+
+  set anUnitAbsPath [file normalize "${aCasRoot}/src/${theUnit}"]
+
+  if {[file exists "${anUnitAbsPath}/FILES"]} {
+    set aFilesFile [open "${anUnitAbsPath}/FILES" rb]
+    set aFilesFileList [split [read ${aFilesFile}] "\n"]
+    close ${aFilesFile}
+
+    set aFilesFileList [lsearch -inline -all -not -exact ${aFilesFileList} ""]
+
+    # report all files not listed in FILES
+    set anAllFiles [glob -tails -nocomplain -dir ${anUnitAbsPath} "*"]
+    foreach aFile ${anAllFiles} {
+      if { "${aFile}" == "FILES" } {
+        continue
+      }
+      if { [lsearch -exact ${aFilesFileList} ${aFile}] == -1 } {
+        puts "Warning: file ${anUnitAbsPath}/${aFile} is not listed in ${anUnitAbsPath}/FILES!"
+      }
+    }
+  }
+}

adm/occaux.tcl

@@ -32,12 +32,12 @@ proc OCCDoc_ParseArguments {arguments} {
   array set args_values {}
 
   foreach arg $arguments {
-    if {[regexp {^(-)[a-z]+$} $arg] == 1} {
+    if {[regexp {^(-)[a-z_]+$} $arg] == 1} {
       set name [string range $arg 1 [string length $arg]-1]
       lappend args_names $name
       set args_values($name) "NULL"
       continue
-    } elseif {[regexp {^(-)[a-z]+=.+$} $arg] == 1} {
+    } elseif {[regexp {^(-)[a-z_]+=.+$} $arg] == 1} {
       set equal_symbol_position [string first "=" $arg]
       set name [string range $arg 1 $equal_symbol_position-1]
       lappend args_names $name
@@ -59,8 +59,19 @@ proc OCCDoc_ParseArguments {arguments} {
 }
 
 # Returns script parent folder
-proc OCCDoc_GetDoxDir {} {
-  return [file normalize [file dirname [info script]]/../dox]
+proc OCCDoc_GetDoxDir { {theProductsPath ""} } {
+  if { $theProductsPath == "" } {
+    return [file normalize [file dirname [info script]]/../dox]
+  } else {
+    return [file normalize $theProductsPath]/dox
+  }
+}
+
+# Returns products root folder
+proc OCCDoc_GetProdRootDir {} {
+  if {[info exists ::env(PRODROOT)]} {
+    return [file normalize $::env(PRODROOT)]
+  }
 }
 
 # Returns OCCT root dir
@@ -71,7 +82,6 @@ proc OCCDoc_GetOCCTRootDir {} {
 
 # Returns root dir
 proc OCCDoc_GetRootDir { {theProductsPath ""} } {
-
   if { $theProductsPath == "" } {
     return [OCCDoc_GetOCCTRootDir]
   } else {
@@ -736,8 +746,7 @@ proc OCCDoc_PostProcessor {outDir} {
 
 # Loads a list of docfiles from file FILES.txt
 proc OCCDoc_LoadFilesList {} {
-
-  set INPUTDIR [OCCDoc_GetDoxDir]
+  set INPUTDIR [OCCDoc_GetDoxDir [OCCDoc_GetProdRootDir]]
 
   global available_docfiles
   set available_docfiles {}
@@ -799,7 +808,11 @@ proc OCCDoc_MakeRefmanTex {fileName latexDir verboseMode latexFilesList} {
   }
 
   # Copy template file to latex folder
-  file copy "[OCCDoc_GetDoxDir]/resources/occt_pdf_template.tex" $DOCNAME
+  if { "[OCCDoc_GetProdRootDir]" != "" } {
+    file copy "[OCCDoc_GetDoxDir [OCCDoc_GetProdRootDir]]/resources/prod_pdf_template.tex" $DOCNAME
+  } else {
+    file copy "[OCCDoc_GetDoxDir]/resources/occt_pdf_template.tex" $DOCNAME
+  }
 
   # Get templatized data
   set texfile [open $DOCNAME "r"]
@@ -808,6 +821,7 @@ proc OCCDoc_MakeRefmanTex {fileName latexDir verboseMode latexFilesList} {
 
   # Replace dummy values 
   set year       [clock format [clock seconds] -format {%Y}]
+  set month      [clock format [clock seconds] -format {%B}]
   set texfile    [open $DOCNAME "w"]
   set casVersion [OCCDoc_DetectCasVersion]
 
@@ -815,23 +829,23 @@ proc OCCDoc_MakeRefmanTex {fileName latexDir verboseMode latexFilesList} {
   set docLabel   ""
   foreach aFileName $latexFilesList {
     # Find the file in FILES_PDF.txt
-    set parsedFileName [split $aFileName "/" ]
-    set newfileName [string range $fileName [expr [string first "__" $fileName] + 2] end]
-
-    if { [lsearch -nocase $parsedFileName "$newfileName.md" ] != -1 } {
-      set filepath "[OCCDoc_GetDoxDir]/$aFileName"
+    set parsedFileName [file rootname [lindex [split $aFileName "/" ] end]]
+    if { [regexp "${parsedFileName}$" $fileName] } {
+      set filepath "[OCCDoc_GetDoxDir [OCCDoc_GetProdRootDir]]/$aFileName"
       if { [file exists $filepath] } {
         set MDFile   [open $filepath "r"]
         set label    [split [gets $MDFile] "\{"]
         set docLabel [lindex $label 0]
         close $MDFile
-        
         break
       }
     }
   }
 
-  set texfile_loaded [string map [list DEFDOCLABEL "$docLabel" DEFCASVERSION "$casVersion" DEFFILENAME "$fileName" DEFYEAR "$year"] $texfile_loaded]
+  set occtlogo_path "[OCCDoc_GetDoxDir]/resources/occt_logo.png"
+  set occlogo_path  "[OCCDoc_GetDoxDir]/resources/occ_logo.png"
+  set copyright_path  "[OCCDoc_GetDoxDir [OCCDoc_GetProdRootDir]]/resources/prod_pdf_template.tex"
+  set texfile_loaded [string map [list DEFDOCLABEL "$docLabel" DEFCASVERSION "$casVersion" DEFFILENAME "$fileName" DEFYEAR "$year" DEFMONTH "$month" DEFCOPYRIGHT "$copyright_path" DEFLOGO "$occtlogo_path" DEFOCCLOGO "$occlogo_path" DEFTITLE ""] $texfile_loaded]
 
   # Get data
   puts $texfile $texfile_loaded
@@ -885,4 +899,4 @@ proc OCCDoc_ProcessTex {{texFiles {}} {latexDir} verboseMode} {
     file delete -force $TEX
     file rename $TMPFILENAME $TEX
   }
-}
+}

adm/templates/DRAWEXE.vcxproj.user.in

@@ -2,6 +2,7 @@
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|@X_COMPILER_BITNESS@'">
   <LocalDebuggerEnvironment>CASROOT=@CMAKE_SOURCE_DIR@
+CSF_FPE=@BUILD_ENABLE_FPE_SIGNAL_HANDLER@
 CSF_OCCTResourcePath=@CMAKE_SOURCE_DIR@/src
 CSF_OCCTDataPath=@CMAKE_SOURCE_DIR@/data
 CSF_OCCTSamplesPath=@CMAKE_SOURCE_DIR@/samples
@@ -14,6 +15,7 @@ PATH=@3RDPARTY_DLL_DIRS_FOR_PATH@;%PATH%
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|@X_COMPILER_BITNESS@'">
   <LocalDebuggerEnvironment>CASROOT=@CMAKE_SOURCE_DIR@
+CSF_FPE=@BUILD_ENABLE_FPE_SIGNAL_HANDLER@
 CSF_OCCTResourcePath=@CMAKE_SOURCE_DIR@/src
 CSF_OCCTDataPath=@CMAKE_SOURCE_DIR@/data
 CSF_OCCTSamplesPath=@CMAKE_SOURCE_DIR@/samples
@@ -26,6 +28,7 @@ PATH=@3RDPARTY_DLL_DIRS_FOR_PATH@;%PATH%
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|@X_COMPILER_BITNESS@'">
   <LocalDebuggerEnvironment>CASROOT=@CMAKE_SOURCE_DIR@
+CSF_FPE=@BUILD_ENABLE_FPE_SIGNAL_HANDLER@
 CSF_OCCTResourcePath=@CMAKE_SOURCE_DIR@/src
 CSF_OCCTDataPath=@CMAKE_SOURCE_DIR@/data
 CSF_OCCTSamplesPath=@CMAKE_SOURCE_DIR@/samples

adm/templates/OpenCASCADEConfig.cmake.in

@@ -61,6 +61,7 @@ set (OpenCASCADE_WITH_FREEIMAGE @USE_FREEIMAGE@)
 set (OpenCASCADE_WITH_GL2PS     @USE_GL2PS@)
 set (OpenCASCADE_WITH_TBB       @USE_TBB@)
 set (OpenCASCADE_WITH_VTK       @USE_VTK@)
+set (OpenCASCADE_WITH_FFMPEG    @USE_FFMPEG@)
 set (OpenCASCADE_WITH_GLES2     @USE_GLES2@)
 @SET_OpenCASCADE_WITH_D3D@
 @SET_OpenCASCADE_WITH_GLX@

adm/templates/android.toolchain.config.cmake

@@ -0,0 +1,8 @@
+# A toolchain file to configure a Makefile Generators or the Ninja generator to target Android for cross-compiling.
+# Set CMAKE_ANDROID_NDK variable equal to your Android NDK path.
+
+set (CMAKE_SYSTEM_NAME       Android)
+set (CMAKE_SYSTEM_VERSION    15) # API level
+set (CMAKE_ANDROID_ARCH_ABI  armeabi-v7a)
+set (CMAKE_ANDROID_NDK       "")
+set (CMAKE_ANDROID_STL_TYPE  gnustl_shared)

adm/templates/custom.build.bat.in

@@ -2,16 +2,23 @@ echo off
 
 if /I "%VCVER%" == "@COMPILER@" (
   if "%ARCH%" == "@COMPILER_BITNESS@" (
+    rem set environment variables used by OCCT
+    set CSF_FPE=@BUILD_ENABLE_FPE_SIGNAL_HANDLER@
+
     set "TCL_DIR=@3RDPARTY_TCL_DLL_DIR@"
     set "TK_DIR=@3RDPARTY_TK_DLL_DIR@"
     set "FREETYPE_DIR=@3RDPARTY_FREETYPE_DLL_DIR@"
-    set "FREEIMAGE_DIR=@3RDPARTY_FREEIMAGE_DLL_DIR@"
-    set "EGL_DIR=@3RDPARTY_EGL_DLL_DIR@"
-    set "GLES2_DIR=@3RDPARTY_GLES2_DLL_DIR@"
-    set "GL2PS_DIR=@3RDPARTY_GL2PS_DLL_DIR@"
+    set "FREEIMAGE_DIR=@3RDPARTY_FREEIMAGE_DLL_DIRS@"
+    set "EGL_DIR=@3RDPARTY_EGL_DLL_DIRS@"
+    set "GLES2_DIR=@3RDPARTY_GLES2_DLL_DIRS@"
+    set "GL2PS_DIR=@3RDPARTY_GL2PS_DLL_DIRS@"
     set "TBB_DIR=@3RDPARTY_TBB_DLL_DIR@"
     set "VTK_DIR=@3RDPARTY_VTK_DLL_DIR@"
+    set "FFMPEG_DIR=@3RDPARTY_FFMPEG_DLL_DIR@"
 
+    if not "@3RDPARTY_QT_DIR@" == "" (
+      set "QTDIR=@3RDPARTY_QT_DIR@"
+    )
     set "TCL_VERSION_WITH_DOT=@3RDPARTY_TCL_LIBRARY_VERSION_WITH_DOT@"
     set "TK_VERSION_WITH_DOT=@3RDPARTY_TK_LIBRARY_VERSION_WITH_DOT@"
 

adm/templates/custom.build.sh.in

@@ -2,13 +2,21 @@
 
 if [ "$1" == "@BIN_LETTER@" ]; then
   if [ "$2" == "@COMPILER_BITNESS@" ]; then
+    # set environment variables used by OCCT
+    export CSF_FPE=@BUILD_ENABLE_FPE_SIGNAL_HANDLER@
+
     export TCL_DIR="@3RDPARTY_TCL_LIBRARY_DIR@"
     export TK_DIR="@3RDPARTY_TK_LIBRARY_DIR@"
     export FREETYPE_DIR="@3RDPARTY_FREETYPE_LIBRARY_DIR@"
-    export FREEIMAGE_DIR="@3RDPARTY_FREEIMAGE_LIBRARY_DIR@"
-    export GL2PS_DIR="@3RDPARTY_GL2PS_LIBRARY_DIR@"
+    export FREEIMAGE_DIR="@3RDPARTY_FREEIMAGE_LIBRARY_DIRS@"
+    export GL2PS_DIR="@3RDPARTY_GL2PS_LIBRARY_DIRS@"
     export TBB_DIR="@3RDPARTY_TBB_LIBRARY_DIR@"
     export VTK_DIR="@3RDPARTY_VTK_LIBRARY_DIR@"
+    export FFMPEG_DIR="@3RDPARTY_FFMPEG_LIBRARY_DIR@"
+
+    if [ "x@3RDPARTY_QT_DIR" != "x" ]; then
+      export QTDIR="@3RDPARTY_QT_DIR@"
+    fi
 
     export TCL_VERSION_WITH_DOT="@3RDPARTY_TCL_LIBRARY_VERSION_WITH_DOT@"
     export TK_VERSION_WITH_DOT="@3RDPARTY_TK_LIBRARY_VERSION_WITH_DOT@"

adm/templates/custom.install.bat.in

@@ -4,31 +4,38 @@ rem CASDEB comes as third argument
 
 if /I "%VCVER%" == "@COMPILER@" (
   if "%ARCH%" == "@COMPILER_BITNESS@" (
+    rem set environment variables used by OCCT
+    set CSF_FPE=@BUILD_ENABLE_FPE_SIGNAL_HANDLER@
+
     set "TCL_DIR=@USED_3RDPARTY_TCL_DIR@"
     set "TK_DIR=@USED_3RDPARTY_TK_DIR@"
     set "FREETYPE_DIR=@USED_3RDPARTY_FREETYPE_DIR@"
-    set "FREEIMAGE_DIR=@USED_3RDPARTY_FREEIMAGE_DIR@"
-    set "EGL_DIR=@USED_3RDPARTY_EGL_DIR@"
-    set "GLES2_DIR=@USED_3RDPARTY_GLES2_DIR@"
-    set "GL2PS_DIR=@USED_3RDPARTY_GL2PS_DIR@"
+    set "FREEIMAGE_DIR=@USED_3RDPARTY_FREEIMAGE_DIRS@"
+    set "EGL_DIR=@USED_3RDPARTY_EGL_DIRS@"
+    set "GLES2_DIR=@USED_3RDPARTY_GLES2_DIRS@"
+    set "GL2PS_DIR=@USED_3RDPARTY_GL2PS_DIRS@"
     set "TBB_DIR=@USED_3RDPARTY_TBB_DIR@"
     set "VTK_DIR=@USED_3RDPARTY_VTK_DIR@"
+    set "FFMPEG_DIR=@USED_3RDPARTY_FFMPEG_DIR@"
 
+    if not "@USED_3RDPARTY_QT_DIR@" == "" (
+      set "QTDIR=@USED_3RDPARTY_QT_DIR@"
+    )
     set "TCL_VERSION_WITH_DOT=@3RDPARTY_TCL_LIBRARY_VERSION_WITH_DOT@"
     set "TK_VERSION_WITH_DOT=@3RDPARTY_TK_LIBRARY_VERSION_WITH_DOT@"
 
-    set "CSF_OCCTBinPath=@INSTALL_DIR@/@INSTALL_DIR_BIN@%3"
-    set "CSF_OCCTLibPath=@INSTALL_DIR@/@INSTALL_DIR_LIB@%3"
+    set "CSF_OCCTBinPath=@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_BIN@%3"
+    set "CSF_OCCTLibPath=@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_LIB@%3"
 
-    set "CSF_OCCTIncludePath=@INSTALL_DIR@/@INSTALL_DIR_INCLUDE@"
-    set "CSF_OCCTResourcePath=@INSTALL_DIR@/@INSTALL_DIR_RESOURCE@"
-    set "CSF_OCCTDataPath=@INSTALL_DIR@/@INSTALL_DIR_DATA@"
-    set "CSF_OCCTSamplesPath=@INSTALL_DIR@/@INSTALL_DIR_SAMPLES@"
-    set "CSF_OCCTTestsPath=@INSTALL_DIR@/@INSTALL_DIR_TESTS@"
-    set "CSF_OCCTDocPath=@INSTALL_DIR@/@INSTALL_DIR_DOC@"
+    set "CSF_OCCTIncludePath=@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_INCLUDE@"
+    set "CSF_OCCTResourcePath=@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_RESOURCE@"
+    set "CSF_OCCTDataPath=@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_DATA@"
+    set "CSF_OCCTSamplesPath=@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_SAMPLES@"
+    set "CSF_OCCTTestsPath=@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_TESTS@"
+    set "CSF_OCCTDocPath=@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_DOC@"
 
     rem for compatability with external application using CASROOT
-    set "CASROOT=@INSTALL_DIR@"
+    set "CASROOT=@INSTALL_DIR_ABSOLUTE@"
   )
 )
 

adm/templates/custom.install.sh.in

@@ -2,28 +2,36 @@
 
 if [ "$1" == "@BIN_LETTER@" ]; then
   if [ "$2" == "@COMPILER_BITNESS@" ]; then
+    # set environment variables used by OCCT
+    export CSF_FPE=@BUILD_ENABLE_FPE_SIGNAL_HANDLER@
+
     export TCL_DIR="@USED_3RDPARTY_TCL_DIR@"
     export TK_DIR="@USED_3RDPARTY_TK_DIR@"
     export FREETYPE_DIR="@USED_3RDPARTY_FREETYPE_DIR@"
-    export FREEIMAGE_DIR="@USED_3RDPARTY_FREEIMAGE_DIR@"
-    export GL2PS_DIR="@USED_3RDPARTY_GL2PS_DIR@"
+    export FREEIMAGE_DIR="@USED_3RDPARTY_FREEIMAGE_DIRS@"
+    export GL2PS_DIR="@USED_3RDPARTY_GL2PS_DIRS@"
     export TBB_DIR="@USED_3RDPARTY_TBB_DIR@"
     export VTK_DIR="@USED_3RDPARTY_VTK_DIR@"
+    export FFMPEG_DIR="@USED_3RDPARTY_FFMPEG_DIR@"
+
+    if [ "x@USED_3RDPARTY_QT_DIR@" != "x" ]; then
+      export QTDIR="@USED_3RDPARTY_QT_DIR@"
+    fi
 
     export TCL_VERSION_WITH_DOT="@3RDPARTY_TCL_LIBRARY_VERSION_WITH_DOT@"
     export TK_VERSION_WITH_DOT="@3RDPARTY_TK_LIBRARY_VERSION_WITH_DOT@"
 
-    export CSF_OCCTBinPath="@INSTALL_DIR@/@INSTALL_DIR_BIN@"
-    export CSF_OCCTLibPath="@INSTALL_DIR@/@INSTALL_DIR_LIB@"
-    export CSF_OCCTIncludePath="@INSTALL_DIR@/@INSTALL_DIR_INCLUDE@"
-    export CSF_OCCTResourcePath="@INSTALL_DIR@/@INSTALL_DIR_RESOURCE@"
-    export CSF_OCCTDataPath="@INSTALL_DIR@/@INSTALL_DIR_DATA@"
-    export CSF_OCCTSamplesPath="@INSTALL_DIR@/@INSTALL_DIR_SAMPLES@"
-    export CSF_OCCTTestsPath="@INSTALL_DIR@/@INSTALL_DIR_TESTS@"
-    export CSF_OCCTDocPath="@INSTALL_DIR@/@INSTALL_DIR_DOC@"
+    export CSF_OCCTBinPath="@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_BIN@"
+    export CSF_OCCTLibPath="@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_LIB@"
+    export CSF_OCCTIncludePath="@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_INCLUDE@"
+    export CSF_OCCTResourcePath="@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_RESOURCE@"
+    export CSF_OCCTDataPath="@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_DATA@"
+    export CSF_OCCTSamplesPath="@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_SAMPLES@"
+    export CSF_OCCTTestsPath="@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_TESTS@"
+    export CSF_OCCTDocPath="@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_DOC@"
     
     # for compatability with external application using CASROOT
-    export CASROOT="@INSTALL_DIR@"
+    export CASROOT="@INSTALL_DIR_ABSOLUTE@"
   fi
 fi
 

adm/templates/dfbrowser.bat

@@ -0,0 +1,7 @@
+@echo off
+
+rem Setup environment and launch TInspector
+call "%~dp0env.bat" %1 %2 %3
+
+TInspectorEXE.exe --dfbrowser
+

adm/templates/dfbrowser.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+aCurrentPath="$PWD"
+aScriptPath=${BASH_SOURCE%/*}; if [ -d "${aScriptPath}" ]; then cd "$aScriptPath"; fi; aScriptPath="$PWD";
+
+source "${aScriptPath}/env.sh" "$1"
+
+cd ${aCurrentPath}
+TInspectorEXE --dfbrowser

adm/templates/env.bat

@@ -18,10 +18,13 @@ set "VCVARS="
 set "HAVE_TBB=false"
 set "HAVE_OPENCL=false"
 set "HAVE_FREEIMAGE=false"
+set "HAVE_FFMPEG=false"
 set "HAVE_GL2PS=false"
 set "HAVE_VTK=false"
 set "HAVE_GLES2=false"
 set "HAVE_D3D=false"
+set "HAVE_ZLIB=false"
+set "HAVE_LIBLZMA=false"
 set "CSF_OPT_INC="
 set "CSF_OPT_LIB32="
 set "CSF_OPT_LIB64="
@@ -46,6 +49,59 @@ if /I ["%3"]     == ["d"]     set "CASDEB=d"
 if /I ["%3"]     == ["i"]     set "CASDEB=i"
 if /I ["%3"]     == ["relwithdeb"] set "CASDEB=i"
 
+rem Decode VCVER
+call "%~dp0adm\vcver.bat"
+
+rem ----- Parsing of Visual Studio platform -----
+set "VisualStudioExpressName=VCExpress"
+
+if not "%DevEnvDir%" == "" (
+  rem If DevEnvDir is already defined (e.g. in custom.bat), use that value
+) else if /I "%VCFMT%" == "vc10" (
+  set "DevEnvDir=%VS100COMNTOOLS%..\IDE"
+) else if /I "%VCFMT%" == "vc11" (
+  set "DevEnvDir=%VS110COMNTOOLS%..\IDE"
+  rem Visual Studio Express starting from VS 2012 is called "for Windows Desktop"
+  rem and has a new name for executable - WDExpress
+  set "VisualStudioExpressName=WDExpress"
+) else if /I "%VCFMT%" == "vc12" (
+  set "DevEnvDir=%VS120COMNTOOLS%..\IDE"
+  set "VisualStudioExpressName=WDExpress"
+) else if /I "%VCFMT%" == "vc14" (
+  set "DevEnvDir=%VS140COMNTOOLS%..\IDE"
+) else if /I "%VCFMT%" == "vc141" (
+  for /f "usebackq delims=" %%i in (`vswhere.exe -version "[15.0,15.99]" -requires Microsoft.VisualStudio.Workload.%VCPROP% -property installationPath`) do (
+    set "DevEnvDir=%%i\Common7\IDE\"
+  )
+) else (
+  echo Error: wrong VS identifier
+  exit /B
+)
+
+rem ----- Parsing vcvarsall for qt samples and define PlatformToolset -----
+if /I "%VCFMT%" == "vc10" (
+  set "VCVARS=%VS100COMNTOOLS%..\..\VC\vcvarsall.bat"
+  set "VCPlatformToolSet=v100"
+) else if /I "%VCFMT%" == "vc11" (
+  set "VCVARS=%VS110COMNTOOLS%..\..\VC\vcvarsall.bat"
+  set "VCPlatformToolSet=v110"
+) else if /I "%VCFMT%" == "vc12" (
+  set "VCVARS=%VS120COMNTOOLS%..\..\VC\vcvarsall.bat"
+  set "VCPlatformToolSet=v120"
+) else if /I "%VCFMT%" == "vc14" (
+  set "VCVARS=%VS140COMNTOOLS%..\..\VC\vcvarsall.bat"
+  set "VCPlatformToolSet=v140"
+) else if /I "%VCFMT%" == "vc141" (
+  for /f "usebackq delims=" %%i in (`vswhere.exe -version "[15.0,15.99]" -requires Microsoft.VisualStudio.Workload.%VCPROP% -property installationPath`) do (
+    set "VCVARS=%%i\VC\Auxiliary\Build\vcvarsall.bat"
+  )
+  set "VCPlatformToolSet=v141"
+) else (
+  echo Error: first argument ^(%VCVER%^) should specify supported version of Visual C++,
+  echo one of: vc10 ^(VS 2010 SP3^), vc11 ^(VS 2012 SP3^), vc12 ^(VS 2013^) or vc14 ^(VS 2015^)
+  exit
+)
+
 set "CSF_OPT_LIB32D=%CSF_OPT_LIB32%"
 set "CSF_OPT_LIB64D=%CSF_OPT_LIB64%"
 set "CSF_OPT_BIN32D=%CSF_OPT_BIN32%"
@@ -58,20 +114,16 @@ set "CSF_OPT_BIN64I=%CSF_OPT_BIN64%"
 rem ----- Optional 3rd-parties should be enabled by HAVE macros -----
 set "CSF_OPT_CMPL="
 set "PRODUCTS_DEFINES="
-if ["%HAVE_TBB%"]       == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_TBB"
-if ["%HAVE_OPENCL%"]    == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_OPENCL"
-if ["%HAVE_GL2PS%"]     == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_GL2PS"
-if ["%HAVE_FREEIMAGE%"] == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_FREEIMAGE"
-if ["%HAVE_VTK%"]       == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_VTK"
-if ["%HAVE_GLES2%"]     == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_GLES2"
-if ["%HAVE_D3D%"]       == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_D3D"
-if ["%HAVE_TBB%"]       == ["true"] set "CSF_DEFINES=HAVE_TBB;%CSF_DEFINES%"
-if ["%HAVE_OPENCL%"]    == ["true"] set "CSF_DEFINES=HAVE_OPENCL;%CSF_DEFINES%"
-if ["%HAVE_GL2PS%"]     == ["true"] set "CSF_DEFINES=HAVE_GL2PS;%CSF_DEFINES%"
-if ["%HAVE_FREEIMAGE%"] == ["true"] set "CSF_DEFINES=HAVE_FREEIMAGE;%CSF_DEFINES%"
-if ["%HAVE_VTK%"]       == ["true"] set "CSF_DEFINES=HAVE_VTK;%CSF_DEFINES%"
-if ["%HAVE_GLES2%"]     == ["true"] set "CSF_DEFINES=HAVE_GLES2;%CSF_DEFINES%"
-if ["%HAVE_D3D%"]       == ["true"] set "CSF_DEFINES=HAVE_D3D;%CSF_DEFINES%"
+if ["%HAVE_TBB%"]       == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_TBB"       & set "CSF_DEFINES=HAVE_TBB;%CSF_DEFINES%"
+if ["%HAVE_OPENCL%"]    == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_OPENCL"    & set "CSF_DEFINES=HAVE_OPENCL;%CSF_DEFINES%"
+if ["%HAVE_GL2PS%"]     == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_GL2PS"     & set "CSF_DEFINES=HAVE_GL2PS;%CSF_DEFINES%"
+if ["%HAVE_FREEIMAGE%"] == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_FREEIMAGE" & set "CSF_DEFINES=HAVE_FREEIMAGE;%CSF_DEFINES%"
+if ["%HAVE_FFMPEG%"]    == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_FFMPEG"    & set "CSF_DEFINES=HAVE_FFMPEG;%CSF_DEFINES%"
+if ["%HAVE_VTK%"]       == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_VTK"       & set "CSF_DEFINES=HAVE_VTK;%CSF_DEFINES%"
+if ["%HAVE_GLES2%"]     == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_GLES2"     & set "CSF_DEFINES=HAVE_GLES2;%CSF_DEFINES%"
+if ["%HAVE_D3D%"]       == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_D3D"       & set "CSF_DEFINES=HAVE_D3D;%CSF_DEFINES%"
+if ["%HAVE_ZLIB%"]      == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_ZLIB"      & set "CSF_DEFINES=HAVE_ZLIB;%CSF_DEFINES%"
+if ["%HAVE_LIBLZMA%"]   == ["true"] set "PRODUCTS_DEFINES=%PRODUCTS_DEFINES% -DHAVE_LIBLZMA"   & set "CSF_DEFINES=HAVE_LIBLZMA;%CSF_DEFINES%"
 
 rem Eliminate VS warning
 if ["%CSF_DEFINES%"]  == [""] set "CSF_DEFINES=;"
@@ -112,8 +164,8 @@ if "%CSF_OCCTResourcePath%" == "" set "CSF_OCCTResourcePath=%CASROOT%\src"
 if "%CSF_OCCTSamplesPath%" == "" set "CSF_OCCTSamplesPath=%CASROOT%\samples"
 if "%CSF_OCCTDataPath%" == "" set "CSF_OCCTDataPath=%CASROOT%\data"
 if "%CSF_OCCTTestsPath%" == "" set "CSF_OCCTTestsPath=%CASROOT%\tests"
-if "%CSF_OCCTBinPath%" == "" set "CSF_OCCTBinPath=%CASROOT%\win%ARCH%\%VCVER%\bin%CASDEB%"
-if "%CSF_OCCTLibPath%" == "" set "CSF_OCCTLibPath=%CASROOT%\win%ARCH%\%VCVER%\lib%CASDEB%"
+if "%CSF_OCCTBinPath%" == "" set "CSF_OCCTBinPath=%CASROOT%\win%ARCH%\%VCLIB%\bin%CASDEB%"
+if "%CSF_OCCTLibPath%" == "" set "CSF_OCCTLibPath=%CASROOT%\win%ARCH%\%VCLIB%\lib%CASDEB%"
 
 rem ----- Set path to 3rd party and OCCT libraries -----
 set "PATH=%CSF_OCCTBinPath%;%PATH%"
@@ -137,8 +189,6 @@ set "CSF_PluginDefaults=%CSF_OCCTResourcePath%\StdResource"
 set "CSF_XCAFDefaults=%CSF_OCCTResourcePath%\StdResource"
 set "CSF_TObjDefaults=%CSF_OCCTResourcePath%\StdResource"
 set "CSF_StandardLiteDefaults=%CSF_OCCTResourcePath%\StdResource"
-set "CSF_UnitsLexicon=%CSF_OCCTResourcePath%\UnitsAPI\Lexi_Expr.dat"
-set "CSF_UnitsDefinition=%CSF_OCCTResourcePath%\UnitsAPI\Units.dat"
 set "CSF_IGESDefaults=%CSF_OCCTResourcePath%\XSTEPResource"
 set "CSF_STEPDefaults=%CSF_OCCTResourcePath%\XSTEPResource"
 set "CSF_XmlOcafResource=%CSF_OCCTResourcePath%\XmlOcafResource"

adm/templates/env.bat.in

@@ -17,13 +17,94 @@ if /I ["%3"]     == ["d"]     set "CASDEB=d"
 if /I ["%3"]     == ["i"]     set "CASDEB=i"
 if /I ["%3"]     == ["relwithdeb"] set "CASDEB=i"
 
+rem ----- Decode VCVER variable and define related ones -----
+rem
+rem VCFMT - "vc" followed by full version number of Visual Studio toolset
+rem         (same as VCVER without optional suffix "-uwp")
+rem VCLIB - name of folder contining binaries
+rem         (same as VCVER except without third version in number)
+rem VCPROP - name of required Visual Studion Workload (starting with VS 2017)
+rem
+rem Note that for VS before 2015 (vc14) always
+rem VCFMT=VCLIB=VCVER and VCPROP=NativeDesktop
+
+rem Since VS 2017, environment variables like VS100COMNTOOLS are not defined 
+rem any more, we can only use vswhere.exe tool to find Visual Studio.
+rem Add path to vswhere.exe
+set "PATH=%PATH%;%ProgramFiles(x86)%\Microsoft Visual Studio\Installer"
+
+rem for vc10-12, interpretation is trivial
+set VCFMT=%VCVER%
+set VCLIB=%VCVER:~0,4%
+set VCPROP=NativeDesktop
+rem vc14 and later can have optional suffix "-uwp"
+if "%VCVER:~-4%" == "-uwp" (
+  set VCFMT=%VCVER:~0,-4%
+  set VCLIB=%VCLIB%-uwp
+  set VCPROP=Universal
+)
+rem echo VCVER=%VCVER% VCFMT=%VCFMT% VCLIB=%VCLIB% VCPROP=%VCPROP%
+
+rem ----- Parsing of Visual Studio platform -----
+set "VisualStudioExpressName=VCExpress"
+
+if not "%DevEnvDir%" == "" (
+  rem If DevEnvDir is already defined (e.g. in custom.bat), use that value
+) else if /I "%VCFMT%" == "vc10" (
+  set "DevEnvDir=%VS100COMNTOOLS%..\IDE"
+) else if /I "%VCFMT%" == "vc11" (
+  set "DevEnvDir=%VS110COMNTOOLS%..\IDE"
+  rem Visual Studio Express starting from VS 2012 is called "for Windows Desktop"
+  rem and has a new name for executable - WDExpress
+  set "VisualStudioExpressName=WDExpress"
+) else if /I "%VCFMT%" == "vc12" (
+  set "DevEnvDir=%VS120COMNTOOLS%..\IDE"
+  set "VisualStudioExpressName=WDExpress"
+) else if /I "%VCFMT%" == "vc14" (
+  set "DevEnvDir=%VS140COMNTOOLS%..\IDE"
+) else if /I "%VCFMT%" == "vc141" (
+  for /f "usebackq delims=" %%i in (`vswhere.exe -version "[15.0,15.99]" -requires Microsoft.VisualStudio.Workload.%VCPROP% -property installationPath`) do (
+    set "DevEnvDir=%%i\Common7\IDE\"
+  )
+) else (
+  echo Error: wrong VS identifier
+  exit /B
+)
+
+rem ----- Parsing vcvarsall for qt samples and define PlatformToolset -----
+if /I "%VCFMT%" == "vc10" (
+  set "VCVARS=%VS100COMNTOOLS%..\..\VC\vcvarsall.bat"
+  set "VCPlatformToolSet=v100"
+) else if /I "%VCFMT%" == "vc11" (
+  set "VCVARS=%VS110COMNTOOLS%..\..\VC\vcvarsall.bat"
+  set "VCPlatformToolSet=v110"
+) else if /I "%VCFMT%" == "vc12" (
+  set "VCVARS=%VS120COMNTOOLS%..\..\VC\vcvarsall.bat"
+  set "VCPlatformToolSet=v120"
+) else if /I "%VCFMT%" == "vc14" (
+  set "VCVARS=%VS140COMNTOOLS%..\..\VC\vcvarsall.bat"
+  set "VCPlatformToolSet=v140"
+) else if /I "%VCFMT%" == "vc141" (
+  for /f "usebackq delims=" %%i in (`vswhere.exe -version "[15.0,15.99]" -requires Microsoft.VisualStudio.Workload.%VCPROP% -property installationPath`) do (
+    set "VCVARS=%%i\VC\Auxiliary\Build\vcvarsall.bat"
+  )
+  set "VCPlatformToolSet=v141"
+) else (
+  echo Error: first argument ^(%VCVER%^) should specify supported version of Visual C++,
+  echo one of: vc10 ^(VS 2010 SP3^), vc11 ^(VS 2012 SP3^), vc12 ^(VS 2013^) or vc14 ^(VS 2015^)
+  exit
+)
+
+if ["%ARCH%"] == ["32"] set VCARCH=x86
+if ["%ARCH%"] == ["64"] set VCARCH=amd64
+
+if /I ["%1"] == ["vc141"] set "VCVER=vc14"
 if exist "%~dp0custom.bat" (
   call "%~dp0custom.bat" %VCVER% %ARCH% %CASDEB%
 )
 
 rem for compatability with external application using CASROOT
 if ["%CASROOT%"] == [""] set "CASROOT=%SCRIPTROOT%"
-set "PRODROOT="
 
 if not ["%TCL_DIR%"] == [""]           set "PATH=%TCL_DIR%;%PATH%"
 if not ["%TK_DIR%"] == [""]            set "PATH=%TK_DIR%;%PATH%"
@@ -34,6 +115,8 @@ if not ["%GLES2_DIR%"] == [""]         set "PATH=%GLES2_DIR%;%PATH%"
 if not ["%GL2PS_DIR%"] == [""]         set "PATH=%GL2PS_DIR%;%PATH%"
 if not ["%TBB_DIR%"] == [""]           set "PATH=%TBB_DIR%;%PATH%"
 if not ["%VTK_DIR%"] == [""]           set "PATH=%VTK_DIR%;%PATH%"
+if not ["%FFMPEG_DIR%"] == [""]        set "PATH=%FFMPEG_DIR%;%PATH%"
+if not ["%QTDIR%"] == [""]             set "PATH=%QTDIR%/bin;%PATH%"
 
 rem ----- Set path to 3rd party and OCCT libraries -----
 if not "%CSF_OCCTBinPath%" == "" (
@@ -58,8 +141,6 @@ set "CSF_PluginDefaults=%CSF_OCCTResourcePath%\StdResource"
 set "CSF_XCAFDefaults=%CSF_OCCTResourcePath%\StdResource"
 set "CSF_TObjDefaults=%CSF_OCCTResourcePath%\StdResource"
 set "CSF_StandardLiteDefaults=%CSF_OCCTResourcePath%\StdResource"
-set "CSF_UnitsLexicon=%CSF_OCCTResourcePath%\UnitsAPI\Lexi_Expr.dat"
-set "CSF_UnitsDefinition=%CSF_OCCTResourcePath%\UnitsAPI\Units.dat"
 set "CSF_IGESDefaults=%CSF_OCCTResourcePath%\XSTEPResource"
 set "CSF_STEPDefaults=%CSF_OCCTResourcePath%\XSTEPResource"
 set "CSF_XmlOcafResource=%CSF_OCCTResourcePath%\XmlOcafResource"

adm/templates/env.samples.bat.in

@@ -4,8 +4,8 @@ if exist "%~dp0custom.bat" (
   call "%~dp0custom.bat" %1 %2 %3
 )
 
-call "@INSTALL_DIR@\@INSTALL_DIR_SCRIPT@\env.bat" %1 %2 %3
-
+call "@INSTALL_DIR_ABSOLUTE@\@INSTALL_DIR_SCRIPT@\env.bat" %1 %2 %3
+if /I ["%1"] == ["vc141"] set "VCVER=vc141"
 set "BIN_DIR=win%ARCH%\%VCVER%\bind"
 set "LIB_DIR=win%ARCH%\%VCVER%\libd"
 

adm/templates/env.samples.sh.in

@@ -6,8 +6,8 @@ if [ -e "custom.sh" ]; then
    source "custom.sh";
 fi
 
-if [ -e "@INSTALL_DIR@/@INSTALL_DIR_SCRIPT@/env.sh" ]; then
-   source "@INSTALL_DIR@/@INSTALL_DIR_SCRIPT@/env.sh";
+if [ -e "@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_SCRIPT@/env.sh" ]; then
+   source "@INSTALL_DIR_ABSOLUTE@/@INSTALL_DIR_SCRIPT@/env.sh";
 fi
 
 if test "${QTDIR}" == ""; then

adm/templates/env.sh

@@ -10,9 +10,12 @@ export TARGET="";
 export HAVE_TBB="false";
 export HAVE_OPENCL="false";
 export HAVE_FREEIMAGE="false";
+export HAVE_FFMPEG="false";
 export HAVE_GL2PS="false";
 export HAVE_VTK="false";
 export HAVE_GLES2="false";
+export HAVE_ZLIB="false";
+export HAVE_LIBLZMA="false";
 export MACOSX_USE_GLX="false";
 export CSF_OPT_INC=""
 export CSF_OPT_LIB32=""
@@ -91,28 +94,17 @@ fi
 export CSF_OPT_CMPL=""
 
 # Optiona 3rd-parties should be enabled by HAVE macros
-if [ "$HAVE_TBB" == "true" ]; then
-  export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_TBB"
-fi
-if [ "$HAVE_OPENCL" == "true" ]; then
-  export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_OPENCL"
-fi
-if [ "$HAVE_FREEIMAGE" == "true" ]; then
-  export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_FREEIMAGE"
-fi
-if [ "$HAVE_GL2PS" == "true" ]; then
-  export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_GL2PS"
-fi
-if [ "$HAVE_GLES2" == "true" ]; then
-  export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_GLES2"
-fi
-if [ "$HAVE_VTK" == "true" ]; then
-  export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_VTK"
-fi
+if [ "$HAVE_TBB"       == "true" ]; then export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_TBB"; fi
+if [ "$HAVE_OPENCL"    == "true" ]; then export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_OPENCL"; fi
+if [ "$HAVE_FREEIMAGE" == "true" ]; then export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_FREEIMAGE"; fi
+if [ "$HAVE_FFMPEG"    == "true" ]; then export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_FFMPEG"; fi
+if [ "$HAVE_GL2PS"     == "true" ]; then export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_GL2PS"; fi
+if [ "$HAVE_GLES2"     == "true" ]; then export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_GLES2"; fi
+if [ "$HAVE_VTK"       == "true" ]; then export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_VTK"; fi
+if [ "$HAVE_ZLIB"      == "true" ]; then export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_ZLIB"; fi
+if [ "$HAVE_LIBLZMA"   == "true" ]; then export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_LIBLZMA"; fi
 # Option to compile OCCT with X11 libs on Mac OS X
-if [ "$MACOSX_USE_GLX" == "true" ]; then
-  export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DMACOSX_USE_GLX"
-fi
+if [ "$MACOSX_USE_GLX" == "true" ]; then export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DMACOSX_USE_GLX"; fi
 
 # To split string into array
 aDelimBack=$IFS
@@ -217,8 +209,6 @@ export CSF_PluginDefaults="${CASROOT}/src/StdResource"
 export CSF_XCAFDefaults="${CASROOT}/src/StdResource"
 export CSF_TObjDefaults="${CASROOT}/src/StdResource"
 export CSF_StandardLiteDefaults="${CASROOT}/src/StdResource"
-export CSF_UnitsLexicon="${CASROOT}/src/UnitsAPI/Lexi_Expr.dat"
-export CSF_UnitsDefinition="${CASROOT}/src/UnitsAPI/Units.dat"
 export CSF_IGESDefaults="${CASROOT}/src/XSTEPResource"
 export CSF_STEPDefaults="${CASROOT}/src/XSTEPResource"
 export CSF_XmlOcafResource="${CASROOT}/src/XmlOcafResource"

adm/templates/env.sh.in

@@ -66,6 +66,14 @@ if [ "$VTK_DIR" != "" ]; then
   THRDPARTY_PATH="${VTK_DIR}:${THRDPARTY_PATH}"
 fi
 
+if [ "$FFMPEG_DIR" != "" ]; then
+  THRDPARTY_PATH="${FFMPEG_DIR}:${THRDPARTY_PATH}"
+fi
+
+if [ "$QTDIR" != "" ]; then
+  THRDPARTY_PATH="${QTDIR}/lib:${THRDPARTY_PATH}"
+fi
+
 if [ "$TK_DIR" != "$TCL_DIR" ]; then
   if [ "$TK_DIR" != "" ]; then
     export TK_LIBRARY="${TK_DIR}/../lib/tk${TK_VERSION_WITH_DOT}"
@@ -114,8 +122,6 @@ export CSF_PluginDefaults="${CSF_OCCTResourcePath}/StdResource"
 export CSF_XCAFDefaults="${CSF_OCCTResourcePath}/StdResource"
 export CSF_TObjDefaults="${CSF_OCCTResourcePath}/StdResource"
 export CSF_StandardLiteDefaults="${CSF_OCCTResourcePath}/StdResource"
-export CSF_UnitsLexicon="${CSF_OCCTResourcePath}/UnitsAPI/Lexi_Expr.dat"
-export CSF_UnitsDefinition="${CSF_OCCTResourcePath}/UnitsAPI/Units.dat"
 export CSF_IGESDefaults="${CSF_OCCTResourcePath}/XSTEPResource"
 export CSF_STEPDefaults="${CSF_OCCTResourcePath}/XSTEPResource"
 export CSF_XmlOcafResource="${CSF_OCCTResourcePath}/XmlOcafResource"

adm/templates/header.in

@@ -1 +1 @@
-#include "@OCCT_HEADER_FILE@"
+@OCCT_HEADER_FILE_CONTENT@

adm/templates/msvc.bat

@@ -10,29 +10,6 @@ if not "%4" == "" (
   set "PRJFILE=%4"
 )
 
-set "VisualStudioExpressName=VCExpress"
-
-if /I "%VCVER%" == "vc8" (
-  set "DevEnvDir=%VS80COMNTOOLS%..\IDE"
-) else if /I "%VCVER%" == "vc9" (
-  set "DevEnvDir=%VS90COMNTOOLS%..\IDE"
-) else if /I "%VCVER%" == "vc10" (
-  set "DevEnvDir=%VS100COMNTOOLS%..\IDE"
-) else if /I "%VCVER%" == "vc11" (
-  set "DevEnvDir=%VS110COMNTOOLS%..\IDE"
-  rem Visual Studio Express starting from VS 2012 is called "for Windows Desktop"
-  rem and has a new name for executable - WDExpress
-  set "VisualStudioExpressName=WDExpress"
-) else if /I "%VCVER%" == "vc12" (
-  set "DevEnvDir=%VS120COMNTOOLS%..\IDE"
-  set "VisualStudioExpressName=WDExpress"
-) else if /I "%VCVER%" == "vc14" (
-  set "DevEnvDir=%VS140COMNTOOLS%..\IDE"
-) else (
-  echo Error: wrong VS identifier
-  exit /B
-)
-
 rem Launch Visual Studio - either professional (devenv) or Express, as available
 if exist "%DevEnvDir%\devenv.exe"  (
   start "" "%DevEnvDir%\devenv.exe" "%PRJFILE%"
@@ -40,5 +17,5 @@ if exist "%DevEnvDir%\devenv.exe"  (
   start "" "%DevEnvDir%\%VisualStudioExpressName%.exe" "%PRJFILE%"
 ) else (
   echo Error: Could not find MS Visual Studio ^(%VCVER%^)
-  echo Check relevant environment variable ^(e.g. VS80COMNTOOLS for vc8^)
+  echo For VS 2010-2015, check relevant environment variable ^(e.g. VS100COMNTOOLS^)
 )

adm/templates/template.vc10

@@ -20,23 +20,28 @@
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <ProjectGuid>__PROJECT_GUID__</ProjectGuid>
+    __UWP_PROPERTIES__
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <PlatformToolset>__VCVEREXT__</PlatformToolset>
+    <CharacterSet>__VCCHARSET__</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <PlatformToolset>__VCVEREXT__</PlatformToolset>
+    <CharacterSet>__VCCHARSET__</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <PlatformToolset>__VCVEREXT__</PlatformToolset>
+    <CharacterSet>__VCCHARSET__</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <PlatformToolset>__VCVEREXT__</PlatformToolset>
+    <CharacterSet>__VCCHARSET__</CharacterSet>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
@@ -96,21 +101,25 @@
       <WarningLevel>Level4</WarningLevel>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <DisableSpecificWarnings>%(DisableSpecificWarnings)</DisableSpecificWarnings>
-      <FloatingPointModel>Precise</FloatingPointModel>__VCMPL32__
+      <FloatingPointModel>Precise</FloatingPointModel>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      __VCMPL32__
     </ClCompile>
     <ResourceCompile>
       <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>NDEBUG;No_Exception;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ResourceCompile>
     <Link>
-      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>.\..\..\..\win32\__VCVER__\bin\__TKNAM__.dll</OutputFile>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <AdditionalLibraryDirectories>..\..\..\win32\__VCVER__\lib;$(CSF_OPT_LIB32);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>No</GenerateDebugInformation>
+      <GenerateDebugInformation>__VCReleasePDB__</GenerateDebugInformation>
       <ProgramDatabaseFile>.\..\..\..\win32\__VCVER__\bin\__TKNAM__.pdb</ProgramDatabaseFile>
       <SubSystem>Console</SubSystem>
       <ImportLibrary>..\..\..\win32\__VCVER__\lib\__TKNAM__.lib</ImportLibrary>
+      __VCLNKREL__
+      __UWP_GENERATE_METADATA__
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
@@ -141,14 +150,16 @@
       <CompileAs>Default</CompileAs>
       <DisableSpecificWarnings>%(DisableSpecificWarnings)</DisableSpecificWarnings>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <FloatingPointModel>Precise</FloatingPointModel>__VCMPL32__
+      <FloatingPointModel>Precise</FloatingPointModel>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      __VCMPL32__
     </ClCompile>
     <ResourceCompile>
       <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_DEBUG;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ResourceCompile>
     <Link>
-      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>.\..\..\..\win32\__VCVER__\bind\__TKNAM__.dll</OutputFile>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <AdditionalLibraryDirectories>..\..\..\win32\__VCVER__\libd;$(CSF_OPT_LIB32D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
@@ -156,6 +167,7 @@
       <ProgramDatabaseFile>..\..\..\win32\__VCVER__\bind\__TKNAM__.pdb</ProgramDatabaseFile>
       <SubSystem>Console</SubSystem>
       <ImportLibrary>..\..\..\win32\__VCVER__\libd\__TKNAM__.lib</ImportLibrary>
+      __UWP_GENERATE_METADATA__
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@@ -185,21 +197,25 @@
       <WarningLevel>Level4</WarningLevel>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <DisableSpecificWarnings>%(DisableSpecificWarnings)</DisableSpecificWarnings>
-      <FloatingPointModel>Precise</FloatingPointModel>__VCMPL64__
+      <FloatingPointModel>Precise</FloatingPointModel>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      __VCMPL64__
     </ClCompile>
     <ResourceCompile>
       <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>NDEBUG;No_Exception;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ResourceCompile>
     <Link>
-      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>.\..\..\..\win64\__VCVER__\bin\__TKNAM__.dll</OutputFile>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <AdditionalLibraryDirectories>..\..\..\win64\__VCVER__\lib;$(CSF_OPT_LIB64);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>No</GenerateDebugInformation>
+      <GenerateDebugInformation>__VCReleasePDB__</GenerateDebugInformation>
       <ProgramDatabaseFile>.\..\..\..\win64\__VCVER__\bin\__TKNAM__.pdb</ProgramDatabaseFile>
       <SubSystem>Console</SubSystem>
       <ImportLibrary>..\..\..\win64\__VCVER__\lib\__TKNAM__.lib</ImportLibrary>
+      __VCLNKREL__
+      __UWP_GENERATE_METADATA__
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -230,14 +246,16 @@
       <CompileAs>Default</CompileAs>
       <DisableSpecificWarnings>%(DisableSpecificWarnings)</DisableSpecificWarnings>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <FloatingPointModel>Precise</FloatingPointModel>__VCMPL64__
+      <FloatingPointModel>Precise</FloatingPointModel>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      __VCMPL64__
     </ClCompile>
     <ResourceCompile>
       <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_DEBUG;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ResourceCompile>
     <Link>
-      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>.\..\..\..\win64\__VCVER__\bind\__TKNAM__.dll</OutputFile>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <AdditionalLibraryDirectories>..\..\..\win64\__VCVER__\libd;$(CSF_OPT_LIB64D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
@@ -245,6 +263,7 @@
       <ProgramDatabaseFile>..\..\..\win64\__VCVER__\bind\__TKNAM__.pdb</ProgramDatabaseFile>
       <SubSystem>Console</SubSystem>
       <ImportLibrary>..\..\..\win64\__VCVER__\libd\__TKNAM__.lib</ImportLibrary>
+      __UWP_GENERATE_METADATA__
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>

adm/templates/template.vc10x

@@ -106,10 +106,12 @@
       <AdditionalDependencies>__TKDEP__;%(AdditionalDependencies)</AdditionalDependencies>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <AdditionalLibraryDirectories>..\..\..\win32\__VCVER__\lib;$(CSF_OPT_LIB32);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>No</GenerateDebugInformation>
+      <GenerateDebugInformation>__VCReleasePDB__</GenerateDebugInformation>
       <ProgramDatabaseFile>.\..\..\..\win32\__VCVER__\bin\__XQTNAM__.pdb</ProgramDatabaseFile>
       <SubSystem>Console</SubSystem>
       <ImportLibrary>..\..\..\win32\__VCVER__\lib\__XQTNAM__.lib</ImportLibrary>
+      <AdditionalOptions>/LARGEADDRESSAWARE %(AdditionalOptions)</AdditionalOptions>
+      __VCLNKREL__
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
@@ -154,6 +156,7 @@
       <ProgramDatabaseFile>..\..\..\win32\__VCVER__\bind\__XQTNAM__.pdb</ProgramDatabaseFile>
       <SubSystem>Console</SubSystem>
       <ImportLibrary>..\..\..\win32\__VCVER__\libd\__XQTNAM__.lib</ImportLibrary>
+      <AdditionalOptions>/LARGEADDRESSAWARE %(AdditionalOptions)</AdditionalOptions>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@@ -193,10 +196,11 @@
       <AdditionalDependencies>__TKDEP__;%(AdditionalDependencies)</AdditionalDependencies>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <AdditionalLibraryDirectories>..\..\..\win64\__VCVER__\lib;$(CSF_OPT_LIB64);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>No</GenerateDebugInformation>
+      <GenerateDebugInformation>__VCReleasePDB__</GenerateDebugInformation>
       <ProgramDatabaseFile>.\..\..\..\win64\__VCVER__\bin\__XQTNAM__.pdb</ProgramDatabaseFile>
       <SubSystem>Console</SubSystem>
       <ImportLibrary>..\..\..\win64\__VCVER__\lib\__XQTNAM__.lib</ImportLibrary>
+      __VCLNKREL__
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

adm/templates/template.vc7

@@ -36,7 +36,7 @@
 				Name="VCCustomBuildTool"/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="__TKDEP__ opengl32.lib ws2_32.lib vfw32.lib odbc32.lib odbccp32.lib"
+				AdditionalDependencies="__TKDEP__ opengl32.lib ws2_32.lib odbc32.lib odbccp32.lib"
 				OutputFile=".\..\..\..\win32\vc7\bin\__TKNAM__.dll"
 				LinkIncremental="1"
 				SuppressStartupBanner="TRUE"
@@ -105,7 +105,7 @@
 				Name="VCCustomBuildTool"/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="__TKDEP__ opengl32.lib ws2_32.lib vfw32.lib odbc32.lib odbccp32.lib"
+				AdditionalDependencies="__TKDEP__ opengl32.lib ws2_32.lib odbc32.lib odbccp32.lib"
 				OutputFile=".\..\..\..\win32\vc7\bind\__TKNAM__.dll"
 				LinkIncremental="1"
 				SuppressStartupBanner="TRUE"

adm/templates/template.vc8

@@ -78,7 +78,7 @@
 			/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="__TKDEP__ opengl32.lib ws2_32.lib vfw32.lib odbc32.lib odbccp32.lib"
+				AdditionalDependencies="__TKDEP__ opengl32.lib ws2_32.lib odbc32.lib odbccp32.lib"
 				OutputFile=".\..\..\..\win32\vc8\bin\__TKNAM__.dll"
 				LinkIncremental="1"
 				SuppressStartupBanner="true"
@@ -178,7 +178,7 @@
 			/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="__TKDEP__ opengl32.lib ws2_32.lib vfw32.lib odbc32.lib odbccp32.lib"
+				AdditionalDependencies="__TKDEP__ opengl32.lib ws2_32.lib odbc32.lib odbccp32.lib"
 				OutputFile=".\..\..\..\win32\vc8\bind\__TKNAM__.dll"
 				LinkIncremental="1"
 				SuppressStartupBanner="true"
@@ -276,7 +276,7 @@
 			/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="__TKDEP__ opengl32.lib ws2_32.lib vfw32.lib odbc32.lib odbccp32.lib"
+				AdditionalDependencies="__TKDEP__ opengl32.lib ws2_32.lib odbc32.lib odbccp32.lib"
 				OutputFile=".\..\..\..\win64\vc8\bin\__TKNAM__.dll"
 				LinkIncremental="1"
 				SuppressStartupBanner="true"
@@ -376,7 +376,7 @@
 			/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="__TKDEP__ opengl32.lib ws2_32.lib vfw32.lib odbc32.lib odbccp32.lib"
+				AdditionalDependencies="__TKDEP__ opengl32.lib ws2_32.lib odbc32.lib odbccp32.lib"
 				OutputFile=".\..\..\..\win64\vc8\bind\__TKNAM__.dll"
 				LinkIncremental="1"
 				SuppressStartupBanner="true"

adm/templates/template.vc9

@@ -79,7 +79,7 @@
 			/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="__TKDEP__ ws2_32.lib vfw32.lib"
+				AdditionalDependencies="__TKDEP__ ws2_32.lib"
 				OutputFile=".\..\..\..\win32\vc9\bin\__TKNAM__.dll"
 				LinkIncremental="1"
 				SuppressStartupBanner="true"
@@ -178,7 +178,7 @@
 			/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="__TKDEP__ ws2_32.lib vfw32.lib"
+				AdditionalDependencies="__TKDEP__ ws2_32.lib"
 				OutputFile=".\..\..\..\win32\vc9\bind\__TKNAM__.dll"
 				LinkIncremental="1"
 				SuppressStartupBanner="true"
@@ -272,7 +272,7 @@
 			/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="__TKDEP__ ws2_32.lib vfw32.lib"
+				AdditionalDependencies="__TKDEP__ ws2_32.lib"
 				OutputFile=".\..\..\..\win64\vc9\bin\__TKNAM__.dll"
 				LinkIncremental="1"
 				SuppressStartupBanner="true"
@@ -368,7 +368,7 @@
 			/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="__TKDEP__ ws2_32.lib vfw32.lib"
+				AdditionalDependencies="__TKDEP__ ws2_32.lib"
 				OutputFile=".\..\..\..\win64\vc9\bind\__TKNAM__.dll"
 				LinkIncremental="1"
 				SuppressStartupBanner="true"

adm/upgrade.dat

@@ -2,6 +2,7 @@
 BRepExtrema_OverlappedSubShapes BRepExtrema_MapOfIntegerPackedMapOfInteger
 ShapeConstruct_CompBezierCurves2dToBSplineCurve2d Convert_CompBezierCurves2dToBSplineCurve2d
 ShapeConstruct_CompBezierCurves2dToBSplineCurve Convert_CompBezierCurves2dToBSplineCurve
+Image_PixMap::Img Image_Format_
 
 [tcollection]
 AdvApp2Var_SequenceOfNode
@@ -800,13 +801,6 @@ TDF_LabelSequence
 TDocStd_LabelIDMapDataMap
 TDocStd_SequenceOfApplicationDelta
 TDocStd_SequenceOfDocument
-TestTopOpeDraw_Array1OfDrawableMesure
-TestTopOpeDraw_Array1OfDrawableP3D
-TestTopOpeDraw_HArray1OfDrawableMesure
-TestTopOpeDraw_HArray1OfDrawableP3D
-TestTopOpeDraw_ListOfPnt2d
-TestTopOpeTools_Array1OfMesure
-TestTopOpeTools_HArray1OfMesure
 TFunction_Array1OfDataMapOfGUIDDriver
 TFunction_DataMapOfGUIDDriver
 TFunction_DataMapOfLabelListOfLabel

adm/vcver.bat

@@ -0,0 +1,30 @@
+@echo off
+rem Decode VCVER variable and define related ones:
+rem
+rem VCFMT - "vc" followed by full version number of Visual Studio toolset
+rem         (same as VCVER without optional suffix "-uwp")
+rem VCLIB - name of folder contining binaries
+rem         (same as VCVER except without third version in number)
+rem VCPROP - name of required Visual Studion Workload (starting with VS 2017)
+rem
+rem Note that for VS before 2015 (vc14) always
+rem VCFMT=VCLIB=VCVER and VCPROP=NativeDesktop
+
+rem Since VS 2017, environment variables like VS100COMNTOOLS are not defined 
+rem any more, we can only use vswhere.exe tool to find Visual Studio.
+rem Add path to vswhere.exe
+set "PATH=%PATH%;%ProgramFiles(x86)%\Microsoft Visual Studio\Installer"
+
+rem for vc10-12, interpretation is trivial
+set VCFMT=%VCVER%
+set VCLIB=%VCVER:~0,4%
+set VCPROP=NativeDesktop
+
+rem vc14 and later can have optional suffix "-uwp"
+if "%VCVER:~-4%" == "-uwp" (
+  set VCFMT=%VCVER:~0,-4%
+  set VCLIB=%VCLIB%-uwp
+  set VCPROP=Universal
+)
+
+rem echo VCVER=%VCVER% VCFMT=%VCFMT% VCLIB=%VCLIB% VCPROP=%VCPROP%

dox/CMakeLists.txt

@@ -35,7 +35,7 @@ endif()
 # configuration file for doxygen
 set (OCCT_CONFIG_FOR_DOXYGEN "${OCCT_GENERATED_DOC_DIR}/occt.cfg")
 
-set (3RDPARTY_MATHJAX_RELATIVE_PATH "http://cdn.mathjax.org/mathjax/latest")
+set (3RDPARTY_MATHJAX_RELATIVE_PATH "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1")
 
 configure_file ("${OCCT_OVERVIEW_RESOURCE_DIR}/occt_ug_html.doxyfile" "${OCCT_CONFIG_FOR_DOXYGEN}" COPYONLY)
 
@@ -92,11 +92,22 @@ file (APPEND ${OCCT_CONFIG_FOR_DOXYGEN} "\nMATHJAX_RELPATH        = ${3RDPARTY_M
 # Copy index file to provide fast access to HTML documentation
 file(COPY "${OCCT_OVERVIEW_RESOURCE_DIR}/index.html" DESTINATION "${OCCT_GENERATED_OVERVIEW_DIR}")
 
-add_custom_target (${PROJECT_NAME}
-                   COMMAND ${3RDPARTY_DOXYGEN_EXECUTABLE} ${OCCT_CONFIG_FOR_DOXYGEN}
-                   WORKING_DIRECTORY ${OCCT_GENERATED_DOC_DIR}
-                   COMMENT "Generating OCCT overview documentation with Doxygen"
-                   SOURCES ${OCCT_ARTICLES_ABSPATH}
-                   VERBATIM)
+# get relative paths to documentation source files
+file (GLOB_RECURSE OCCT_OVERVIEW_FILES "${OCCT_OVERVIEW_DIR}/*")
 
+add_custom_command(OUTPUT "${OCCT_GENERATED_DOC_DIR}/overview/html/occt_logo.png"
+  COMMAND ${3RDPARTY_DOXYGEN_EXECUTABLE} ${OCCT_CONFIG_FOR_DOXYGEN}
+  DEPENDS ${OCCT_OVERVIEW_FILES}
+  WORKING_DIRECTORY ${OCCT_GENERATED_DOC_DIR}
+  COMMENT "Generating OCCT overview documentation with Doxygen"
+  VERBATIM
+)
+
+add_custom_target(${PROJECT_NAME} ALL
+  DEPENDS "${OCCT_GENERATED_DOC_DIR}/overview/html/occt_logo.png" ${OCCT_OVERVIEW_FILES}
+  SOURCES ${OCCT_ARTICLES_ABSPATH}
+  VERBATIM
+)
+
+# Create Documentation folder in solution view
 set_property (TARGET ${PROJECT_NAME} PROPERTY FOLDER "Documentation")

dox/dev_guides/building/3rdparty/3rdparty_windows.md

@@ -112,13 +112,11 @@ FreeType is required for text display in a 3D viewer. You can download its sourc
 
 5. If you build FreeType for a 64 bit platform, select in the main menu **Build - Configuration Manager**  and add *x64* platform to the solution configuration by copying the settings from Win32 platform: 
 
-   @image html /dev_guides/building/3rdparty/images/3rdparty_image001.png 
-   @image latex /dev_guides/building/3rdparty/images/3rdparty_image001.png 
+   @figure{/dev_guides/building/3rdparty/images/3rdparty_image001.png}
 
    Update the value of the Output File for  x64 configuration: 
 
-   @image html /dev_guides/building/3rdparty/images/3rdparty_image003.png 
-   @image latex /dev_guides/building/3rdparty/images/3rdparty_image003.png 
+   @figure{/dev_guides/building/3rdparty/images/3rdparty_image003.png}
 
    Build the *freetype* project. 
 
@@ -207,24 +205,20 @@ You can download its sources from  http://geuz.org/gl2ps/src/.
 
    * Press  **Configure** button. 
    
-     @image html /dev_guides/building/3rdparty/images/3rdparty_image004.png 
-     @image latex /dev_guides/building/3rdparty/images/3rdparty_image004.png 
+     @figure{/dev_guides/building/3rdparty/images/3rdparty_image004.png}
 
    * Select the generator (the compiler  and the target platform -- 32 or 64 bit) in the pop-up window. 
    
-     @image html /dev_guides/building/3rdparty/images/3rdparty_image005.png 
-     @image latex /dev_guides/building/3rdparty/images/3rdparty_image005.png 
+     @figure{/dev_guides/building/3rdparty/images/3rdparty_image005.png}
 
    * Press **Finish** button to  return to the main CMake window. 
      Expand the ENABLE group and uncheck  ENABLE_PNG and ENABLE_ZLIB check boxes. 
 	 
-     @image html /dev_guides/building/3rdparty/images/3rdparty_image006.png 
-     @image latex /dev_guides/building/3rdparty/images/3rdparty_image006.png 
+     @figure{/dev_guides/building/3rdparty/images/3rdparty_image006.png}
 
    * Expand the CMAKE group and define *CMAKE_INSTALL_PREFIX* which is the path where you want to install the build results, for example, *c:\\occ3rdparty\\gl2ps-1.3.5*. 
    
-     @image html /dev_guides/building/3rdparty/images/3rdparty_image007.png 
-     @image latex /dev_guides/building/3rdparty/images/3rdparty_image007.png 
+     @figure{/dev_guides/building/3rdparty/images/3rdparty_image007.png}
 
    * Press **Configure** button again, then press **Generate** button to generate Visual Studio projects. After completion, close CMake application. 
 

dox/dev_guides/building/android/android.md

@@ -10,32 +10,40 @@ The steps on Windows and Ubuntu are similar. There is the only one difference: m
 on Windows and native GNU make on Ubuntu.
 
 Required tools (download and install if it is required):
-  - CMake v3.0+ http://www.cmake.org/cmake/resources/software.html
-  - Cross-compilation toolchain for CMake https://github.com/taka-no-me/android-cmake
+  - CMake v3.7+ http://www.cmake.org/cmake/resources/software.html
   - Android NDK rev.10+ https://developer.android.com/tools/sdk/ndk/index.html
   - GNU Make: MinGW v4.82+ for Windows (http://sourceforge.net/projects/mingw/files/), GNU Make 4.0 for Ubuntu. 
-  
-## Generation of makefiles
+
+## Prerequisites
+
+In toolchain file <i>$CASROOT/adm/templates/android.toolchain.config.cmake</i>:
+
+  - Set CMAKE_ANDROID_NDK variable equal to your Android NDK path.
+  - Set CMAKE_ANDROID_STL_TYPE variable to specify which C++ standard library to use.
+
+The default value of CMAKE_ANDROID_STL_TYPE is <i>gnustl_shared</i> (GNU libstdc++ Shared)
+
+@figure{/dev_guides/building/android/images/android_image001.png}
+
+## Generation of makefiles using CMake GUI tool
 Run GUI tool provided by CMake: cmake-gui
 
 ### Tools configuration
   - Specify the root folder of OCCT (<i>$CASROOT</i>, which contains *CMakelists.txt* file) by clicking **Browse Source**.
   - Specify the location (build folder) for Cmake generated project files by clicking **Browse Build**.
 
-@figure{/dev_guides/building/android/images/android_image001.png}
+@figure{/dev_guides/building/android/images/android_image002.png}
 
 Click **Configure** button. It opens the window with a drop-down list of generators supported by CMake project.
 
-Select "MinGW MakeFiles" item from the list
+Select "MinGW Makefiles" item from the list
   - Choose "Specify toolchain file for cross-compiling"
   - Click "Next"
-@figure{/dev_guides/building/android/images/android_image002.png}
 
-  - Specify a toolchain file at the next dialog by android.toolchain.cmake . It is contained by cross-compilation toolchain for CMake
-  - Click "Finish"
 @figure{/dev_guides/building/android/images/android_image003.png}
 
-If ANDROID_NDK environment variable is not defined in current OS, add cache entry ANDROID_NDK (entry type is PATH) -- path to the NDK folder ("Add Entry" button)
+  - Specify a toolchain file at the next dialog by <i>android.toolchain.config.cmake</i> . It is contained by cross-compilation toolchain for CMake
+  - Click "Finish"
 @figure{/dev_guides/building/android/images/android_image004.png}
 
 If on Windows the message is appeared: "CMake Error: CMake was unable to find a build program corresponding to "MinGW Makefiles"
@@ -46,18 +54,19 @@ specify **CMAKE_MAKE_PROGRAM** to mingw32-make executable.
 ### OCCT Configuration
 
 How to configure OCCT, see "OCCT Configuration" section of @ref occt_dev_guides__building_cmake "Building with CMake"
-taking into account the specific configuration variables for android:
-  - ANDROID_ABI = armeabi-v7a
-  - ANDROID_NATIVE_API_LEVEL = 15
-  - ANDROID_NDK_LAYOUT is equal to CMAKE_BUILD_TYPE variable
-  - **BUILD_MODULE_Draw = OFF**
-
-@figure{/dev_guides/building/android/images/android_image006.png}
 
 ### Generation of makefiles
 
 Click **Generate** button and wait until the generation process is finished. 
-Then makefiles will appear in the build folder (e.g. <i> D:/tmp/occt-android </i>).
+Then makefiles will appear in the build folder (e.g. <i> D:/occt/build-android </i>).
+
+## Generation of makefiles using CMake from the command line
+
+Alternatively one may specify the values without a toolchain file:
+
+> cmake -G "MinGW Makefiles" -DCMAKE_SYSTEM_NAME=Android -DCMAKE_ANDROID_NDK=D:/DevTools/android-ndk-r13b -DCMAKE_ANDROID_STL_TYPE=gnustl_shared -DCMAKE_SYSTEM_VERSION=15 -DCMAKE_ANDROID_ARCH_ABI=armeabi-v7a -DCMAKE_MAKE_PROGRAM=D:/DevTools/MinGW/bin/mingw32-make.exe -D3RDPARTY_DIR=D:/occt-3rdparty D:/occt
+
+@figure{/dev_guides/building/android/images/android_image006.png}
 
 ## Building makefiles of OCCT