0024786: Move functionality of WOK command wgenproj to OCCT tool genproj
authorski <ski@opencascade.com>
Wed, 9 Jul 2014 09:37:07 +0000 (13:37 +0400)
committerabv <abv@opencascade.com>
Thu, 16 Jul 2015 14:22:33 +0000 (17:22 +0300)
WOK scripts used in generation of MSVC projects are put to adm/genproj.tcl
Batch script genproj.bat added, replacing 'wgenproj' command of WOK.

WOK tool for configuring custom.bat is also copied; it is called by genproj if custom.bat does not exist

Environment variable SHORTCUT_HEADERS can be defined in custom.bat to have headers put in inc just shortcuts to actual headers, instead of copies.
Corresponding option "copy OCCT short-cut headers instead of original one to inc folder" is added to genconf dialog

36 files changed:
.gitignore
CMakeLists.txt
adm/CMPLRS [new file with mode: 0644]
adm/genconf.tcl [new file with mode: 0644]
adm/genconfdeps.tcl [new file with mode: 0644]
adm/genproj.tcl [new file with mode: 0644]
adm/templates/acinclude.m4 [new file with mode: 0644]
adm/templates/codeblocks.sh [new file with mode: 0644]
adm/templates/draw.bat
adm/templates/draw.sh
adm/templates/env.bat [new file with mode: 0644]
adm/templates/env.sh [new file with mode: 0644]
adm/templates/msvc.bat [new file with mode: 0644]
adm/templates/template.ac [new file with mode: 0644]
adm/templates/template.mam [new file with mode: 0644]
adm/templates/template.mamx [new file with mode: 0644]
adm/templates/template.plist [new file with mode: 0644]
adm/templates/template.vc10 [new file with mode: 0644]
adm/templates/template.vc10x [new file with mode: 0644]
adm/templates/template.vc11 [new file with mode: 0644]
adm/templates/template.vc11x [new file with mode: 0644]
adm/templates/template.vc12 [new file with mode: 0644]
adm/templates/template.vc12x [new file with mode: 0644]
adm/templates/template.vc7 [new file with mode: 0644]
adm/templates/template.vc7x [new file with mode: 0644]
adm/templates/template.vc8 [new file with mode: 0644]
adm/templates/template.vc8x [new file with mode: 0644]
adm/templates/template.vc9 [new file with mode: 0644]
adm/templates/template.vc9x [new file with mode: 0644]
adm/templates/template.xcscheme [new file with mode: 0644]
adm/templates/template_dll.rc [new file with mode: 0644]
adm/templates/vcproj.user.vc9x [new file with mode: 0644]
adm/templates/vcxproj.user.vc10x [new file with mode: 0644]
adm/templates/vcxproj.user.vc11x [new file with mode: 0644]
adm/templates/vcxproj.user.vc12x [new file with mode: 0644]
genproj.bat [new file with mode: 0644]

index 51b72b1..628c67e 100644 (file)
@@ -43,12 +43,12 @@ Release
 # Emacs backup files
 *~
 
-#Generated files
+# Generated files
 /*.am
 /*.m4
 /*.ac
 /*.sh
-/*.bat
+/custom.bat
 /autom4te.cache
 /build_configure
 /configure
index 8e17d93..238ffa3 100644 (file)
@@ -295,86 +295,85 @@ if ("${INSTALL_DIR}" STREQUAL "")
   set (CMAKE_INSTALL_PREFIX "${INSTALL_DIR}" CACHE INTERNAL "" FORCE )
 
   message (STATUS "INSTALL_DIR has been set as ${INSTALL_DIR}")
-else()
+endif()
 
-  OCCT_INSTALL_FILE_OR_DIR ("data" "${INSTALL_DIR}")
-  OCCT_INSTALL_FILE_OR_DIR ("samples/tcl" "${INSTALL_DIR}/samples")
+OCCT_INSTALL_FILE_OR_DIR ("data" "${INSTALL_DIR}")
+OCCT_INSTALL_FILE_OR_DIR ("samples/tcl" "${INSTALL_DIR}/samples")
 
-  if (INSTALL_SAMPLES)
-    OCCT_INSTALL_FILE_OR_DIR ("samples" "${INSTALL_DIR}")
-  endif()
+if (INSTALL_SAMPLES)
+  OCCT_INSTALL_FILE_OR_DIR ("samples" "${INSTALL_DIR}")
+endif()
 
-  if (TESTS_INSTALL)
-    OCCT_INSTALL_FILE_OR_DIR ("tests" "${INSTALL_DIR}")
-  endif()
+if (TESTS_INSTALL)
+  OCCT_INSTALL_FILE_OR_DIR ("tests" "${INSTALL_DIR}")
+endif()
 
-  if (WIN32)
-    set (SCRIPT_EXT bat)
-  else()
-    set (SCRIPT_EXT sh)
-  endif()
+if (WIN32)
+  set (SCRIPT_EXT bat)
+else()
+  set (SCRIPT_EXT sh)
+endif()
 
-  # Creation of "START_TESTS" project
-  if (TESTS_RUN AND TESTS_INSTALL)
-    #set(BUILD_TESTING ON)
-    #enable_testing ()
-    #add_test(NAME RUN_TESTS COMMAND ${INSTALL_DIR}/draw.${SCRIPT_EXT} -c testgrid -overwrite -outdir ${INSTALL_DIR}/TestResults)
-    add_custom_target(START_TESTS ${INSTALL_DIR}/draw.${SCRIPT_EXT} -c testgrid -overwrite -outdir ${INSTALL_DIR}/TestResults DEPENDS INSTALL)
-  endif()
+# Creation of "START_TESTS" project
+if (TESTS_RUN AND TESTS_INSTALL)
+  #set(BUILD_TESTING ON)
+  #enable_testing ()
+  #add_test(NAME RUN_TESTS COMMAND ${INSTALL_DIR}/draw.${SCRIPT_EXT} -c testgrid -overwrite -outdir ${INSTALL_DIR}/TestResults)
+  add_custom_target(START_TESTS ${INSTALL_DIR}/draw.${SCRIPT_EXT} -c testgrid -overwrite -outdir ${INSTALL_DIR}/TestResults DEPENDS INSTALL)
+endif()
 
-  # Creation of "GenerateDocumentation" project
-  if (DOC_GENERATE_OVERVIEW OR DOC_GENERATE_REFMAN)
-    OCCT_INCLUDE_CMAKE_FILE("adm/cmake/occt_gendoc")
-    if(DOC_GENERATE_OVERVIEW)
-      gendoc(-overview -${DOC_OVERVIEW_OUTPUT_FORMAT})
-    endif()
-    if(DOC_GENERATE_REFMAN)
-      gendoc(-refman -html)
-    endif()
+# Creation of "GenerateDocumentation" project
+if (DOC_GENERATE_OVERVIEW OR DOC_GENERATE_REFMAN)
+  OCCT_INCLUDE_CMAKE_FILE("adm/cmake/occt_gendoc")
+  if(DOC_GENERATE_OVERVIEW)
+    gendoc(-overview -${DOC_OVERVIEW_OUTPUT_FORMAT})
   endif()
-
-  # DRAW.BAT or DRAW.SH
-  if (NOT "${BUILD_PATCH_DIR}" STREQUAL "" AND EXISTS "${BUILD_PATCH_DIR}/adm/templates/draw.${SCRIPT_EXT}")
-    install (FILES "${BUILD_PATCH_DIR}/adm/templates/draw.${SCRIPT_EXT}" DESTINATION  "${INSTALL_DIR}" 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}" PERMISSIONS
-            OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_WRITE GROUP_EXECUTE WORLD_READ WORLD_WRITE WORLD_EXECUTE)
+  if(DOC_GENERATE_REFMAN)
+    gendoc(-refman -html)
   endif()
-  OCCT_COPY_FILE_OR_DIR ("adm/templates/draw.${SCRIPT_EXT}" "${CMAKE_BINARY_DIR}")
+endif()
 
-  set (SUB_CUSTOM "custom_${COMPILER}_${COMPILER_BITNESS}.${SCRIPT_EXT}")
+# DRAW.BAT or DRAW.SH
+if (NOT "${BUILD_PATCH_DIR}" STREQUAL "" AND EXISTS "${BUILD_PATCH_DIR}/adm/templates/draw.${SCRIPT_EXT}")
+  install (FILES "${BUILD_PATCH_DIR}/adm/templates/draw.${SCRIPT_EXT}" DESTINATION  "${INSTALL_DIR}" 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}" PERMISSIONS
+          OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_WRITE GROUP_EXECUTE WORLD_READ WORLD_WRITE WORLD_EXECUTE)
+endif()
+OCCT_COPY_FILE_OR_DIR ("adm/templates/draw.${SCRIPT_EXT}" "${CMAKE_BINARY_DIR}")
 
-  if (WIN32)
-    set (ADDITIONAL_CUSTOM_CONTENT "\nif exist \"%~dp0${SUB_CUSTOM}\" (\n  call \"%~dp0${SUB_CUSTOM}\" %VCVER% %ARCH% %CASDEB% \n)")
-  else()
-    set (ADDITIONAL_CUSTOM_CONTENT "\nif [ -e \"\${aScriptPath}/${SUB_CUSTOM}\" ]; then\n  source \"\${aScriptPath}/${SUB_CUSTOM}\" \"\${COMPILER}\" \"\${WOKSTATION}\${ARCH}\" \"\${CASDEB}\" \nfi")
-  endif()
+set (SUB_CUSTOM "custom_${COMPILER}_${COMPILER_BITNESS}.${SCRIPT_EXT}")
 
-   # change custom.bat/sh
-  if (EXISTS "${INSTALL_DIR}/custom.${SCRIPT_EXT}")
-    file (READ "${INSTALL_DIR}/custom.${SCRIPT_EXT}" CUSTOM_CONTENT)
+if (WIN32)
+  set (ADDITIONAL_CUSTOM_CONTENT "\nif exist \"%~dp0${SUB_CUSTOM}\" (\n  call \"%~dp0${SUB_CUSTOM}\" %VCVER% %ARCH% %CASDEB% \n)")
+else()
+  set (ADDITIONAL_CUSTOM_CONTENT "\nif [ -e \"\${aScriptPath}/${SUB_CUSTOM}\" ]; then\n  source \"\${aScriptPath}/${SUB_CUSTOM}\" \"\${COMPILER}\" \"\${WOKSTATION}\${ARCH}\" \"\${CASDEB}\" \nfi")
+endif()
 
-    set (CUSTOM_CONTENT "${CUSTOM_CONTENT} ${ADDITIONAL_CUSTOM_CONTENT}")
+ # change custom.bat/sh
+if (EXISTS "${INSTALL_DIR}/custom.${SCRIPT_EXT}")
+  file (READ "${INSTALL_DIR}/custom.${SCRIPT_EXT}" CUSTOM_CONTENT)
 
-    file (WRITE "${INSTALL_DIR}/custom.${SCRIPT_EXT}" "${CUSTOM_CONTENT}")
-  else()
-    OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.${SCRIPT_EXT}.main" "custom.${SCRIPT_EXT}" "${INSTALL_DIR}")
-  endif()
+  set (CUSTOM_CONTENT "${CUSTOM_CONTENT} ${ADDITIONAL_CUSTOM_CONTENT}")
 
-  # write current custom.bat/sh
-  OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.${SCRIPT_EXT}.in" "${SUB_CUSTOM}" "${INSTALL_DIR}")
+  file (WRITE "${INSTALL_DIR}/custom.${SCRIPT_EXT}" "${CUSTOM_CONTENT}")
+else()
+  OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.${SCRIPT_EXT}.main" "custom.${SCRIPT_EXT}" "${INSTALL_DIR}")
+endif()
 
-  if (BUILD_MFC_SAMPLES)
-    OCCT_INSTALL_FILE_OR_DIR ("adm/templates/sample.bat" "${INSTALL_DIR}")
-    OCCT_COPY_FILE_OR_DIR ("adm/templates/sample.bat" "${CMAKE_BINARY_DIR}")
-  endif()
+# write current custom.bat/sh
+OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.${SCRIPT_EXT}.in" "${SUB_CUSTOM}" "${INSTALL_DIR}")
 
-  OCCT_CONFIGURE ("adm/templates/env.build.${SCRIPT_EXT}.in" "env.${SCRIPT_EXT}")
-  OCCT_CONFIGURE ("adm/templates/env.${SCRIPT_EXT}.in" "env.install.${SCRIPT_EXT}")
-  install (FILES "${CMAKE_BINARY_DIR}/env.install.${SCRIPT_EXT}" DESTINATION  "${INSTALL_DIR}" RENAME "env.${SCRIPT_EXT}")
+if (BUILD_MFC_SAMPLES)
+  OCCT_INSTALL_FILE_OR_DIR ("adm/templates/sample.bat" "${INSTALL_DIR}")
+  OCCT_COPY_FILE_OR_DIR ("adm/templates/sample.bat" "${CMAKE_BINARY_DIR}")
 endif()
 
+OCCT_CONFIGURE ("adm/templates/env.build.${SCRIPT_EXT}.in" "env.${SCRIPT_EXT}")
+OCCT_CONFIGURE ("adm/templates/env.${SCRIPT_EXT}.in" "env.install.${SCRIPT_EXT}")
+install (FILES "${CMAKE_BINARY_DIR}/env.install.${SCRIPT_EXT}" DESTINATION  "${INSTALL_DIR}" RENAME "env.${SCRIPT_EXT}")
+
 # RESOURCES
 FILE_TO_LIST ("adm/RESOURCES" RESOURCES)
 foreach(RESOURCE ${RESOURCES})
diff --git a/adm/CMPLRS b/adm/CMPLRS
new file mode 100644 (file)
index 0000000..e62e1b3
--- /dev/null
@@ -0,0 +1,33 @@
+wnt WOKSteps_exec_link DRAWEXE #WOKStep_EXELink(exec.tks)
+lin WOKSteps_exec_link DRAWEXE #WOKStep_EXELink(exec.tks)
+
+wnt cmplrs_cxx f -DWNT -D_WINDOWS -D_CRT_SECURE_NO_DEPRECATE -DHAVE_FREEIMAGE -DHAVE_GL2PS -DHAVE_TBB -DHAVE_OPENCL
+wnt cmplrs_cxx b -DWNT -D_WINDOWS -D_CRT_SECURE_NO_DEPRECATE -DHAVE_FREEIMAGE -DHAVE_GL2PS -DHAVE_TBB -DHAVE_OPENCL
+wnt cmplrs_cxx Aspect (wnt cmplrs_cxx b) -D_AFXDLL
+wnt cmplrs_cxx WNT (wnt cmplrs_cxx b) -D_AFXDLL -D_AFXDLL
+
+wnt cmplrs_c f -DWNT -D_WINDOWS -D_CRT_SECURE_NO_DEPRECATE -DHAVE_FREEIMAGE -DHAVE_GL2PS -DHAVE_TBB -DHAVE_OPENCL
+wnt cmplrs_c b -DWNT -D_WINDOWS -D_CRT_SECURE_NO_DEPRECATE -DHAVE_FREEIMAGE -DHAVE_GL2PS -DHAVE_TBB -DHAVE_OPENCL
+wnt cmplrs_c NIS (wnt cmplrs_c b) -DSILGL -DSILGL_VRS=50
+
+win csf CSF_TclLibs tcl86.lib
+win csf CSF_TclTkLibs tk86.lib
+win csf CSF_gdi32 gdi32.lib
+win csf CSF_advapi32 advapi32.lib
+win csf CSF_user32 user32.lib
+win csf CSF_advapi32 advapi32.lib
+win csf CSF_gdi32 gdi32.lib
+win csf CSF_user32 user32.lib
+win csf CSF_kernel32 kernel32.lib
+win csf CSF_OpenGlLibs opengl32.lib glu32.lib
+win csf CSF_wsock32 wsock32.lib
+win csf CSF_AviLibs ws2_32.lib vfw32.lib
+
+
+
+lin cmplrs_cxx f -DLIN -DLININTEL -DOCC_CONVERT_SIGNALS -D_GNU_SOURCE=1 -DHAVE_FREEIMAGE -DHAVE_GL2PS -DHAVE_TBB -DHAVE_OPENCL
+lin cmplrs_cxx b -DLIN -DLININTEL -DOCC_CONVERT_SIGNALS -D_GNU_SOURCE=1 -DHAVE_FREEIMAGE -DHAVE_GL2PS -DHAVE_TBB -DHAVE_OPENCL
+
+lin cmplrs_c f -DLIN -DLININTEL -D_GNU_SOURCE=1 -fexceptions
+lin cmplrs_c b -DLIN -DLININTEL -D_GNU_SOURCE=1 -fexceptions
+
diff --git a/adm/genconf.tcl b/adm/genconf.tcl
new file mode 100644 (file)
index 0000000..872b1b2
--- /dev/null
@@ -0,0 +1,517 @@
+#!/usr/bin/tclsh
+
+package require Tk
+
+source "./adm/genconfdeps.tcl"
+
+set aRowIter 0
+frame .myFrame -padx 5 -pady 5
+pack  .myFrame -fill both -expand 1
+
+set SYS_VS_LIST {}
+set SYS_VC_LIST {}
+set SYS_VCVARS_LIST {}
+
+# detect installed Visual Studio instances from global environment
+if { [info exists ::env(VS130COMNTOOLS)] } {
+  lappend ::SYS_VS_LIST "Visual Studio 201x (vc13)"
+  lappend ::SYS_VC_LIST "vc13"
+  lappend ::SYS_VCVARS_LIST "%VS130COMNTOOLS%..\\..\\VC\\vcvarsall.bat"
+}
+if { [info exists ::env(VS120COMNTOOLS)] } {
+  lappend ::SYS_VS_LIST "Visual Studio 2013 (vc12)"
+  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_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_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_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_VC_LIST "vc8"
+  lappend ::SYS_VCVARS_LIST "%VS80COMNTOOLS%..\\..\\VC\\vcvarsall.bat"
+}
+lappend ::SYS_VS_LIST "Custom"
+lappend ::SYS_VC_LIST "vcX"
+lappend ::SYS_VCVARS_LIST "%VSXXCOMNTOOLS%..\\..\\VC\\vcvarsall.bat"
+
+set aVcVerIndex [lsearch $::SYS_VC_LIST $::VCVER]
+set ::VSVER  [lindex $::SYS_VS_LIST     $aVcVerIndex]
+if { "$::VCVARS" == "" } {
+  set ::VCVARS [lindex $::SYS_VCVARS_LIST $aVcVerIndex]
+}
+
+proc wokdep:gui:Close {} {
+  # if changed ask
+  exit
+}
+
+proc wokdep:gui:SwitchConfig {} {
+  set ::VCVER  [lindex $::SYS_VC_LIST     [.myFrame.myVsCombo current]]
+  set ::VCVARS [lindex $::SYS_VCVARS_LIST [.myFrame.myVsCombo current]]
+
+  set ::CSF_OPT_INC {}
+  set ::CSF_OPT_LIB32 {}
+  set ::CSF_OPT_LIB64 {}
+  set ::CSF_OPT_BIN32 {}
+  set ::CSF_OPT_BIN64 {}
+  wokdep:gui:UpdateList
+}
+
+proc wokdep:gui:SwitchArch {} {
+  if { "$::ARCH" == "32" } {
+    wokdep:gui:Show32Bitness ::aRowIter
+  }
+  if { "$::ARCH" == "64" } {
+    wokdep:gui:Show64Bitness ::aRowIter
+  }
+
+  if { [llength [grid info .myFrame.mySave]] != 0 } {
+    grid forget .myFrame.mySave .myFrame.myClose
+  }
+
+  # Bottom section
+  grid .myFrame.mySave  -row $::aRowIter -column 4 -columnspan 2
+  grid .myFrame.myClose -row $::aRowIter -column 6 -columnspan 2
+}
+
+proc wokdep:gui:UpdateList {} {
+  set anIncErrs   {}
+  set anLib32Errs {}
+  set anLib64Errs {}
+  set anBin32Errs {}
+  set anBin64Errs {}
+  wokdep:SearchTclTk     anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
+  wokdep:SearchFreeType  anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
+  wokdep:SearchX11       anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
+  if { "$::HAVE_FREEIMAGE" == "true" } {
+    wokdep:SearchFreeImage anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
+  }
+  if { "$::HAVE_GL2PS" == "true" } {
+    wokdep:SearchGL2PS   anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
+  }
+  if { "$::HAVE_TBB" == "true" } {
+    wokdep:SearchTBB     anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
+  }
+  if { "$::HAVE_OPENCL" == "true" } {
+    wokdep:SearchOpenCL  anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
+  }
+  if { "$::HAVE_VTK" == "true" } {
+    wokdep:SearchVTK  anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
+  }
+  if { "$::CHECK_QT4" == "true" } {
+    wokdep:SearchQt4     anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
+  }
+  if { "$::CHECK_JDK" == "true" } {
+    wokdep:SearchJDK     anIncErrs anLib32Errs anLib64Errs anBin32Errs anBin64Errs
+  }
+
+  .myFrame.myIncErrLbl   configure -text [join $anIncErrs   "\n"]
+  .myFrame.myLib32ErrLbl configure -text [join $anLib32Errs "\n"]
+  .myFrame.myLib64ErrLbl configure -text [join $anLib64Errs "\n"]
+  .myFrame.myBin32ErrLbl configure -text [join $anBin32Errs "\n"]
+  .myFrame.myBin64ErrLbl configure -text [join $anBin64Errs "\n"]
+}
+
+proc wokdep:gui:BrowseVcVars {} {
+  set aResult [tk_chooseDirectory -initialdir $::VCVARS -title "Choose a directory"]
+  if { "$aResult" != "" } {
+    set ::VCVARS $aResult
+  }
+}
+
+proc wokdep:gui:BrowsePartiesRoot {} {
+  set aResult [tk_chooseDirectory -initialdir $::PRODUCTS_PATH -title "Choose a directory"]
+  if { "$aResult" != "" } {
+    set ::PRODUCTS_PATH $aResult
+    wokdep:gui:UpdateList
+  }
+}
+
+proc wokdep:gui:AddIncPath {} {
+  set aResult [tk_chooseDirectory -title "Choose a directory"]
+  if { "$aResult" != "" } {
+    lappend ::CSF_OPT_INC "$aResult"
+    wokdep:gui:UpdateList
+  }
+}
+
+proc wokdep:gui:AddLib32Path {} {
+  set aResult [tk_chooseDirectory -title "Choose a directory"]
+  if { "$aResult" != "" } {
+    lappend ::CSF_OPT_LIB32 "$aResult"
+    wokdep:gui:UpdateList
+  }
+}
+
+proc wokdep:gui:AddLib64Path {} {
+  set aResult [tk_chooseDirectory -title "Choose a directory"]
+  if { "$aResult" != "" } {
+    lappend ::CSF_OPT_LIB64 "$aResult"
+    wokdep:gui:UpdateList
+  }
+}
+
+proc wokdep:gui:AddBin32Path {} {
+  set aResult [tk_chooseDirectory -title "Choose a directory"]
+  if { "$aResult" != "" } {
+    lappend ::CSF_OPT_BIN32 "$aResult"
+    wokdep:gui:UpdateList
+  }
+}
+
+proc wokdep:gui:AddBin64Path {} {
+  set aResult [tk_chooseDirectory -title "Choose a directory"]
+  if { "$aResult" != "" } {
+    lappend ::CSF_OPT_BIN64 "$aResult"
+    wokdep:gui:UpdateList
+  }
+}
+
+proc wokdep:gui:RemoveIncPath {} {
+  set aSelIndices [.myFrame.myIncList curselection]
+  if { [llength $aSelIndices] != 0 } {
+    .myFrame.myIncList delete [lindex $aSelIndices 0]
+  }
+  wokdep:gui:UpdateList
+}
+
+proc wokdep:gui:RemoveLib32Path {} {
+  set aSelIndices [.myFrame.myLib32List curselection]
+  if { [llength $aSelIndices] != 0 } {
+    .myFrame.myLib32List delete [lindex $aSelIndices 0]
+  }
+  wokdep:gui:UpdateList
+}
+
+proc wokdep:gui:RemoveLib64Path {} {
+  set aSelIndices [.myFrame.myLib64List curselection]
+  if { [llength $aSelIndices] != 0 } {
+    .myFrame.myLib64List delete [lindex $aSelIndices 0]
+  }
+  wokdep:gui:UpdateList
+}
+
+proc wokdep:gui:RemoveBin32Path {} {
+  set aSelIndices [.myFrame.myBin32List curselection]
+  if { [llength $aSelIndices] != 0 } {
+    .myFrame.myBin32List delete [lindex $aSelIndices 0]
+  }
+  wokdep:gui:UpdateList
+}
+
+proc wokdep:gui:RemoveBin64Path {} {
+  set aSelIndices [.myFrame.myBin64List curselection]
+  if { [llength $aSelIndices] != 0 } {
+    .myFrame.myBin64List delete [lindex $aSelIndices 0]
+  }
+  wokdep:gui:UpdateList
+}
+
+proc wokdep:gui:ResetIncPath {} {
+  set ::CSF_OPT_INC {}
+  wokdep:gui:UpdateList
+}
+
+proc wokdep:gui:ResetLib32Path {} {
+  set ::CSF_OPT_LIB32 {}
+  wokdep:gui:UpdateList
+}
+
+proc wokdep:gui:ResetLib64Path {} {
+  set ::CSF_OPT_LIB64 {}
+  wokdep:gui:UpdateList
+}
+
+proc wokdep:gui:ResetBin32Path {} {
+  set ::CSF_OPT_BIN32 {}
+  wokdep:gui:UpdateList
+}
+
+proc wokdep:gui:ResetBin64Path {} {
+  set ::CSF_OPT_BIN64 {}
+  wokdep:gui:UpdateList
+}
+
+proc wokdep:gui:Show32Bitness { theRowIter } {
+  upvar $theRowIter aRowIter
+
+  if { [llength [grid info .myFrame.myLib64Lbl]] != 0 } {
+    grid forget .myFrame.myLib64Lbl .myFrame.myLib64List   .myFrame.myLib64Scrl
+    grid forget .myFrame.myLib64Add .myFrame.myLib64Remove .myFrame.myLib64Clear .myFrame.myLib64ErrLbl
+    grid forget .myFrame.myBin64Lbl .myFrame.myBin64List   .myFrame.myBin64Scrl
+    grid forget .myFrame.myBin64Add .myFrame.myBin64Remove .myFrame.myBin64Clear .myFrame.myBin64ErrLbl
+  }
+
+  # Additional libraries (32-bit) search paths
+  grid .myFrame.myLib32Lbl    -row $aRowIter -column 0 -columnspan 10 -sticky w
+  incr aRowIter
+  grid .myFrame.myLib32List   -row $aRowIter -column 0 -rowspan 4 -columnspan 5
+  grid .myFrame.myLib32Scrl   -row $aRowIter -column 5 -rowspan 4
+  grid .myFrame.myLib32Add    -row $aRowIter -column 6
+  incr aRowIter
+  #grid .myFrame.myLib32Edit   -row $aRowIter -column 6
+  incr aRowIter
+  grid .myFrame.myLib32Remove -row $aRowIter -column 6
+  incr aRowIter
+  grid .myFrame.myLib32Clear  -row $aRowIter -column 6
+  incr aRowIter
+  grid .myFrame.myLib32ErrLbl -row $aRowIter -column 0 -columnspan 10 -sticky w
+  incr aRowIter
+
+  # Additional executables (32-bit) search paths
+  grid .myFrame.myBin32Lbl    -row $aRowIter -column 0 -columnspan 10 -sticky w
+  incr aRowIter
+  grid .myFrame.myBin32List   -row $aRowIter -column 0 -rowspan 4 -columnspan 5
+  grid .myFrame.myBin32Scrl   -row $aRowIter -column 5 -rowspan 4
+  grid .myFrame.myBin32Add    -row $aRowIter -column 6
+  incr aRowIter
+  #grid .myFrame.myBin32Edit   -row $aRowIter -column 6
+  incr aRowIter
+  grid .myFrame.myBin32Remove -row $aRowIter -column 6
+  incr aRowIter
+  grid .myFrame.myBin32Clear  -row $aRowIter -column 6
+  incr aRowIter
+  grid .myFrame.myBin32ErrLbl -row $aRowIter -column 0 -columnspan 10 -sticky w
+  incr aRowIter
+}
+
+proc wokdep:gui:Show64Bitness { theRowIter } {
+  upvar $theRowIter aRowIter
+
+  if { [llength [grid info .myFrame.myLib32Lbl]] != 0 } {
+    grid forget .myFrame.myLib32Lbl .myFrame.myLib32List   .myFrame.myLib32Scrl
+    grid forget .myFrame.myLib32Add .myFrame.myLib32Remove .myFrame.myLib32Clear .myFrame.myLib32ErrLbl
+    grid forget .myFrame.myBin32Lbl .myFrame.myBin32List   .myFrame.myBin32Scrl
+    grid forget .myFrame.myBin32Add .myFrame.myBin32Remove .myFrame.myBin32Clear .myFrame.myBin32ErrLbl
+  }
+
+  # Additional libraries (64-bit) search paths
+  grid .myFrame.myLib64Lbl    -row $aRowIter -column 0 -columnspan 10 -sticky w
+  incr aRowIter
+  grid .myFrame.myLib64List   -row $aRowIter -column 0 -rowspan 4 -columnspan 5
+  grid .myFrame.myLib64Scrl   -row $aRowIter -column 5 -rowspan 4
+  grid .myFrame.myLib64Add    -row $aRowIter -column 6
+  incr aRowIter
+  #grid .myFrame.myLib64Edit   -row $aRowIter -column 6
+  incr aRowIter
+  grid .myFrame.myLib64Remove -row $aRowIter -column 6
+  incr aRowIter
+  grid .myFrame.myLib64Clear  -row $aRowIter -column 6
+  incr aRowIter
+  grid .myFrame.myLib64ErrLbl -row $aRowIter -column 0 -columnspan 10 -sticky w
+  incr aRowIter
+
+  # Additional executables (64-bit) search paths
+  grid .myFrame.myBin64Lbl    -row $aRowIter -column 0 -columnspan 10 -sticky w
+  incr aRowIter
+  grid .myFrame.myBin64List   -row $aRowIter -column 0 -rowspan 4 -columnspan 5
+  grid .myFrame.myBin64Scrl   -row $aRowIter -column 5 -rowspan 4
+  grid .myFrame.myBin64Add    -row $aRowIter -column 6
+  incr aRowIter
+  #grid .myFrame.myBin64Edit   -row $aRowIter -column 6
+  incr aRowIter
+  grid .myFrame.myBin64Remove -row $aRowIter -column 6
+  incr aRowIter
+  grid .myFrame.myBin64Clear  -row $aRowIter -column 6
+  incr aRowIter
+  grid .myFrame.myBin64ErrLbl -row $aRowIter -column 0 -columnspan 10 -sticky w
+  incr aRowIter
+}
+
+# Header
+ttk::label    .myFrame.myVsLbl       -text "Visual Studio configuration" -relief solid -padding {5 5 80 5}
+ttk::combobox .myFrame.myVsCombo     -values $SYS_VS_LIST -state readonly -textvariable VSVER -width 30
+ttk::combobox .myFrame.myArchCombo   -values { {32} {64} } -textvariable ARCH -state readonly -width 6
+entry         .myFrame.myVcEntry     -textvariable VCVER  -width 6
+entry         .myFrame.myVcVarsEntry -textvariable VCVARS -width 70
+ttk::button   .myFrame.myVcBrowseBtn -text "Browse" -command wokdep:gui:BrowseVcVars
+
+#
+ttk::label    .myFrame.myOcctBuildLbl -text "OCCT headers configuration" -relief solid -padding {5 5 80 5}
+checkbutton   .myFrame.myScutsCheck   -offvalue "false" -onvalue "true" -variable SHORTCUT_HEADERS
+ttk::label    .myFrame.myScutsLbl     -text "Short-cut headers instead original ones in inc"
+
+#
+ttk::label    .myFrame.mySrchLbl       -text "3rd-parties search path" -relief solid -padding {5 5 80 5}
+entry         .myFrame.mySrchEntry     -textvariable PRODUCTS_PATH -width 80
+ttk::button   .myFrame.mySrchBrowseBtn -text "Browse" -command wokdep:gui:BrowsePartiesRoot
+checkbutton   .myFrame.myFImageCheck   -offvalue "false" -onvalue "true" -variable HAVE_FREEIMAGE -command wokdep:gui:UpdateList
+ttk::label    .myFrame.myFImageLbl     -text "Use FreeImage"
+checkbutton   .myFrame.myGl2psCheck    -offvalue "false" -onvalue "true" -variable HAVE_GL2PS     -command wokdep:gui:UpdateList
+ttk::label    .myFrame.myGl2psLbl      -text "Use GL2PS"
+checkbutton   .myFrame.myTbbCheck      -offvalue "false" -onvalue "true" -variable HAVE_TBB       -command wokdep:gui:UpdateList
+ttk::label    .myFrame.myTbbLbl        -text "Use Intel TBB"
+checkbutton   .myFrame.myOpenClCheck   -offvalue "false" -onvalue "true" -variable HAVE_OPENCL    -command wokdep:gui:UpdateList
+ttk::label    .myFrame.myOpenClLbl     -text "Use OpenCL"
+checkbutton   .myFrame.myMacGLXCheck   -offvalue "false" -onvalue "true" -variable MACOSX_USE_GLX
+ttk::label    .myFrame.myMacGLXLbl     -text "Use X11 for windows drawing"
+ttk::label    .myFrame.myVtkLbl        -text "Use VTK"
+checkbutton   .myFrame.myVtkCheck      -offvalue "false" -onvalue "true" -variable HAVE_VTK       -command wokdep:gui:UpdateList
+checkbutton   .myFrame.myQt4Check      -offvalue "false" -onvalue "true" -variable CHECK_QT4      -command wokdep:gui:UpdateList
+ttk::label    .myFrame.myQt4Lbl        -text "Search Qt4"
+checkbutton   .myFrame.myJDKCheck      -offvalue "false" -onvalue "true" -variable CHECK_JDK      -command wokdep:gui:UpdateList
+ttk::label    .myFrame.myJDKLbl        -text "Search JDK"
+
+# Additional headers search paths
+ttk::label    .myFrame.myIncLbl    -text "Additional headers search paths" -relief solid -padding {5 5 80 5}
+scrollbar     .myFrame.myIncScrl   -command ".myFrame.myIncList yview"
+listbox       .myFrame.myIncList   -listvariable CSF_OPT_INC -width 80 -height 5 -yscrollcommand ".myFrame.myIncScrl set"
+ttk::button   .myFrame.myIncAdd    -text "Add"     -command wokdep:gui:AddIncPath
+ttk::button   .myFrame.myIncEdit   -text "Edit"
+ttk::button   .myFrame.myIncRemove -text "Remove"  -command wokdep:gui:RemoveIncPath
+ttk::button   .myFrame.myIncClear  -text "Reset"   -command wokdep:gui:ResetIncPath
+ttk::label    .myFrame.myIncErrLbl -text "Error: " -foreground red -padding {5 5 5 5}
+
+# Additional libraries (32-bit) search paths
+ttk::label    .myFrame.myLib32Lbl    -text "Additional libraries (32-bit) search paths" -relief solid -padding {5 5 80 5}
+scrollbar     .myFrame.myLib32Scrl   -command ".myFrame.myLib32List yview"
+listbox       .myFrame.myLib32List   -listvariable CSF_OPT_LIB32 -width 80 -height 5 -yscrollcommand ".myFrame.myLib32Scrl set"
+ttk::button   .myFrame.myLib32Add    -text "Add"     -command wokdep:gui:AddLib32Path
+ttk::button   .myFrame.myLib32Edit   -text "Edit"
+ttk::button   .myFrame.myLib32Remove -text "Remove"  -command wokdep:gui:RemoveLib32Path
+ttk::button   .myFrame.myLib32Clear  -text "Reset"   -command wokdep:gui:ResetLib32Path
+ttk::label    .myFrame.myLib32ErrLbl -text "Error: " -foreground red -padding {5 5 5 5}
+
+# Additional libraries (64-bit) search paths
+ttk::label    .myFrame.myLib64Lbl    -text "Additional libraries (64-bit) search paths" -relief solid -padding {5 5 80 5}
+scrollbar     .myFrame.myLib64Scrl   -command ".myFrame.myLib64List yview"
+listbox       .myFrame.myLib64List   -listvariable CSF_OPT_LIB64 -width 80 -height 5 -yscrollcommand ".myFrame.myLib64Scrl set"
+ttk::button   .myFrame.myLib64Add    -text "Add"     -command wokdep:gui:AddLib64Path
+ttk::button   .myFrame.myLib64Edit   -text "Edit"
+ttk::button   .myFrame.myLib64Remove -text "Remove"  -command wokdep:gui:RemoveLib64Path
+ttk::button   .myFrame.myLib64Clear  -text "Reset"   -command wokdep:gui:ResetLib64Path
+ttk::label    .myFrame.myLib64ErrLbl -text "Error: " -foreground red -padding {5 5 5 5}
+
+# Additional executables (32-bit) search paths
+ttk::label    .myFrame.myBin32Lbl    -text "Additional executables (32-bit) search paths" -relief solid -padding {5 5 80 5}
+scrollbar     .myFrame.myBin32Scrl   -command ".myFrame.myBin32List yview"
+listbox       .myFrame.myBin32List   -listvariable CSF_OPT_BIN32 -width 80 -height 5 -yscrollcommand ".myFrame.myBin32Scrl set"
+ttk::button   .myFrame.myBin32Add    -text "Add"     -command wokdep:gui:AddBin32Path
+ttk::button   .myFrame.myBin32Edit   -text "Edit"
+ttk::button   .myFrame.myBin32Remove -text "Remove"  -command wokdep:gui:RemoveBin32Path
+ttk::button   .myFrame.myBin32Clear  -text "Reset"   -command wokdep:gui:ResetBin32Path
+ttk::label    .myFrame.myBin32ErrLbl -text "Error: " -foreground red -padding {5 5 5 5}
+
+# Additional executables (64-bit) search paths
+ttk::label    .myFrame.myBin64Lbl    -text "Additional executables (64-bit) search paths" -relief solid -padding {5 5 80 5}
+scrollbar     .myFrame.myBin64Scrl   -command ".myFrame.myBin64List yview"
+listbox       .myFrame.myBin64List   -listvariable CSF_OPT_BIN64 -width 80 -height 5 -yscrollcommand ".myFrame.myBin64Scrl set"
+ttk::button   .myFrame.myBin64Add    -text "Add"     -command wokdep:gui:AddBin64Path
+ttk::button   .myFrame.myBin64Edit   -text "Edit"
+ttk::button   .myFrame.myBin64Remove -text "Remove"  -command wokdep:gui:RemoveBin64Path
+ttk::button   .myFrame.myBin64Clear  -text "Reset"   -command wokdep:gui:ResetBin64Path
+ttk::label    .myFrame.myBin64ErrLbl -text "Error: " -foreground red -padding {5 5 5 5}
+
+# Bottom
+ttk::button   .myFrame.mySave  -text "Save"  -command wokdep:SaveCustom
+ttk::button   .myFrame.myClose -text "Close" -command wokdep:gui:Close
+
+# Create grid
+# Header
+if { "$tcl_platform(platform)" == "windows" } {
+  grid .myFrame.myVsLbl       -row $aRowIter -column 0 -columnspan 10 -sticky w
+  incr aRowIter
+  grid .myFrame.myVsCombo     -row $aRowIter -column 0 -columnspan 2 -sticky w
+  grid .myFrame.myArchCombo   -row $aRowIter -column 2 -sticky w
+  incr aRowIter
+  grid .myFrame.myVcEntry     -row $aRowIter -column 0
+  grid .myFrame.myVcVarsEntry -row $aRowIter -column 1 -columnspan 4 -sticky w
+  grid .myFrame.myVcBrowseBtn -row $aRowIter -column 6
+  incr aRowIter
+}
+
+#
+grid .myFrame.myOcctBuildLbl -row $aRowIter -column 0 -columnspan 10 -sticky w
+incr aRowIter
+grid .myFrame.myScutsCheck   -row $aRowIter -column 0 -sticky e
+grid .myFrame.myScutsLbl     -row $aRowIter -column 1 -columnspan 2 -sticky w
+incr aRowIter
+#
+grid .myFrame.mySrchLbl       -row $aRowIter -column 0 -columnspan 10 -sticky w
+incr aRowIter
+grid .myFrame.mySrchEntry     -row $aRowIter -column 0 -columnspan 5
+grid .myFrame.mySrchBrowseBtn -row $aRowIter -column 6
+incr aRowIter
+grid .myFrame.myFImageCheck   -row $aRowIter -column 0 -sticky e
+grid .myFrame.myFImageLbl     -row $aRowIter -column 1 -sticky w
+grid .myFrame.myQt4Check      -row $aRowIter -column 2 -sticky e
+grid .myFrame.myQt4Lbl        -row $aRowIter -column 3 -sticky w
+incr aRowIter
+grid .myFrame.myGl2psCheck    -row $aRowIter -column 0 -sticky e
+grid .myFrame.myGl2psLbl      -row $aRowIter -column 1 -sticky w
+grid .myFrame.myJDKCheck      -row $aRowIter -column 2 -sticky e
+grid .myFrame.myJDKLbl        -row $aRowIter -column 3 -sticky w
+incr aRowIter
+grid .myFrame.myTbbCheck      -row $aRowIter -column 0 -sticky e
+grid .myFrame.myTbbLbl        -row $aRowIter -column 1 -sticky w
+incr aRowIter
+grid .myFrame.myOpenClCheck   -row $aRowIter -column 0 -sticky e
+grid .myFrame.myOpenClLbl     -row $aRowIter -column 1 -sticky w
+incr aRowIter
+grid .myFrame.myVtkCheck      -row $aRowIter -column 0 -sticky e
+grid .myFrame.myVtkLbl        -row $aRowIter -column 1 -sticky w
+incr aRowIter
+if { "$::tcl_platform(os)" == "Darwin" } {
+  grid .myFrame.myMacGLXCheck -row $aRowIter -column 0 -sticky e
+  grid .myFrame.myMacGLXLbl   -row $aRowIter -column 1 -sticky w
+  incr aRowIter
+}
+
+# Additional headers search paths
+grid .myFrame.myIncLbl    -row $aRowIter -column 0 -columnspan 10 -sticky w
+incr aRowIter
+grid .myFrame.myIncList   -row $aRowIter -column 0 -rowspan 4 -columnspan 5
+grid .myFrame.myIncScrl   -row $aRowIter -column 5 -rowspan 4
+grid .myFrame.myIncAdd    -row $aRowIter -column 6
+incr aRowIter
+#grid .myFrame.myIncEdit   -row $aRowIter -column 6
+incr aRowIter
+grid .myFrame.myIncRemove -row $aRowIter -column 6
+incr aRowIter
+grid .myFrame.myIncClear  -row $aRowIter -column 6
+incr aRowIter
+grid .myFrame.myIncErrLbl -row $aRowIter -column 0 -columnspan 10 -sticky w
+incr aRowIter
+
+# Additional 32-bit search paths
+if { "$ARCH" == "32" } {
+  wokdep:gui:Show32Bitness aRowIter
+}
+
+# Additional 64-bit search paths
+if { "$ARCH" == "64" } {
+  wokdep:gui:Show64Bitness aRowIter
+}
+
+# Bottom section
+grid .myFrame.mySave  -row $aRowIter -column 4 -columnspan 2
+grid .myFrame.myClose -row $aRowIter -column 6 -columnspan 2
+
+# Bind events
+bind .myFrame.myVsCombo <<ComboboxSelected>> {
+  wokdep:gui:SwitchConfig
+}
+bind .myFrame.myArchCombo <<ComboboxSelected>> {
+  wokdep:gui:SwitchArch
+}
+
+.myFrame.mySrchEntry configure -validate all -validatecommand {
+  #return [file exists "$::PRODUCTS_PATH"]
+  wokdep:gui:UpdateList
+  return 1
+}
+
+wokdep:gui:UpdateList
diff --git a/adm/genconfdeps.tcl b/adm/genconfdeps.tcl
new file mode 100644 (file)
index 0000000..3470530
--- /dev/null
@@ -0,0 +1,996 @@
+#!/usr/bin/tclsh
+
+set ARCH "32"
+
+if { "$tcl_platform(platform)" == "unix" } {
+  set SYS_PATH_SPLITTER ":"
+  set SYS_LIB_PREFIX    "lib"
+  set SYS_EXE_SUFFIX    ""
+  if { "$tcl_platform(os)" == "Darwin" } {
+    set SYS_LIB_SUFFIX "dylib"
+  } else {
+    set SYS_LIB_SUFFIX "so"
+  }
+  set VCVER "gcc"
+  set VCVARS ""
+} elseif { "$tcl_platform(platform)" == "windows" } {
+  set SYS_PATH_SPLITTER ";"
+  set SYS_LIB_PREFIX    ""
+  set SYS_LIB_SUFFIX    "lib"
+  set SYS_EXE_SUFFIX    ".exe"
+  set VCVER  "vc10"
+  set VCVARS ""
+}
+
+set SHORTCUT_HEADERS "true"
+
+set HAVE_FREEIMAGE "false"
+set HAVE_GL2PS     "false"
+set HAVE_TBB       "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]
+set CSF_OPT_LIB64 [list]
+set CSF_OPT_BIN32 [list]
+set CSF_OPT_BIN64 [list]
+
+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 { [info exists ::env(HAVE_FREEIMAGE)] } {
+  set HAVE_FREEIMAGE "$::env(HAVE_FREEIMAGE)"
+}
+if { [info exists ::env(HAVE_GL2PS)] } {
+  set HAVE_GL2PS "$::env(HAVE_GL2PS)"
+}
+if { [info exists ::env(HAVE_TBB)] } {
+  set HAVE_TBB "$::env(HAVE_TBB)"
+}
+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)"
+}
+if { [info exists ::env(CSF_OPT_INC)] } {
+  set CSF_OPT_INC [split "$::env(CSF_OPT_INC)" $::SYS_PATH_SPLITTER]
+}
+if { [info exists ::env(CSF_OPT_LIB32)] } {
+  set CSF_OPT_LIB32 [split "$::env(CSF_OPT_LIB32)" $::SYS_PATH_SPLITTER]
+}
+if { [info exists ::env(CSF_OPT_LIB64)] } {
+  set CSF_OPT_LIB64 [split "$::env(CSF_OPT_LIB64)" $::SYS_PATH_SPLITTER]
+}
+if { [info exists ::env(CSF_OPT_BIN32)] } {
+  set CSF_OPT_BIN32 [split "$::env(CSF_OPT_BIN32)" $::SYS_PATH_SPLITTER]
+}
+if { [info exists ::env(CSF_OPT_BIN64)] } {
+  set CSF_OPT_BIN64 [split "$::env(CSF_OPT_BIN64)" $::SYS_PATH_SPLITTER]
+}
+
+# Search header file in $::CSF_OPT_INC and standard paths
+proc wokdep:SearchHeader {theHeader} {
+  # search in custom paths
+  foreach anIncPath $::CSF_OPT_INC {
+    set aPath "${anIncPath}/${theHeader}"
+    if { [file exists "$aPath"] } {
+      return "$aPath"
+    }
+  }
+
+  # search in system
+  set aPath "/usr/include/${theHeader}"
+  if { [file exists "$aPath"] } {
+    return "$aPath"
+  }
+  return ""
+}
+
+# Search library file in $::CSF_OPT_LIB* and standard paths
+proc wokdep:SearchLib {theLib theBitness {theSearchPath ""}} {
+  if { "$theSearchPath" != "" } {
+    set aPath "${theSearchPath}/${::SYS_LIB_PREFIX}${theLib}.${::SYS_LIB_SUFFIX}"
+    if { [file exists "$aPath"] } {
+      return "$aPath"
+    } else {
+      return ""
+    }
+  }
+
+  # search in custom paths
+  foreach aLibPath [set ::CSF_OPT_LIB$theBitness] {
+    set aPath "${aLibPath}/${::SYS_LIB_PREFIX}${theLib}.${::SYS_LIB_SUFFIX}"
+    if { [file exists "$aPath"] } {
+      return "$aPath"
+    }
+  }
+
+  # search in system
+  if { "$::ARCH" == "$theBitness"} {
+    set aPath "/usr/lib/${::SYS_LIB_PREFIX}${theLib}.${::SYS_LIB_SUFFIX}"
+    if { [file exists "$aPath"] } {
+      return "$aPath"
+    }
+  }
+
+  if { "$::tcl_platform(platform)" == "linux" } {
+    if { "$theBitness" == "64" } {
+      set aPath "/usr/lib/x86_64-linux-gnu/lib${theLib}.so"
+      if { [file exists "$aPath"] } {
+        return "$aPath"
+      }
+    } else {
+      set aPath "/usr/lib/i386-linux-gnu/lib${theLib}.so"
+      if { [file exists "$aPath"] } {
+        return "$aPath"
+      }
+    }
+  }
+
+  return ""
+}
+
+# Search file in $::CSF_OPT_BIN* and standard paths
+proc wokdep:SearchBin {theBin theBitness {theSearchPath ""}} {
+  if { "$theSearchPath" != "" } {
+    set aPath "${theSearchPath}/${theBin}"
+    if { [file exists "$aPath"] } {
+      return "$aPath"
+    } else {
+      return ""
+    }
+  }
+
+  # search in custom paths
+  foreach aBinPath [set ::CSF_OPT_BIN$theBitness] {
+    set aPath "${aBinPath}/${theBin}"
+    if { [file exists "$aPath"] } {
+      return "$aPath"
+    }
+  }
+
+  # search in system
+  if { "$::ARCH" == "$theBitness"} {
+    set aPath "/usr/bin/${theBin}"
+    if { [file exists "$aPath"] } {
+      return "$aPath"
+    }
+  }
+
+  return ""
+}
+
+# Detect compiler C-runtime version 'vc*' and architecture '32'/'64'
+# to determine preferred path.
+proc wokdep:Preferred {theList theCmpl theArch} {
+  if { [llength $theList] == 0 } {
+    return ""
+  }
+
+  set aShortList {}
+  foreach aPath $theList {
+    if { [string first "$theCmpl" "$aPath"] != "-1" } {
+      lappend aShortList "$aPath"
+    }
+  }
+
+  if { [llength $aShortList] == 0 } {
+    #return [lindex $theList 0]
+    set aShortList $theList
+  }
+
+  set aVeryShortList {}
+  foreach aPath $aShortList {
+    if { [string first "$theArch" "$aPath"] != "-1" } {
+      lappend aVeryShortList "$aPath"
+    }
+  }
+  if { [llength $aVeryShortList] == 0 } {
+    return [lindex [lsort -decreasing $aShortList] 0]
+  }
+
+  return [lindex [lsort -decreasing $aVeryShortList] 0]
+}
+
+# Search Tcl/Tk libraries placement
+proc wokdep:SearchTclTk {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64} {
+  upvar $theErrInc   anErrInc
+  upvar $theErrLib32 anErrLib32
+  upvar $theErrLib64 anErrLib64
+  upvar $theErrBin32 anErrBin32
+  upvar $theErrBin64 anErrBin64
+
+  set tclver_maj 8
+  set tclver_min 6
+  
+  set isFound "true"
+  set aTclHPath [wokdep:SearchHeader "tcl.h"]
+  set aTkHPath  [wokdep:SearchHeader "tk.h"]
+  if { "$aTclHPath" == "" || "$aTkHPath" == "" } {
+    if { [file exists "/usr/include/tcl8.6/tcl.h"]
+      && [file exists "/usr/include/tcl8.6/tk.h" ] } {
+      lappend ::CSF_OPT_INC "/usr/include/tcl8.6"
+      set aTclHPath "/usr/include/tcl8.6/tcl.h"
+    } else {
+      set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{tcl}*] "$::VCVER" "$::ARCH" ]
+      if { "$aPath" != "" && [file exists "$aPath/include/tcl.h"] && [file exists "$aPath/include/tk.h"] } {
+        lappend ::CSF_OPT_INC "$aPath/include"
+        set aTclHPath "$aPath/include/tcl.h"
+      } else {
+        lappend anErrInc "Error: 'tcl.h' or 'tk.h' not found (Tcl/Tk)"
+        set isFound "false"
+      }
+    }
+  }
+
+  # detect tcl version by parsing header file
+  if { $isFound } {
+    set fh [open $aTclHPath]
+    set tcl_h [read $fh]
+    close $fh
+    regexp {define\s+TCL_MAJOR_VERSION\s+([0-9]+)} $tcl_h dummy tclver_maj
+    regexp {define\s+TCL_MINOR_VERSION\s+([0-9]+)} $tcl_h dummy tclver_min
+  }
+
+  if { "$::tcl_platform(platform)" == "windows" } {
+    set aTclLibName "tcl${tclver_maj}${tclver_min}"
+    set aTkLibName  "tk${tclver_maj}${tclver_min}"
+  } else {
+    set aTclLibName "tcl${tclver_maj}.${tclver_min}"
+    set aTkLibName  "tk${tclver_maj}.${tclver_min}"
+  }
+
+  foreach anArchIter {64 32} {
+    set aTclLibPath [wokdep:SearchLib "$aTclLibName" "$anArchIter"]
+    set aTkLibPath  [wokdep:SearchLib "$aTkLibName"  "$anArchIter"]
+    if { "$aTclLibPath" == "" || "$aTkLibPath" == "" } {
+      set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{tcl}*] "$::VCVER" "$anArchIter" ]
+      set aTclLibPath [wokdep:SearchLib "$aTclLibName" "$anArchIter" "$aPath/lib"]
+      set aTkLibPath  [wokdep:SearchLib "$aTkLibName"  "$anArchIter" "$aPath/lib"]
+      if { "$aTclLibPath" != "" && "$aTkLibPath" != "" } {
+        lappend ::CSF_OPT_LIB$anArchIter "$aPath/lib"
+      } else {
+        lappend anErrLib$anArchIter "Error: '${::SYS_LIB_PREFIX}${aTclLibName}.${::SYS_LIB_SUFFIX}' or '${::SYS_LIB_PREFIX}${aTkLibName}.${::SYS_LIB_SUFFIX}' not found (Tcl/Tk)"
+        if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
+      }
+    }
+
+    if { "$::tcl_platform(platform)" == "windows" } {
+      set aTclDllPath [wokdep:SearchBin "${aTclLibName}.dll" "$anArchIter"]
+      set aTkDllPath  [wokdep:SearchBin "${aTkLibName}.dll"  "$anArchIter"]
+      if { "$aTclDllPath" == "" || "$aTkDllPath" == "" } {
+        set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{tcl}*] "$::VCVER" "$anArchIter" ]
+        set aTclDllPath [wokdep:SearchBin "${aTclLibName}.dll" "$anArchIter" "$aPath/bin"]
+        set aTkDllPath  [wokdep:SearchBin "${aTkLibName}.dll"  "$anArchIter" "$aPath/bin"]
+        if { "$aTclDllPath" != "" && "$aTkDllPath" != "" } {
+          lappend ::CSF_OPT_BIN$anArchIter "$aPath/bin"
+        } else {
+          lappend anErrBin$anArchIter "Error: '${aTclLibName}.dll' or '${aTkLibName}.dll' not found (Tcl/Tk)"
+          if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
+        }
+      }
+    }
+  }
+
+  return "$isFound"
+}
+
+# Search FreeType library placement
+proc wokdep:SearchFreeType {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64} {
+  upvar $theErrInc   anErrInc
+  upvar $theErrLib32 anErrLib32
+  upvar $theErrLib64 anErrLib64
+  upvar $theErrBin32 anErrBin32
+  upvar $theErrBin64 anErrBin64
+
+  set isFound "true"
+  set aFtBuildPath [wokdep:SearchHeader "ft2build.h"]
+
+  # new layout of headers in Freetype 2.5.x
+  if { "$aFtBuildPath" == "" } {
+    set aFtBuildPath [wokdep:SearchHeader "freetype2/ft2build.h"]
+  }
+
+  if { "$aFtBuildPath" == "" } {
+    # TODO - use `freetype-config --cflags` instead
+    set aSysFreeType "/usr/include/freetype2"
+    if { [file exists "$aSysFreeType/ftbuild.h"] } {
+      lappend ::CSF_OPT_INC "$aSysFreeType"
+    } elseif { [file exists "$aSysFreeType/freetype2/ft2build.h"] } {
+      lappend ::CSF_OPT_INC "$aSysFreeType/freetype2"
+    } else {
+      set aSysFreeType "/usr/X11/include/freetype2"
+      if { [file exists "$aSysFreeType/ft2build.h"] } {
+        lappend ::CSF_OPT_INC "/usr/X11/include"
+        lappend ::CSF_OPT_INC "$aSysFreeType"
+      } else {
+        set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{freetype}*] "$::VCVER" "$::ARCH" ]
+        if {"$aPath" != ""} {
+          if {[file exists "$aPath/include/ft2build.h"]} {
+            lappend ::CSF_OPT_INC "$aPath/include"
+          } elseif {[file exists "$aPath/include/freetype2/ft2build.h"]} {
+            lappend ::CSF_OPT_INC "$aPath/include/freetype2"
+          }
+        } else {
+          lappend anErrInc "Error: 'freetype.h' not found (FreeType2)"
+          set isFound "false"
+        }
+      }
+    }
+  }
+
+  # parse 'freetype-config --libs'
+  set aConfLibPath ""
+  if { [catch { set aConfLibs [exec freetype-config --libs] } ] == 0 } {
+    foreach aPath [split $aConfLibs " "] {
+      if { [string first "-L" "$aPath"] == 0 } {
+        set aConfLibPath [string range "$aPath" 2 [string length "$aPath"]]
+      }
+    }
+  }
+
+  foreach anArchIter {64 32} {
+    set aFtLibPath [wokdep:SearchLib "freetype" "$anArchIter"]
+    if { "$aFtLibPath" == "" } {
+      set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{freetype}*] "$::VCVER" "$anArchIter" ]
+      set aFtLibPath [wokdep:SearchLib "freetype" "$anArchIter" "$aPath/lib"]
+      if { "$aFtLibPath" != "" } {
+        lappend ::CSF_OPT_LIB$anArchIter "$aPath/lib"
+      } else {
+        set aFtLibPath [wokdep:SearchLib "freetype" "$anArchIter" "$aConfLibPath"]
+        if { "$aFtLibPath" != "" } {
+          lappend ::CSF_OPT_LIB$anArchIter "$aConfLibPath"
+        } else {
+          lappend anErrLib$anArchIter "Error: '${::SYS_LIB_PREFIX}freetype.${::SYS_LIB_SUFFIX}' not found (FreeType2)"
+          if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
+        }
+      }
+    }
+    if { "$::tcl_platform(platform)" == "windows" } {
+      set aFtDllPath [wokdep:SearchBin "freetype.dll" "$anArchIter"]
+      if { "$aFtDllPath" == "" } {
+        set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{freetype}*] "$::VCVER" "$anArchIter" ]
+        set aFtDllPath [wokdep:SearchBin "freetype.dll" "$anArchIter" "$aPath/bin"]
+        if { "$aFtDllPath" != "" } {
+          lappend ::CSF_OPT_BIN$anArchIter "$aPath/bin"
+        } else {
+          set aFtDllPath [wokdep:SearchBin "freetype.dll" "$anArchIter" "$aPath/lib"]
+          if { "$aFtDllPath" != "" } {
+            lappend ::CSF_OPT_BIN$anArchIter "$aPath/lib"
+          } else {
+            lappend anErrBin$anArchIter "Error: 'freetype.dll' not found (FreeType2)"
+            if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
+          }
+        }
+      }
+    }
+  }
+
+  return "$isFound"
+}
+
+# Search FreeImage library placement
+proc wokdep:SearchFreeImage {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64} {
+  upvar $theErrInc   anErrInc
+  upvar $theErrLib32 anErrLib32
+  upvar $theErrLib64 anErrLib64
+  upvar $theErrBin32 anErrBin32
+  upvar $theErrBin64 anErrBin64
+
+  # binary distribution has another layout
+  set aFImageDist     "Dist"
+  set aFImagePlusDist "Wrapper/FreeImagePlus/dist"
+
+  set isFound "true"
+  set aFImageHPath     [wokdep:SearchHeader "FreeImage.h"]
+  set aFImagePlusHPath [wokdep:SearchHeader "FreeImagePlus.h"]
+  if { "$aFImageHPath" == "" || "$aFImagePlusHPath"  == "" } {
+    set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{freeimage}*] "$::VCVER" "$::ARCH" ]
+    if { "$aPath" != "" && [file exists "$aPath/include/FreeImage.h"] && [file exists "$aPath/include/FreeImagePlus.h"] } {
+      lappend ::CSF_OPT_INC "$aPath/include"
+    } elseif { "$aPath" != "" && [file exists "$aPath/$aFImageDist/FreeImage.h"] && [file exists "$aPath/$aFImagePlusDist/FreeImagePlus.h"] } {
+      lappend ::CSF_OPT_INC "$aPath/$aFImageDist"
+      lappend ::CSF_OPT_INC "$aPath/$aFImagePlusDist"
+    } else {
+      lappend anErrInc "Error: 'FreeImage.h' or 'FreeImagePlus.h' not found (FreeImage)"
+      set isFound "false"
+    }
+  }
+
+  foreach anArchIter {64 32} {
+    set aFImageLibPath     [wokdep:SearchLib "freeimage"     "$anArchIter"]
+    set aFImagePlusLibPath [wokdep:SearchLib "freeimageplus" "$anArchIter"]
+    if { "$aFImageLibPath" == "" || "$aFImagePlusLibPath"  == "" } {
+      set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{freeimage}*] "$::VCVER" "$anArchIter" ]
+      set aFImageLibPath     [wokdep:SearchLib "freeimage"     "$anArchIter" "$aPath/lib"]
+      set aFImagePlusLibPath [wokdep:SearchLib "freeimageplus" "$anArchIter" "$aPath/lib"]
+      if { "$aFImageLibPath" != "" && "$aFImagePlusLibPath"  != "" } {
+        lappend ::CSF_OPT_LIB$anArchIter "$aPath/lib"
+      } else {
+        set aFImageLibPath     [wokdep:SearchLib "freeimage"     "$anArchIter" "$aPath/$aFImageDist"]
+        set aFImagePlusLibPath [wokdep:SearchLib "freeimageplus" "$anArchIter" "$aPath/$aFImagePlusDist"]
+        if { "$aFImageLibPath" != "" && "$aFImagePlusLibPath"  != "" } {
+          lappend ::CSF_OPT_LIB$anArchIter "$aPath/$aFImageDist"
+          lappend ::CSF_OPT_LIB$anArchIter "$aPath/$aFImagePlusDist"
+        } else {
+          lappend anErrLib$anArchIter "Error: '${::SYS_LIB_PREFIX}freeimage.${::SYS_LIB_SUFFIX}' or '${::SYS_LIB_PREFIX}freeimageplus.${::SYS_LIB_SUFFIX}' not found (FreeImage)"
+          if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
+        }
+      }
+    }
+    if { "$::tcl_platform(platform)" == "windows" } {
+      set aFImageDllPath     [wokdep:SearchBin "freeimage.dll"     "$anArchIter"]
+      set aFImagePlusDllPath [wokdep:SearchBin "freeimageplus.dll" "$anArchIter"]
+      if { "$aFImageDllPath" == "" || "$aFImagePlusDllPath" == "" } {
+        set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{freeimage}*] "$::VCVER" "$anArchIter" ]
+        set aFImageDllPath     [wokdep:SearchBin "freeimage.dll"     "$anArchIter" "$aPath/bin"]
+        set aFImagePlusDllPath [wokdep:SearchBin "freeimageplus.dll" "$anArchIter" "$aPath/bin"]
+        if { "$aFImageDllPath" != "" && "$aFImagePlusDllPath" != "" } {
+          lappend ::CSF_OPT_BIN$anArchIter "$aPath/bin"
+        } else {
+          set aFImageDllPath     [wokdep:SearchBin "freeimage.dll"     "$anArchIter" "$aPath/$aFImageDist"]
+          set aFImagePlusDllPath [wokdep:SearchBin "freeimageplus.dll" "$anArchIter" "$aPath/$aFImagePlusDist"]
+          if { "$aFImageDllPath" != "" && "$aFImagePlusDllPath" != "" } {
+            lappend ::CSF_OPT_BIN$anArchIter "$aPath/$aFImageDist"
+            lappend ::CSF_OPT_BIN$anArchIter "$aPath/$aFImagePlusDist"
+          } else {
+            lappend anErrBin$anArchIter "Error: 'freeimage.dll' or 'freeimageplus.dll' not found (FreeImage)"
+            if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
+          }
+        }
+      }
+    }
+  }
+
+  return "$isFound"
+}
+
+# Search GL2PS library placement
+proc wokdep:SearchGL2PS {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64} {
+  upvar $theErrInc   anErrInc
+  upvar $theErrLib32 anErrLib32
+  upvar $theErrLib64 anErrLib64
+  upvar $theErrBin32 anErrBin32
+  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"] } {
+      lappend ::CSF_OPT_INC "$aPath/include"
+    } else {
+      lappend anErrInc "Error: 'gl2ps.h' not found (GL2PS)"
+      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" != "" } {
+        lappend ::CSF_OPT_LIB$anArchIter "$aPath/lib"
+      } else {
+        lappend anErrLib$anArchIter "Error: '${::SYS_LIB_PREFIX}gl2ps.${::SYS_LIB_SUFFIX}' not found (GL2PS)"
+        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"
+}
+
+# Search TBB library placement
+proc wokdep:SearchTBB {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64} {
+  upvar $theErrInc   anErrInc
+  upvar $theErrLib32 anErrLib32
+  upvar $theErrLib64 anErrLib64
+  upvar $theErrBin32 anErrBin32
+  upvar $theErrBin64 anErrBin64
+
+  set isFound "true"
+  set aTbbHPath [wokdep:SearchHeader "tbb/scalable_allocator.h"]
+  if { "$aTbbHPath"  == "" } {
+    set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{tbb}*] "$::VCVER" "$::ARCH" ]
+    if { "$aPath" != "" && [file exists "$aPath/include/tbb/scalable_allocator.h"] } {
+      lappend ::CSF_OPT_INC "$aPath/include"
+    } else {
+      lappend anErrInc "Error: 'tbb/scalable_allocator.h' not found (Intel TBB)"
+      set isFound "false"
+    }
+  }
+
+  foreach anArchIter {64 32} {
+    set aSubDir "ia32"
+    if { "$anArchIter" == "64"} {
+      set aSubDir "intel64"
+    }
+
+    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}"]
+      if { "$aTbbLibPath" == "" } {
+        # Set the path to the TBB library for Linux
+        if { "$::tcl_platform(platform)" != "windows" } {
+          set aSubDir "$aSubDir/cc4.1.0_libc2.4_kernel2.6.16.21"
+        }
+        set aTbbLibPath [wokdep:SearchLib "tbb" "$anArchIter" "$aPath/lib/$aSubDir"]
+        if { "$aTbbLibPath" != "" } {
+          lappend ::CSF_OPT_LIB$anArchIter "$aPath/lib/$aSubDir"
+        }
+      } else {
+        lappend ::CSF_OPT_LIB$anArchIter "$aPath/lib/$aSubDir/${::VCVER}"
+      }
+      if { "$aTbbLibPath" == "" } {
+        lappend anErrLib$anArchIter "Error: '${::SYS_LIB_PREFIX}tbb.${::SYS_LIB_SUFFIX}' not found (Intel TBB)"
+        if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
+      }
+    }
+    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}"]
+        if { "$aTbbDllPath" != "" } {
+          lappend ::CSF_OPT_BIN$anArchIter "$aPath/bin/$aSubDir/${::VCVER}"
+        } else {
+          lappend anErrBin$anArchIter "Error: 'tbb.dll' not found (Intel TBB)"
+          if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
+        }
+      }
+    }
+  }
+
+  return "$isFound"
+}
+
+# Search OpenCL library placement
+proc wokdep:SearchOpenCL {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64} {
+  upvar $theErrInc   anErrInc
+  upvar $theErrLib32 anErrLib32
+  upvar $theErrLib64 anErrLib64
+  upvar $theErrBin32 anErrBin32
+  upvar $theErrBin64 anErrBin64
+
+  set isFound "true"
+  if { "$::tcl_platform(os)" == "Darwin" } {
+    # OpenCL framework available since Mac OS X 16
+    return "$isFound"
+  }
+
+  set aCLHPath [wokdep:SearchHeader "CL/cl_gl.h"]
+  if { "$aCLHPath"  == "" } {
+    set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{OpenCL}*] "$::VCVER" "$::ARCH" ]
+    if { "$aPath" != "" && [file exists "$aPath/include/CL/cl_gl.h"] } {
+      lappend ::CSF_OPT_INC "$aPath/include"
+    } else {
+      lappend anErrInc "Error: 'CL/cl_gl.h' not found (OpenCL)"
+      set isFound "false"
+    }
+  }
+
+  foreach anArchIter {64 32} {
+    set aCLLibPath [wokdep:SearchLib "OpenCL" "$anArchIter"]
+    if { "$aCLLibPath" == "" } {
+      set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{OpenCL}*] "$::VCVER" "$anArchIter" ]
+      set aCLLibPath [wokdep:SearchLib "OpenCL" "$anArchIter" "$aPath/lib"]
+      if { "$aCLLibPath" != "" } {
+        lappend ::CSF_OPT_LIB$anArchIter "$aPath/lib"
+      } else {
+        lappend anErrLib$anArchIter "Error: '${::SYS_LIB_PREFIX}OpenCL.${::SYS_LIB_SUFFIX}' not found (OpenCL)"
+        if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
+      }
+    }
+  }
+
+  return "$isFound"
+}
+
+# Auxiliary function, gets VTK version to set default search directory
+proc wokdep:VtkVersion { thePath } {
+  set aResult "6.1"
+
+  set aVtkRoot [lindex [regexp -all -inline {[0-9.]*} [file tail $thePath]] 0]
+  if { "$aVtkRoot" != "" } {
+    set aVtkRoot [regexp -inline {[0-9]*.[0-9]*} $aVtkRoot]
+    if { "$aVtkRoot" != "" } {
+    set aResult $aVtkRoot
+    }
+  }
+
+  return $aResult
+}
+
+# Search VTK library placement
+proc wokdep:SearchVTK {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64} {
+  upvar $theErrInc   anErrInc
+  upvar $theErrLib32 anErrLib32
+  upvar $theErrLib64 anErrLib64
+  upvar $theErrBin32 anErrBin32
+  upvar $theErrBin64 anErrBin64
+
+  set isFound "true"
+  
+  set aVtkPath ""
+  set aVtkIncPath [wokdep:SearchHeader "vtkConfigure.h"]
+  set aVtkVer [wokdep:VtkVersion $aVtkIncPath]
+  if { "$aVtkIncPath" == ""} {
+    set aPathList [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{VTK}*]
+    set aVtkPath [wokdep:Preferred "$aPathList" "$::VCVER" "$::ARCH" ]
+    if { "$aVtkPath" != "" && [file exists "$aVtkPath/include/vtk-[wokdep:VtkVersion $aVtkPath]/vtkConfigure.h"]} { 
+      set aVtkVer [wokdep:VtkVersion $aVtkPath]
+      lappend ::CSF_OPT_INC "$aVtkPath/include/vtk-[wokdep:VtkVersion $aVtkPath]"
+    } else { # try to search in all found paths
+      set isFound "false"
+      foreach anIt $aPathList {
+        if { [file exists "$anIt/include/vtk-[wokdep:VtkVersion $anIt]/vtkConfigure.h"] } {
+          set aVtkPath $anIt
+          set aVtkVer [wokdep:VtkVersion $aVtkPath]
+          lappend ::CSF_OPT_INC "$anIt/include/vtk-[wokdep:VtkVersion $anIt]"
+          set isFound "true"
+          break
+        }
+      }
+
+      # Bad case: we do not found vtkConfigure.h in all paths.
+      if { "$isFound" == "false"} {
+        lappend anErrInc "Error: 'vtkConfigure.h' not found (VTK)"
+        set isFound "false"
+      }
+    }
+  }
+
+  set aVtkLibPath ""
+  foreach anArchIter {64 32} {
+    set aVtkLibPath [wokdep:SearchLib "vtkCommonCore-$aVtkVer" "$anArchIter"]
+    if { "$aVtkLibPath" == "" } {
+      set aPathList [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{VTK}*]
+      set aPath [wokdep:Preferred $aPathList "$::VCVER" "$anArchIter" ]
+      set aVtkLibPath [wokdep:SearchLib "vtkCommonCore-$aVtkVer" "$anArchIter" "$aPath/lib"]
+      if { "$aVtkLibPath" != "" } {
+        lappend ::CSF_OPT_LIB$anArchIter "$aPath/lib"
+      } else {
+        set aPath [wokdep:SearchLib "vtkCommonCore-$aVtkVer" "$anArchIter" "$aVtkPath/lib"]
+        if { "$aPath" != "" } {
+          set aLibPath $aVtkIncPath
+          lappend ::CSF_OPT_LIB$anArchIter "$aLibPath/lib"
+        } else {
+          # The last chance: search /lib directory in all found paths
+          foreach anIt $aPathList {
+            set aVtkLibPath [wokdep:SearchLib "vtkCommonCore-$aVtkVer" "$anArchIter" "$anIt/lib"]
+            if { "$aVtkLibPath" != ""} {
+              lappend ::CSF_OPT_LIB$anArchIter "$anIt/lib"
+              break
+            }
+          }
+          if { "$aVtkLibPath" == "" } {
+            lappend anErrLib$anArchIter "Error: '${::SYS_LIB_PREFIX}vtkCommonCore-${aVtkVer}\.${::SYS_LIB_SUFFIX}' not found (VTK)"
+            if { "$::ARCH" == "$anArchIter" } {
+              set isFound "false"
+            }
+          }
+        }
+      }
+    }
+  }
+  
+    # Search binary path
+    if { "$::tcl_platform(platform)" == "windows" } {
+      foreach anArchIter {64 32} {
+        set aVtkBinPath [wokdep:SearchBin "vtkCommonCore-${aVtkVer}.dll" "$anArchIter"]
+        if { "$aVtkBinPath" == "" } {
+          set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{VTK}*] "$::VCVER" "$anArchIter" ]
+          set aVtkBinPath [wokdep:SearchBin "vtkCommonCore-${aVtkVer}.dll" "$anArchIter" "$aPath/bin"]
+          if { "$aVtkBinPath" != "" } { lappend ::CSF_OPT_BIN$anArchIter "$aPath/bin"
+          } else {
+            set aVtkBinPath [wokdep:SearchBin "vtkCommonCore-${aVtkVer}.dll" "$anArchIter" "$aPath/lib"]
+            if { "$aVtkBinPath" != "" } { lappend ::CSF_OPT_BIN$anArchIter "$aPath/lib" } 
+          }
+        }
+      }
+      
+      # We didn't find preferred binary path => search through inc path or among all available VTK directories
+      if { "$aVtkBinPath" == "" } {
+        # Try to find in lib path
+        set aPath [wokdep:SearchBin "vtkCommonCore-${aVtkVer}.dll" "$anArchIter" "$aLibPath/bin"]
+        if { "$aPath" != "" } { lappend ::CSF_OPT_BIN$anArchIter "$aLibPath/bin"
+        } elseif { [wokdep:SearchBin "vtkCommonCore-${aVtkVer}.dll" "$anArchIter" "$aLibPath/lib"] != "" } {
+          lappend ::CSF_OPT_BIN$anArchIter "$aLibPath/lib"
+        } else {
+           lappend anErrBin$anArchIter "Error: 'vtkCommonCore-${aVtkVer}.dll' not found (VTK)"
+           set isFound "false"
+        }
+      }
+    }
+
+  return "$isFound"
+}
+
+# Search Qt4 libraries placement
+proc wokdep:SearchQt4 {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64} {
+  upvar $theErrInc   anErrInc
+  upvar $theErrLib32 anErrLib32
+  upvar $theErrLib64 anErrLib64
+  upvar $theErrBin32 anErrBin32
+  upvar $theErrBin64 anErrBin64
+
+  set isFound "true"
+  set aQMsgBoxHPath [wokdep:SearchHeader "QtGui/qmessagebox.h"]
+  if { "$aQMsgBoxHPath" == "" } {
+    set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{qt4}*] "$::VCVER" "$::ARCH" ]
+    if { "$aPath" != "" && [file exists "$aPath/include/QtGui/qmessagebox.h"] } {
+      lappend ::CSF_OPT_INC "$aPath/include"
+      lappend ::CSF_OPT_INC "$aPath/include/Qt"
+      lappend ::CSF_OPT_INC "$aPath/include/QtGui"
+      lappend ::CSF_OPT_INC "$aPath/include/QtCore"
+    } else {
+      if { [file exists "/usr/include/qt4/QtGui/qmessagebox.h"] } {
+        lappend ::CSF_OPT_INC "/usr/include/qt4"
+        lappend ::CSF_OPT_INC "/usr/include/qt4/Qt"
+        lappend ::CSF_OPT_INC "/usr/include/qt4/QtGui"
+        lappend ::CSF_OPT_INC "/usr/include/qt4/QtCore"
+      } else {
+        lappend anErrInc "Error: 'QtGui/qmessagebox.h' not found (Qt4)"
+        set isFound "false"
+      }
+    }
+  }
+
+  set aQtGuiLibName "QtGui"
+  if { "$::tcl_platform(platform)" == "windows" } {
+    set aQtGuiLibName "QtGui4"
+  }
+
+  foreach anArchIter {64 32} {
+    set aQMsgBoxLibPath [wokdep:SearchLib "${aQtGuiLibName}" "$anArchIter"]
+    if { "$aQMsgBoxLibPath" == "" } {
+      set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{qt4}*] "$::VCVER" "$anArchIter" ]
+      set aQMsgBoxLibPath [wokdep:SearchLib "${aQtGuiLibName}" "$anArchIter" "$aPath/lib"]
+      if { "$aQMsgBoxLibPath" != "" } {
+        lappend ::CSF_OPT_LIB$anArchIter "$aPath/lib"
+      } else {
+        lappend anErrLib$anArchIter "Error: '${::SYS_LIB_PREFIX}${aQtGuiLibName}.${::SYS_LIB_SUFFIX}' not found (Qt4)"
+        if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
+      }
+    }
+    if { "$::tcl_platform(platform)" == "windows" } {
+      set aQMsgBoxDllPath [wokdep:SearchBin "QtGui4.dll" "$anArchIter"]
+      if { "$aQMsgBoxDllPath" == "" } {
+        set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{qt4}*] "$::VCVER" "$anArchIter" ]
+        set aQMsgBoxDllPath [wokdep:SearchBin "QtGui4.dll" "$anArchIter" "$aPath/bin"]
+        if { "$aQMsgBoxDllPath" != "" } {
+          lappend ::CSF_OPT_BIN$anArchIter "$aPath/bin"
+        } else {
+          lappend anErrBin$anArchIter "Error: 'QtGui4.dll' not found (Qt4)"
+          if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
+        }
+      }
+    }
+  }
+
+  return "$isFound"
+}
+
+# Search JDK placement
+proc wokdep:SearchJDK {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64} {
+  upvar $theErrInc   anErrInc
+  upvar $theErrLib32 anErrLib32
+  upvar $theErrLib64 anErrLib64
+  upvar $theErrBin32 anErrBin32
+  upvar $theErrBin64 anErrBin64
+
+  set isFound "true"
+  set aJniHPath   [wokdep:SearchHeader "jni.h"]
+  set aJniMdHPath [wokdep:SearchHeader "jni_md.h"]
+  if { "$aJniHPath" == "" || "$aJniMdHPath" == "" } {
+    set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{jdk,java}*] "$::VCVER" "$::ARCH" ]
+    if { "$aPath" != "" && [file exists "$aPath/include/jni.h"] } {
+      lappend ::CSF_OPT_INC "$aPath/include"
+      if { "$::tcl_platform(platform)" == "windows" } {
+        lappend ::CSF_OPT_INC "$aPath/include/win32"
+      } elseif { [file exists "$aPath/include/linux"] } {
+        lappend ::CSF_OPT_INC "$aPath/include/linux"
+      }
+    } else {
+      if { [file exists "/System/Library/Frameworks/JavaVM.framework/Home/include/jni.h"] } {
+        lappend ::CSF_OPT_INC "/System/Library/Frameworks/JavaVM.framework/Home/include"
+      } else {
+        lappend anErrInc "Error: 'jni.h' or 'jni_md.h' not found (JDK)"
+        set isFound "false"
+      }
+    }
+  }
+
+  foreach anArchIter {64 32} {
+    set aJavacPath [wokdep:SearchBin "javac${::SYS_EXE_SUFFIX}" "$anArchIter"]
+    if { "$aJavacPath" == "" } {
+      set aPath [wokdep:Preferred [glob -nocomplain -directory "$::PRODUCTS_PATH" -type d *{jdk,java}*] "$::VCVER" "$anArchIter" ]
+      set aJavacPath [wokdep:SearchBin "javac${::SYS_EXE_SUFFIX}" "$anArchIter" "$aPath/bin"]
+      if { "$aJavacPath" != "" } {
+        lappend ::CSF_OPT_BIN$anArchIter "$aPath/bin"
+      } else {
+        if { "$::ARCH" == "$anArchIter" && [file exists "/System/Library/Frameworks/JavaVM.framework/Home/bin/javac${::SYS_EXE_SUFFIX}"] } {
+          lappend ::CSF_OPT_BIN$anArchIter "/System/Library/Frameworks/JavaVM.framework/Home/bin"
+        } else {
+          lappend anErrBin$anArchIter "Error: 'javac${::SYS_EXE_SUFFIX}' not found (JDK)"
+          if { "$::ARCH" == "$anArchIter"} { set isFound "false" }
+        }
+      }
+    }
+  }
+
+  return "$isFound"
+}
+
+# Search X11 libraries placement
+proc wokdep:SearchX11 {theErrInc theErrLib32 theErrLib64 theErrBin32 theErrBin64} {
+  upvar $theErrInc   anErrInc
+  upvar $theErrLib32 anErrLib32
+  upvar $theErrLib64 anErrLib64
+  upvar $theErrBin32 anErrBin32
+  upvar $theErrBin64 anErrBin64
+
+  set isFound "true"
+  if { "$::tcl_platform(platform)" == "windows" || ( "$::tcl_platform(os)" == "Darwin" && "$::MACOSX_USE_GLX" != "true" ) } {
+    return "$isFound"
+  }
+
+  set aXmuLibPath [wokdep:SearchLib "Xmu" "$::ARCH"]
+  if { "$aXmuLibPath" == "" } {
+    set aXmuLibPath [wokdep:SearchLib "Xmu" "$::ARCH" "/usr/X11/lib"]
+    if { "$aXmuLibPath" != "" } {
+      #lappend ::CSF_OPT_LIB$::ARCH "/usr/X11/lib"
+    } else {
+      lappend anErrLib$::ARCH "Error: '${::SYS_LIB_PREFIX}Xmu.${::SYS_LIB_SUFFIX}' not found (X11)"
+      set isFound "false"
+    }
+  }
+
+  return "$isFound"
+}
+
+# Generate (override) custom environment file
+proc wokdep:SaveCustom {} {
+  if { "$::tcl_platform(platform)" == "windows" } {
+    set aCustomFilePath "./custom.bat"
+    set aFile [open $aCustomFilePath "w"]
+    puts $aFile "@echo off"
+    puts $aFile "rem This environment file was generated by wok_depsgui.tcl script at [clock format [clock seconds] -format "%Y.%m.%d %H:%M"]"
+
+    puts $aFile ""
+    puts $aFile "set VCVER=$::VCVER"
+    puts $aFile "set ARCH=$::ARCH"
+    puts $aFile "set VCVARS=$::VCVARS"
+    puts $aFile "set SHORTCUT_HEADERS=$::SHORTCUT_HEADERS"
+
+    puts $aFile ""
+    puts $aFile "set \"PRODUCTS_PATH=$::PRODUCTS_PATH\""
+
+    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_OPENCL=$::HAVE_OPENCL"
+    puts $aFile "set HAVE_VTK=$::HAVE_VTK"
+    puts $aFile "set CHECK_QT4=$::CHECK_QT4"
+    puts $aFile "set CHECK_JDK=$::CHECK_JDK"
+
+    set aStringInc [join $::CSF_OPT_INC $::SYS_PATH_SPLITTER]
+    puts $aFile ""
+    puts $aFile "rem Additional headers search paths"
+    puts $aFile "set \"CSF_OPT_INC=$aStringInc\""
+
+    set aStringLib32 [join $::CSF_OPT_LIB32 $::SYS_PATH_SPLITTER]
+    puts $aFile ""
+    puts $aFile "rem Additional libraries (32-bit) search paths"
+    puts $aFile "set \"CSF_OPT_LIB32=$aStringLib32\""
+
+    set aStringLib64 [join $::CSF_OPT_LIB64 $::SYS_PATH_SPLITTER]
+    puts $aFile ""
+    puts $aFile "rem Additional libraries (64-bit) search paths"
+    puts $aFile "set \"CSF_OPT_LIB64=$aStringLib64\""
+
+    set aStringBin32 [join $::CSF_OPT_BIN32 $::SYS_PATH_SPLITTER]
+    puts $aFile ""
+    puts $aFile "rem Additional (32-bit) search paths"
+    puts $aFile "set \"CSF_OPT_BIN32=$aStringBin32\""
+
+    set aStringBin64 [join $::CSF_OPT_BIN64 $::SYS_PATH_SPLITTER]
+    puts $aFile ""
+    puts $aFile "rem Additional (64-bit) search paths"
+    puts $aFile "set \"CSF_OPT_BIN64=$aStringBin64\""
+
+    close $aFile
+  } else {
+    set aCustomFilePath "./custom.sh"
+    set aFile [open $aCustomFilePath "w"]
+    puts $aFile "#!/bin/bash"
+    puts $aFile "# This environment file was generated by wok_depsgui.tcl script at [clock format [clock seconds] -format "%Y.%m.%d %H:%M"]"
+
+    #puts $aFile ""
+    #puts $aFile "export ARCH=$::ARCH"
+
+    puts $aFile ""
+    puts $aFile "export PRODUCTS_PATH=\"$::PRODUCTS_PATH\""
+
+    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_OPENCL=$::HAVE_OPENCL"
+    puts $aFile "export HAVE_VTK=$::HAVE_VTK"
+    if { "$::tcl_platform(os)" == "Darwin" } {
+      puts $aFile "export MACOSX_USE_GLX=$::MACOSX_USE_GLX"
+    }
+    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 ""
+    puts $aFile "# Additional headers search paths"
+    puts $aFile "export CSF_OPT_INC=\"$aStringInc\""
+
+    set aStringLib$::ARCH [join [set ::CSF_OPT_LIB$::ARCH] $::SYS_PATH_SPLITTER]
+    puts $aFile ""
+    puts $aFile "# Additional libraries ($::ARCH-bit) search paths"
+    puts $aFile "export CSF_OPT_LIB$::ARCH=\"[set aStringLib$::ARCH]\""
+
+    set aStringBin$::ARCH [join [set ::CSF_OPT_BIN$::ARCH] $::SYS_PATH_SPLITTER]
+    puts $aFile ""
+    puts $aFile "# Additional ($::ARCH-bit) search paths"
+    puts $aFile "export CSF_OPT_BIN$::ARCH=\"[set aStringBin$::ARCH]\""
+
+    close $aFile
+  }
+
+  puts "Configuration saved to file '$aCustomFilePath'"
+}
diff --git a/adm/genproj.tcl b/adm/genproj.tcl
new file mode 100644 (file)
index 0000000..0adf812
--- /dev/null
@@ -0,0 +1,3046 @@
+# =======================================================================
+# This script generates project files for different IDEs:
+#      "vc7" "vc8" "vc9" "vc10" "vc11" "vc12" "cbp" "amk"
+#
+# Example:
+#      genproj -path=D:/occt -target=vc10
+# =======================================================================
+
+set path ""
+set fBranch ""
+switch -exact -- "$tcl_platform(platform)" {
+    "windows"   {set targetStation "wnt"}
+    "unix"      {set targetStation "lin"}
+    #"macos"   {set targetStation "wnt"}
+}
+
+proc _get_options { platform type branch } {
+  global path
+  set res ""
+  if {[file exists "$path/adm/CMPLRS"]} {
+    set fd [open "$path/adm/CMPLRS" rb]
+    set opts [split [read $fd] "\n"]
+    close $fd
+    foreach line $opts {
+      if {[regexp "^${platform} ${type} ${branch} (.+)$" $line dummy res]} {
+        while {[regexp {\(([^\(\)]+) ([^\(\)]+) ([^\(\)]+)\)(.+)} $res dummy p t b oldres]} {
+          set res "[_get_options $p $t $b] $oldres"
+        }
+      }
+    }
+  }
+  return $res
+}
+
+proc _get_type { name } {
+  global path
+  if {[file exists "$path/adm/UDLIST"]} {
+    set fd [open "$path/adm/UDLIST" rb]
+    set UDLIST [split [read $fd] "\n"]
+    close $fd
+    foreach uitem $UDLIST {
+      set line [split $uitem]
+      if {[lindex $line 1] == "$name"} {
+        return [lindex $line 0]
+      }
+    }
+  }
+  return ""
+}
+
+proc _get_used_files { pk {inc true} {src true} } {
+  global path
+  set type [_get_type $pk]
+  set lret {}
+  set pk_path  "$path/src/$pk"
+  set FILES_path "$path/src/$pk/FILES"
+  set FILES {}
+  if {[file exists $FILES_path]} {
+    set fd [open $FILES_path rb]
+    set FILES [split [read $fd] "\n"]
+    close $fd
+  }
+  set FILES [lsearch -inline -all -not -exact $FILES ""]
+
+  set index -1
+  foreach line $FILES {
+    incr index
+    if {$inc && ([regexp {([^:\s]*\.[hgl]xx)$} $line dummy name] || [regexp {([^:\s]*\.h)$} $line dummy name]) && [file exists $pk_path/$name]} {
+      lappend lret "pubinclude $name $pk_path/$name"
+      continue
+    }
+    if {[regexp {:} $line]} {
+      regexp {[^:]*:+([^\s]*)} $line dummy line
+    }
+    regexp {([^\s]*)} $line dummy line
+    if {$src && [file exists $pk_path/$line]} {
+      lappend lret "source $line $pk_path/$line"
+    }
+  }
+  return $lret
+}
+
+# Wrapper-function to generate VS project files
+proc genproj { args } {
+  global path targetStation
+  set aSupportedTargets { "vc7" "vc8" "vc9" "vc10" "vc11" "vc12" "cbp" "amk" }
+  set anArgs $args
+
+  # Setting default IDE.
+  set anTarget ""
+  switch -exact -- "$targetStation" {
+    "wnt"   {set anTarget "$::env(VCVER)"}
+    "lin"   {set anTarget "amk"}
+    "mac"   {set anTarget "cbp"}
+  }
+
+  set isTargetDefault true
+
+  if { [set anIndex [lsearch -nocase $anArgs -target=*]] != -1 } {
+    regsub -nocase "\\-target=" [lindex $anArgs $anIndex] "" anTarget
+    set anArgs [removeAllOccurrencesOf -target=* $anArgs]
+    set isTargetDefault false
+  }
+
+  if { [set anIndex [lsearch -nocase $anArgs -path=*]] != -1} {
+    regsub -nocase "\\-path=" [lindex $anArgs $anIndex] "" path
+    set anArgs [removeAllOccurrencesOf -path=* $anArgs]
+    puts "Starting work with \"$path\""
+  }
+
+  if { [llength $anArgs] == 0 && $isTargetDefault == true } {
+    puts "the default \'$anTarget\' target has been applied"
+  }
+
+  set isHelpRequire false
+  if { [lsearch -nocase $anArgs -h] != -1} {
+    set anArgs [removeAllOccurrencesOf -h $anArgs]
+    set isHelpRequire true
+  }
+
+  if {$path == ""} {
+    set isHelpRequire true
+  }
+
+  if { [lsearch -nocase $aSupportedTargets $anTarget] == -1} {
+    puts "the \'$anTarget\' is wrong TARGET"
+    set isHelpRequire true
+  }
+
+  if {[llength $anArgs] > 0} {
+    set isHelpRequire true
+
+    foreach anArg $anArgs {
+      puts "genproj: unrecognized option \'$anArg\'"
+    }
+  }
+
+  if {  $isHelpRequire == true } {
+    puts "usage: genproj \[ -target=<TARGET> \] \[ -path=<PATH> \]
+
+    PATH: 
+      path to the project
+
+    TARGET:
+      vc8   -  Visual Studio 2005
+      vc9   -  Visual Studio 2008
+      vc10  -  Visual Studio 2010
+      vc11  -  Visual Studio 2012
+      vc12  -  Visual Studio 2013
+      cbp   -  CodeBlocks
+      amk   -  AutoMake"
+      return
+  }
+
+  if {!$isTargetDefault} {
+    puts "the \'$anTarget\' target has been applied"
+  }
+  
+  if {"$anTarget" == "amk"} {
+    set targetStation "lin"
+  }
+  set anAdmPath "$path/adm"
+
+  OS:MKPRC "$anAdmPath" "$anTarget"
+
+  genprojbat "$anAdmPath" "$anTarget"
+}
+
+proc genprojbat {thePath theIDE} {
+  global path
+  
+  set anOsIncPath "$path/src/OS"
+  set anOsRootPath "$path"
+
+  set aTargetPlatform "lin"
+  if { "$::tcl_platform(platform)" == "windows" } {
+    set aTargetPlatform "wnt"
+  }
+  
+  if {[regexp {(vc)[0-9]*$} $theIDE] == 1} {
+    set aTargetPlatform wnt
+  } elseif {"$theIDE" == "amk"} {
+    set aTargetPlatform lin
+  }
+
+  set aTargetPlatformExt sh
+  if { "$aTargetPlatform" == "wnt" } {
+    set aTargetPlatformExt bat
+  }
+
+  set aBox [file normalize "$thePath/.."]
+
+  if { "$aTargetPlatform" != "wnt" } {
+    file copy -force -- "$path/adm/templates/config.h" "$aBox/src/config.h"
+  }
+
+  if {"$theIDE" != "cmake"} {
+    set anEnvTmplFile [open "$path/adm/templates/env.${aTargetPlatformExt}" "r"]
+    set anEnvTmpl [read $anEnvTmplFile]
+    close $anEnvTmplFile
+
+    set aCasRoot ""
+    if { [file normalize "$anOsRootPath"] != "$aBox" } {
+      set aCasRoot [relativePath "$aBox" "$anOsRootPath"]
+    }
+    set anOsIncPath [relativePath "$aBox" "$anOsRootPath"]
+
+    regsub -all -- {__CASROOT__}   $anEnvTmpl "$aCasRoot" anEnvTmpl
+
+    set anEnvFile [open "$aBox/env.${aTargetPlatformExt}" "w"]
+    puts $anEnvFile $anEnvTmpl
+    close $anEnvFile
+
+    file copy -force -- "$path/adm/templates/draw.${aTargetPlatformExt}" "$aBox/draw.${aTargetPlatformExt}"
+  }
+
+  if {[regexp {(vc)[0-9]*$} $theIDE] == 1} {
+    file copy -force -- "$path/adm/templates/msvc.bat" "$aBox/msvc.bat"
+  } else {
+    switch -exact -- "$theIDE" {
+      "cbp"   { file copy -force -- "$path/adm/templates/codeblocks.sh" "$aBox/codeblocks.sh" }
+    }
+  }
+}
+
+###### MSVC #############################################################33
+proc removeAllOccurrencesOf { theObject theList } {
+  set aSortIndices [lsort -decreasing [lsearch -all -nocase $theList $theObject]]
+  foreach anIndex $aSortIndices {
+    set theList [lreplace $theList $anIndex $anIndex]
+  }
+  return $theList
+}
+
+proc OS:mkdir { d } {
+    global tcl_version
+    if ![file exists $d] {
+       if { "$tcl_version" == "7.5" } {
+           mkdir -path $d
+       } else {
+           file mkdir $d
+       }
+       if [file exists $d] {
+           return $d
+       } else {
+           return {}
+       }
+    } else {
+       return $d
+    }
+}
+
+# Entry function to generate project files and solutions for IDE
+proc OS:MKPRC { {theOutDir {}} {theIDE ""} } {
+  global path targetStation
+  set aSupportedIDE { "vc7" "vc8" "vc9" "vc10" "vc11" "vc12" "cbp" "amk" }
+
+  if { [lsearch $aSupportedIDE $theIDE] < 0 } {
+    puts stderr "WOK does not support generation of project files for the selected IDE: $theIDE\nSupported IDEs: [join ${aSupportedIDE} " "]"
+    return
+  }
+  
+  set anOutRoot $theOutDir
+  if { $anOutRoot == "" } {
+    error "Error : \"theOutDir\" is not initialized"
+  }
+
+  # Create output directory
+  set aWokStation "$targetStation"
+
+  if { [lsearch -exact {vc7 vc8 vc9 vc10 vc11 vc12} $theIDE] != -1 } {
+    set aWokStation "msvc"
+  }
+
+  set anOutDir "${anOutRoot}/${aWokStation}/${theIDE}"
+
+  # read map of already generated GUIDs
+  set aGuidsFilePath [file join $anOutDir "wok_${theIDE}_guids.txt"]
+  if [file exists "$aGuidsFilePath"] {
+    set aFileIn [open "$aGuidsFilePath" r]
+    set aFileDataRaw [read $aFileIn]
+    close $aFileIn
+    set aFileData [split $aFileDataRaw "\n"]
+    foreach aLine $aFileData {
+      set aLineSplt [split $aLine "="]
+      if { [llength $aLineSplt] == 2 } {
+        set ::THE_GUIDS_LIST([lindex $aLineSplt 0]) [lindex $aLineSplt 1]
+      }
+    }
+  }
+
+  # make list of modules and platforms
+  set aModules [OS:init]
+
+  # generate one solution for all projects if complete OS or VAS is processed
+  set anAllSolution "OCCT"
+
+  OS:mkdir $anOutDir
+  if { ![file exists $anOutDir] } {
+    puts stderr "Error: Could not create output directory \"$anOutDir\""
+    return
+  }
+
+  # create the out dir if it does not exist
+  if (![file isdirectory $path/inc]) {
+    puts "$path/inc folder does not exists and will be created"
+    wokUtils:FILES:mkdir $path/inc
+  }
+
+  # collect all required header files
+  puts "Collecting required header files into $path/inc ..."
+  osutils:collectinc $aModules $path/inc $targetStation
+
+  # Generating project files for the selected IDE
+  switch -exact -- "$theIDE" {
+    "vc7"   -
+    "vc8"   -
+    "vc9"   -
+    "vc10"   -
+    "vc11"   -
+    "vc12"  { OS:MKVC  $anOutDir $aModules $anAllSolution $theIDE }
+    "cbp"   { OS:MKCBP $anOutDir $aModules $anAllSolution }
+    "amk"   { OS:MKAMK $anOutDir $aModules "adm/${aWokStation}/${theIDE}"}
+  }
+  # generate config.txt file
+  #if { ${anAllSolution} == "Products" && "$targetStation" == "wnt" } {
+  #  osutils:mkCollectScript "collect_binary.cfg" "$anOutRoot/../" ${theIDE} $::env(ARCH) "release"
+  #}
+
+  # Store generated GUIDs map
+  set anOutFile [open "$aGuidsFilePath" "w"]
+  fconfigure $anOutFile -translation lf
+  foreach aKey [array names ::THE_GUIDS_LIST] {
+    set aValue $::THE_GUIDS_LIST($aKey)
+    puts $anOutFile "${aKey}=${aValue}"
+  }
+  close $anOutFile
+}
+
+# Function to generate Visual Studio solution and project files
+proc OS:MKVC { theOutDir {theModules {}} {theAllSolution ""} {theVcVer "vc8"} } {
+
+  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
+  }
+
+  # generate single solution "OCCT" containing projects from all modules
+  if { "$theAllSolution" != "" } {
+    OS:vcsolution $theVcVer $theAllSolution $theModules $theOutDir ::THE_GUIDS_LIST
+  }
+
+  puts "The Visual Studio solution and project files are stored in the $theOutDir directory"
+}
+
+proc OS:init {{os {}}} {
+    global path
+    global env
+    global tcl_platform
+    
+    set askplat $os
+    if { "$os" == "" } {
+      set os $tcl_platform(os)
+    }
+
+    ;# Load list of OCCT modules and their definitions
+    source "$path/src/OS/Modules.tcl"
+    set Modules {}
+    foreach module [OS:Modules] {
+        set f "$path/src/OS/${module}.tcl"
+        if [file exists $f] {
+            source $f
+            lappend Modules $module
+        } else {
+            puts stderr "Definition file for module $module is not found in unit OS"
+        }
+    }
+
+    # Load list of products and their definitions
+#    set Products [woklocate -p VAS:source:Products.tcl]
+    #if { "$Products" != "" } {
+       #source "$Products"
+       #foreach product [VAS:Products] {
+           #set f [woklocate -p VAS:source:${product}.tcl]
+           #if [file exists $f] {
+               #source $f
+           #} else {
+               #puts stderr "Definition file for product $product is not found in unit VAS"
+           #}
+       #}
+    #}
+
+    return $Modules
+}
+
+# topological sort. returns a list {  {a h} {b g} {c f} {c h} {d i}  } => { d a b c i g f h }
+proc wokUtils:EASY:tsort { listofpairs } {
+    foreach x $listofpairs {
+       set e1 [lindex $x 0]
+       set e2 [lindex $x 1]
+       if ![info exists pcnt($e1)] {
+           set pcnt($e1) 0
+       }
+       if ![ info exists pcnt($e2)] {
+           set pcnt($e2) 1
+       } else {
+           incr pcnt($e2)
+       }
+       if ![info exists scnt($e1)] {
+           set scnt($e1) 1
+       } else {
+           incr scnt($e1)
+       }
+       set l {}
+       if [info exists slist($e1)] {
+           set l $slist($e1)
+       }
+       lappend l $e2
+       set slist($e1) $l
+    }
+    set nodecnt 0
+    set back 0
+    foreach node [array names pcnt] {
+       incr nodecnt
+       if { $pcnt($node) == 0 } {
+           incr back
+           set q($back) $node
+       }
+       if ![info exists scnt($node)] {
+           set scnt($node) 0
+       }
+    }
+    set res {}
+    for {set front 1} { $front <= $back } { incr front } {
+       lappend res [set node $q($front)]
+       for {set i 1} {$i <= $scnt($node) } { incr i } {
+           set ll $slist($node)
+           set j [expr {$i - 1}]
+           set u [expr { $pcnt([lindex $ll $j]) - 1 }]
+           if { [set pcnt([lindex $ll $j]) $u] == 0 } {
+               incr back
+               set q($back) [lindex $ll $j]
+           }
+       }
+    }
+    if { $back != $nodecnt } {
+       puts stderr "input contains a cycle"
+       return {}
+    } else {
+       return $res
+    }
+}
+
+proc wokUtils:LIST:Purge { l } {
+    set r {}
+     foreach e $l {
+        if ![info exist tab($e)] {
+            lappend r $e
+            set tab($e) {}
+        } 
+     }
+     return $r
+}
+
+# Read file pointed to by path
+# 1. sort = 1 tri 
+# 2. trim = 1 plusieurs blancs => 1 seul blanc
+# 3. purge= not yet implemented.
+# 4. emptl= dont process blank lines
+proc wokUtils:FILES:FileToList { path {sort 0} {trim 0} {purge 0} {emptl 1} } {
+    if ![ catch { set id [ open $path r ] } ] {
+       set l  {}
+       while {[gets $id line] >= 0 } {
+           if { $trim } {
+               regsub -all {[ ]+} $line " " line
+           }
+           if { $emptl } {
+               if { [string length ${line}] != 0 } {
+                   lappend l $line
+               }
+           } else {
+               lappend l $line
+           }
+       }
+       close $id
+       if { $sort } {
+           return [lsort $l]
+       } else {
+           return $l
+       }
+    } else {
+       return {}
+    }
+}
+
+# retorn the list of executables in module.
+proc OS:executable { module } {
+    set lret {}
+    foreach XXX  [${module}:ressources] {
+       if { "[lindex $XXX 1]" == "x" } {
+           lappend lret [lindex $XXX 2]
+       }
+    }
+    return $lret
+}
+
+# Topological sort of toolkits in tklm
+proc osutils:tk:sort { tklm } {
+  set tkby2 {}
+  foreach tkloc $tklm {
+    set lprg [wokUtils:LIST:Purge [osutils:tk:close $tkloc]]
+    foreach tkx  $lprg {
+      if { [lsearch $tklm $tkx] != -1 } {
+        lappend tkby2 [list $tkx $tkloc]
+      } else {
+        lappend tkby2 [list $tkloc {}]
+      }
+    }
+  }
+  set lret {}
+  foreach e [wokUtils:EASY:tsort $tkby2] {
+    if { $e != {} } {
+      lappend lret $e
+    }
+  }
+  return $lret
+}
+
+#  close dependencies of ltk. (full wok pathes of toolkits)
+# The CURRENT WOK LOCATION MUST contains ALL TOOLKITS required.
+# (locate not performed.)
+proc osutils:tk:close { ltk } {
+  set result {}
+  set recurse {}
+  foreach dir $ltk {
+    set ids [LibToLink $dir]
+    set eated [osutils:tk:eatpk $ids]
+    set result [concat $result $eated]
+    set ids [LibToLink $dir]
+    set result [concat $result $ids]
+
+    foreach file $eated {
+      set kds "$path/src/$file/EXTERNLIB"
+      if { [osutils:tk:eatpk $kds] !=  {} } {
+        lappend recurse $file
+      }
+    }
+  }
+  if { $recurse != {} } {
+    set result [concat $result [osutils:tk:close $recurse]]
+  }
+  return $result
+}
+
+proc osutils:tk:eatpk { EXTERNLIB  } {
+  set l [wokUtils:FILES:FileToList $EXTERNLIB]
+  set lret  {}
+  foreach str $l {
+    if ![regexp -- {(CSF_[^ ]*)} $str csf] {
+      lappend lret $str
+    }
+  }
+  return $lret
+}
+# Define libraries to link using only EXTERNLIB file
+
+proc LibToLink {theTKit} {
+  global path
+  regexp {^.*:([^:]+)$} $theTKit dummy theTKit
+  set type [_get_type $theTKit]
+  if {$type != "t" && $type != "x"} {
+    return
+  }
+  set aToolkits {}
+  set anExtLibList [osutils:tk:eatpk "$path/src/$theTKit/EXTERNLIB"]
+  foreach anExtLib $anExtLibList {
+    set aFullPath [LocateRecur $anExtLib]
+    if { "$aFullPath" != "" && [_get_type $anExtLib] == "t" } {
+      lappend aToolkits $anExtLib
+    }
+  }
+  return $aToolkits
+}
+# Search unit recursively
+
+proc LocateRecur {theName} {
+  global path
+  set theNamePath "$path/src/$theName"
+  if {[file isdirectory $theNamePath]} {
+    return $theNamePath
+  }
+  return ""
+}
+
+proc OS:genGUID { {theIDE "vc"} } {
+  if { "$theIDE" == "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) }]]"
+    set p4 "[format %04X [expr { int(rand() * 6536) }]]"
+    set p5 "[format %06X [expr { int(rand() * 16777216) }]][format %06X [expr { int(rand() * 16777216) }]]"
+    return "{$p1-$p2-$p3-$p4-$p5}"
+  } else {
+    set p1 "[format %04X [expr { int(rand() * 6536) }]]"
+    set p2 "[format %04X [expr { int(rand() * 6536) }]]"
+    set p3 "[format %04X [expr { int(rand() * 6536) }]]"
+    set p4 "[format %04X [expr { int(rand() * 6536) }]]"
+    set p5 "[format %04X [expr { int(rand() * 6536) }]]"
+    set p6 "[format %04X [expr { int(rand() * 6536) }]]"
+    return "$p1$p2$p3$p4$p5$p6"
+  }
+}
+
+# collect all include file that required for theModules in theOutDir
+proc osutils:collectinc {theModules theIncPath theTargetStation} {
+  global path
+
+  set aCasRoot [file normalize $path]
+  set anIncPath [file normalize $theIncPath]
+
+  if {![file isdirectory $aCasRoot]} {
+    puts "OCCT directory is not defined correctly: $aCasRoot"
+    return
+  }
+
+  set anUsedToolKits {}
+  foreach aModule $theModules {
+    foreach aToolKit [${aModule}:toolkits] {
+      lappend anUsedToolKits $aToolKit
+
+      foreach aDependency [LibToLink $aToolKit] {
+        lappend anUsedToolKits $aDependency
+      }
+    }
+    foreach anExecutable [OS:executable ${aModule}] {
+      lappend anUsedToolKits $anExecutable
+
+      foreach aDependency [LibToLink $anExecutable] {
+        lappend anUsedToolKits $aDependency
+      }
+    }
+  }
+  lsort -unique $anUsedToolKits
+
+  set anUnits {}
+  foreach anUsedToolKit $anUsedToolKits {
+    set anUnits [concat $anUnits [osutils:tk:units $anUsedToolKit]]
+  }
+  lsort -unique $anUnits
+
+  if { [info exists ::env(SHORTCUT_HEADERS)] && 
+       $::env(SHORTCUT_HEADERS) == "true" } {
+    # template preparation
+    if { ![file exists $aCasRoot/adm/templates/header.in] } {
+      puts "template file does not exist: $aCasRoot/adm/templates/header.in"
+      return
+    }
+    set aHeaderTmpl [wokUtils:FILES:FileToString $aCasRoot/adm/templates/header.in]
+
+    # relative anIncPath in connection with aCasRoot/src
+    set aFromBuildIncToSrcPath [relativePath "$anIncPath" "$aCasRoot/src"]
+
+    # 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]
+
+        regsub -all -- {@OCCT_HEADER_FILE@} $aHeaderTmpl "$aFromBuildIncToSrcPath/$anUnit/$aHeaderFileName" aShortCutHeaderFileContent
+
+        if {[file exists "$theIncPath/$aHeaderFileName"] && [file readable "$theIncPath/$aHeaderFileName"]} {
+          set fp [open "$theIncPath/$aHeaderFileName" r]
+          set aHeaderContent [read $fp]
+          close $fp
+
+          # minus eof
+          set aHeaderLenght  [expr [string length $aHeaderContent] - 1]
+
+          if {$aHeaderLenght == [string length $aShortCutHeaderFileContent]} {
+            # remove eof from string
+            set aHeaderContent [string range $aHeaderContent 0 [expr $aHeaderLenght - 1]]
+
+            if {[string compare $aShortCutHeaderFileContent $aHeaderContent] == 0} {
+              continue
+            }
+          }
+        }
+
+        set aShortCutHeaderFile [open "$theIncPath/$aHeaderFileName" "w"]
+        fconfigure $aShortCutHeaderFile -translation lf
+        puts $aShortCutHeaderFile $aShortCutHeaderFileContent
+        close $aShortCutHeaderFile
+      }
+    }  
+  } 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]
+
+        # copy file only if target does not exist or is older than original
+        set torig [file mtime $aHeaderFile]
+        if { ! [file isfile $anIncPath/$aHeaderFileName] } {
+          set tcopy 0
+        } else {
+          set tcopy [file mtime $anIncPath/$aHeaderFileName]
+        }
+        if { $tcopy < $torig } {
+          incr nbcopied
+          file copy -force $aHeaderFile $anIncPath/$aHeaderFileName
+        } elseif { $tcopy != $torig } {
+          puts "Warning: file $anIncPath/$aHeaderFileName is newer than $aHeaderFile, not changed!"
+        }
+      }
+    }
+    puts "Info: $nbcopied files updated"
+  }
+}
+
+# Generate header for VS solution file
+proc osutils:vcsolution:header { vcversion } {
+  if { "$vcversion" == "vc7" } {
+    append var \
+      "Microsoft Visual Studio Solution File, Format Version 8.00\n"
+  } elseif { "$vcversion" == "vc8" } {
+    append var \
+      "Microsoft Visual Studio Solution File, Format Version 9.00\n" \
+      "# Visual Studio 2005\n"
+  } elseif { "$vcversion" == "vc9" } {
+    append var \
+      "Microsoft Visual Studio Solution File, Format Version 10.00\n" \
+      "# Visual Studio 2008\n"
+  } elseif { "$vcversion" == "vc10" } {
+    append var \
+      "Microsoft Visual Studio Solution File, Format Version 11.00\n" \
+      "# Visual Studio 2010\n"
+  } elseif { "$vcversion" == "vc11" } {
+    append var \
+      "Microsoft Visual Studio Solution File, Format Version 12.00\n" \
+      "# Visual Studio 2012\n"
+  } elseif { "$vcversion" == "vc12" } {
+    append var \
+      "Microsoft Visual Studio Solution File, Format Version 13.00\n" \
+      "# Visual Studio 2013\n"
+  } else {
+    puts stderr "Error: Visual Studio version $vcversion is not supported by this function!"
+  }
+  return $var
+}
+# Returns extension (without dot) for project files of given version of VC
+
+proc osutils:vcproj:ext { vcversion } {
+  if { "$vcversion" == "vc7" || "$vcversion" == "vc8" || "$vcversion" == "vc9" } {
+    return "vcproj"
+  } elseif { "$vcversion" == "vc10" || "$vcversion" == "vc11" || "$vcversion" == "vc12" } {
+    return "vcxproj"
+  } else {
+    puts stderr "Error: Visual Studio version $vc is not supported by this function!"
+  }
+}
+# Generate start of configuration section of VS solution file
+
+proc osutils:vcsolution:config:begin { vcversion } {
+  if { "$vcversion" == "vc7" } {
+    append var \
+      "Global\n" \
+      "\tGlobalSection(SolutionConfiguration) = preSolution\n" \
+      "\t\tDebug = Debug\n" \
+      "\t\tRelease = Release\n" \
+      "\tEndGlobalSection\n" \
+      "\tGlobalSection(ProjectConfiguration) = postSolution\n"
+  } elseif { "$vcversion" == "vc8" || "$vcversion" == "vc9" ||
+             "$vcversion" == "vc10" || "$vcversion" == "vc11" ||
+             "$vcversion" == "vc12" } {
+    append var \
+      "Global\n" \
+      "\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\n" \
+      "\t\tDebug|Win32 = Debug|Win32\n" \
+      "\t\tRelease|Win32 = Release|Win32\n" \
+      "\t\tDebug|x64 = Debug|x64\n" \
+      "\t\tRelease|x64 = Release|x64\n" \
+      "\tEndGlobalSection\n" \
+      "\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\n"
+  } else {
+    puts stderr "Error: Visual Studio version $vcversion is not supported by this function!"
+  }
+  return $var
+}
+# Generate part of configuration section of VS solution file describing one project
+
+proc osutils:vcsolution:config:project { vcversion guid } {
+  if { "$vcversion" == "vc7" } {
+    append var \
+      "\t\t$guid.Debug.ActiveCfg = Debug|Win32\n" \
+      "\t\t$guid.Debug.Build.0 = Debug|Win32\n" \
+      "\t\t$guid.Release.ActiveCfg = Release|Win32\n" \
+      "\t\t$guid.Release.Build.0 = Release|Win32\n"
+  } elseif { "$vcversion" == "vc8" || "$vcversion" == "vc9" ||
+             "$vcversion" == "vc10" || "$vcversion" == "vc11" ||
+             "$vcversion" == "vc12" } {
+    append var \
+      "\t\t$guid.Debug|Win32.ActiveCfg = Debug|Win32\n" \
+      "\t\t$guid.Debug|Win32.Build.0 = Debug|Win32\n" \
+      "\t\t$guid.Release|Win32.ActiveCfg = Release|Win32\n" \
+      "\t\t$guid.Release|Win32.Build.0 = Release|Win32\n" \
+      "\t\t$guid.Debug|x64.ActiveCfg = Debug|x64\n" \
+      "\t\t$guid.Debug|x64.Build.0 = Debug|x64\n" \
+      "\t\t$guid.Release|x64.ActiveCfg = Release|x64\n" \
+      "\t\t$guid.Release|x64.Build.0 = Release|x64\n"
+  } else {
+    puts stderr "Error: Visual Studio version $vcversion is not supported by this function!"
+  }
+  return $var
+}
+# Generate start of configuration section of VS solution file
+
+proc osutils:vcsolution:config:end { vcversion } {
+  if { "$vcversion" == "vc7" } {
+    append var \
+      "\tEndGlobalSection\n" \
+      "\tGlobalSection(ExtensibilityGlobals) = postSolution\n" \
+      "\tEndGlobalSection\n" \
+      "\tGlobalSection(ExtensibilityAddIns) = postSolution\n" \
+      "\tEndGlobalSection\n"
+  } elseif { "$vcversion" == "vc8" || "$vcversion" == "vc9" ||
+             "$vcversion" == "vc10" || "$vcversion" == "vc11" ||
+             "$vcversion" == "vc12" } {
+    append var \
+      "\tEndGlobalSection\n" \
+      "\tGlobalSection(SolutionProperties) = preSolution\n" \
+      "\t\tHideSolutionNode = FALSE\n" \
+      "\tEndGlobalSection\n"
+  } else {
+    puts stderr "Error: Visual Studio version $vcversion is not supported by this function!"
+  }
+  return $var
+}
+# generate Visual Studio solution file
+# if module is empty, generates one solution for all known modules
+
+proc OS:vcsolution { theVcVer theSolName theModules theOutDir theGuidsMap } {
+  global path
+  upvar $theGuidsMap aGuidsMap
+
+  # collect list of projects to be created
+  set aProjects {}
+  set aDependencies {}
+  foreach aModule $theModules {
+    # toolkits
+    foreach aToolKit [osutils:tk:sort [${aModule}:toolkits]] {
+      lappend aProjects $aToolKit
+      lappend aProjectsInModule($aModule) $aToolKit
+      lappend aDependencies [LibToLink $aToolKit]
+    }
+    # executables, assume one project per cxx file...
+    foreach aUnit [OS:executable ${aModule}] {
+      set aUnitLoc $aUnit
+      set src_files [_get_used_files $aUnit false]
+      set aSrcFiles {}
+      foreach s $src_files {
+        regexp {source ([^\s]+)} $s dummy name
+        lappend aSrcFiles $name
+      }
+      foreach aSrcFile $aSrcFiles {
+        set aFileExtension [file extension $aSrcFile]
+        if { $aFileExtension == ".cxx" } {
+          set aPrjName [file rootname $aSrcFile]
+          lappend aProjects $aPrjName
+          lappend aProjectsInModule($aModule) $aPrjName
+          if {[file isdirectory $path/src/$aUnitLoc]} {
+            lappend aDependencies [LibToLinkX $aUnitLoc [file rootname $aSrcFile]]
+          } else {
+            lappend aDependencies {}
+          }
+        }
+      }
+    }
+  }
+
+# generate GUIDs for projects (unless already known)
+  foreach aProject $aProjects {
+    if { ! [info exists aGuidsMap($aProject)] } {
+      set aGuidsMap($aProject) [OS:genGUID]
+    }
+  }
+
+  # generate solution file
+#  puts "Generating Visual Studio ($theVcVer) solution file for $theSolName ($aProjects)"
+  append aFileBuff [osutils:vcsolution:header $theVcVer]
+
+  # GUID identifying group projects in Visual Studio
+  set VC_GROUP_GUID "{2150E333-8FDC-42A3-9474-1A3956D46DE8}"
+
+  # generate group projects -- one per module
+  if { "$theVcVer" != "vc7" && [llength "$theModules"] > 1 } {
+    foreach aModule $theModules {
+      if { ! [info exists aGuidsMap(_$aModule)] } {
+        set aGuidsMap(_$aModule) [OS:genGUID]
+      }
+      set aGuid $aGuidsMap(_$aModule)
+      append aFileBuff "Project(\"${VC_GROUP_GUID}\") = \"$aModule\", \"$aModule\", \"$aGuid\"\nEndProject\n"
+    }
+  }
+
+  # extension of project files
+  set aProjExt [osutils:vcproj:ext $theVcVer]
+
+  # GUID identifying C++ projects in Visual Studio
+  set VC_CPP_GUID "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}"
+
+  # generate normal projects
+  set aProjsNb [llength $aProjects]
+  for {set aProjId 0} {$aProjId < $aProjsNb} {incr aProjId} {
+    set aProj [lindex $aProjects $aProjId]
+    set aGuid $aGuidsMap($aProj)
+    append aFileBuff "Project(\"${VC_CPP_GUID}\") = \"$aProj\", \"$aProj.${aProjExt}\", \"$aGuid\"\n"
+    # write projects dependencies information (vc7 to vc9)
+    set aDepGuids ""
+    foreach aDepLib [lindex $aDependencies $aProjId] {
+      if { $aDepLib != $aProj && [lsearch $aProjects $aDepLib] != "-1" } {
+        set depGUID $aGuidsMap($aDepLib)
+        append aDepGuids "\t\t$depGUID = $depGUID\n"
+      }
+    }
+    if { "$aDepGuids" != "" } {
+      append aFileBuff "\tProjectSection(ProjectDependencies) = postProject\n"
+      append aFileBuff "$aDepGuids"
+      append aFileBuff "\tEndProjectSection\n"
+    }
+    append aFileBuff "EndProject\n"
+  }
+
+  # generate configuration section
+  append aFileBuff [osutils:vcsolution:config:begin $theVcVer]
+  foreach aProj $aProjects {
+    append aFileBuff [osutils:vcsolution:config:project $theVcVer $aGuidsMap($aProj)]
+  }
+  append aFileBuff [osutils:vcsolution:config:end $theVcVer]
+
+  # write information of grouping of projects by module
+  if { "$theVcVer" != "vc7" && [llength "$theModules"] > 1 } {
+    append aFileBuff " GlobalSection(NestedProjects) = preSolution\n"
+    foreach aModule $theModules {
+      if { ! [info exists aProjectsInModule($aModule)] } { continue }
+      foreach aProject $aProjectsInModule($aModule) {
+        append aFileBuff "             $aGuidsMap($aProject) = $aGuidsMap(_$aModule)\n"
+      }
+    }
+    append aFileBuff " EndGlobalSection\n"
+  }
+
+  # final word (footer)
+  append aFileBuff "EndGlobal"
+
+  # write solution
+  set aFile [open [set fdsw [file join $theOutDir ${theSolName}.sln]] w]
+  fconfigure $aFile -translation crlf
+  puts $aFile $aFileBuff
+  close $aFile
+  return [file join $theOutDir ${theSolName}.sln]
+}
+# Generate Visual Studio projects for specified version
+
+proc OS:vcproj { theVcVer theModules theOutDir theGuidsMap } {
+  upvar $theGuidsMap aGuidsMap
+
+  set aProjectFiles {}
+
+  foreach aModule $theModules {
+    foreach aToolKit [${aModule}:toolkits] {
+      lappend aProjectFiles [osutils:vcproj  $theVcVer $theOutDir $aToolKit     aGuidsMap]
+    }
+    foreach anExecutable [OS:executable ${aModule}] {
+      lappend aProjectFiles [osutils:vcprojx $theVcVer $theOutDir $anExecutable aGuidsMap]
+    }
+  }
+  return $aProjectFiles
+}
+# generate template name and load it for given version of Visual Studio and platform
+
+proc osutils:vcproj:readtemplate {vc isexec} {
+  set ext $vc
+  set what "$vc"
+  if { $isexec } {
+    set ext "${ext}x"
+    set what "$what executable"
+  }
+  return [osutils:readtemplate $ext "MS VC++ project ($what)"]
+}
+
+proc osutils:readtemplate {ext what} {
+  global env
+  global path
+  set loc "$path/adm/templates/template.$ext"
+  return [wokUtils:FILES:FileToString $loc]
+}
+# Read a file in a string as is.
+
+proc wokUtils:FILES:FileToString { fin } {
+    if { [catch { set in [ open $fin r ] } errin] == 0 } {
+       set strin [read $in [file size $fin]]
+       close $in
+       return $strin
+    } else {
+       return {}
+    }
+}
+# List extensions of compilable files in OCCT
+
+proc osutils:compilable { } {
+  global targetStation
+  set aWokStation "$targetStation"
+  if { "$aWokStation" == "mac" } {
+    return [list .c .cxx .cpp .mm]
+  }
+  return [list .c .cxx .cpp]
+}
+
+proc osutils:commonUsedTK { theToolKit } {
+  global path
+  set anUsedToolKits [list]
+  set aDepToolkits [LibToLink $theToolKit]
+  foreach tkx $aDepToolkits {
+    if {[_get_type $tkx] == "t"} {
+      lappend anUsedToolKits "${tkx}"
+    }
+  }
+  return $anUsedToolKits
+}
+# Return the list of name *CSF_ in a EXTERNLIB description of a toolkit
+
+proc osutils:tk:hascsf { EXTERNLIB } {
+  set l [wokUtils:FILES:FileToList $EXTERNLIB]
+  set lret  {STLPort}
+  foreach str $l {
+    if [regexp -- {(CSF_[^ ]*)} $str csf] {
+      lappend lret $csf
+    }
+  }
+  return $lret
+}
+
+proc osutils:csfList { theOS  theCsfMap } {
+  upvar $theCsfMap aCsfMap
+
+  unset theCsfMap
+
+  if { "$theOS" == "wnt" } {
+    # -- WinAPI libraries
+    set aCsfMap(CSF_kernel32)   "kernel32.lib"
+    set aCsfMap(CSF_advapi32)   "advapi32.lib"
+    set aCsfMap(CSF_gdi32)      "gdi32.lib"
+    set aCsfMap(CSF_user32)     "user32.lib"
+    set aCsfMap(CSF_glu32)      "glu32.lib"
+    set aCsfMap(CSF_opengl32)   "opengl32.lib"
+    set aCsfMap(CSF_wsock32)    "wsock32.lib"
+    set aCsfMap(CSF_netapi32)   "netapi32.lib"
+    set aCsfMap(CSF_AviLibs)    "ws2_32.lib vfw32.lib"
+    set aCsfMap(CSF_OpenGlLibs) "opengl32.lib glu32.lib"
+
+    # -- 3rd-parties precompiled libraries
+    # Note: Tcl library name depends on version and is chosen by #pragma
+    set aCsfMap(CSF_QT)         "QtCore4.lib QtGui4.lib"
+
+  } else {
+
+    #-- Tcl/Tk configuration
+    set aCsfMap(CSF_TclLibs)    "tcl8.6"
+    set aCsfMap(CSF_TclTkLibs)  "X11 tk8.6"
+
+    if { "$theOS" == "lin" } {
+      set aCsfMap(CSF_ThreadLibs) "pthread rt"
+      set aCsfMap(CSF_OpenGlLibs) "GLU GL"
+
+    } elseif { "$theOS" == "mac" } {
+      set aCsfMap(CSF_objc)     "objc"
+
+      # frameworks
+      set aCsfMap(CSF_Appkit)     "Appkit"
+      set aCsfMap(CSF_IOKit)      "IOKit"
+      set aCsfMap(CSF_OpenGlLibs) "OpenGL"
+      set aCsfMap(CSF_TclLibs)    "Tcl"
+      set aCsfMap(CSF_TclTkLibs)  "Tk"
+    }
+
+    set aCsfMap(CSF_XwLibs)     "X11 Xext Xmu Xi"
+    set aCsfMap(CSF_MotifLibs)  "X11"
+
+    # variable is required for support for OCCT version that use fgtl
+    #-- FTGL (font renderer for OpenGL)
+    set aCsfMap(CSF_FTGL)       "ftgl"
+
+    #-- FreeType
+    set aCsfMap(CSF_FREETYPE)   "freetype"
+
+    #-- optional 3rd-parties
+    #-- TBB
+    set aCsfMap(CSF_TBB)            "tbb tbbmalloc"
+
+    #-- FreeImage
+    set aCsfMap(CSF_FreeImagePlus)  "freeimage"
+
+    #-- GL2PS
+    set aCsfMap(CSF_GL2PS)          "gl2ps"
+
+    #-- VTK
+    set aCsfMap(CSF_VTK)         "vtkCommonCore-6.1 vtkCommonDataModel-6.1 vtkCommonExecutionModel-6.1 vtkCommonMath-6.1 vtkCommonTransforms-6.1 vtkRenderingCore-6.1"
+  }
+}
+
+proc osutils:usedOsLibs { theToolKit theOS } {
+  global path
+  set aUsedLibs [list]
+
+  osutils:csfList $theOS anOsCsfList
+
+  foreach element [osutils:tk:hascsf "$path/src/${theToolKit}/EXTERNLIB"] {
+    # test if variable is not setted - continue
+    if ![info exists anOsCsfList($element)] {
+      continue
+    }
+
+    foreach aLib [split "$anOsCsfList($element)"] {
+      if { [lsearch $aUsedLibs $aLib] == "-1"} {
+        lappend aUsedLibs $aLib
+      }
+    }
+  }
+
+  return $aUsedLibs
+}
+
+# Returns liste of UD in a toolkit. tkloc is a full path wok.
+proc osutils:tk:units { tkloc } {
+  global path
+  set l {}
+  set PACKAGES "$path/src/$tkloc/PACKAGES"
+  foreach u [wokUtils:FILES:FileToList $PACKAGES] {
+    if {[file isdirectory "$path/src/$u"]} {
+      lappend l $u
+    }
+  }
+  if { $l == {} } {
+    ;#puts stderr "Warning. No devunit included in $tkloc"
+  }
+  return $l
+}
+
+proc osutils:justwnt { listloc } {
+  # ImageUtility is required for support for old (<6.5.4) versions of OCCT
+  set goaway [list Xdps Xw  ImageUtility WOKUnix]
+  return [osutils:juststation $goaway $listloc]
+}
+
+# remove from listloc OpenCascade units indesirables on NT
+proc osutils:juststation {goaway listloc} {
+  global path
+  set lret {}
+  foreach u $listloc {
+    if {([file isdirectory "$path/src/$u"] && [lsearch $goaway $u] == -1 )
+     || (![file isdirectory "$path/src/$u"] && [lsearch $goaway $u] == -1 ) } {
+      lappend lret $u
+    }
+  }
+  return $lret
+}
+
+# intersect3 - perform the intersecting of two lists, returning a list containing three lists.
+# The first list is everything in the first list that wasn't in the second,
+# the second list contains the intersection of the two lists, the third list contains everything
+# in the second list that wasn't in the first.
+proc osutils:intersect3 {list1 list2} {
+  set la1(0) {} ; unset la1(0)
+  set lai(0) {} ; unset lai(0)
+  set la2(0) {} ; unset la2(0)
+  foreach v $list1 {
+    set la1($v) {}
+  }
+  foreach v $list2 {
+    set la2($v) {}
+  }
+  foreach elem [concat $list1 $list2] {
+    if {[info exists la1($elem)] && [info exists la2($elem)]} {
+      unset la1($elem)
+      unset la2($elem)
+      set lai($elem) {}
+    }
+  }
+  list [lsort [array names la1]] [lsort [array names lai]] [lsort [array names la2]]
+}
+
+# Prepare relative path
+proc relativePath {thePathFrom thePathTo} {
+  if { [file isdirectory "$thePathFrom"] == 0 } {
+    return ""
+  }
+
+  set aPathFrom [file normalize "$thePathFrom"]
+  set aPathTo   [file normalize "$thePathTo"]
+
+  set aCutedPathFrom "${aPathFrom}/dummy"
+  set aRelatedDeepPath ""
+
+  while { "$aCutedPathFrom" != [file normalize "$aCutedPathFrom/.."] } {
+    set aCutedPathFrom [file normalize "$aCutedPathFrom/.."]
+    # does aPathTo contain aCutedPathFrom?
+    regsub -all $aCutedPathFrom $aPathTo "" aPathFromAfterCut
+    if { "$aPathFromAfterCut" != "$aPathTo" } { # if so
+      if { "$aCutedPathFrom" == "$aPathFrom" } { # just go higher, for example, ./somefolder/someotherfolder
+        set aPathTo ".${aPathTo}"
+      } elseif { "$aCutedPathFrom" == "$aPathTo" } { # remove the last "/"
+        set aRelatedDeepPath [string replace $aRelatedDeepPath end end ""]
+      }
+      regsub -all $aCutedPathFrom $aPathTo $aRelatedDeepPath aPathToAfterCut
+      regsub -all "//" $aPathToAfterCut "/" aPathToAfterCut
+      return $aPathToAfterCut
+    }
+    set aRelatedDeepPath "$aRelatedDeepPath../"
+
+  }
+
+  return $thePathTo
+}
+
+proc wokUtils:EASY:bs1 { s } {
+    regsub -all {/} $s {\\} r
+    return $r
+}
+
+# Returs for a full path the liste of n last directory part
+# n = 1 => tail
+# n = 2 => dir/file.c
+# n = 3 => sdir/dir/file.c
+# etc..
+proc wokUtils:FILES:wtail { f n } {
+    set ll [expr [llength [set lif [file split $f]]] -$n]
+    return [join [lrange $lif $ll end] /]
+}
+
+# Generate entry for one source file in Visual Studio 10 project file
+proc osutils:vcxproj:file { vcversion 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"
+  }
+
+  if { $params != "" } {
+    append text "      <AdditionalOptions Condition=\"\'\$(Configuration)|\$(Platform)\'==\'Release|Win32\'\">[string trim ${params}]  %(AdditionalOptions)</AdditionalOptions>\n"
+  }
+
+  if { $params != "" } {
+    append text "      <AdditionalOptions Condition=\"\'\$(Configuration)|\$(Platform)\'==\'Debug|x64\'\">[string trim ${params}]  %(AdditionalOptions)</AdditionalOptions>\n"
+  }
+
+  if { $params != "" } {
+    append text "      <AdditionalOptions Condition=\"\'\$(Configuration)|\$(Platform)\'==\'Release|x64\'\">[string trim ${params}]  %(AdditionalOptions)</AdditionalOptions>\n"
+  }
+
+  append text "    </ClCompile>\n"
+  return $text
+}
+
+# Generate Visual Studio 2010 project filters file
+proc osutils:vcxproj:filters { dir proj theFilesMap } {
+  upvar $theFilesMap aFilesMap
+
+  # header
+  append text "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
+  append text "<Project ToolsVersion=\"4.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n"
+
+  # list of "filters" (units)
+  append text "  <ItemGroup>\n"
+  append text "    <Filter Include=\"Source files\">\n"
+  append text "      <UniqueIdentifier>[OS:genGUID]</UniqueIdentifier>\n"
+  append text "    </Filter>\n"
+  foreach unit $aFilesMap(units) {
+    append text "    <Filter Include=\"Source files\\${unit}\">\n"
+    append text "      <UniqueIdentifier>[OS:genGUID]</UniqueIdentifier>\n"
+    append text "    </Filter>\n"
+  }
+  append text "  </ItemGroup>\n"
+
+  # list of files
+  append text "  <ItemGroup>\n"
+  foreach unit $aFilesMap(units) {
+    foreach file $aFilesMap($unit) {
+      append text "    <ClCompile Include=\"..\\..\\..\\[wokUtils:EASY:bs1 [wokUtils:FILES:wtail $file 3]]\">\n"
+      append text "      <Filter>Source files\\${unit}</Filter>\n"
+      append text "    </ClCompile>\n"
+    }
+  }
+  append text "  </ItemGroup>\n"
+
+  # end
+  append text "</Project>"
+
+  # write file
+  set fp [open [set fvcproj [file join $dir ${proj}.vcxproj.filters]] w]
+  fconfigure $fp -translation crlf
+  puts $fp $text
+  close $fp
+
+  return ${proj}.vcxproj.filters
+}
+
+# Generate Visual Studio 2011 project filters file
+proc osutils:vcx1proj:filters { dir proj theFilesMap } {
+  upvar $theFilesMap aFilesMap
+
+  # header
+  append text "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
+  append text "<Project ToolsVersion=\"4.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n"
+
+  # list of "filters" (units)
+  append text "  <ItemGroup>\n"
+  append text "    <Filter Include=\"Source files\">\n"
+  append text "      <UniqueIdentifier>[OS:genGUID]</UniqueIdentifier>\n"
+  append text "    </Filter>\n"
+  foreach unit $aFilesMap(units) {
+    append text "    <Filter Include=\"Source files\\${unit}\">\n"
+    append text "      <UniqueIdentifier>[OS:genGUID]</UniqueIdentifier>\n"
+    append text "    </Filter>\n"
+  }
+  append text "  </ItemGroup>\n"
+
+  # list of files
+  append text "  <ItemGroup>\n"
+  foreach unit $aFilesMap(units) {
+    foreach file $aFilesMap($unit) {
+      append text "    <ClCompile Include=\"..\\..\\..\\[wokUtils:EASY:bs1 [wokUtils:FILES:wtail $file 3]]\">\n"
+      append text "      <Filter>Source files\\${unit}</Filter>\n"
+      append text "    </ClCompile>\n"
+    }
+  }
+  append text "  </ItemGroup>\n"
+
+  append text "  <ItemGroup>\n"
+  append text "    <ResourceCompile Include=\"${proj}.rc\" />"
+  append text "  </ItemGroup>\n"
+
+  # end
+  append text "</Project>"
+
+  # write file
+  set fp [open [set fvcproj [file join $dir ${proj}.vcxproj.filters]] w]
+  fconfigure $fp -translation crlf
+  puts $fp $text
+  close $fp
+
+  return ${proj}.vcxproj.filters
+}
+
+# Generate RC file content for ToolKit from template
+proc osutils:readtemplate:rc {theOutDir theToolKit} {
+  global path
+  set aLoc "$path/adm/templates/template_dll.rc"
+  set aBody [wokUtils:FILES:FileToString $aLoc]
+  regsub -all -- {__TKNAM__} $aBody $theToolKit aBody
+
+  set aFile [open "${theOutDir}/${theToolKit}.rc" "w"]
+  fconfigure $aFile -translation lf
+  puts $aFile $aBody
+  close $aFile
+  return "${theOutDir}/${theToolKit}.rc"
+}
+
+# Generate Visual Studio project file for ToolKit
+proc osutils:vcproj { theVcVer theOutDir theToolKit theGuidsMap {theProjTmpl {} } } {
+  if { $theProjTmpl == {} } {set theProjTmpl [osutils:vcproj:readtemplate $theVcVer 0]}
+
+  set l_compilable [osutils:compilable]
+  regsub -all -- {__TKNAM__} $theProjTmpl $theToolKit theProjTmpl
+
+  upvar $theGuidsMap aGuidsMap
+  if { ! [info exists aGuidsMap($theToolKit)] } {
+    set aGuidsMap($theToolKit) [OS:genGUID]
+  }
+  regsub -all -- {__PROJECT_GUID__} $theProjTmpl $aGuidsMap($theToolKit) theProjTmpl
+
+  set aCommonUsedTK [list]
+  foreach tkx [osutils:commonUsedTK  $theToolKit] {
+    lappend aCommonUsedTK "${tkx}.lib"
+  }
+
+  set aUsedToolKits [concat $aCommonUsedTK [osutils:usedOsLibs $theToolKit "wnt"]]
+
+  # correct names of referred third-party libraries that are named with suffix
+  # depending on VC version
+  regsub -all -- {vc[0-9]+} $aUsedToolKits $theVcVer aUsedToolKits
+
+  # and put this list to project file
+  #puts "$theToolKit requires  $aUsedToolKits"
+  if { "$theVcVer" == "vc10" || "$theVcVer" == "vc11" || "$theVcVer" == "vc12" } {
+    set aUsedToolKits [join $aUsedToolKits {;}]
+  }
+  regsub -all -- {__TKDEP__} $theProjTmpl $aUsedToolKits theProjTmpl
+
+  set anIncPaths "..\\..\\..\\inc"
+  set aTKDefines ""
+  set aFilesSection ""
+  set aVcFilesX(units) ""
+  set listloc [osutils:tk:units $theToolKit]
+  set resultloc [osutils:justwnt $listloc]
+  if [array exists written] { unset written }
+  #puts "\t1 [wokparam -v %CMPLRS_CXX_Options [w_info -f]] father"
+  #puts "\t2 [wokparam -v %CMPLRS_CXX_Options] branch"
+  #puts "\t1 [wokparam -v %CMPLRS_C_Options [w_info -f]] father"
+  #puts "\t2 [wokparam -v %CMPLRS_C_Options] branch"
+  set fxloparamfcxx [lindex [osutils:intersect3 [_get_options wnt cmplrs_cxx f] [_get_options wnt cmplrs_cxx b]] 2]
+  set fxloparamfc   [lindex [osutils:intersect3 [_get_options wnt cmplrs_c f] [_get_options wnt cmplrs_c b]] 2]
+  set fxloparam ""
+  foreach fxlo $resultloc {
+    set xlo $fxlo
+    set aSrcFiles [osutils:tk:files $xlo osutils:compilable 0]
+       set fxlo_cmplrs_options_cxx [_get_options wnt cmplrs_cxx $fxlo]
+    if {$fxlo_cmplrs_options_cxx == ""} {
+      set fxlo_cmplrs_options_cxx [_get_options wnt cmplrs_cxx b]
+    }
+       set fxlo_cmplrs_options_c [_get_options wnt cmplrs_c $fxlo]
+    if {$fxlo_cmplrs_options_c == ""} {
+      set fxlo_cmplrs_options_c [_get_options wnt cmplrs_c b]
+    }
+    set fxloparam "$fxloparam [lindex [osutils:intersect3 [_get_options wnt cmplrs_cxx b] $fxlo_cmplrs_options_cxx] 2]"
+    set fxloparam "$fxloparam [lindex [osutils:intersect3 [_get_options wnt cmplrs_c b] $fxlo_cmplrs_options_c] 2]"
+       #puts "\t3 [wokparam -v %CMPLRS_CXX_Options] branch CXX "
+       #puts "\t4 [wokparam -v %CMPLRS_CXX_Options $fxlo] $fxlo  CXX"
+       #puts "\t5 [wokparam -v %CMPLRS_C_Options] branch C"
+       #puts "\t6 [wokparam -v %CMPLRS_C_Options   $fxlo] $fxlo  C"
+    set needparam ""
+    foreach partopt $fxloparam {
+      if {[string first "-I" $partopt] == "0"} {
+        # this is an additional includes search path
+        continue
+      }
+      set needparam "$needparam $partopt"
+    }
+
+    # Format of projects in vc10 and vc11 is different from vc7-9
+    if { "$theVcVer" == "vc10" || "$theVcVer" == "vc11" || "$theVcVer" == "vc12" } {
+      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]
+        } else {
+          puts "Warning : in vcproj more than one occurences for [file tail $aSrcFile]"
+        }
+        if { ! [info exists aVcFilesX($xlo)] } { lappend aVcFilesX(units) $xlo }
+        lappend aVcFilesX($xlo) $aSrcFile
+      }
+    } else {
+      append aFilesSection "\t\t\t<Filter\n"
+      append aFilesSection "\t\t\t\tName=\"${xlo}\"\n"
+      append aFilesSection "\t\t\t\t>\n"
+      foreach aSrcFile [lsort $aSrcFiles] {
+        if { ![info exists written([file tail $aSrcFile])] } {
+          set written([file tail $aSrcFile]) 1
+          append aFilesSection [osutils:vcproj:file $theVcVer $aSrcFile $needparam]
+        } else {
+          puts "Warning : in vcproj more than one occurences for [file tail $aSrcFile]"
+        }
+      }
+      append aFilesSection "\t\t\t</Filter>\n"
+    }
+
+    # macros
+    append aTKDefines ";__${xlo}_DLL"
+    # common includes
+#    append anIncPaths ";..\\..\\..\\src\\${xlo}"
+  }
+
+  regsub -all -- {__TKINC__}  $theProjTmpl $anIncPaths theProjTmpl
+  regsub -all -- {__TKDEFS__} $theProjTmpl $aTKDefines theProjTmpl
+  regsub -all -- {__FILES__}  $theProjTmpl $aFilesSection theProjTmpl
+
+  # write file
+  set aFile [open [set aVcFiles [file join $theOutDir ${theToolKit}.[osutils:vcproj:ext $theVcVer]]] w]
+  fconfigure $aFile -translation crlf
+  puts $aFile $theProjTmpl
+  close $aFile
+
+  # write filters file for vc10 and vc11
+  if { "$theVcVer" == "vc10" } {
+    lappend aVcFiles [osutils:vcxproj:filters $theOutDir $theToolKit aVcFilesX]
+  } elseif { "$theVcVer" == "vc11" || "$theVcVer" == "vc12" } {
+    lappend aVcFiles [osutils:vcx1proj:filters $theOutDir $theToolKit aVcFilesX]
+  }
+
+  # write resource file
+  lappend aVcFiles [osutils:readtemplate:rc $theOutDir $theToolKit]
+
+  return $aVcFiles
+}
+
+# for a unit returns a map containing all its file in the current
+# workbench
+# local = 1 only local files
+proc osutils:tk:loadunit { loc map } {
+  #puts $loc
+  upvar $map TLOC
+  catch { unset TLOC }
+  set lfiles [_get_used_files $loc]
+  foreach f $lfiles {
+    #puts "\t$f"
+    set t [lindex $f 0]
+    set p [lindex $f 2]
+    if [info exists TLOC($t)] {
+      set l $TLOC($t)
+      lappend l $p
+      set TLOC($t) $l
+    } else {
+      set TLOC($t) $p
+    }
+  }
+  return
+}
+
+# Returns the list of all compilable files name in a toolkit, or devunit of any type
+# Call unit filter on units name to accept or reject a unit
+# Tfiles lists for each unit the type of file that can be compiled.
+proc osutils:tk:files { tkloc  {l_compilable {} } {justail 1} {unitfilter {}} } {
+  global path
+  set Tfiles(source,nocdlpack)     {source pubinclude}
+  set Tfiles(source,toolkit)       {}
+  set Tfiles(source,executable)    {source pubinclude}
+  set listloc [concat [osutils:tk:units $tkloc] $tkloc]
+  #puts " listloc = $listloc"
+  if { $l_compilable == {} } {
+    set l_comp [list .c .cxx .cpp]
+  } else {
+    set l_comp [$l_compilable]
+  }
+  if { $unitfilter == {} } {
+    set resultloc $listloc
+  } else {
+    set resultloc [$unitfilter $listloc]
+  }
+  set lret {}
+  foreach loc $resultloc {
+    set utyp [_get_type $loc]
+    #puts "\"$utyp\" \"$loc\""
+    switch $utyp {
+         "t" { set utyp "toolkit" }
+         "n" { set utyp "nocdlpack" }
+         "x" { set utyp "executable" }
+    }
+    if [array exists map] { unset map }
+    osutils:tk:loadunit $loc map
+    #puts " loc = $loc === > [array names map]"
+    set LType $Tfiles(source,${utyp})
+    foreach typ [array names map] {
+      if { [lsearch $LType $typ] == -1 } {
+        unset map($typ)
+      }
+    }
+    foreach type [array names map] {
+      #puts $type
+      foreach f $map($type) {
+        #puts $f
+        if { [lsearch $l_comp [file extension $f]] != -1 } {
+          if { $justail == 1 } {
+            if {$type == "source"} {
+              if {[lsearch $lret "@top_srcdir@/src/$loc/[file tail $f]"] == -1} {
+                lappend lret @top_srcdir@/src/$loc/[file tail $f]
+              }
+            }
+          } else {
+            lappend lret $f
+          }
+        }
+      }
+    }
+  }
+  return $lret
+}
+
+# Generate Visual Studio project file for executable
+proc osutils:vcprojx { theVcVer theOutDir theToolKit theGuidsMap {theProjTmpl {} } } {
+  global path
+  set aVcFiles {}
+  foreach f [osutils:tk:files $theToolKit osutils:compilable 0] {
+    if { $theProjTmpl == {} } {
+      set aProjTmpl [osutils:vcproj:readtemplate $theVcVer 1]
+    } else {
+      set aProjTmpl $theProjTmpl
+    }
+    set aProjName [file rootname [file tail $f]]
+    set l_compilable [osutils:compilable]
+    regsub -all -- {__XQTNAM__} $aProjTmpl $aProjName aProjTmpl
+
+    upvar $theGuidsMap aGuidsMap
+    if { ! [info exists aGuidsMap($aProjName)] } {
+      set aGuidsMap($aProjName) [OS:genGUID]
+    }
+    regsub -all -- {__PROJECT_GUID__} $aProjTmpl $aGuidsMap($aProjName) aProjTmpl
+
+    set aCommonUsedTK [list]
+    foreach tkx [osutils:commonUsedTK  $theToolKit] {
+      lappend aCommonUsedTK "${tkx}.lib"
+    }
+
+    set aUsedToolKits [concat $aCommonUsedTK [osutils:usedOsLibs $theToolKit "wnt"]]
+       #puts "\t 7 $WOKSteps_exec_link($theToolKit)"
+    if { [regexp {WOKStep_DLLink} [_get_options wnt WOKSteps_exec_link $theToolKit]] || [regexp {WOKStep_Libink} [_get_options wnt WOKSteps_exec_link $theToolKit]] } {
+      set aUsedToolKits [concat $aUsedToolKits "\/dll"]
+      set binext 2
+    } else {
+      set binext 1
+    }
+
+    # correct names of referred third-party libraries that are named with suffix
+    # depending on VC version
+    regsub -all -- {vc[0-9]+} $aUsedToolKits $theVcVer aUsedToolKits
+
+#    puts "$aProjName requires  $aUsedToolKits"
+    if { "$theVcVer" == "vc10" || "$theVcVer" == "vc11" || "$theVcVer" == "vc12" } {
+      set aUsedToolKits [join $aUsedToolKits {;}]
+    }
+    regsub -all -- {__TKDEP__} $aProjTmpl $aUsedToolKits aProjTmpl
+
+    set aFilesSection ""
+    set aVcFilesX(units) ""
+
+    if { ![info exists written([file tail $f])] } {
+      set written([file tail $f]) 1
+
+      if { "$theVcVer" == "vc10" || "$theVcVer" == "vc11" || "$theVcVer" == "vc12" } {
+        append aFilesSection [osutils:vcxproj:file $theVcVer $f ""]
+        if { ! [info exists aVcFilesX($theToolKit)] } { lappend aVcFilesX(units) $theToolKit }
+        lappend aVcFilesX($theToolKit) $f
+      } else {
+        append aFilesSection "\t\t\t<Filter\n"
+        append aFilesSection "\t\t\t\tName=\"$theToolKit\"\n"
+        append aFilesSection "\t\t\t\t>\n"
+        append aFilesSection [osutils:vcproj:file $theVcVer $f ""]
+        append aFilesSection "\t\t\t</Filter>"
+      }
+    } else {
+      puts "Warning : in vcproj there are than one occurences for [file tail $f]"
+    }
+    #puts "$aProjTmpl $aFilesSection"
+    set aTKDefines ";__${theToolKit}_DLL"
+    set anIncPaths "..\\..\\..\\inc"
+    regsub -all -- {__TKINC__}  $aProjTmpl $anIncPaths    aProjTmpl
+    regsub -all -- {__TKDEFS__} $aProjTmpl $aTKDefines    aProjTmpl
+    regsub -all -- {__FILES__}  $aProjTmpl $aFilesSection aProjTmpl
+    regsub -all -- {__CONF__}   $aProjTmpl $binext        aProjTmpl
+    if { $binext == 2 } {
+      regsub -all -- {__XQTEXT__} $aProjTmpl "dll" aProjTmpl
+    } else {
+      regsub -all -- {__XQTEXT__} $aProjTmpl "exe" aProjTmpl
+    }
+
+    set aFile [open [set aVcFilePath [file join $theOutDir ${aProjName}.[osutils:vcproj:ext $theVcVer]]] w]
+    fconfigure $aFile -translation crlf
+    puts $aFile $aProjTmpl
+    close $aFile
+
+    set aCommonSettingsFile "$aVcFilePath.user"
+    lappend aVcFiles $aVcFilePath
+
+    # write filters file for vc10
+    if { "$theVcVer" == "vc10" || "$theVcVer" == "vc11" || "$theVcVer" == "vc12" } {
+      lappend aVcFiles [osutils:vcxproj:filters $theOutDir $aProjName aVcFilesX]
+    }
+
+    set aCommonSettingsFileTmpl ""
+    if { "$theVcVer" == "vc9" } {
+      set aCommonSettingsFileTmpl "$path/adm/templates/vcproj.user.vc9x"
+    } elseif { "$theVcVer" == "vc10" } {
+      set aCommonSettingsFileTmpl "$path/adm/templates/vcxproj.user.vc10x"
+    } elseif { "$theVcVer" == "vc11" } {
+      set aCommonSettingsFileTmpl "$path/adm/templates/vcxproj.user.vc11x"
+    } elseif { "$theVcVer" == "vc12" } {
+      set aCommonSettingsFileTmpl "$path/adm/templates/vcxproj.user.vc12x"
+    }
+    if { "$aCommonSettingsFileTmpl" != "" } {
+      file copy -force -- "$aCommonSettingsFileTmpl" "$aCommonSettingsFile"
+      lappend aVcFiles "$aCommonSettingsFile"
+    }
+  }
+  return $aVcFiles
+}
+
+# Generate entry for one source file in Visual Studio 7 - 9 project file
+proc osutils:vcproj:file { theVcVer theFile theOptions } {
+  append aText "\t\t\t\t<File\n"
+  append aText "\t\t\t\t\tRelativePath=\"..\\..\\..\\[wokUtils:EASY:bs1 [wokUtils:FILES:wtail $theFile 3]]\">\n"
+  if { $theOptions == "" } {
+    append aText "\t\t\t\t</File>\n"
+    return $aText
+  }
+
+  append aText "\t\t\t\t\t<FileConfiguration\n"
+  append aText "\t\t\t\t\t\tName=\"Release\|Win32\">\n"
+  append aText "\t\t\t\t\t\t<Tool\n"
+  append aText "\t\t\t\t\t\t\tName=\"VCCLCompilerTool\"\n"
+  append aText "\t\t\t\t\t\t\tAdditionalOptions=\""
+  foreach aParam $theOptions {
+    append aText "$aParam "
+  }
+  append aText "\"\n"
+  append aText "\t\t\t\t\t\t/>\n"
+  append aText "\t\t\t\t\t</FileConfiguration>\n"
+
+  append aText "\t\t\t\t\t<FileConfiguration\n"
+  append aText "\t\t\t\t\t\tName=\"Debug\|Win32\">\n"
+  append aText "\t\t\t\t\t\t<Tool\n"
+  append aText "\t\t\t\t\t\t\tName=\"VCCLCompilerTool\"\n"
+  append aText "\t\t\t\t\t\t\tAdditionalOptions=\""
+  foreach aParam $theOptions {
+    append aText "$aParam "
+  }
+  append aText "\"\n"
+  append aText "\t\t\t\t\t\t/>\n"
+  append aText "\t\t\t\t\t</FileConfiguration>\n"
+  if { "$theVcVer" == "vc7" } {
+    append aText "\t\t\t\t</File>\n"
+    return $aText
+  }
+
+  append aText "\t\t\t\t\t<FileConfiguration\n"
+  append aText "\t\t\t\t\t\tName=\"Release\|x64\">\n"
+  append aText "\t\t\t\t\t\t<Tool\n"
+  append aText "\t\t\t\t\t\t\tName=\"VCCLCompilerTool\"\n"
+  append aText "\t\t\t\t\t\t\tAdditionalOptions=\""
+  foreach aParam $theOptions {
+    append aText "$aParam "
+  }
+  append aText "\"\n"
+  append aText "\t\t\t\t\t\t/>\n"
+  append aText "\t\t\t\t\t</FileConfiguration>\n"
+
+  append aText "\t\t\t\t\t<FileConfiguration\n"
+  append aText "\t\t\t\t\t\tName=\"Debug\|x64\">\n"
+  append aText "\t\t\t\t\t\t<Tool\n"
+  append aText "\t\t\t\t\t\t\tName=\"VCCLCompilerTool\"\n"
+  append aText "\t\t\t\t\t\t\tAdditionalOptions=\""
+  foreach aParam $theOptions {
+    append aText "$aParam "
+  }
+  append aText "\"\n"
+  append aText "\t\t\t\t\t\t/>\n"
+  append aText "\t\t\t\t\t</FileConfiguration>\n"
+
+  append aText "\t\t\t\t</File>\n"
+  return $aText
+}
+
+### AUTOMAKE ###############################################################################
+proc OS:MKAMK { theOutDir {theModules {}} theSubPath} {
+  global path
+  wokUtils:FILES:mkdir $theOutDir
+
+  foreach aModule $theModules {
+    foreach aToolKit [$aModule:toolkits] {
+      puts " toolkit: $aToolKit ==> $path/src/$aToolKit/EXTERNLIB"
+      wokUtils:FILES:rmdir $theOutDir/$aToolKit
+      wokUtils:FILES:mkdir $theOutDir/$aToolKit
+      osutils:tk:mkam $theOutDir/$aToolKit $aToolKit
+    }
+    foreach anExecutable [OS:executable $aModule] {
+      wokUtils:FILES:rmdir $theOutDir/$anExecutable
+      wokUtils:FILES:mkdir $theOutDir/$anExecutable
+      osutils:tk:mkamx $theOutDir/$anExecutable $anExecutable
+    }
+  }
+  osutils:am:adm $theOutDir $theModules
+  osutils:am:root $path $theSubPath $theModules
+
+  puts "The automake files are stored in the $theOutDir directory"
+}
+
+proc wokUtils:FILES:rmdir { d } {
+    global env
+    global tcl_platform tcl_version  
+    regsub -all {\.[^.]*} $tcl_version "" major
+    if { $major == 8 } {
+       file delete -force $d
+    } else {
+       if { "$tcl_platform(platform)" == "unix" } {
+           catch { exec rm -rf $d}
+       } else {
+           
+       }
+    }
+    return 
+}
+
+proc wokUtils:FILES:mkdir { d } {
+    global tcl_version
+    regsub -all {\.[^.]*} $tcl_version "" major
+    if { $major == 8 } {
+       file mkdir $d
+    } else {
+       if ![file exists $d] {
+           if { "[info command mkdir]" == "mkdir" } {
+               mkdir -path $d
+           } else {
+               puts stderr "wokUtils:FILES:mkdir : Error unable to find a mkdir command."
+           }
+       }
+    }
+    if [file exists $d] {
+       return $d
+    } else {
+       return {}
+    }
+}
+
+# "Nice letter: %s" { a b c } => {Nice letter: %a}  {Nice letter: %b} ..
+# as a string without backslash
+proc wokUtils:EASY:FmtSimple1 { fmt l {backslh 1} } {
+    foreach e $l {
+       if { $backslh } {
+           append str [format $fmt $e] "\n"
+       } else {
+           append str [format $fmt $e]
+       }
+    }
+    return $str
+}
+
+# edit_last is performed ONCE fmt has been applied.
+proc wokUtils:EASY:FmtString2 { fmt l {yes_for_last 0} {edit_last {}} } {
+    set ldeb [lrange $l 0 [expr [llength $l] -2]]
+    set last [lrange $l end end]
+    foreach e $ldeb {
+       append str [format $fmt $e $e] " \\" "\n"
+    }
+
+    if {$edit_last != {} } {
+       set slast [$edit_last [format $fmt $last $last]]
+    } else {
+       set slast [format $fmt $last $last]
+    }
+
+    if { $yes_for_last } {
+       append str $slast " \\" "\n" 
+    } else {
+       append str $slast "\n"
+    }
+
+    return $str
+}
+
+# { a.x b.c c.v } => { a b c}
+proc wokUtils:LIST:sanspoint { l } {
+    set rr {}
+    foreach x $l {
+       lappend rr [file root $x]
+    }
+    return $rr
+}
+
+# remove from listloc OpenCascade units indesirables on Unix
+proc osutils:justunix { listloc } {
+  if { "$::tcl_platform(os)" == "Darwin" && "$::MACOSX_USE_GLX" != "true" } {
+    set goaway [list Xw WNT]
+  } else {
+    set goaway [list WNT]
+  }
+  return [osutils:juststation $goaway $listloc]
+}
+
+# remove ":" from last item of dependencies list in target VPATH of Makefile.am
+proc osutils:am:__VPATH__lastoccur { str } {
+  if { [regsub {:$} $str "" u] != 0 } {
+    return $u
+  }
+}
+
+#  ((((((((((((( Formats in Makefile.am )))))))))))))
+# Used to replace the string __VPATH__ in Makefile.am
+# l is the list of the units in a toolkit.
+proc osutils:am:__VPATH__ { l } {
+  set fmt "@top_srcdir@/src/%s:"
+  return [wokUtils:EASY:FmtString2 $fmt $l 0 osutils:am:__VPATH__lastoccur]
+}
+
+# Used to replace the string __INCLUDES__ in Makefile.am
+# l is the list of packages in a toolkit.
+proc osutils:am:__INCLUDES__ { l } {
+  set fmt "-I@top_srcdir@/src/%s"
+  return [wokUtils:EASY:FmtString2 $fmt $l]
+}
+
+# Used to replace the string __LIBADD__ in Makefile.am
+# l is the toolkit closure list of a toolkit.
+proc osutils:am:__LIBADD__ { theIncToolkits {final 0} } {
+  global path
+  global fBranch
+  set aFatherModules ""
+  set aCurrentWorkBench [file tail $path]
+  if { $fBranch != "" } {
+    set fd [open $fBranch/adm/UDLIST rb]
+    set fileContent [split [read $fd] "\n"]
+    close $fd
+    set ftoolkits [lsearch -all -inline $fileContent "t *"]
+    foreach ft $ftoolkits {
+      set aFatherModules "$aFatherModules [string range $ft 2 end]"
+    }
+  }
+  set aLibString ""
+  foreach aIncToolkit $theIncToolkits {
+    if { [lsearch [split $aFatherModules " "] $aIncToolkit] != -1} {
+      append aLibString " \\\n-l$aIncToolkit"
+    } else {
+      append aLibString " \\\n../$aIncToolkit/lib$aIncToolkit.la"
+    }
+  }
+  return $aLibString
+}
+
+# Used to replace the string __SOURCES__ in Makefile.am
+# l is the list of all compilable files in a toolkit.
+proc osutils:am:__SOURCES__ { l } {
+  set fmt "%s"
+  return [wokUtils:EASY:FmtString1 $fmt $l]
+}
+
+proc osutils:am:__CXXFLAG__ { l } {
+  set fmt "%s"
+  return [wokUtils:EASY:FmtString1 $fmt [osutils:am:PkCXXOption $l]]
+}
+
+proc osutils:am:PkCXXOption { ppk } {
+  global path
+  #puts "\t 1 [lindex [wokparam -e  %CMPLRS_CXX_Options [wokcd]] 0]"
+  set CXXCOMMON [_get_options lin cmplrs_cxx b]
+  #puts "\t 2 [wokparam -v %CMPLRS_CXX_Options [w_info -f]]"
+  #puts "\t 3 [wokparam -v %CMPLRS_CXX_Options]"
+  set FoundFlag "[lindex [osutils:intersect3 [split [_get_options lin cmplrs_cxx f]] [split [_get_options lin cmplrs_cxx b]] ] 2]"
+  foreach pk $ppk {
+    #puts $pk
+       if {![file isdirectory $path/src/$pk]} {
+         continue
+       }
+    set src_files [_get_used_files $pk false]
+    set only_src_files {}
+    foreach s $src_files { 
+      regexp {source ([^\s]+)} $s dummy name
+      lappend only_src_files $name
+    }
+    if {[lsearch $only_src_files ${pk}_CMPLRS.edl] != "-1"} {
+      set pk_cmplrs_cxx [_get_options lin cmplrs_cxx $pk]
+      if {$pk_cmplrs_cxx == ""} {
+           set pk_cmplrs_cxx [_get_options lin cmplrs_cxx b]
+         }
+      set CXXStr  $pk_cmplrs_cxx
+         #puts "\t 4 [wokparam -e %CMPLRS_CXX_Options [woklocate -u $pk]] $pk"
+      set LastIndex [expr {[string length $CXXCOMMON ] - 1}]
+      if {[string equal $CXXCOMMON [string range $CXXStr 0 $LastIndex]]} {
+        set CXXOption " "
+      } else {
+        set CXXOption [string range $CXXStr 0 [expr {[string last $CXXCOMMON $CXXStr] - 1}]]
+      }
+      if {$CXXOption != " " && $CXXOption != "" && $CXXOption != "  " && $CXXOption != "   "} {
+        set FoundList [split $CXXOption " "]
+        foreach elem $FoundList {
+          if {$elem != ""} {
+            if {[string first "-I" $elem] == "-1"  } {
+              if {[string first $elem $FoundFlag] == "-1"} {
+                set FoundFlag "$FoundFlag $elem"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return $FoundFlag
+}
+
+# Create in dir the Makefile.am associated with toolkit tkloc.
+# Returns the full path of the created file.
+proc osutils:tk:mkam { dir tkloc } {
+  global path
+  set pkgs $path/src/${tkloc}/PACKAGES
+  if { ![file exists $pkgs] } {
+    puts stderr "osutils:tk:mkam : Error. File PACKAGES not found for toolkit $tkloc."
+    return {}
+  }
+
+  set tmplat [osutils:readtemplate mam "Makefile.am"]
+  set lpkgs  [osutils:justunix [wokUtils:FILES:FileToList $pkgs]]
+  set close  [wokUtils:LIST:Purge [osutils:tk:close $tkloc]]
+  set lsrc   [lsort [osutils:tk:files $tkloc osutils:compilable 1 osutils:justunix]]
+  set lobj   [wokUtils:LIST:sanspoint $lsrc]
+
+  set lcsf   [osutils:tk:hascsf $path/src/${tkloc}/EXTERNLIB]
+
+  set final 0
+  set externinc ""
+  set externlib ""
+  if { $lcsf != {} } {
+    set final 1
+    set fmtinc "\$(%s_INCLUDES) "
+    set fmtlib "\$(%s_LIB) "
+    set externinc [wokUtils:EASY:FmtSimple1 $fmtinc $lcsf 0]
+    set externlib [wokUtils:EASY:FmtSimple1 $fmtlib $lcsf 0]
+  }
+
+  regsub -all -- {__TKNAM__} $tmplat $tkloc tmplat
+  set vpath [osutils:am:__VPATH__ $lpkgs]
+  regsub -all -- {__VPATH__} $tmplat $vpath tmplat
+  set inclu [osutils:am:__INCLUDES__ $lpkgs]
+  regsub -all -- {__INCLUDES__} $tmplat $inclu tmplat
+  if { $close != {} } {
+    set libadd [osutils:am:__LIBADD__ $close $final]
+  } else {
+    set libadd ""
+  }
+  regsub -all -- {__LIBADD__} $tmplat $libadd tmplat
+  set source [osutils:am:__SOURCES__ $lsrc]
+  regsub -all -- {__SOURCES__} $tmplat $source tmplat
+  regsub -all -- {__EXTERNINC__} $tmplat $externinc tmplat
+  set CXXFl [osutils:am:__CXXFLAG__ $lpkgs]
+  regsub -all -- {__CXXFLAG__} $tmplat $CXXFl tmplat
+  set CFl [osutils:am:__CFLAG__ $lpkgs]
+  regsub -all -- {__CFLAG__} $tmplat $CFl tmplat
+
+  regsub -all -- {__EXTERNLIB__} $tmplat $externlib tmplat
+
+  wokUtils:FILES:StringToFile $tmplat [set fmam [file join $dir Makefile.am]]
+  return [list $fmam]
+}
+
+# Write a string in a file
+proc wokUtils:FILES:StringToFile { str path } {
+    if { [catch { set out [ open $path w ] } errout] == 0 } {
+       puts -nonewline $out $str
+       close $out
+       return 1
+    } else {
+       return {}
+    }
+}
+
+# Create in dir the Makefile.am associated with toolkit tkloc.
+# Returns the full path of the created file.
+proc osutils:tk:mkamx { dir tkloc } {
+  global path
+  set src_files [_get_used_files $tkloc false]
+  set only_src_files {}
+  foreach s $src_files { 
+    regexp {source ([^\s]+)} $s dummy name
+    lappend only_src_files $name
+  }
+  if { [lsearch $only_src_files ${tkloc}_WOKSteps.edl] != "-1"} {
+    set pkgs "$path/src/${tkloc}/EXTERNLIB"
+    if { $pkgs == {} } {
+      puts stderr "osutils:tk:mkamx : Error. File EXTERNLIB not found for executable $tkloc."
+      #return {}
+    }
+    set tmplat [osutils:readtemplate mamx "Makefile.am (executable)"]
+    set close  [wokUtils:LIST:Purge [osutils:tk:close $tkloc]]
+    set lsrc   [lsort [osutils:tk:files $tkloc osutils:compilable 1 osutils:justunix]]
+    set lobj   [wokUtils:LIST:sanspoint $lsrc]
+    set CXXList {}
+    foreach SourceFile $only_src_files {
+      if {[file extension $SourceFile] == ".cxx"} {
+        lappend CXXList [file rootname $SourceFile]
+      }
+    }
+    set pkgs [LibToLinkX $tkloc [lindex $CXXList 0]]
+    set lpkgs  [osutils:justunix [wokUtils:FILES:FileToList $pkgs]]
+    puts "pkgs $pkgs"
+    #set lcsf   [osutils:tk:hascsf [woklocate -p ${tkloc}:source:EXTERNLIB [wokcd]]]
+
+    set lcsf {}
+    foreach tk $pkgs {
+      foreach element [osutils:tk:hascsf "$path/src/${tk}/EXTERNLIB"] {
+        if {[lsearch $lcsf $element] == "-1"} {
+          set lcsf [concat $lcsf $element]
+        }
+      }
+    }
+    set final 0
+    set externinc ""
+    set externlib ""
+    if { $lcsf != {} } {
+      set final 1
+      set fmtinc "\$(%s_INCLUDES) "
+      set fmtlib "\$(%s_LIB) "
+      set externinc [wokUtils:EASY:FmtSimple1 $fmtinc $lcsf 0]
+      set externlib [wokUtils:EASY:FmtSimple1 $fmtlib $lcsf 0]
+    }
+    regsub -all -- {__XQTNAM__} $tmplat $tkloc tmplat
+    set tmplat "$tmplat \nlib_LTLIBRARIES="
+    foreach entity $CXXList {
+      set tmplat "$tmplat lib${entity}.la"
+    }
+    set tmplat "$tmplat\n"
+    set inclu [osutils:am:__INCLUDES__ $lpkgs]
+    regsub -all -- {__INCLUDES__} $tmplat $inclu tmplat
+    if { $pkgs != {} } {
+      set libadd [osutils:am:__LIBADD__ $pkgs $final]
+    } else {
+      set libadd ""
+    }
+    regsub -all -- {__LIBADD__} $tmplat $libadd tmplat
+    set source [osutils:am:__SOURCES__ $CXXList]
+    regsub -all -- {__SOURCES__} $tmplat $source tmplat
+    regsub -all -- {__EXTERNINC__} $tmplat $externinc tmplat
+    foreach entity $CXXList {
+      set tmplat "$tmplat lib${entity}_la_SOURCES = @top_srcdir@/src/${tkloc}/${entity}.cxx \n"
+    }
+    foreach entity $CXXList {
+      set tmplat "$tmplat lib${entity}_la_LIBADD = $libadd $externlib \n"
+    }
+    wokUtils:FILES:StringToFile $tmplat [set fmam [file join $dir Makefile.am]]
+
+    unset tmplat
+
+    return [list $fmam]
+
+  } else {
+    set pkgs "$path/src/${tkloc}/EXTERNLIB"
+    if { $pkgs == {} } {
+      puts stderr "osutils:tk:mkamx : Error. File EXTERNLIB not found for executable $tkloc."
+      #return {}
+    }
+    set tmplat [osutils:readtemplate mamx "Makefile.am (executable)"]
+    set close  [wokUtils:LIST:Purge [osutils:tk:close $tkloc]]
+    set lsrc   [lsort [osutils:tk:files $tkloc osutils:compilable 1 osutils:justunix]]
+    set lobj   [wokUtils:LIST:sanspoint $lsrc]
+    set CXXList {}
+    foreach SourceFile $only_src_files {
+      if {[file extension $SourceFile] == ".cxx"} {
+        lappend CXXList [file rootname $SourceFile]
+      }
+    }
+    set pkgs [LibToLinkX $tkloc [lindex $CXXList 0]]
+    set lpkgs  [osutils:justunix [wokUtils:FILES:FileToList $pkgs]]
+    set lcsf   [osutils:tk:hascsf "$path/src/${tkloc}/EXTERNLIB"]
+
+    set lcsf {}
+    foreach tk $pkgs {
+      foreach element [osutils:tk:hascsf "$path/src/${tk}/EXTERNLIB"] {
+        if {[lsearch $lcsf $element] == "-1"} {
+          set lcsf [concat $lcsf $element]
+        }
+      }
+    }
+    set final 0
+    set externinc ""
+    set externlib ""
+    if { $lcsf != {} } {
+      set final 1
+      set fmtinc "\$(%s_INCLUDES) "
+      set fmtlib "\$(%s_LIB) "
+      set externinc [wokUtils:EASY:FmtSimple1 $fmtinc $lcsf 0]
+      set externlib [wokUtils:EASY:FmtSimple1 $fmtlib $lcsf 0]
+    }
+    regsub -all -- {__XQTNAM__} $tmplat $tkloc tmplat
+    set tmplat "$tmplat \nbin_PROGRAMS="
+    foreach entity $CXXList {
+      set tmplat "${tmplat} ${entity}"
+    }
+
+    set tmplat "${tmplat}\n"
+    set inclu [osutils:am:__INCLUDES__ $lpkgs]
+    regsub -all -- {__INCLUDES__} $tmplat $inclu tmplat
+    if { $pkgs != {} } {
+      set libadd [osutils:am:__LIBADD__ $pkgs $final]
+    } else {
+      set libadd ""
+    }
+    set source [osutils:am:__SOURCES__ $CXXList]
+    regsub -all -- {__SOURCES__} $tmplat $source tmplat
+    regsub -all -- {__EXTERNINC__} $tmplat $externinc tmplat
+    foreach entity $CXXList {
+      set tmplat "$tmplat ${entity}_SOURCES = @top_srcdir@/src/${tkloc}/${entity}.cxx \n"
+    }
+    foreach entity $CXXList {
+      set tmplat "$tmplat ${entity}_LDADD = $libadd $externlib \n"
+    }
+    wokUtils:FILES:StringToFile $tmplat [set fmam [file join $dir Makefile.am]]
+
+    return [list $fmam]
+  }
+}
+
+# Create in dir the Makefile.am in $dir directory.
+# Returns the full path of the created file.
+proc osutils:am:adm { dir {lesmodules {}} } {
+  set amstring "srcdir = @srcdir@\n\n"
+  set subdirs "SUBDIRS ="
+  set vpath "VPATH = @srcdir@ ${dir}: "
+  set make ""
+  set phony ".PHONY:"
+  foreach theModule $lesmodules {
+    set units [osutils:tk:sort [$theModule:toolkits]]
+    set units [concat $units [OS:executable $theModule]]
+    append amstring "${theModule}_PKGS ="
+    append vpath "\\\n"
+    foreach unit $units {
+      append amstring " ${unit}"
+      append vpath "${dir}/${unit}: "
+    }
+    set up ${theModule}
+    if { [info procs ${theModule}:alias] != "" } {
+      set up [${theModule}:alias]
+    }
+    set up [string toupper ${up}]
+    append amstring "\n\nif ENABLE_${up}\n"
+    append amstring "  ${theModule}_DIRS = \$(${theModule}_PKGS)\n"
+    append amstring "else\n"
+    append amstring "  ${theModule}_DIRS = \n"
+    append amstring "endif\n\n"
+    append subdirs " \$(${theModule}_DIRS)"
+    append make "${theModule}:\n"
+    append make "\tfor d in \$(${theModule}_PKGS); do \\\n"
+    append make "\t\tcd \$\$d; \$(MAKE) \$(AM_MAKEFLAGS) lib\$\$d.la; cd ..; \\\n"
+    append make "\tdone\n\n"
+    append phony " ${theModule}"
+  }
+  append amstring "$subdirs\n\n"
+  append amstring "$vpath\n\n"
+  append amstring $make
+  append amstring $phony
+  wokUtils:FILES:StringToFile $amstring [set fmam [file join $dir Makefile.am]]
+  return [list $fmam]
+}
+
+# retourne la liste de dependances de module.
+proc OS:lsdep { m } {
+    set res {}
+    set l [${m}:depends]
+    if { $l != {} } {
+       set res [concat $res $l]
+       foreach h $l {
+           set res [concat $res [OS:lsdep ${h}]]
+       }
+    }
+    return $res
+}
+
+# Create in dir the Makefile.am and configure.ac in CASROOT directory.
+# Returns the full path of the created file.
+proc osutils:am:root { dir theSubPath {lesmodules {}} } {
+  global path
+  set amstring "srcdir = @srcdir@\n\n"
+  append amstring "SUBDIRS = ${theSubPath}\n\n"
+  append amstring "VPATH = @srcdir@ @top_srcdir@/${theSubPath}: @top_srcdir@/${theSubPath}:\n\n"
+
+  set phony ".PHONY:"
+
+  set acstring [osutils:readtemplate ac "Makefile.am"]
+  set enablestr ""
+  set confstr ""
+  set condstr ""
+  set repstr ""
+  set acconfstr ""
+
+  set exelocal "install-exec-local:\n"
+  append exelocal "\t"
+  append exelocal {$(INSTALL) -d $(prefix)/$(platform)}
+  append exelocal "\n"
+  foreach d {bin lib} {
+    append exelocal "\t"
+    append exelocal "if \[ -e \$(prefix)/${d} -a ! -e \$(prefix)/\$(platform)/${d} \]; then \\\n"
+    append exelocal "\t\tcd \$(prefix)/\$(platform) && ln -s ../${d} ${d}; \\\n"
+    append exelocal "\tfi\n"
+  }
+  append exelocal "\t"
+  append exelocal {buildd=`pwd`; cd $(top_srcdir); sourced=`pwd`; cd $(prefix); installd=`pwd`; cd $$buildd;}
+  append exelocal " \\\n"
+  append exelocal "\t"
+  append exelocal {if [ "$$installd" != "$$sourced" ]; then}
+  append exelocal " \\\n"
+  append exelocal "\t\t"
+  append exelocal {$(INSTALL) -d $(prefix)/src;}
+  append exelocal " \\\n"
+  append exelocal "\t\t"
+  append exelocal {cp -frL $(top_srcdir)/src $(prefix);}
+  append exelocal " \\\n"
+  append exelocal "\t\t"
+  append exelocal {cp -frL $$buildd/config.h $(prefix);}
+  append exelocal " \\\n"
+  append exelocal "\t\tfor d in "
+
+  foreach theModule $lesmodules {
+    append amstring "${theModule}_PKGS ="
+    foreach r [${theModule}:ressources] {
+      if { "[lindex $r 1]" == "r" } {
+       append amstring " [lindex $r 2]"
+      }
+    }
+    set up ${theModule}
+    if { [info procs ${theModule}:alias] != "" } {
+      set up [${theModule}:alias]
+    }
+    set up [string toupper ${up}]
+    set lower ${theModule}
+    if { [info procs ${theModule}:alias] != "" } {
+      set lower [${theModule}:alias]
+    }
+    set lower [string tolower ${lower}]
+
+    append amstring "\n\nif ENABLE_${up}\n"
+    append amstring "  ${theModule}_DIRS = \$(${theModule}_PKGS)\n"
+    append amstring "else\n"
+    append amstring "  ${theModule}_DIRS = \n"
+    append amstring "endif\n\n"
+    append amstring "${theModule}:\n"
+    append amstring "\tcd \$(top_builddir)/${theSubPath} && \$(MAKE) \$(AM_MAKEFLAGS) ${theModule}\n\n"
+    append phony " ${theModule}"
+
+    append exelocal " \$(${theModule}_DIRS)"
+
+    append enablestr "AC_ARG_ENABLE(\[${lower}\],\n"
+    append enablestr "  \[AS_HELP_STRING(\[--disable-${lower}\],\[Disable ${theModule} components\])\],\n"
+    append enablestr "  \[ENABLE_${up}=\${enableval}\],\[ENABLE_${up}=yes\])\n"
+
+    set deplist [OS:lsdep ${theModule}]
+    set acdeplist {}
+    if { [info procs ${theModule}:acdepends] != "" } {
+      set acdeplist [${theModule}:acdepends]
+    }
+
+    if { [llength $deplist] > 0 || [llength $acdeplist] > 0} {
+      append confstr "if test \"xyes\" = \"x\$ENABLE_${up}\"; then\n"
+    } else {
+      append confstr "if test \"xyes\" != \"x\$ENABLE_${up}\"; then\n"
+    }
+    foreach dep $deplist {
+      set dup ${dep}
+      if { [info procs ${dep}:alias] != "" } {
+       set dup [${dep}:alias]
+      }
+      set dup [string toupper ${dup}]
+      append confstr "  if test \"xyes\" = \"x\$ENABLE_${up}\" -a \"xyes\" != \"x\$ENABLE_${dup}\"; then\n"
+      append confstr "    AC_MSG_NOTICE(\[Disabling ${theModule}: not building ${dep} component\])\n"
+      append confstr "    DISABLE_${up}_REASON=\"(${dep} component disabled)\"\n"
+      append confstr "    ENABLE_${up}=no\n"
+      append confstr "  fi\n"
+    }
+    foreach dep $acdeplist {
+      append confstr "  if test \"xyes\" = \"x\$ENABLE_${up}\" -a \"xyes\" != \"x\$HAVE_${dep}\"; then\n"
+      append confstr "    AC_MSG_NOTICE(\[Disabling ${theModule}: ${dep} not found\])\n"
+      append confstr "    DISABLE_${up}_REASON=\"(${dep} not found)\"\n"
+      append confstr "    ENABLE_${up}=no\n"
+      append confstr "  fi\n"
+    }
+    if { [llength $deplist] > 0 || [llength $acdeplist] > 0 } {
+      append confstr "else\n"
+    }
+    append confstr "  DISABLE_${up}_REASON=\"(Disabled)\"\n"
+    append confstr "fi\n"
+
+    append condstr "AM_CONDITIONAL(\[ENABLE_${up}\], \[test \"xyes\" = \"x\$ENABLE_${up}\"\])\n"
+    append repstr [format "echo \"%-*s  \$ENABLE_${up} \$DISABLE_${up}_REASON\"" 26 ${theModule}]
+    append repstr "\n"
+
+    set units [$theModule:toolkits]
+    set units [concat $units [OS:executable $theModule]]
+    foreach unit $units {
+      append acconfstr "${theSubPath}/${unit}/Makefile \\\n"
+    }
+  }
+
+  append exelocal "; do \\\n"
+  append exelocal "\t\t\t"
+  append exelocal {$(INSTALL) -d $(prefix)/src/$$d;}
+  append exelocal " \\\n"
+  append exelocal "\t\t\t"
+  append exelocal {cp -frL $(top_srcdir)/src/$$d $(prefix)/src;}
+  append exelocal " \\\n"
+  append exelocal "\t\tdone; \\\n"
+  append exelocal "\tfi\n"
+  append exelocal "\t"
+  append exelocal {if [ -e $(prefix)/src/config.h ]; then}
+  append exelocal " \\\n"
+  append exelocal "\t\t"
+  append exelocal {unlink $(prefix)/src/config.h;}
+  append exelocal " \\\n"
+  append exelocal "\tfi\n"
+  append exelocal "\t"
+  append exelocal {cd $(prefix)/src && ln -s ../config.h config.h}
+  append exelocal "\n"
+  append exelocal "\t"
+  append exelocal {cd $(top_srcdir) && cp *.sh $(prefix)}
+  append exelocal "\n"
+  append exelocal "\n"
+
+  append amstring $exelocal
+  append amstring $phony
+
+  regsub -all -- {__ENABLEMODULES__} $acstring $enablestr acstring
+  regsub -all -- {__CONFMODULES__} $acstring $confstr acstring
+  regsub -all -- {__CONDMODULES__} $acstring $condstr acstring
+  regsub -all -- {__REPMODULES__} $acstring $repstr acstring
+  regsub -all -- {__ACCONFMODULES__} $acstring $acconfstr acstring
+
+  wokUtils:FILES:StringToFile $amstring [set fmam [file join $dir Makefile.am]]
+  wokUtils:FILES:StringToFile $acstring [set fmam [file join $dir configure.ac]]
+  file copy -force -- [file join $path/adm/templates build_configure] [file join $dir build_configure]
+  file copy -force -- [file join $path/adm/templates acinclude.m4] [file join $dir acinclude.m4]
+  file copy -force -- [file join $path/adm/templates custom.sh.in] [file join $dir custom.sh.in]
+  return [list $fmam]
+}
+
+proc wokUtils:EASY:FmtString1 { fmt l {yes_for_last 0} {edit_last {}} } {
+    set ldeb [lrange $l 0 [expr [llength $l] -2]]
+    set last [lrange $l end end]
+    foreach e $ldeb {
+       append str [format $fmt $e] " \\" "\n"
+    }
+
+    if {$edit_last != {} } {
+       set slast [$edit_last [format $fmt $last]]
+    } else {
+       set slast [format $fmt $last]
+    }
+
+    if { $yes_for_last } {
+       append str $slast " \\" "\n" 
+    } else {
+       append str $slast "\n"
+    }
+    return $str
+}
+
+# Used to replace the string __CFLAG__ in Makefile.am
+# l is the list of all compilable files in a toolkit.
+proc osutils:am:__CFLAG__ { l } {
+  set fmt "%s"
+  return [wokUtils:EASY:FmtString1 $fmt [osutils:am:PkCOption $l]]
+}
+
+proc osutils:am:PkCOption { ppk } {
+  global path
+  #puts "\t\t $ppk"
+  #puts "\t 5 [lindex [wokparam -e  %CMPLRS_C_Options [wokcd]] 0]"
+  set CCOMMON [_get_options lin cmplrs_c b]
+  #puts "\t 6 [lindex [wokparam -v %CMPLRS_C_Options [w_info -f]] 0]"
+  set FoundFlag "[lindex [osutils:intersect3 [split [_get_options lin cmplrs_c f]] [split [_get_options lin cmplrs_c b]]] 2]"
+  foreach pk $ppk {
+    if {![file isdirectory $path/src/$pk]} {
+         continue
+       }
+       set src_files [_get_used_files $pk false]
+    set only_src_files {}
+    foreach s $src_files {
+      regexp {source ([^\s]+)} $s dummy name
+      lappend only_src_files $name
+    }
+    if {[lsearch $src_files ${pk}_CMPLRS.edl] != "-1"} {
+         #puts "\t 7 [lindex [wokparam -e %CMPLRS_C_Options [woklocate -u $pk]] 0] $pk"
+      set aPkList   [split "[_get_options lin cmplrs_c $pk]" " "]
+      set aCcomList [split "$CCOMMON" " "]
+
+      foreach aPkItem $aPkList {
+        if { [lsearch aCcomList $aPkItem] != -1 } {
+          if {[string first "-I" $aPkItem] == "-1"  } {
+            set FoundFlag "$FoundFlag $aPkItem"
+          }
+        }
+      }
+    }
+  }
+  return $FoundFlag
+}
+
+proc osutils:tksrcfiles { theUnits  theRelatedPath {theCompatible {}} } {
+  set aTKSrcFiles [list]
+
+  if [array exists written] { unset written }
+  foreach anUnit $theUnits {
+    set xlo       $anUnit
+    set aSrcFiles [osutils:tk:files $xlo osutils:compilable 0]
+
+    if { $theCompatible != {} } {
+      set aSrcFiles [osutils:tk:files $xlo $theCompatible 0]
+    }
+
+    foreach aSrcFile [lsort $aSrcFiles] {
+      if { ![info exists written([file tail $aSrcFile])] } {
+        set written([file tail $aSrcFile]) 1
+        lappend aTKSrcFiles "${theRelatedPath}/[wokUtils:FILES:wtail $aSrcFile 3]"
+      } else {
+        puts "Warning : more than one occurences for [file tail $aSrcFile]"
+      }
+    }
+  }
+
+  return $aTKSrcFiles
+}
+
+proc osutils:mm_compilable { } {
+  return [list .mm]
+}
+
+proc osutils:tkdefs { theUnits } {
+  set aTKDefines [list]
+
+  foreach anUnit $theUnits {
+    lappend aTKDefines "__${anUnit}_DLL"
+  }
+
+  return $aTKDefines
+}
+
+proc osutils:fileGroupName { theSrcFile } {
+  set path [file dirname [file normalize ${theSrcFile}]]
+  regsub -all [file normalize "${path}/.."] ${path} "" aGroupName
+
+  return $aGroupName
+}
+
+
+####### CODEBLOCK ###################################################################
+# Function to generate Code Blocks workspace and project files
+proc OS:MKCBP { theOutDir {theModules {}} {theAllSolution ""} } {
+  puts stderr "Generating project files for Code Blocks"
+
+  # Generate projects for toolkits and separate workspace for each module
+  foreach aModule $theModules {
+    OS:cworkspace $aModule $aModule $theOutDir
+    OS:cbp        $aModule          $theOutDir
+  }
+
+  # Generate single workspace "OCCT" containing projects from all modules
+  if { "$theAllSolution" != "" } {
+    OS:cworkspace $theAllSolution $theModules $theOutDir
+  }
+
+  puts "The Code Blocks workspace and project files are stored in the $theOutDir directory"
+}
+
+# Generate Code Blocks projects
+proc OS:cbp { theModules theOutDir } {
+  set aProjectFiles {}
+  foreach aModule $theModules {
+    foreach aToolKit [${aModule}:toolkits] {
+      lappend aProjectFiles [osutils:cbptk $theOutDir $aToolKit ]
+    }
+    foreach anExecutable [OS:executable ${aModule}] {
+      lappend aProjectFiles [osutils:cbpx  $theOutDir $anExecutable]
+    }
+  }
+  return $aProjectFiles
+}
+
+# Generate Code::Blocks project file for ToolKit
+proc osutils:cbptk { theOutDir theToolKit } {
+  set aUsedToolKits [list]
+  set aFrameworks   [list]
+  set anIncPaths    [list]
+  set aTKDefines    [list]
+  set aTKSrcFiles   [list]
+
+  osutils:tkinfo "../../.." $theToolKit aUsedToolKits aFrameworks anIncPaths aTKDefines aTKSrcFiles
+
+  return [osutils:cbp $theOutDir $theToolKit $aTKSrcFiles $aUsedToolKits $aFrameworks $anIncPaths $aTKDefines]
+}
+
+# Generates Code Blocks workspace.
+proc OS:cworkspace { theSolName theModules theOutDir } {
+  global path
+  set aWsFilePath "${theOutDir}/${theSolName}.workspace"
+  set aFile [open $aWsFilePath "w"]
+  set isActiveSet 0
+  puts $aFile "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>"
+  puts $aFile "<CodeBlocks_workspace_file>"
+  puts $aFile "\t<Workspace title=\"${theSolName}\">"
+
+  # collect list of projects to be created
+  foreach aModule $theModules {
+    # toolkits
+    foreach aToolKit [osutils:tk:sort [${aModule}:toolkits]] {
+      set aDependencies [LibToLink $aToolKit]
+      if { [llength $aDependencies] == 0 } {
+        puts $aFile "\t\t<Project filename=\"${aToolKit}.cbp\" />"
+      } else {
+        puts $aFile "\t\t<Project filename=\"${aToolKit}.cbp\" >"
+        foreach aDepTk $aDependencies {
+          puts $aFile "\t\t\t<Depends filename=\"${aDepTk}.cbp\" />"
+        }
+        puts $aFile "\t\t</Project>"
+      }
+    }
+
+    # executables, assume one project per cxx file...
+    foreach aUnit [OS:executable ${aModule}] {
+      set aUnitLoc $aUnit
+      set src_files [_get_used_files $aUnit false]
+      set aSrcFiles {}
+      foreach s $src_files { 
+        regexp {source ([^\s]+)} $s dummy name
+        lappend aSrcFiles $name
+      }
+      foreach aSrcFile $aSrcFiles {
+        set aFileExtension [file extension $aSrcFile]
+        if { $aFileExtension == ".cxx" } {
+          set aPrjName [file rootname $aSrcFile]
+          set aDependencies [list]
+          if {[file isdirectory $path/src/$aUnitLoc]} {
+            set aDependencies [LibToLinkX $aUnitLoc [file rootname $aSrcFile]]
+          }
+          set anActiveState ""
+          if { $isActiveSet == 0 } {
+            set anActiveState " active=\"1\""
+            set isActiveSet 1
+          }
+          if { [llength $aDependencies] == 0 } {
+            puts $aFile "\t\t<Project filename=\"${aPrjName}.cbp\"${anActiveState}/>"
+          } else {
+            puts $aFile "\t\t<Project filename=\"${aPrjName}.cbp\"${anActiveState}>"
+            foreach aDepTk $aDependencies {
+              puts $aFile "\t\t\t<Depends filename=\"${aDepTk}.cbp\" />"
+            }
+            puts $aFile "\t\t</Project>"
+          }
+        }
+      }
+    }
+  }
+
+  puts $aFile "\t</Workspace>"
+  puts $aFile "</CodeBlocks_workspace_file>"
+  close $aFile
+
+  return $aWsFilePath
+}
+
+# Generate Code::Blocks project file for Executable
+proc osutils:cbpx { theOutDir theToolKit } {
+  global path targetStation
+  set aWokStation "$targetStation"
+  set aWokArch    "$::env(ARCH)"
+
+  set aCbpFiles {}
+  foreach aSrcFile [osutils:tk:files $theToolKit osutils:compilable 0] {
+    # collect list of referred libraries to link with
+    set aUsedToolKits [list]
+    set aFrameworks   [list]
+    set anIncPaths    [list]
+    set aTKDefines    [list]
+    set aTKSrcFiles   [list]
+    set aProjName [file rootname [file tail $aSrcFile]]
+
+    set aDepToolkits [LibToLinkX $theToolKit $aProjName]
+    foreach tkx $aDepToolkits {
+      if {[_get_type $tkx] == "t"} {
+        lappend aUsedToolKits "${tkx}"
+      }
+      if {[lsearch [glob -tails -directory "$path/src" -types d *] $tkx] == "-1"} {
+        lappend aUsedToolKits "${tkx}"
+      }
+    }
+
+    #wokparam -l CSF
+
+    foreach tk $aDepToolkits {
+      foreach element [osutils:tk:hascsf $path/src/${tk}/EXTERNLIB] {
+        if {[_get_options lin csf $element] == ""} {
+          continue
+        }
+        set isFrameworkNext 0
+        foreach fl [split [_get_options lin csf $element]] {
+          if {[string first "-libpath" $fl] != "-1"} {
+            # this is library search path, not the library name
+            continue
+          } elseif {[string first "-framework" $fl] != "-1"} {
+            set isFrameworkNext 1
+            continue
+          }
+
+          set felem [file tail $fl]
+          if {$isFrameworkNext == 1} {
+            if {[lsearch $aFrameworks $felem] == "-1"} {
+              lappend aFrameworks "${felem}"
+            }
+            set isFrameworkNext 0
+          } elseif {[lsearch $aUsedToolKits $felem] == "-1"} {
+            if {$felem != "\{\}" & $felem != "lib"} {
+              if {[lsearch -nocase [osutils:optinal_libs] $felem] == -1} {
+                lappend aUsedToolKits [string trimleft "${felem}" "-l"]
+              }
+            }
+          }
+        }
+      }
+    }
+
+    set WOKSteps_exec_link [_get_options lin WOKSteps_exec_link $theToolKit]
+    if { [regexp {WOKStep_DLLink} $WOKSteps_exec_link] || [regexp {WOKStep_Libink} $WOKSteps_exec_link] } {
+      set isExecutable "false"
+    } else {
+      set isExecutable "true"
+    }
+
+    if { ![info exists written([file tail $aSrcFile])] } {
+      set written([file tail $aSrcFile]) 1
+      lappend aTKSrcFiles $aSrcFile
+    } else {
+      puts "Warning : in cbp there are more than one occurences for [file tail $aSrcFile]"
+    }
+
+    # macros for correct DLL exports
+    if { "$aWokStation" == "wnt" } {
+      lappend aTKDefines "__${theToolKit}_DLL"
+    }
+
+    # common include paths
+    lappend anIncPaths "../../../inc"
+
+    # macros for UNIX to use config.h file
+    lappend aTKDefines "CSFDB"
+    if { "$aWokStation" == "wnt" } {
+      lappend aTKDefines "WNT"
+      lappend aTKDefines "_CRT_SECURE_NO_DEPRECATE"
+    } else {
+      lappend aTKDefines "HAVE_WOK_CONFIG_H"
+      lappend aTKDefines "HAVE_CONFIG_H"
+      if { "$aWokStation" == "lin" } {
+        lappend aTKDefines "LIN"
+      }
+      lappend aTKDefines "OCC_CONVERT_SIGNALS"
+      #lappend aTKDefines "_GNU_SOURCE=1"
+    }
+
+    lappend aCbpFiles [osutils:cbp $theOutDir $aProjName $aTKSrcFiles $aUsedToolKits $aFrameworks $anIncPaths $aTKDefines $isExecutable]
+  }
+
+  return $aCbpFiles
+}
+
+proc osutils:optinal_libs { } {
+  return [list tbb.lib tbbmalloc.lib FreeImage.lib FreeImagePlus.lib gl2ps.lib]
+}
+
+# This function intended to generate Code::Blocks project file
+# @param theOutDir     - output directory to place project file
+# @param theProjName   - project name
+# @param theSrcFiles   - list of source files
+# @param theLibsList   - dependencies (libraries  list)
+# @param theFrameworks - dependencies (frameworks list, Mac OS X specific)
+# @param theIncPaths   - header search paths
+# @param theDefines    - compiler macro definitions
+# @param theIsExe      - flag to indicate executable / library target
+proc osutils:cbp { theOutDir theProjName theSrcFiles theLibsList theFrameworks theIncPaths theDefines {theIsExe "false"} } {
+  global targetStation
+  set aWokStation "$targetStation"
+  set aWokArch    "$::env(ARCH)"
+
+  set aCbpFilePath "${theOutDir}/${theProjName}.cbp"
+  set aFile [open $aCbpFilePath "w"]
+  puts $aFile "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>"
+  puts $aFile "<CodeBlocks_project_file>"
+  puts $aFile "\t<FileVersion major=\"1\" minor=\"6\" />"
+  puts $aFile "\t<Project>"
+  puts $aFile "\t\t<Option title=\"$theProjName\" />"
+  puts $aFile "\t\t<Option pch_mode=\"2\" />"
+  if { "$aWokStation" == "wnt" } {
+    puts $aFile "\t\t<Option compiler=\"msvc8\" />"
+  } else {
+    puts $aFile "\t\t<Option compiler=\"gcc\" />"
+  }
+  puts $aFile "\t\t<Build>"
+
+  # 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=\"1\" extension_auto=\"1\" />"
+    puts $aFile "\t\t\t\t<Option type=\"1\" />"
+  } else {
+    if { "$aWokStation" == "wnt" } {
+      puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/lib/${theProjName}\" prefix_auto=\"1\" extension_auto=\"1\" />"
+    } else {
+      puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/lib/lib${theProjName}\" prefix_auto=\"1\" extension_auto=\"1\" />"
+    }
+    puts $aFile "\t\t\t\t<Option type=\"3\" />"
+  }
+  puts $aFile "\t\t\t\t<Option object_output=\"../../../${aWokStation}/cbp/obj\" />"
+  if { "$aWokStation" == "wnt" } {
+    puts $aFile "\t\t\t\t<Option compiler=\"msvc8\" />"
+  } else {
+    puts $aFile "\t\t\t\t<Option compiler=\"gcc\" />"
+  }
+  puts $aFile "\t\t\t\t<Option createDefFile=\"1\" />"
+  puts $aFile "\t\t\t\t<Option createStaticLib=\"1\" />"
+
+  # compiler options per TARGET (including defines)
+  puts $aFile "\t\t\t\t<Compiler>"
+  if { "$aWokStation" == "wnt" } {
+    puts $aFile "\t\t\t\t\t<Add option=\"-MD\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-arch:SSE2\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-EHsc\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-O2\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-W4\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-MP\" />"
+  } else {
+    puts $aFile "\t\t\t\t\t<Add option=\"-O2\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-mmmx\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-msse\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-msse2\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-mfpmath=sse\" />"
+  }
+  foreach aMacro $theDefines {
+    puts $aFile "\t\t\t\t\t<Add option=\"-D${aMacro}\" />"
+  }
+  puts $aFile "\t\t\t\t\t<Add option=\"-DNDEBUG\" />"
+  puts $aFile "\t\t\t\t\t<Add option=\"-DNo_Exception\" />"
+
+  puts $aFile "\t\t\t\t</Compiler>"
+
+  puts $aFile "\t\t\t\t<Linker>"
+  puts $aFile "\t\t\t\t\t<Add directory=\"../../../${aWokStation}/cbp/lib\" />"
+  if { "$aWokStation" == "mac" && [ 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})\" />"
+  puts $aFile "\t\t\t\t</Linker>"
+
+  puts $aFile "\t\t\t</Target>"
+
+  # 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=\"1\" extension_auto=\"1\" />"
+    puts $aFile "\t\t\t\t<Option type=\"1\" />"
+  } else {
+    if { "$aWokStation" == "wnt" } {
+      puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/libd/${theProjName}\" prefix_auto=\"1\" extension_auto=\"1\" />"
+    } else {
+      puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/libd/lib${theProjName}\" prefix_auto=\"1\" extension_auto=\"1\" />"
+    }
+    puts $aFile "\t\t\t\t<Option type=\"3\" />"
+  }
+  puts $aFile "\t\t\t\t<Option object_output=\"../../../${aWokStation}/cbp/objd\" />"
+  if { "$aWokStation" == "wnt" } {
+    puts $aFile "\t\t\t\t<Option compiler=\"msvc8\" />"
+  } else {
+    puts $aFile "\t\t\t\t<Option compiler=\"gcc\" />"
+  }
+  puts $aFile "\t\t\t\t<Option createDefFile=\"1\" />"
+  puts $aFile "\t\t\t\t<Option createStaticLib=\"1\" />"
+
+  # compiler options per TARGET (including defines)
+  puts $aFile "\t\t\t\t<Compiler>"
+  if { "$aWokStation" == "wnt" } {
+    puts $aFile "\t\t\t\t\t<Add option=\"-MDd\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-arch:SSE2\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-EHsc\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-Od\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-Zi\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-W4\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-MP\" />"
+  } else {
+    puts $aFile "\t\t\t\t\t<Add option=\"-O0\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-g\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-mmmx\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-msse\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-msse2\" />"
+    puts $aFile "\t\t\t\t\t<Add option=\"-mfpmath=sse\" />"
+  }
+  foreach aMacro $theDefines {
+    puts $aFile "\t\t\t\t\t<Add option=\"-D${aMacro}\" />"
+  }
+  puts $aFile "\t\t\t\t\t<Add option=\"-D_DEBUG\" />"
+  puts $aFile "\t\t\t\t\t<Add option=\"-DDEB\" />"
+  puts $aFile "\t\t\t\t</Compiler>"
+
+  puts $aFile "\t\t\t\t<Linker>"
+  puts $aFile "\t\t\t\t\t<Add directory=\"../../../${aWokStation}/cbp/libd\" />"
+  if { "$aWokStation" == "mac" && [ 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)\" />"
+  puts $aFile "\t\t\t\t</Linker>"
+
+  puts $aFile "\t\t\t</Target>"
+
+  puts $aFile "\t\t</Build>"
+
+  # COMMON compiler options
+  puts $aFile "\t\t<Compiler>"
+  puts $aFile "\t\t\t<Add option=\"-Wall\" />"
+  puts $aFile "\t\t\t<Add option=\"-fexceptions\" />"
+  puts $aFile "\t\t\t<Add option=\"-fPIC\" />"
+  puts $aFile "\t\t\t<Add option=\"\$(CSF_OPT_CMPL)\" />"
+  foreach anIncPath $theIncPaths {
+    puts $aFile "\t\t\t<Add directory=\"$anIncPath\" />"
+  }
+  puts $aFile "\t\t</Compiler>"
+
+  # COMMON linker options
+  puts $aFile "\t\t<Linker>"
+  foreach aFrameworkName $theFrameworks {
+    if { "$aFrameworkName" != "" } {
+      puts $aFile "\t\t\t<Add option=\"-framework $aFrameworkName\" />"
+    }
+  }
+  foreach aLibName $theLibsList {
+    if { "$aLibName" != "" } {
+      puts $aFile "\t\t\t<Add library=\"$aLibName\" />"
+    }
+  }
+  puts $aFile "\t\t</Linker>"
+
+  # list of sources
+  foreach aSrcFile $theSrcFiles {
+    if {[string equal -nocase [file extension $aSrcFile] ".mm"]} {
+      puts $aFile "\t\t<Unit filename=\"$aSrcFile\">"
+      puts $aFile "\t\t\t<Option compile=\"1\" />"
+      puts $aFile "\t\t\t<Option link=\"1\" />"
+      puts $aFile "\t\t</Unit>"
+    } elseif {[string equal -nocase [file extension $aSrcFile] ".c"]} {
+      puts $aFile "\t\t<Unit filename=\"$aSrcFile\">"
+      puts $aFile "\t\t\t<Option compilerVar=\"CC\" />"
+      puts $aFile "\t\t</Unit>"
+    } else {
+      puts $aFile "\t\t<Unit filename=\"$aSrcFile\" />"
+    }
+  }
+
+  puts $aFile "\t</Project>"
+  puts $aFile "</CodeBlocks_project_file>"
+  close $aFile
+
+  return $aCbpFilePath
+}
+
+# Auxiliary function to achieve complete information to build Toolkit
+# @param theRelativePath - relative path to CASROOT
+# @param theToolKit      - Toolkit name
+# @param theUsedLib      - dependencies (libraries  list)
+# @param theFrameworks   - dependencies (frameworks list, Mac OS X specific)
+# @param theIncPaths     - header search paths
+# @param theTKDefines    - compiler macro definitions
+# @param theTKSrcFiles   - list of source files
+proc osutils:tkinfo { theRelativePath theToolKit theUsedLib theFrameworks theIncPaths theTKDefines theTKSrcFiles } {
+  global path targetStation
+  set aWokStation "$targetStation"
+
+  # collect list of referred libraries to link with
+  upvar $theUsedLib    aUsedLibs
+  upvar $theFrameworks aFrameworks
+  upvar $theIncPaths   anIncPaths
+  upvar $theTKDefines  aTKDefines
+  upvar $theTKSrcFiles aTKSrcFiles
+
+  set aDepToolkits [wokUtils:LIST:Purge [osutils:tk:close $theToolKit]]
+  foreach tkx $aDepToolkits {
+    lappend aUsedLibs "${tkx}"
+  }
+
+ # wokparam -l CSF
+
+  foreach tk [lappend aDepToolkits $theToolKit] {
+    foreach element [osutils:tk:hascsf $path/src/${tk}/EXTERNLIB] {
+      if {[_get_options lin csf $element] == ""} {
+        continue
+      }
+      set isFrameworkNext 0
+      foreach fl [split [_get_options lin csf $element]] {
+        if {[string first "-libpath" $fl] != "-1"} {
+          # this is library search path, not the library name
+          continue
+        } elseif {[string first "-framework" $fl] != "-1"} {
+          set isFrameworkNext 1
+          continue
+        }
+
+        set felem [file tail $fl]
+        if {$isFrameworkNext == 1} {
+          if {[lsearch $aFrameworks $felem] == "-1"} {
+            lappend aFrameworks "${felem}"
+          }
+          set isFrameworkNext 0
+        } elseif {[lsearch $aUsedLibs $felem] == "-1"} {
+          if {$felem != "\{\}" & $felem != "lib"} {
+            if {[lsearch -nocase [osutils:optinal_libs] $felem] == -1} {
+              lappend aUsedLibs [string trimleft "${felem}" "-l"]
+            }
+          }
+        }
+      }
+    }
+  }
+
+  lappend anIncPaths "$theRelativePath/inc"
+  set listloc [osutils:tk:units $theToolKit]
+
+  if { [llength $listloc] == 0 } {
+    set listloc $theToolKit
+  }
+
+  if { "$aWokStation" == "wnt" } {
+    set resultloc [osutils:justwnt  $listloc]
+  } else {
+    set resultloc [osutils:justunix $listloc]
+  }
+  if [array exists written] { unset written }
+  foreach fxlo $resultloc {
+    set xlo       $fxlo
+    set aSrcFiles [osutils:tk:files $xlo osutils:compilable 0]
+    foreach aSrcFile [lsort $aSrcFiles] {
+      if { ![info exists written([file tail $aSrcFile])] } {
+        set written([file tail $aSrcFile]) 1
+        lappend aTKSrcFiles "${theRelativePath}/[wokUtils:FILES:wtail $aSrcFile 3]"
+      } else {
+        puts "Warning : more than one occurences for [file tail $aSrcFile]"
+      }
+    }
+
+    # macros for correct DLL exports
+    if { "$aWokStation" == "wnt" } {
+      lappend aTKDefines "__${xlo}_DLL"
+    }
+
+    # common include paths
+#    lappend anIncPaths "${theRelativePath}/src/${xlo}"
+  }
+
+  # macros for UNIX to use config.h file
+  lappend aTKDefines "CSFDB"
+  if { "$aWokStation" == "wnt" } {
+    lappend aTKDefines "WNT"
+    lappend aTKDefines "_CRT_SECURE_NO_DEPRECATE"
+  } else {
+    lappend aTKDefines "HAVE_WOK_CONFIG_H"
+    lappend aTKDefines "HAVE_CONFIG_H"
+    if { "$aWokStation" == "lin" } {
+      lappend aTKDefines "LIN"
+    }
+    lappend aTKDefines "OCC_CONVERT_SIGNALS"
+    #lappend aTKDefines "_GNU_SOURCE=1"
+  }
+}
+
+# Define libraries to link using only EXTERNLIB file
+proc LibToLinkX {thePackage theDummyName} {
+  set aToolKits [LibToLink $thePackage]
+  return $aToolKits
+}
+
+# launch generation
+genproj {*}$::argv
diff --git a/adm/templates/acinclude.m4 b/adm/templates/acinclude.m4
new file mode 100644 (file)
index 0000000..0c84f00
--- /dev/null
@@ -0,0 +1,157 @@
+#------------------------------------------------------------------------
+# Check for TCL
+# Options: --with-tcl=  :    Specify location of tclConfig.sh
+#          --without-tcl=  : Skip check for TCL, assume not installed
+# Defines:
+#          HAVE_TCL : yes/no
+#          Everything from tclConfig.sh
+#------------------------------------------------------------------------
+AC_DEFUN([SC_TCL_CFG], [
+  AC_ARG_WITH(tcl, 
+AC_HELP_STRING([--with-tcl=PATH],[Directory containing tclConfig.sh])
+AC_HELP_STRING([--without-tcl],  [Assume no tcl libraries available]) , 
+              [with_tcl="${withval}";require_tcl=yes],[with_tcl=yes;require_tcl=no])
+  
+  # If user requested disabling of tcl check
+  if test "xno" = "x$with_tcl"; then
+    HAVE_TCL=no
+    require_tcl=no
+  # Otherwise...
+  else
+    HAVE_TCL=no
+    # Search for tclConfig.sh
+    if test "xyes" != "x$with_tcl"; then
+      # If user specified location
+      . "${with_tcl}/tclConfig.sh" || AC_MSG_ERROR("Cannot read file: ${with_tcl}/tclConfig.sh")
+      HAVE_TCL=yes
+    else
+      # Search for tclConfig.sh in usual spots
+      tcl_cfg_file=
+      AC_MSG_CHECKING([for tclConfig.sh])
+      for i in /usr /usr/local ${prefix} /opt/sfw /usr/tcltk; do
+        if test -d $i; then
+          for j in $i/lib $i/lib/tcl $i/lib/tcl[[8-9]].[[0-9]] $i/lib/itcl; do
+            if test -r "$j/tclConfig.sh"; then
+              tcl_cfg_file="$j/tclConfig.sh"
+              break
+            fi
+          done
+        fi
+        if test "x" != "x$tcl_cfg_file"; then
+          break
+        fi
+      done
+      AC_MSG_RESULT("$tcl_cfg_file")
+      
+      if test "x" != "x$tcl_cfg_file"; then
+        . "$tcl_cfg_file" || AC_MSG_ERROR("Cannot read file: $tcl_cfg_file") 
+        HAVE_TCL=yes
+
+        # if TCL_INCLUDE_SPEC wasn't defined, try to define it using TCL_INC_DIR
+        if test "x" = "x$TCL_INCLUDE_SPEC"; then
+          inc_path=`expr "x$TCL_INC_DIR" : "x\(.*\)/tcl-private/generic"`
+          if test "x" != "$inc_path"; then
+            TCL_INCLUDE_SPEC="-I$inc_path"
+          elif test "x" != "x$TCL_INC_DIR"; then
+            TCL_INCLUDE_SPEC="-I$TCL_INC_DIR"
+          fi
+        fi
+      else
+        HAVE_TCL=no
+      fi
+    fi
+    
+    # Check for tcl.h
+    AC_LANG_C
+    save_CPPFLAGS="$CPPFLAGS"
+    CPPFLAGS="$CPPFLAGS $TCL_INCLUDE_SPEC"
+    AC_CHECK_HEADER([tcl.h],[],[HAVE_TCL=no])
+    CPPFLAGS="$save_CPPFLAGS"
+    
+    if test "xyes" = "x$require_tcl"; then
+      if test "xno" = "x$HAVE_TCL"; then
+        AC_MSG_ERROR([TCL not found.])
+      fi
+    fi
+  fi
+])
+
+
+#------------------------------------------------------------------------
+# Check for Tk
+# Options: --with-tk=  :    Specify location of Tk
+#          --without-tk=  : Skip check for Tk, assume not installed
+# Defines:
+#          HAVE_TK : yes/no
+#          Everything from tkConfig.sh
+#------------------------------------------------------------------------
+AC_DEFUN([SC_TK_CFG], [
+  AC_ARG_WITH(tk, 
+AC_HELP_STRING([--with-tk=PATH],[Directory containing tkConfig.sh])
+AC_HELP_STRING([--without-tk],  [Assume no Tk libraries available]) , 
+              [with_tk="${withval}";require_tk=yes],[with_tk=yes;require_tk=no])
+  
+  # If user requested disabling of Tk check
+  if test "xno" = "x$with_tk"; then
+    HAVE_TK=no
+    require_tk=no
+  # Otherwise...
+  else
+    HAVE_TK=no
+    # Search for tkConfig.sh
+    if test "xyes" != "x$with_tk"; then
+      # If user specified location
+      . "${with_tk}/tkConfig.sh" || AC_MSG_ERROR("Cannot read file: ${with_tk}/tkConfig.sh")
+      HAVE_TK=yes
+    else
+      # Search for tkConfig.sh in usual spots
+      tk_cfg_file=
+      AC_MSG_CHECKING([for tkConfig.sh])
+      for i in /usr /usr/local ${prefix} /opt/sfw /usr/tcltk; do
+        if test -d $i; then
+          for j in $i/lib $i/lib/tk $i/lib/tk[[8-9]].[[0-9]] $i/lib/itcl; do
+            if test -r "$j/tkConfig.sh"; then
+              tk_cfg_file="$j/tkConfig.sh"
+              break
+            fi
+          done
+        fi
+        if test "x" != "x$tk_cfg_file"; then
+          break
+        fi
+      done
+      AC_MSG_RESULT("$tk_cfg_file")
+      
+      if test "x" != "x$tk_cfg_file"; then
+        . "$tk_cfg_file" || AC_MSG_ERROR("Cannot read file: $tk_cfg_file") 
+        HAVE_TK=yes
+
+        # if TK_INCLUDE_SPEC wasn't defined, try to define it using TK_INC_DIR
+        if test "x" = "x$TK_INCLUDE_SPEC"; then
+          inc_path=`expr "x$TK_INC_DIR" : "x\(.*\)/tk-private/generic"`
+          if test "x" != "$inc_path"; then
+            TK_INCLUDE_SPEC="-I$inc_path"
+          elif test "x" != "x$TK_INC_DIR"; then
+            TK_INCLUDE_SPEC="-I$TK_INC_DIR"
+          fi
+        fi
+      else
+        HAVE_TK=no
+      fi
+    fi
+    
+    # Check for tk.h
+    AC_LANG_C
+    HAVE_TK=yes
+    save_CPPFLAGS="$CPPFLAGS"
+    CPPFLAGS="$CPPFLAGS $TCL_INCLUDE_SPEC $TK_INCLUDE_SPEC"
+    AC_CHECK_HEADER([tk.h],[],[HAVE_TK=no])
+    CPPFLAGS="$save_CPPFLAGS"
+    
+    if test "xyes" = "x$require_tk"; then
+      if test "xno" = "x$HAVE_TK"; then
+        AC_MSG_ERROR([Tk not found.])
+      fi
+    fi
+  fi
+])
diff --git a/adm/templates/codeblocks.sh b/adm/templates/codeblocks.sh
new file mode 100644 (file)
index 0000000..12eb8d2
--- /dev/null
@@ -0,0 +1,11 @@
+#!/bin/bash
+
+export TARGET="cbp"
+
+source ./env.sh "$1" "$TARGET"
+
+if [ -e "/Applications/CodeBlocks.app/Contents/MacOS/CodeBlocks" ]; then
+  /Applications/CodeBlocks.app/Contents/MacOS/CodeBlocks ./adm/$WOKSTATION/cbp/OCCT.workspace
+else
+  codeblocks ./adm/$WOKSTATION/cbp/OCCT.workspace
+fi
index 7b8cf29..b5c66c9 100644 (file)
@@ -5,6 +5,3 @@ call "%~dp0env.bat" %1 %2 %3
 
 echo Hint: use "pload ALL" command to load standard commands
 DRAWEXE.exe
-
-set "PATH=%ORIGIN_PATH%"
-
index 5dc0f24..49e5436 100644 (file)
@@ -2,7 +2,7 @@
 
 aScriptPath=${BASH_SOURCE%/*}; if [ -d "${aScriptPath}" ]; then cd "$aScriptPath"; fi; aScriptPath="$PWD";
 
-source "${aScriptPath}/env.sh" "$1"
+source "${aScriptPath}/env.sh" "$1" "$2"
 
 echo 'Hint: use "pload ALL" command to load standard commands'
 DRAWEXE
diff --git a/adm/templates/env.bat b/adm/templates/env.bat
new file mode 100644 (file)
index 0000000..ac9bfa7
--- /dev/null
@@ -0,0 +1,155 @@
+@echo off
+
+rem Use:
+rem - first argument specifies version of Visual Studio (vc8, vc9, or vc10),
+rem - second argument specifies architecture (win32 or win64),
+rem - third argument specifies build mode (Debug or Release)
+rem Default options are:
+rem   vc8 win32 Release
+
+set "SCRIPTROOT=%~dp0"
+set "SCRIPTROOT=%SCRIPTROOT:~0,-1%"
+set "CASROOT=__CASROOT__"
+if not ["%CASROOT%"] == [""] if exist "%SCRIPTROOT%\%CASROOT%" set "CASROOT=%SCRIPTROOT%\%CASROOT%"
+if     ["%CASROOT%"] == [""] set "CASROOT=%SCRIPTROOT%"
+
+rem ----- Reset values to defaults -----
+set "CASDEB="
+set "VCVER=vc8"
+set "ARCH=32"
+set "VCVARS="
+set "HAVE_TBB=false"
+set "HAVE_OPENCL=false"
+set "HAVE_FREEIMAGE=false"
+set "HAVE_GL2PS=false"
+set "HAVE_OPENCL=false"
+set "HAVE_VTK=false"
+set "CSF_OPT_INC="
+set "CSF_OPT_LIB32="
+set "CSF_OPT_LIB64="
+set "CSF_OPT_BIN32="
+set "CSF_OPT_BIN64="
+
+rem ----- Load local settings -----
+if exist "%~dp0custom.bat" (
+  call "%~dp0custom.bat" %1 %2 %3 %4 %5
+)
+
+rem ----- Read script arguments (override local settings) -----
+if not ["%1"]    == [""]      set "VCVER=%1"
+if not ["%2"]    == [""]      set "ARCH=%2"
+if /I ["%ARCH%"] == ["win32"] set "ARCH=32"
+if /I ["%ARCH%"] == ["win64"] set "ARCH=64"
+if /I ["%3"]     == ["debug"] set "CASDEB=d"
+if /I ["%3"]     == ["d"]     set "CASDEB=d"
+
+set "CSF_OPT_INC=%CSF_OPT_INC%;%CASROOT%\inc"
+set "CSF_OPT_LIB32D=%CSF_OPT_LIB32%;%CASROOT%\win32\%VCVER%\libd"
+set "CSF_OPT_LIB64D=%CSF_OPT_LIB64%;%CASROOT%\win64\%VCVER%\libd"
+set "CSF_OPT_BIN32D=%CSF_OPT_BIN32%;%CASROOT%\win32\%VCVER%\bind"
+set "CSF_OPT_BIN64D=%CSF_OPT_BIN64%;%CASROOT%\win64\%VCVER%\bind"
+set "CSF_OPT_LIB32=%CSF_OPT_LIB32%;%CASROOT%\win32\%VCVER%\lib"
+set "CSF_OPT_LIB64=%CSF_OPT_LIB64%;%CASROOT%\win64\%VCVER%\lib"
+set "CSF_OPT_BIN32=%CSF_OPT_BIN32%;%CASROOT%\win32\%VCVER%\bin"
+set "CSF_OPT_BIN64=%CSF_OPT_BIN64%;%CASROOT%\win64\%VCVER%\bin"
+
+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_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%"
+
+rem Eliminate VS warning
+if ["%CSF_DEFINES%"]  == [""] set "CSF_DEFINES=;"
+
+rem ----- Optional 3rd-parties should be enabled by HAVE macros -----
+if not ["%PRODUCTS_DEFINES%"] == [""] set "CSF_OPT_CMPL=%CSF_OPT_CMPL% %PRODUCTS_DEFINES%"
+
+rem ----- Colect 3rd-parties additional include paths into compiler options -----
+for %%a in ("%CSF_OPT_INC:;=";"%") do (
+  set "anItem=%%~a"
+  if not ["%%~a"] == [""] call :concatCmplInc %%~a
+)
+
+rem ----- Colect 3rd-parties additional library paths (32-bit) into linker options -----
+set "OPT_LIB32="
+for %%a in ("%CSF_OPT_LIB32:;=";"%") do (
+  set "anItem=%%~a"
+  if not ["%%~a"] == [""] call :concatLib32 %%~a
+)
+
+rem ----- Colect 3rd-parties additional library paths (64-bit) into linker options -----
+set "OPT_LIB64="
+for %%a in ("%CSF_OPT_LIB64:;=";"%") do (
+  set "anItem=%%~a"
+  if not ["%%~a"] == [""] call :concatLib64 %%~a
+)
+
+set "CSF_OPT_LNK32="
+set "CSF_OPT_LNK64="
+set "CSF_OPT_LNK32D="
+set "CSF_OPT_LNK64D="
+set "CSF_OPT_LNK32=%CSF_OPT_LNK32% %OPT_LIB32%"
+set "CSF_OPT_LNK32D=%CSF_OPT_LNK32D% %OPT_LIB32%"
+set "CSF_OPT_LNK64=%CSF_OPT_LNK64% %OPT_LIB64%"
+set "CSF_OPT_LNK64D=%CSF_OPT_LNK64D% %OPT_LIB64%"
+
+set "CASBIN=win%ARCH%\%VCVER%"
+
+rem ----- Set path to 3rd party and OCCT libraries -----
+set "PATH=%SCRIPTROOT%\%CASBIN%\bin%CASDEB%;%PATH%"
+if     ["%CASDEB%"] == [""] if ["%ARCH%"] == ["32"] set "PATH=%CSF_OPT_BIN32%;%PATH%"
+if     ["%CASDEB%"] == [""] if ["%ARCH%"] == ["64"] set "PATH=%CSF_OPT_BIN64%;%PATH%"
+if not ["%CASDEB%"] == [""] if ["%ARCH%"] == ["32"] set "PATH=%CSF_OPT_BIN32D%;%PATH%"
+if not ["%CASDEB%"] == [""] if ["%ARCH%"] == ["64"] set "PATH=%CSF_OPT_BIN64D%;%PATH%"
+
+rem ----- Set envoronment variables used by OCCT -----
+set CSF_LANGUAGE=us
+set MMGT_CLEAR=1
+set CSF_EXCEPTION_PROMPT=1
+set "CSF_SHMessage=%CASROOT%\src\SHMessage"
+set "CSF_MDTVTexturesDirectory=%CASROOT%\src\Textures"
+set "CSF_ShadersDirectory=%CASROOT%\src\Shaders"
+set "CSF_XSMessage=%CASROOT%\src\XSMessage"
+set "CSF_TObjMessage=%CASROOT%\src\TObj"
+set "CSF_StandardDefaults=%CASROOT%\src\StdResource"
+set "CSF_PluginDefaults=%CASROOT%\src\StdResource"
+set "CSF_XCAFDefaults=%CASROOT%\src\StdResource"
+set "CSF_TObjDefaults=%CASROOT%\src\StdResource"
+set "CSF_StandardLiteDefaults=%CASROOT%\src\StdResource"
+set "CSF_UnitsLexicon=%CASROOT%\src\UnitsAPI\Lexi_Expr.dat"
+set "CSF_UnitsDefinition=%CASROOT%\src\UnitsAPI\Units.dat"
+set "CSF_IGESDefaults=%CASROOT%\src\XSTEPResource"
+set "CSF_STEPDefaults=%CASROOT%\src\XSTEPResource"
+set "CSF_XmlOcafResource=%CASROOT%\src\XmlOcafResource"
+set "CSF_MIGRATION_TYPES=%CASROOT%\src\StdResource\MigrationSheet.txt"
+
+rem Draw Harness special stuff
+if exist "%CASROOT%\src\DrawResources" (
+  set "DRAWHOME=%CASROOT%\src\DrawResources"
+  set "CSF_DrawPluginDefaults=%DRAWHOME%"
+)
+if exist "%SCRIPTROOT%\src\DrawResourcesProducts" (
+  set "CSF_DrawPluginProductsDefaults=%SCRIPTROOT%\src\DrawResourcesProducts"
+)
+goto :eof
+
+:concatCmplInc
+set "CSF_OPT_CMPL=%CSF_OPT_CMPL% -I%1"
+goto :eof
+
+:concatLib32
+set "OPT_LIB32=%OPT_LIB32% /LIBPATH:%1"
+goto :eof
+
+:concatLib64
+set "OPT_LIB64=%OPT_LIB64% /LIBPATH:%1"
+goto :eof
diff --git a/adm/templates/env.sh b/adm/templates/env.sh
new file mode 100644 (file)
index 0000000..472608f
--- /dev/null
@@ -0,0 +1,199 @@
+#!/bin/bash
+
+# go to the script directory
+aScriptPath=${BASH_SOURCE%/*}; if [ -d "${aScriptPath}" ]; then cd "$aScriptPath"; fi; aScriptPath="$PWD";
+
+export CASROOT="__CASROOT__"
+
+if [ "${CASROOT}" != "" ] && [ -d "${aScriptPath}/${CASROOT}" ]; then
+  export CASROOT="${aScriptPath}/${CASROOT}"
+fi
+if [ "${CASROOT}" == "" ]; then
+  export CASROOT="${aScriptPath}"
+fi
+
+# Reset values
+export CASDEB=""
+export HAVE_TBB="false";
+export HAVE_OPENCL="false";
+export HAVE_FREEIMAGE="false";
+export HAVE_GL2PS="false";
+export HAVE_VTK="false";
+export MACOSX_USE_GLX="false";
+export CSF_OPT_INC=""
+export CSF_OPT_LIB32=""
+export CSF_OPT_LIB64=""
+export CSF_OPT_BIN32=""
+export CSF_OPT_BIN64=""
+
+# ----- Set local settings -----
+if [ -e "${aScriptPath}/custom.sh" ]; then source "${aScriptPath}/custom.sh"; fi
+
+# Read script arguments
+shopt -s nocasematch
+export TARGET="";
+if [[ "$2" == "cbp" ]]; then
+  export TARGET="cbp";
+elif [[ "$2" == "xcd" ]]; then
+  export TARGET="xcd";
+fi
+if [[ "$1" == "debug" ]]; then export CASDEB="d"; fi
+if [[ "$1" == "d" ]]; then export CASDEB="d"; fi
+shopt -u nocasematch
+
+# ----- Setup Environment Variables -----
+anArch=`uname -m`
+if [ "$anArch" != "x86_64" ] && [ "$anArch" != "ia64" ]; then
+  export ARCH="32";
+else
+  export ARCH="64";
+fi
+
+aSystem=`uname -s`
+if [ "$aSystem" == "Darwin" ]; then
+  export WOKSTATION="mac";
+  export ARCH="64";
+else
+  export WOKSTATION="lin";
+fi
+
+export CASBIN=""
+if [ "${TARGET}" == "cbp" ]; then
+  export CASBIN="${WOKSTATION}/cbp"
+elif [ "${TARGET}" == "xcd" ]; then
+  export CASBIN="adm/mac/xcd/build"
+fi
+
+export CSF_OPT_INC="${CSF_OPT_INC}:${CASROOT}/inc"
+
+if [ "${TARGET}" == "cbp" ]; then
+  export CSF_OPT_LIB32D="${CSF_OPT_LIB32}:${CASROOT}/${CASBIN}/libd"
+  export CSF_OPT_LIB64D="${CSF_OPT_LIB64}:${CASROOT}/${CASBIN}/libd"
+  export CSF_OPT_LIB32="${CSF_OPT_LIB32}:${CASROOT}/${CASBIN}/lib"
+  export CSF_OPT_LIB64="${CSF_OPT_LIB64}:${CASROOT}/${CASBIN}/lib"
+elif [ "${TARGET}" == "xcd" ]; then
+  export CSF_OPT_LIB32D="${CSF_OPT_LIB32}:${CASROOT}/${CASBIN}/Debug"
+  export CSF_OPT_LIB64D="${CSF_OPT_LIB64}:${CASROOT}/${CASBIN}/Debug"
+  export CSF_OPT_LIB32="${CSF_OPT_LIB32}:${CASROOT}/${CASBIN}/Release"
+  export CSF_OPT_LIB64="${CSF_OPT_LIB64}:${CASROOT}/${CASBIN}/Release"
+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_VTK" == "true" ]; then
+  export CSF_OPT_CMPL="${CSF_OPT_CMPL} -DHAVE_VTK"
+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
+
+# To split string into array
+aDelimBack=$IFS
+IFS=":"
+
+# 3rd-parties additional include paths
+set -- "$CSF_OPT_INC"
+declare -a aPartiesIncs=($*)
+for anItem in ${aPartiesIncs[*]}
+do
+  export CSF_OPT_CMPL="${CSF_OPT_CMPL} -I${anItem}";
+done
+
+# Append 3rd-parties to LD_LIBRARY_PATH
+if [ "$ARCH" == "32" ]; then
+  set -- "$CSF_OPT_LIB32"
+  declare -a aPartiesLibs=($*)
+  set -- "$CSF_OPT_LIB32D"
+  declare -a aPartiesLibsDeb=($*)
+else
+  set -- "$CSF_OPT_LIB64"
+  declare -a aPartiesLibs=($*)
+  set -- "$CSF_OPT_LIB64D"
+  declare -a aPartiesLibsDeb=($*)
+fi
+
+# Turn back value
+IFS=$aDelimBack
+
+OPT_LINKER_OPTIONS_DEB=""
+for anItem in ${aPartiesLibsDeb[*]}
+do
+  OPT_LINKER_OPTIONS_DEB="${OPT_LINKER_OPTIONS_DEB} -L${anItem}"
+done
+
+OPT_LINKER_OPTIONS=""
+for anItem in ${aPartiesLibs[*]}
+do
+  if [ "${LD_LIBRARY_PATH}" == "" ]; then
+    export LD_LIBRARY_PATH="${anItem}"
+  else
+    export LD_LIBRARY_PATH="${anItem}:${LD_LIBRARY_PATH}"
+  fi
+  OPT_LINKER_OPTIONS="${OPT_LINKER_OPTIONS} -L${anItem}"
+done
+
+if [ "$ARCH" == "64" ]; then
+  export CSF_OPT_LNK64="$OPT_LINKER_OPTIONS"
+  export CSF_OPT_LNK64D="$OPT_LINKER_OPTIONS_DEB"
+else
+  export CSF_OPT_LNK32="$OPT_LINKER_OPTIONS"
+  export CSF_OPT_LNK32D="$OPT_LINKER_OPTIONS_DEB"
+fi
+
+
+BIN_PATH="${CASBIN}/bin${CASDEB}"
+LIBS_PATH="${CASBIN}/lib${CASDEB}"
+if [ "${TARGET}" == "xcd" ]; then
+  [[ "${CASDEB}" == "d" ]] && BIN_PATH="${CASBIN}/Debug" || BIN_PATH="${CASBIN}/Release"
+  LIBS_PATH="$BIN_PATH"
+fi
+
+export PATH="${CASROOT}/${BIN_PATH}:${PATH}"
+export LD_LIBRARY_PATH="${CASROOT}/${LIBS_PATH}:${LD_LIBRARY_PATH}"
+if [ "$WOKSTATION" == "mac" ]; then
+  export DYLD_LIBRARY_PATH="${LD_LIBRARY_PATH}:${DYLD_LIBRARY_PATH}"
+fi
+
+# Set envoronment variables used by OCCT
+export CSF_LANGUAGE="us"
+export MMGT_CLEAR="1"
+export CSF_EXCEPTION_PROMPT="1"
+export CSF_SHMessage="${CASROOT}/src/SHMessage"
+export CSF_MDTVTexturesDirectory="${CASROOT}/src/Textures"
+export CSF_ShadersDirectory="${CASROOT}/src/Shaders"
+export CSF_XSMessage="${CASROOT}/src/XSMessage"
+export CSF_TObjMessage="${CASROOT}/src/TObj"
+export CSF_StandardDefaults="${CASROOT}/src/StdResource"
+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"
+export CSF_MIGRATION_TYPES="${CASROOT}/src/StdResource/MigrationSheet.txt"
+
+# Draw Harness special stuff
+if [ -e "${CASROOT}/src/DrawResources" ]; then
+  export DRAWHOME="${CASROOT}/src/DrawResources"
+  export CSF_DrawPluginDefaults="${DRAWHOME}"
+fi
+if [ -e "${aScriptPath}/src/DrawResourcesProducts" ]; then
+  export CSF_DrawPluginProductsDefaults="${aScriptPath}/src/DrawResourcesProducts"
+fi
diff --git a/adm/templates/msvc.bat b/adm/templates/msvc.bat
new file mode 100644 (file)
index 0000000..6f642f8
--- /dev/null
@@ -0,0 +1,42 @@
+@echo off
+
+rem Setup environment
+call "%~dp0env.bat" %1 %2 %3
+
+rem Define path to project file
+set "PRJFILE=%~dp0\adm\msvc\%VCVER%\OCCT.sln"
+if not exist "%PRJFILE%" set "PRJFILE=%~dp0\adm\msvc\%VCVER%\Products.sln"
+if not "%4" == "" (
+  set "PRJFILE=%4"
+)
+
+set "VisualStudioExpressName=VCExpress"
+
+if "%VCVER%" == "vc8" (
+  set "DevEnvDir=%VS80COMNTOOLS%..\IDE"
+) else if "%VCVER%" == "vc9" (
+  set "DevEnvDir=%VS90COMNTOOLS%..\IDE"
+) else if "%VCVER%" == "vc10" (
+  set "DevEnvDir=%VS100COMNTOOLS%..\IDE"
+) else if "%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 "%VCVER%" == "vc12" (
+  set "DevEnvDir=%VS120COMNTOOLS%..\IDE"
+  set "VisualStudioExpressName=WDExpress"
+) 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%"
+) else if exist "%DevEnvDir%\%VisualStudioExpressName%.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^)
+)
diff --git a/adm/templates/template.ac b/adm/templates/template.ac
new file mode 100644 (file)
index 0000000..4602aa4
--- /dev/null
@@ -0,0 +1,1170 @@
+dnl Process this file with autoconf to produce a configure script.
+AC_INIT([OpenCASCADE], [6.8.0])
+AC_CONFIG_AUX_DIR(make)
+AM_INIT_AUTOMAKE([foreign])
+AC_CANONICAL_HOST
+dnl AM_CONFIG_SRCDIR(src/Standard/Standard.cxx)
+
+CFLAGS="$CFLAGS"
+CXXFLAGS="$CXXFLAGS"
+
+AC_PROG_CC
+
+AM_CONFIG_HEADER(config.h)
+
+dnl AM_MAINTAINER_MODE
+
+AC_AIX
+AC_ISC_POSIX
+AC_C_BIGENDIAN
+
+AC_DISABLE_STATIC
+
+dnl Checks for programs.
+AM_PROG_LIBTOOL
+AC_PROG_CXX
+AC_PROG_CC_C_O
+
+AC_PROG_AWK
+AC_PROG_INSTALL
+AC_PROG_LN_S
+AC_PROG_YACC
+AC_PROG_MAKE_SET
+
+dnl Checks for header files.
+
+AC_HEADER_STDC
+AC_LANG([C])
+AC_MSG_CHECKING([ for C header files ])
+AC_CHECK_HEADERS(dlfcn.h dl.h ieeefp.h time.h sys/time.h pwd.h)
+AC_CHECK_HEADERS(sys/statvfs.h sys/vfs.h sys/param.h osfcn.h netdb.h)
+AC_CHECK_HEADERS(sys/ioctl.h net/if.h sys/systeminfo.h sys/utsname.h)
+AC_CHECK_HEADERS(sysent.h unistd.h sys/unistd.h sys/socket.h)
+AC_CHECK_HEADERS(ndir.h sys/ndir.h sys/dir.h signal.h sys/signal.h)
+AC_CHECK_HEADERS(sigfpe.h floatingpoint.h sys/machsig.h sys/siginfo.h)
+AC_CHECK_HEADERS(malloc.h strings.h sys/stat.h sys/sem.h sys/ipc.h)
+AC_CHECK_HEADERS(sys/times.h dirent.h getopt.h sys/vnode.h)
+
+
+AC_LANG([C++])
+AC_MSG_CHECKING([ for C++ header files ])
+AC_CHECK_HEADERS(istream ostream istream fstream ios iomanip iostream )
+AC_CHECK_HEADERS(stream.h strstream.h istream.h ostream.h fstream.h stdlib.h ios.h iostream.h)
+AC_CHECK_HEADERS(iomanip.h limits.h values.h float.h)
+AC_CHECK_HEADERS(siginfo.h bits/sigset.h bstring.h sys/types.h sys/select.h)
+AC_CHECK_HEADERS(X11/extensions/transovl.h X11/extensions/readdisplay.h)
+AC_CHECK_HEADERS(X11/extensions/multibuf.h,[],[],[#include <X11/Xlib.h>])
+AC_CHECK_HEADERS(sys/filio.h sys/mman.h libc.h)
+
+#-----------------------------------------------------------------------------
+# Posix threads library is required
+#-----------------------------------------------------------------------------
+AC_CHECK_HEADER([pthread.h],[],[AC_MSG_ERROR([Posix threads required])])
+AC_CHECK_LIB([pthread],[pthread_create],[],[AC_MSG_ERROR([Posix threads required])])
+CSF_ThreadLibs_LIB=-lpthread
+AC_SUBST(CSF_ThreadLibs_LIB)
+
+#-----------------------------------------------------------------------------
+# dl library is required
+#-----------------------------------------------------------------------------
+AC_CHECK_LIB([dl],[dlopen],[],[AC_MSG_ERROR([dl library is required])])
+CSF_SOCKETLibs_LIB=-ldl
+
+#---------------------------------------------------------------------
+#
+# Test for 64-bit platforms
+#  
+#  
+#---------------------------------------------------------------------
+AC_MSG_CHECKING([if platform is 64-bit])
+AC_TRY_COMPILE( [], 
+ [int array[((int)sizeof(void*))-6];],
+ [AC_MSG_RESULT([yes]); ARCH=64; case $platform in Linux*) CPPFLAGS="$CPPFLAGS -m64";; esac],
+ [AC_MSG_RESULT([no]); ARCH=32;] )
+AC_SUBST(ARCH)
+
+if test "x${CSF_OPT_INC}" != "x"; then
+   CSF_OPT_INCLUDES=
+   for c in `echo ${CSF_OPT_INC} | sed 's/:/ /g'`; do
+       CSF_OPT_INCLUDES="-I$c ${CSF_OPT_INCLUDES}"
+   done
+fi
+if test "$ARCH" = "32" -a "x${CSF_OPT_LIB32}" != "x"; then
+   CSF_OPT_LIB=${CSF_OPT_LIB32}
+   CSF_OPT_LIBS=
+   for c in `echo ${CSF_OPT_LIB32} | sed 's/:/ /g'`; do
+       CSF_OPT_LIBS="-L$c ${CSF_OPT_LIBS}"
+   done
+fi
+if test "$ARCH" = "64" -a "x${CSF_OPT_LIB64}" != "x"; then
+   CSF_OPT_LIB=${CSF_OPT_LIB64}
+   CSF_OPT_LIBS=
+   for c in `echo ${CSF_OPT_LIB64} | sed 's/:/ /g'`; do
+       CSF_OPT_LIBS="-L$c ${CSF_OPT_LIBS}"
+   done
+fi
+
+AC_SUBST(CSF_OPT_INCLUDES)
+AC_SUBST(CSF_OPT_LIBS)
+
+#------------------------------------------------------------------------------
+# Get Tcl and TK configuration information from tclConfig.sh.
+#------------------------------------------------------------------------------
+
+SC_TCL_CFG
+SC_TK_CFG
+HAVE_TCLTK=no
+if test "xyes" = "x$HAVE_TCL"; then
+  if test "xyes" = "x$HAVE_TK"; then
+    HAVE_TCLTK=yes
+    CSF_TclLibs_INCLUDES="${TCL_INCLUDE_SPEC}"
+    CSF_TclTkLibs_INCLUDES="${TK_INCLUDE_SPEC}"
+    CSF_TclLibs_LIB="${TCL_LIB_SPEC}"
+    CSF_TclTkLibs_LIB="${TK_LIB_SPEC}"
+    CSF_OPT_INC="${TCL_PREFIX}/include:${TK_PREFIX}/include:${CSF_OPT_INC}"
+    CSF_OPT_LIB="${TCL_PREFIX}/lib:${TK_PREFIX}/lib:${CSF_OPT_LIB}"
+  fi
+fi
+if test "x${HAVE_TCLTK}" != "xyes"; then
+   DISABLE_TCLTK_REASON="(tcltk was not found)"
+fi
+AC_SUBST(TCL_VERSION)
+AC_SUBST(TK_VERSION)
+AC_SUBST(HAVE_TCLTK)
+AC_SUBST(CSF_TclLibs_INCLUDES)
+AC_SUBST(CSF_TclTkLibs_INCLUDES)
+AC_SUBST(CSF_TclLibs_LIB)
+AC_SUBST(CSF_TclTkLibs_LIB)
+
+platform=`uname -s`
+
+dnl Make sure CSFDB is defined in CXXFLAGS and CFLAGS
+CXXFLAGS="$CXXFLAGS -DCSFDB -DOCC_CONVERT_SIGNALS"
+CFLAGS="$CFLAGS -DCSFDB -DOCC_CONVERT_SIGNALS"
+
+case $platform in
+       Linux*) CXXFLAGS="$CXXFLAGS -DLIN -DLININTEL -D_GNU_SOURCE=1 -mmmx -msse -msse2 -mfpmath=sse -Wall"
+               CFLAGS="$CFLAGS -DLIN -DLININTEL -fexceptions -mmmx -msse -msse2 -mfpmath=sse -Wall"
+               LDFLAGS="$LDFLAGS -lstdc++ -lrt";;
+       SunOS*) CXXFLAGS="$CXXFLAGS -Usun -DSOLARIS -instances=static"
+               CFLAGS="$CFLAGS -Usun -DSOLARIS -instances=static"
+               LDFLAGS="$LDFLAGS -instances=static"
+               CSF_SOCKETLibs_LIB="-lnsl ${CSF_SOCKETLibs_LIB}";;
+        OSF1*)  CXXFLAGS="$CXXFLAGS -DDECOSF1 -D__USE_STD_IOSTREAM -D_RWSTD_NO_EXCEPTIONS" 
+                CFLAGS="$CFLAGS -std1 -DDECOSF1"
+               LD=$CXX;;
+       *) ;;
+esac
+AC_SUBST(CSF_SOCKETLibs_LIB)
+
+AC_SUBST(platform)
+AC_LANG([C++])
+
+dnl Checks for typedefs, structures, and compiler characteristics.
+AC_TYPE_SIZE_T
+AC_STRUCT_TM
+
+dnl Checks for library functions.
+AC_FUNC_ALLOCA
+AC_FUNC_MEMCMP
+AC_TYPE_SIGNAL
+AC_CHECK_FUNCS(gethostname putenv re_comp regcomp strcspn strdup strtol)
+AC_CHECK_FUNCS(statfs statvfs)
+
+
+AC_CACHE_CHECK([if it is OK to define stream input and output],
+def_cv_ios_ok,
+[AC_LANG([C++])
+ AC_TRY_COMPILE([#include <stream.h>
+static const int input = (ios::in) | (ios::nocreate);
+static const int output= (ios::out);],
+[return 0;],
+ def_cv_ios_ok=yes, def_cv_ios_ok=no)
+])
+if test "$def_cv_ios_ok" = yes; then
+  AC_DEFINE(DEF_IOS_OK,,[define if the compiler allows redefinition of stream input and output])
+fi
+
+
+AC_CACHE_CHECK([if class ostream has member function form],
+[ostream_cv_form_ok],
+[AC_LANG([C++])
+ AC_TRY_COMPILE([#include <iostream.h>],
+[cout << cout.form("%9.3e", 3.14159627e-4) << endl;
+return 0;],
+ ostream_cv_form_ok=yes, ostream_cv_form_ok=no)
+])
+if test "$ostream_cv_form_ok" = yes; then
+  AC_DEFINE(OSTREAM_FORM_OK,,[define if the class ostream has member function form])
+fi
+
+
+dnl Checks for typedefs, structures, and compiler characteristics.
+
+# if the following code compiles then the union semun is
+# defined in the header <sys/sem.h>
+
+AC_CACHE_CHECK([if union semun is defined in <sys/sem.h>],
+[semun_cv_defined],
+[AC_LANG([C])
+AC_TRY_COMPILE([#include <sys/time.h>
+#include <sys/sem.h>],
+[union semun c;],
+ semun_cv_defined=yes, semun_cv_defined=no)
+])
+if test "$semun_cv_defined" = yes; then
+  AC_DEFINE(SEMUN_DEFINED,,[define if the union semun is in sys/sem.h])
+fi
+
+# if the following code compiles then the union semun has
+# the member __buf
+
+if test "$semun_cv_defined" = yes; then
+
+ AC_CACHE_CHECK(if union semun has member __buf,
+ semun_cv_buf_defined,
+ [AC_LANG([C])
+ AC_TRY_COMPILE([#include <sys/sem.h>],
+ [ union semun c; c.__buf = 0;],
+ semun_cv_buf_defined=yes, semun_cv_buf_defined=no)
+ ])
+ if test "$sumun_buf_defined" = yes; then
+  AC_DEFINE(SEMUN_BUF_DEFINED,,[define if semun has member __buf])
+ fi
+fi
+
+
+AC_CACHE_CHECK([if function semop takes a value],
+[semop_cv_no_reference],
+[AC_LANG([C])
+AC_TRY_COMPILE([#include <sys/sem.h>
+static struct sembuf event_flag ;],
+[int status;
+ int *semid;
+ status = semop(*semid,event_flag,1);
+],
+ semop_cv_no_reference=yes, semop_cv_no_reference=no)
+])
+if test "$semop_cv_no_reference" = yes; then
+  AC_DEFINE(SEMOP_NO_REFERENCE,,[define if the function semop takes a value])
+fi
+
+
+AC_CACHE_CHECK([if function semctl takes a value],
+[semctl_cv_no_reference],
+[AC_LANG([C])
+AC_TRY_COMPILE([#include <sys/sem.h>
+int get_semaphore(semid,event,value)
+ int *semid, *event, *value;
+{
+ int status;
+ status = semctl((*semid),*event,GETVAL,value);
+ return 0;
+}
+int *a,*b,*c;],
+[if(get_semaphore(a,b,c))
+ exit 0;],
+ semctl_cv_no_reference=yes, semctl_cv_no_reference=no)
+])
+if test "$semctl_cv_no_reference" = yes; then
+  AC_DEFINE(SEMCTL_NO_REFERENCE,,[define if the function semctl takes a value])
+fi
+
+AC_CHECK_LIB(malloc,mallinfo,[
+  AC_DEFINE(HAVE_MALLINFO,,[Define if we have a function called "mallinfo" in -lmalloc.])
+  LIBS="$LIBS -lmalloc"
+])
+
+AC_CHECK_LIB(sunmath,ieee_handler,[
+  AC_DEFINE(HAVE_SUNMATH,,[Define if we have a function called "ieee_handler" in -lsunmath.])
+  LIBS="$LIBS -lsunmath"
+])
+
+AC_CHECK_LIB(m,finite,[
+  AC_DEFINE(HAVE_FINITE,,[Define if we have a function called "finite" in -lm.])
+])
+
+#---------------------------------------------------------------------
+#
+# Check for Java Header Files 
+#  
+#  
+#---------------------------------------------------------------------
+
+AC_ARG_WITH([java-include],
+  [AC_HELP_STRING([--with-java-include=DIR],[Location of jni.h])],
+  [java_include="${withval}"],[java_include=])
+if test "xno" = "x$java_include"; then
+  # user specified --without-java-include
+  HAVE_JAVA=no
+else
+  if test "xyes" != "x$java_include" && test "x" != "x$java_include"; then
+    # user specified some path
+    
+    # test user-specified value is a directory
+    if test ! -d "$java_include"; then
+      AC_MSG_ERROR([$java_include: Not a directory])
+    fi
+    
+    # search for jni_md.h (typically in a system-specific subdir)
+    AC_MSG_CHECKING([for jni_md.h in $java_include])
+    extra_java_include=
+    if test -f "$java_include/jni_md.h"; then
+      result="$java_include/jni_md.h"
+    else
+      result=
+      for d in "$java_include"/*; do
+        if test -f "$d/jni_md.h"; then
+          extra_java_include="-I$d"
+          result="$d/jni_md.h"
+          break
+        fi
+      done
+      AC_MSG_RESULT([$result])
+    fi
+    
+    # put user-specified directory and jni_mh.h directory (if found)
+    # into CPPFLAGS
+    CPPFLAGS="$CPPFLAGS -I$java_include $extra_java_include"
+  fi
+  
+  # Now we check for a working jni.h that is version 1.2 or newer.
+  # Note: This check is done unless user specified --without-java-include
+  #       If --with-java-include wasn't specified, it will check the
+  #       default compiler search path and any paths the user specified
+  #       via CPPFLAGS on the command line.
+  AC_CHECK_HEADER( [jni.h], [HAVE_JAVA=yes], [HAVE_JAVA=no
+    AC_MSG_NOTICE("Specify --with-java-include=<DIR> to enable Java support")] )
+  if test "xyes" = "x$HAVE_JAVA"; then
+    AC_MSG_CHECKING([java JNI version >= 1.2])
+    AC_TRY_COMPILE( [#include <jni.h>],
+  [#ifndef JNI_VERSION_1_2
+     choke me
+   #endif], [HAVE_JAVA=yes],[HAVE_JAVA=no] )
+    AC_MSG_RESULT([$HAVE_JAVA])
+  fi
+  
+  # If user specified --with-java-include, fail if not found
+  # (If user didn't specify, then we gracefully disable things that
+  # require java.)
+  if test "x" != "x$java_include" && test "xyes" != "x$HAVE_JAVA"; then
+    AC_MSG_ERROR([working jni.h not found])
+  fi
+fi
+
+CFLAGS_save="$CFLAGS"
+CXXFLAGS_save="$CXXFLAGS"
+CPPFLAGS_save="$CPPFLAGS"
+LDFLAGS_save="$LDFLAGS"
+LIBS_save="$LIBS"
+
+#---------------------------------------------------------------------
+#
+# Configure X11 and check for utility library
+#
+#---------------------------------------------------------------------
+AC_LANG([C])
+
+AC_PATH_X
+HAVE_X11=no
+X_INCLUDE=""
+X_LIBS=""
+CSF_XmuLibs_INCLUDES=""
+CSF_XmuLibs_LIB=""
+if test "xyes" != "x$no_x"; then
+  HAVE_X11=yes
+  if test "x" != "x$x_includes"; then
+    X_INCLUDE="-I$x_includes"
+    CSF_XmuLibs_INCLUDES="$X_INCLUDE"
+    CXXFLAGS="$CXXFLAGS -I$x_includes"
+  fi
+  if test "x" != "x$x_libraries"; then
+    X_LIBS="-L$x_libraries"
+    CSF_XmuLibs_LIB="$X_LIBS"
+    LDFLAGS="$LDFLAGS -L$x_libraries"
+  fi
+  AC_CHECK_LIB( [X11], [XCreateWindow], [X_LIBS="${X_LIBS} -lXt -lX11"], [HAVE_X11=no] )
+  AC_CHECK_HEADER( [X11/Xmu/Xmu.h], [], [HAVE_X11=no] )
+  AC_CHECK_LIB( [Xmu], [XmuLookupStandardColormap], [CSF_XmuLibs_LIB="$CSF_XmuLibs_LIB -lXmu"], [HAVE_X11=no], [-lXt -lX11] )
+fi
+
+#---------------------------------------------------------------------
+#
+# Check for OpenGL Libraries
+#  
+#  
+#---------------------------------------------------------------------
+CSF_OpenGlLibs_INCLUDES="$X_INCLUDE"
+CSF_OpenGlLibs_LIB="$X_LIBS"
+if test "xno" = "x$HAVE_X11"; then
+  HAVE_GL=no
+else
+AC_LANG([C])
+  HAVE_GL=yes
+  HAVE_GL_INC=yes
+  AC_CHECK_HEADER( [GL/gl.h], [AC_CHECK_HEADER([GL/glu.h],[],[HAVE_GL_INC=no])], [HAVE_GL_INC=no] )
+  if test "x$HAVE_GL_INC" = "xyes"; then
+    AC_CHECK_TYPE(_GLUfuncptr,[],[CSF_OpenGlLibs_INCLUDES="$CSF_OpenGlLibs_INCLUDES -DNOGLUfuncptr=1"],[#include "GL/glu.h"])
+  else
+    HAVE_GL=no
+    AC_MSG_NOTICE("Specify CPPFLAGS=-I<opengl_inc_dir> to enable OpenGL support")
+  fi
+  CPPFLAGS="$CSF_OpenGlLibs_INCLUDES $CPPFLAGS"
+  HAVE_GL_LIB=yes
+  AC_CHECK_LIB( [GL], [glClear], [AC_CHECK_LIB([GLU],[gluSphere],[CSF_OpenGlLibs_LIB="$CSF_OpenGlLibs_LIB -lGLU -lGL"],[HAVE_GL_LIB=no],[-lGL])], [HAVE_GL_LIB=no] )
+  if test "xno" = "x$HAVE_GL_LIB"; then
+    HAVE_GL=no
+    AC_MSG_NOTICE("Specify LDFLAGS=-L<opengl_lib_dir> to enable OpenGL support")
+  fi
+fi
+AM_CONDITIONAL( HAVE_GL, [test "xyes" = "x$HAVE_GL"] )
+
+#---------------------------------------------------------------------
+#
+# Check for FREETYPE Libraries
+# 
+# 
+#---------------------------------------------------------------------
+AC_ARG_WITH([freetype],
+  [AC_HELP_STRING([--with-freetype=DIR],[Location of FREETYPE])],
+  [freetype="${withval}"],[freetype=yes])
+
+CSF_FREETYPE_INCLUDES=""
+CSF_FREETYPE_LIB=""
+HAVE_FREETYPE=no
+
+if test "xyes" = "x${HAVE_GL}"; then
+  AC_LANG([C++])
+  if test "xno" = "x${freetype}"; then
+    dnl freetype check is explicitly disabled by --without-freetype or --with-freetype=no
+    AC_MSG_NOTICE([freetype check is explicitly disabled])
+    DISABLE_FREETYPE_REASON="(freetype check was explicitly disabled)"
+  else
+    if test "xyes" = "x${freetype}" -o "x/usr" = "x${freetype}"; then
+      dnl try native freetype (default)
+      AC_MSG_NOTICE(try system freetype)
+      FREETYPE_INCLUDES="-I/usr/include/freetype2"
+      FREETYPE_LIBS="-lfreetype"
+      FREETYPE_OPT_INC="/usr/include/freetype2"
+      FREETYPE_OPT_LIB=
+    else
+      AC_MSG_NOTICE(try freetype in $freetype)
+      if test ! -d ${freetype}; then
+    DISABLE_FREETYPE_REASON="(${freetype} directory does not exists)"
+    AC_MSG_ERROR([${freetype} directory does not exists])
+      fi
+      FREETYPE_INCLUDES="-I${freetype}/include -I${freetype}/include/freetype2"
+      FREETYPE_LIBS="-L${freetype}/lib -lfreetype"
+      FREETYPE_OPT_INC="${freetype}/include:${freetype}/include/freetype2"
+      FREETYPE_OPT_LIB="${freetype}/lib"
+    fi
+    CPPFLAGS_old=${CPPFLAGS}
+    LDFLAGS_old=${LDFLAGS}
+    CPPFLAGS="${FREETYPE_INCLUDES} $CPPFLAGS"
+    LDFLAGS="${FREETYPE_LIBS} $LDFLAGS"
+    AC_CHECK_HEADER( [ft2build.h], [HAVE_FREETYPE_INC=yes], [HAVE_FREETYPE_INC=no] )
+    if test "x${HAVE_FREETYPE_INC}" = "xyes"; then
+      AC_CHECK_LIB(freetype, FT_Init_FreeType,
+      [
+    HAVE_FREETYPE=yes
+        CSF_FREETYPE_INCLUDES="${FREETYPE_INCLUDES}"
+    CSF_FREETYPE_LIB="${FREETYPE_LIBS}"
+        LIBS="$CSF_FREETYPE_LIB $LIBS"
+        CSF_OPT_INC="${FREETYPE_OPT_INC}:${CSF_OPT_INC}"
+        CSF_OPT_LIB="${FREETYPE_OPT_LIB}:${CSF_OPT_LIB}"
+      ],
+      [
+    DISABLE_FREETYPE_REASON="(freetype was not found)"
+    AC_MSG_ERROR([Unable to locate the required FreeType library])
+      ])
+    else
+      DISABLE_FREETYPE_REASON="(freetype was not found)"
+    fi
+    CPPFLAGS=${CPPFLAGS_old}
+    LDFLAGS=${LDFLAGS_old}
+  fi
+else
+  DISABLE_FREETYPE_REASON="(freetype requires OpenGL support)"
+fi
+AM_CONDITIONAL( HAVE_FREETYPE, [test "xyes" = "x$HAVE_FREETYPE"] )
+
+#---------------------------------------------------------------------
+#
+# Check for FTGL Libraries
+# 
+# 
+#---------------------------------------------------------------------
+AC_ARG_WITH([ftgl],
+  [AC_HELP_STRING([--with-ftgl=DIR],[Location of FTGL])],
+  [ftgl="${withval}"],[ftgl=yes])
+
+CSF_FTGL_INCLUDES=""
+CSF_FTGL_LIB=""
+HAVE_FTGL=no
+
+if test "xno" = "x${HAVE_FREETYPE}"; then
+  DISABLE_FTGL_REASON=$DISABLE_FREETYPE_REASON
+else
+  AC_LANG([C++])
+  if test "xno" = "x${ftgl}"; then
+    dnl ftgl check is explicitly disabled by --without-ftgl or --with-ftgl=no
+    AC_MSG_NOTICE([ftgl check is explicitly disabled])
+    DISABLE_FTGL_REASON="(ftgl check was explicitly disabled)"
+  else
+    if test "xyes" = "x${ftgl}" -o "x/usr" = "x${ftgl}"; then
+      dnl try native ftgl (default)
+      ftgl=/usr
+      AC_MSG_NOTICE(try system ftgl)
+      FTGL_INCLUDES="-I/usr/include/FTGL"
+      FTGL_LIBS="-lftgl"
+      FTGL_OPT_INC="/usr/include/FTGL"
+      FTGL_OPT_LIB=
+    else
+      AC_MSG_NOTICE(try ftgl in ${ftgl})
+      if test ! -d ${ftgl}; then
+    DISABLE_FTGL_REASON="(${ftgl} directory does not exists)"
+    AC_MSG_ERROR([${ftgl} directory does not exists])
+      fi
+      FTGL_INCLUDES="-I${ftgl}/include -I${ftgl}/include/FTGL"
+      FTGL_LIBS="-L${ftgl}/lib -lftgl"
+      FTGL_OPT_INC="${ftgl}/include:${ftgl}/include/FTGL"
+      FTGL_OPT_LIB="${ftgl}/lib"
+    fi
+    for hf in ftgl.h FTGL.h; do
+      dnl check presence of ftgl header file in the specified directory
+      test -f ${ftgl}/include/FTGL/${hf} -o -f ${ftgl}/include/${hf} && HAVE_FTGL_INC=yes
+      test "xyes" = "x${HAVE_FTGL_INC}" -a "${hf}" = "FTGL.h" && HAVE_FTGL_UPPERCASE=-DHAVE_FTGL_UPPERCASE
+      test "xyes" = "x${HAVE_FTGL_INC}" && break
+    done
+    if test "xyes" = "x${HAVE_FTGL_INC}" ; then
+      CPPFLAGS_old=${CPPFLAGS}
+      LDFLAGS_old=${LDFLAGS}
+      CPPFLAGS="${FTGL_INCLUDES} ${HAVE_FTGL_UPPERCASE} ${CSF_FREETYPE_INCLUDES} $CPPFLAGS"
+      LDFLAGS="${FTGL_LIBS} ${CSF_FREETYPE_LIB} $LDFLAGS"
+      AC_CHECK_HEADERS([${hf}], 
+      [
+        HAVE_FTGL_INC=yes
+        break
+      ],
+      [
+        HAVE_FTGL_INC=no
+      ])
+      if test "x${HAVE_FTGL_INC}" = "xyes"; then
+        AC_MSG_CHECKING([for FTGLTextureFont in -lftgl])
+        CPPFLAGS="${FTGL_INCLUDES} ${HAVE_FTGL_UPPERCASE} ${CSF_FREETYPE_INCLUDES} ${CPPFLAGS_old}"
+        AC_TRY_LINK(
+        [
+          #ifdef HAVE_FTGL_UPPERCASE
+          #include <FTGL/FTGL.h>
+          #include <FTGL/FTGLTextureFont.h>
+          #else
+          #include <FTGL/ftgl.h>
+          #endif
+        ],
+        [
+          FTGLTextureFont font("");
+        ],
+        [
+          AC_MSG_RESULT(yes)
+          HAVE_FTGL=yes
+          CSF_FTGL_INCLUDES="${FTGL_INCLUDES} ${HAVE_FTGL_UPPERCASE}"
+          CSF_FTGL_LIB="${FTGL_LIBS}"
+          CSF_OPT_INC="${FTGL_OPT_INC}:${CSF_OPT_INC}"
+          CSF_OPT_LIB="${FTGL_OPT_LIB}:${CSF_OPT_LIB}"
+        ],
+        [
+          AC_MSG_RESULT(no)
+          DISABLE_FTGL_REASON="(ftgl was not found)"
+      AC_MSG_ERROR([Unable to locate the required ftgl library])
+        ]) 
+      else
+        DISABLE_FTGL_REASON="(ftgl was not found)"
+      fi
+      CPPFLAGS=${CPPFLAGS_old}
+      LDFLAGS=${LDFLAGS_old}
+    else
+      AC_MSG_RESULT([ftgl was not found])
+      DISABLE_FTGL_REASON="(ftgl was not found)"
+    fi
+  fi
+fi
+AM_CONDITIONAL( HAVE_FTGL, [test "xyes" = "x$HAVE_FTGL"] )
+
+#---------------------------------------------------------------------
+#
+# Check for GL2PS Libraries
+#  
+#  
+#---------------------------------------------------------------------
+AC_ARG_WITH([gl2ps],
+  [AC_HELP_STRING([--with-gl2ps=DIR],[Location of GL2PS])],
+  [gl2ps="${withval}"],[gl2ps=])
+
+if test "xno" = "xno$gl2ps"; then
+# user specified --without-gl2ps
+  HAVE_GL2PS=no
+  DISABLE_GL2PS_REASON="(--with-gl2ps=DIR option was not defined)"
+else
+  CSF_GL2PS_INCLUDES=""
+  CSF_GL2PS_LIB=""
+
+  if test "xno" = "x$HAVE_GL"; then
+       HAVE_GL2PS=no
+       DISABLE_GL2PS_REASON="(OpenGL  was not found)"
+  else
+       AC_LANG([C++])
+       HAVE_GL2PS=no
+       HAVE_GL2PS_INC=no
+       CPPFLAGS="-I$gl2ps/include $CPPFLAGS";
+       AC_CHECK_HEADER( [gl2ps.h], [HAVE_GL2PS_INC=yes], [HAVE_GL2PS_INC=no] )
+       if test ! -d $gl2ps; then
+          DISABLE_GL2PS_REASON="($gl2ps directory is not exists)"
+          AC_MSG_ERROR([$gl2ps directory is not exists])
+       elif test "x$HAVE_GL2PS_INC" = "xyes"; then
+          CSF_GL2PS_INCLUDES=""
+          CSF_OPT_INCLUDES="${CSF_OPT_INCLUDES} -I$gl2ps/include -DHAVE_GL2PS"
+          HAVE_GL2PS_LIB=yes
+          AC_MSG_CHECKING([for gl2psEndPage in -lgl2ps])
+          LDFLAGS="-L$gl2ps/lib $LDFLAGS"
+          LIBS="$CSF_OpenGlLibs_LIB $LIBS"
+          AC_CHECK_LIB( [gl2ps], [gl2psEndPage],
+          [
+               CSF_GL2PS_LIB="-L$gl2ps/lib -lgl2ps"
+               CSF_OPT_INC="$gl2ps/include:${CSF_OPT_INC}"
+               CSF_OPT_LIB="$gl2ps/lib:${CSF_OPT_LIB}"
+               HAVE_GL2PS_LIB=yes
+          ],
+          [
+               HAVE_GL2PS_LIB=no
+          ])
+       fi
+       if test "xyes" = "x$HAVE_GL2PS_LIB"; then
+           HAVE_GL2PS=yes
+       else
+           HAVE_GL2PS=no
+            DISABLE_GL2PS_REASON="(gl2ps was not found)"
+       fi
+  fi
+fi
+AM_CONDITIONAL( HAVE_GL2PS, [test "xyes" = "x$HAVE_GL2PS"] )
+
+#---------------------------------------------------------------------
+#
+# Check for FREEIMAGE Libraries and Includes
+#  
+#  
+#---------------------------------------------------------------------
+AC_ARG_WITH([freeimage],
+  [AC_HELP_STRING([--with-freeimage=DIR],[Location of freeimage])],
+  [freeimage="${withval}"],[freeimage=])
+
+if test "xno" = "xno$freeimage"; then
+  # user specified --without-freeimage
+  HAVE_FREEIMAGE=no
+  DISABLE_FREEIMAGE_REASON="(--with-freeimage=DIR option was not defined)"
+else
+  CSF_FreeImagePlus_INCLUDES=""
+  CSF_FreeImagePlus_LIB=""
+
+  AC_LANG([C++])
+  HAVE_FREEIMAGE=no
+  HAVE_FREEIMAGE_INC=yes
+  CPPFLAGS="-I$freeimage/include $CPPFLAGS";
+  AC_CHECK_HEADER( [FreeImage.h], [], [HAVE_FREEIMAGE_INC=no] )
+  if test ! -d $freeimage; then
+    DISABLE_FREEIMAGE_REASON="($freeimage directory is not exists)"
+    AC_MSG_ERROR([$freeimage directory is not exists])
+  elif test "x$HAVE_FREEIMAGE_INC" = "xyes"; then
+    CSF_FreeImagePlus_INCLUDES=""
+    CSF_OPT_INCLUDES="${CSF_OPT_INCLUDES} -I$freeimage/include -DHAVE_FREEIMAGE"
+    HAVE_FREEIMAGE_LIB=yes
+    AC_MSG_CHECKING([for FreeImage_OpenMemory in -lfreeimageplus])
+    LDFLAGS="-L$freeimage/lib $LDFLAGS"
+    LIBS="$CSF_FreeImagePlus_LIB $LIBS"
+    AC_CHECK_LIB( [freeimageplus], [FreeImage_OpenMemory],
+    [
+       HAVE_FREEIMAGE_LIB=yes;
+       CSF_OPT_INC="$freeimage/include:${CSF_OPT_INC}"
+       CSF_OPT_LIB="$freeimage/lib:${CSF_OPT_LIB}"
+       CSF_FreeImagePlus_LIB="-L$freeimage/lib -lfreeimageplus"
+    ], [HAVE_FREEIMAGE_LIB=no] )
+  fi
+  if test "xyes" = "x$HAVE_FREEIMAGE_LIB"; then
+    HAVE_FREEIMAGE=yes
+  else
+    HAVE_FREEIMAGE=no
+    DISABLE_FREEIMAGE_REASON="(freeimage was not found)"
+  fi
+fi
+AM_CONDITIONAL( HAVE_FREEIMAGE, [test "xyes" = "x$HAVE_FREEIMAGE"] )
+
+#---------------------------------------------------------------------
+#
+# Check for TBB Includes
+#  
+#  
+#---------------------------------------------------------------------
+AC_ARG_WITH([tbb-include],
+  [AC_HELP_STRING([--with-tbb-include=DIR],[Location of Intel Threading Building Blocks includes])],
+  [tbb_inc="${withval}"],[tbb_inc=])
+
+if test "xno" = "xno$tbb_inc"; then
+  # user specified --without-tbb-lib
+  HAVE_TBB=no
+  HAVE_TBB_INC=no
+  DISABLE_TBB_REASON_INC="(--with-tbb-include=DIR option was not defined)"
+else
+  CSF_TBB_INCLUDES=""
+  AC_LANG([C++])
+  HAVE_TBB_INC=yes
+  if test ! -d $tbb_inc; then
+    DISABLE_TBB_REASON_INC="($tbb_inc directory is not exists)"
+    AC_MSG_ERROR([$tbb_inc directory is not exists])
+  elif test "x$tbb_inc" != "x"; then
+     CPPFLAGS="-I$tbb_inc $CPPFLAGS";
+  else
+     AC_MSG_NOTICE("--with-tbb-include key is not defined")
+  fi
+  AC_CHECK_HEADER( [tbb/tbb.h], [], [HAVE_TBB_INC=no] )
+  if test "x$HAVE_TBB_INC" != "xyes"; then
+     AC_MSG_NOTICE("Specify --with-tbb-include to enable TBB support")
+     DISABLE_TBB_REASON_INC="(tbb includes were not found)"
+  fi
+fi
+
+#---------------------------------------------------------------------
+#
+# Check for OpenCL SDK Includes
+#  
+#  
+#---------------------------------------------------------------------
+AC_ARG_WITH([opencl-include],
+  [AC_HELP_STRING([--with-opencl-include=DIR],[Location of OpenCL SDK includes])],
+  [opencl_inc="${withval}"],[opencl_inc=])
+
+if test "xno" = "xno$opencl_inc"; then
+  # user specified --without-opencl-lib
+  HAVE_OPENCL=no
+  HAVE_OPENCL_INC=no
+  DISABLE_OPENCL_REASON_INC="(--with-opencl-include=DIR option was not defined)"
+else
+  CSF_OPENCL_INCLUDES=""
+  AC_LANG([C++])
+  HAVE_OPENCL_INC=yes
+  if test ! -d $opencl_inc; then
+    DISABLE_OPENCL_REASON_INC="($opencl_inc directory is not exists)"
+    AC_MSG_ERROR([$opencl_inc directory is not exists])
+  elif test "x$opencl_inc" != "x"; then
+     CPPFLAGS="-I$opencl_inc $CPPFLAGS";
+  else
+     AC_MSG_NOTICE("--with-opencl-include key is not defined")
+  fi
+  # TODO: Add MacOS X specific header check
+  AC_CHECK_HEADER( [CL/cl.h], [], [HAVE_OPENCL_INC=no] )
+  if test "x$HAVE_OPENCL_INC" != "xyes"; then
+     AC_MSG_NOTICE("Specify --with-opencl-include to enable OpenCL support")
+     DISABLE_OPENCL_REASON_INC="(OpenCL includes were not found)"
+  fi
+fi
+
+#---------------------------------------------------------------------
+#
+# Check for VTK Includes
+#  
+#  
+#---------------------------------------------------------------------
+AC_ARG_WITH([vtk-include],
+  [AC_HELP_STRING([--with-vtk-include=DIR],[Location of VTK includes])],
+  [vtk_inc="${withval}"],[vtk_inc=])
+
+if test "xno$vtk_inc" = "xno"; then
+  # user specified --without-vtk-lib
+  HAVE_VTK_INC=no
+  DISABLE_VTK_REASON="(--with-vtk-include=DIR option was not defined)"
+else
+  CSF_VTK_INCLUDES=""
+  AC_LANG([C++])
+  HAVE_VTK_INC=yes
+  if test ! -d $vtk_inc; then
+    DISABLE_VTK_REASON="($vtk_inc directory does not exists)"
+    AC_MSG_ERROR([$vtk_inc directory does not exists])
+  elif test ! -f $vtk_inc/vtkVersion.h; then
+    DISABLE_VTK_REASON="(vtk headers are not found in $vtk_inc)"
+    AC_MSG_ERROR([vtk headers are not found in $vtk_inc])
+  elif test "x$vtk_inc" != "x"; then
+     CPPFLAGS="-I$vtk_inc $CPPFLAGS";
+  else
+     HAVE_VTK_INC=no
+     DISABLE_VTK_REASON="(--with-vtk-include=DIR option was not defined)"
+     AC_MSG_NOTICE("--with-vtk-include=DIR option was not defined")
+  fi
+fi
+
+#---------------------------------------------------------------------
+#
+# Check for TBB Libraries
+#  
+#  
+#---------------------------------------------------------------------
+AC_ARG_WITH([tbb-library],
+  [AC_HELP_STRING([--with-tbb-library=DIR],[Location of Intel Threading Building Blocks libraries])],
+  [tbb_lib="${withval}"],[tbb_lib=])
+
+if test "xno" = "xno$tbb_lib"; then
+  # user specified --without-tbb
+  HAVE_TBB=no
+  DISABLE_TBB_REASON_LIB="(--with-tbb-library=DIR option was not defined)"
+else
+  CSF_TBB_LIB=""
+  HAVE_TBB=yes
+
+  if test "x$HAVE_TBB_INC" = "xyes"; then
+     if test ! -d $tbb_lib; then
+       DISABLE_TBB_REASON_LIB="($tbb_lib directory is not exists)"
+       AC_MSG_ERROR([$tbb_lib directory is not exists])
+     elif test "x$tbb_lib" != "x"; then
+       LDFLAGS="-L$tbb_lib $LDFLAGS"
+     fi
+     AC_CHECK_LIB([tbb], [TBB_runtime_interface_version], [], [HAVE_TBB=no])
+  else
+     HAVE_TBB=no
+  fi
+
+  if test "x$HAVE_TBB" = "xyes"; then
+     if test "x$tbb_inc" != "x"; then
+      CSF_TBB_INCLUDES=""
+      CSF_OPT_INCLUDES="${CSF_OPT_INCLUDES} -I$tbb_inc -DHAVE_TBB"
+     else
+       HAVE_TBB=no
+     fi
+     if test "x$tbb_lib" != "x"; then
+       if test "x$enable_debug" = "xyes"; then
+        CSF_TBB_LIB="-L$tbb_lib -ltbb_debug -ltbbmalloc_debug"
+       else
+        CSF_TBB_LIB="-L$tbb_lib -ltbb -ltbbmalloc"
+       fi
+     else
+       HAVE_TBB=no
+     fi
+     if test "x$HAVE_TBB" = "xyes"; then
+       CSF_OPT_INC="$tbb_inc:${CSF_OPT_INC}"
+       CSF_OPT_LIB="$tbb_lib:${CSF_OPT_LIB}"
+     else
+       DISABLE_TBB_REASON="(tbb was not found)";
+     fi
+  else
+     AC_MSG_NOTICE("Specify --with-tbb-library to enable TBB support")
+     DISABLE_TBB_REASON_LIB="(tbb libraries were not found)"
+  fi
+fi
+
+AM_CONDITIONAL( HAVE_TBB, [test "xyes" = "x$HAVE_TBB"] )
+
+#---------------------------------------------------------------------
+#
+# Check for OpenCL SDK Libraries
+#  
+#  
+#---------------------------------------------------------------------
+AC_ARG_WITH([opencl-library],
+  [AC_HELP_STRING([--with-opencl-library=DIR],[Location of OpenCL SDK libraries])],
+  [opencl_lib="${withval}"],[opencl_lib=])
+
+if test "xno" = "xno$opencl_lib"; then
+  # user specified --without-opencl
+  HAVE_OPENCL=no
+  DISABLE_OPENCL_REASON_LIB="(--with-opencl-library=DIR option was not defined)"
+else
+  CSF_OPENCL_LIB=""
+  HAVE_OPENCL=yes
+
+  if test "x$HAVE_OPENCL_INC" = "xyes"; then
+    if test ! -d $opencl_lib; then
+      DISABLE_OPENCL_REASON_LIB="($opencl_lib directory is not exists)"
+      AC_MSG_ERROR([$opencl_lib directory is not exists])
+    elif test "x$opencl_lib" != "x"; then
+      LDFLAGS="-L$opencl_lib $LDFLAGS"
+    fi
+    AC_CHECK_LIB(OpenCL, [clGetPlatformInfo], [], [HAVE_OPENCL=no])
+  else
+    HAVE_OPENCL=no
+  fi
+
+  if test "x$HAVE_OPENCL" = "xyes"; then
+    if test "x$opencl_inc" != "x"; then
+      CSF_OPENCL_INCLUDES=""
+      CSF_OPT_INCLUDES="${CSF_OPT_INCLUDES} -I$opencl_inc -DHAVE_OPENCL"
+    else
+      HAVE_OPENCL=no
+    fi
+    if test "x$opencl_lib" != "x"; then
+      CSF_OPENCL_LIB="-L$opencl_lib -lOpenCL"
+    else
+      HAVE_OPENCL=no
+    fi
+    
+    if test "x$HAVE_OPENCL" = "xyes"; then
+      CSF_OPT_INC="$opencl_inc:${CSF_OPT_INC}"
+      CSF_OPT_LIB="$opencl_lib:${CSF_OPT_LIB}"
+    else
+      DISABLE_OPENCL_REASON="(OpenCL was not found)";
+    fi
+  else
+    AC_MSG_NOTICE("Specify --with-opencl-library to enable OpenCL support")
+    DISABLE_OPENCL_REASON_LIB="(OpenCL libraries were not found)"
+  fi
+fi
+
+AM_CONDITIONAL( HAVE_OPENCL, [test "xyes" = "x$HAVE_OPENCL"] )
+
+#---------------------------------------------------------------------
+#
+# Check for QT Libraries
+#  
+#  
+#---------------------------------------------------------------------
+AC_ARG_WITH([qt],
+  [AC_HELP_STRING([--with-qt=QTDIR],[Location of QT])],
+  [qt="${withval}"],[qt=])
+
+if test "xno" = "xno$qt"; then
+# user specified --without-qt
+  HAVE_QT=no
+  DISABLE_QT_REASON="(--with-qt=DIR option was not defined)"
+else
+  CSF_QT_INCLUDES=""
+  CSF_QT_LIB=""
+
+  if test "xno" = "x$HAVE_GL"; then
+       HAVE_QT=no
+       DISABLE_QT_REASON="(OpenGL  was not found)"
+  else
+       AC_LANG([C++])
+       HAVE_QT=no
+       HAVE_QT_INC=no
+       CPPFLAGS="-I$qt/include/QtGui -I$qt/include/QtCore -I$qt/include/Qt -I$qt/include $CPPFLAGS"
+       AC_CHECK_HEADER( [Qt/qpixmap.h], [HAVE_QT_INC=yes], [HAVE_QT_INC=no] )
+       if test ! -d $qt; then
+          DISABLE_QT_REASON="($qt directory is not exists)"
+          AC_MSG_ERROR([$qt directory is not exists])
+       elif test "x$HAVE_QT_INC" = "xyes"; then
+          CSF_QT_INCLUDES="-I$qt/include/QtGui -I$qt/include/QtCore -I$qt/include/Qt -I$qt/include"
+          HAVE_QT_LIB=yes
+          AC_MSG_CHECKING([for connect in -lQtGui])
+          LDFLAGS="-L$qt/lib $LDFLAGS"
+          LIBS="$CSF_OpenGlLibs_LIB $LIBS"
+          AC_CHECK_LIB( [QtGui], [connect],
+           [
+               CSF_QT_LIB="-L$qt/lib -lQtGui -lQtCore"
+               CSF_OPT_INC="$qt/include/QtGui:$qt/include/QtCore:$qt/include/Qt:$qt/include:${CSF_OPT_INC}"
+               CSF_OPT_LIB="$qt/lib:${CSF_OPT_LIB}"
+               HAVE_QT_LIB=yes
+          ],
+          [
+               HAVE_QT_LIB=no
+          ])
+       fi
+       if test "xyes" = "x$HAVE_QT_LIB"; then
+           HAVE_QT=yes
+       else
+           HAVE_QT=no
+            DISABLE_QT_REASON="(qt was not found)"
+       fi
+  fi
+fi
+AM_CONDITIONAL( HAVE_QT, [test "xyes" = "x$HAVE_QT"] )
+
+AC_LANG([C])
+
+CFLAGS="$CFLAGS_save"
+CXXFLAGS="$CXXFLAGS_save"
+CPPFLAGS="$CPPFLAGS_save"
+LDFLAGS="$LDFLAGS_save"
+LIBS="$LIBS_save"
+
+AC_ARG_ENABLE([debug],
+              [AC_HELP_STRING([--enable-debug],[Debug Symbols])],
+              [enable_debug=${enableval}],[enable_debug=no])
+AC_ARG_ENABLE([production],
+              [AC_HELP_STRING([--enable-production],[Optimized build (default)])],
+              [enable_prod=${enableval}],[enable_prod=])
+
+# Enable production unless enable-default was specified
+if test "x$enable_prod" = "x"; then
+  if test "x$enable_debug" != "xyes"; then
+    enable_prod=yes
+  fi
+fi
+
+if test "x$enable_prod" = "xyes"; then
+  CFLAGS="$CFLAGS -O2"
+  CXXFLAGS="$CXXFLAGS -O2"
+fi
+if test "x$enable_debug" = "xyes"; then
+  CFLAGS="$CFLAGS -g"
+  CXXFLAGS="$CXXFLAGS -g"
+  CPPFLAGS="$CPPFLAGS -DDEB -D_DEBUG"
+else
+  CPPFLAGS="$CPPFLAGS -DNDEBUG  -DNo_Exception"
+fi
+
+#---------------------------------------------------------------------
+#
+# Check for VTK Libraries
+#  
+#  
+#---------------------------------------------------------------------
+AC_ARG_WITH([vtk-library],
+  [AC_HELP_STRING([--with-vtk-library=DIR],[Location of VTK libraries])],
+  [vtk_lib="${withval}"],[vtk_lib=])
+
+if test "xno" = "xno$vtk_lib"; then
+# user specified --without-vtk
+  HAVE_VTK=no
+  if test "x$DISABLE_VTK_REASON" = "x" ; then
+    DISABLE_VTK_REASON="(--with-vtk-library=DIR option was not defined)"
+  fi
+else
+  CSF_VTK_LIB=""
+  HAVE_VTK=yes
+
+  #CPP_FLAGS="-I$vtk $CPPFLAGS"
+  #AC_CHECK_HEADER( [Vtk/vtkConfigure.h], [HAVE_VTK_INC=yes], [HAVE_VTK_INC=no] )
+  if test "x$HAVE_VTK_INC" = "xyes"; then
+    if test ! -d $vtk_lib; then
+      DISABLE_VTK_REASON="($vtk_lib directory does not exist)"
+      AC_MSG_ERROR([$vtk_lib directory does not exist])
+    elif test ! -f $vtk_lib/libvtkCommonCore-6.1.so; then
+      DISABLE_VTK_REASON="(vtk libraries are not found in $vtk_lib)"
+      AC_MSG_ERROR([vtk libraries are not found in $vtk_lib])
+    elif test "x$vtk_lib" != "x" -a "x$vtk_inc" != "x"; then
+      CSF_VTK_LIB="-L$vtk_lib -lvtkCommonCore-6.1 -lvtkCommonDataModel-6.1 -lvtkCommonExecutionModel-6.1 -lvtkCommonMath-6.1 -lvtkCommonTransforms-6.1 "
+      CSF_VTK_LIB="${CSF_VTK_LIB} -lvtkRenderingCore-6.1 -lvtkRenderingOpenGL-6.1  -lvtkFiltersGeneral-6.1 -lvtkIOCore-6.1 -lvtkIOImage-6.1 -lvtkImagingCore-6.1 -lvtkInteractionStyle-6.1 "
+      CSF_OPT_INC="$vtk_inc:${CSF_OPT_INC}"
+      CSF_OPT_LIB="$vtk_lib:${CSF_OPT_LIB}"
+      CSF_OPT_INCLUDES="${CSF_OPT_INCLUDES} -I$vtk_inc -DHAVE_VTK"
+    else
+      HAVE_VTK=no
+      AC_MSG_NOTICE("--with-vtk-library=DIR option was not defined")
+      DISABLE_VTK_REASON="(--with-vtk-library=DIR option was not defined)"
+    fi
+  else
+    HAVE_VTK=no
+  fi
+fi
+
+#CSF_VTK="$CSF_VTK_LIB"
+AM_CONDITIONAL( HAVE_VTK, [test "xyes" = "x$HAVE_VTK"] )
+
+#----------------------------------------------------------------------
+#
+# Enalbe/Disable Modules
+#
+#----------------------------------------------------------------------
+__ENABLEMODULES__
+# Process options from above.  The behavior we want is:
+#
+# ENABLE_X = yes : User specified --enable-x 
+#                  print informative error and exit if it cannot be built
+#
+# ENABLE_X = no :  User specified --disable-x (or --enable-x=no)
+#                  silently disable building of component
+#
+# ENABLE_X =     : User didn't specify either way
+#                  Build if possible.  Warn if it cannot be build
+#                  because of some missing system requirement.  Inform
+#                  if disabled because some other required component 
+#                  was disabled.
+__CONFMODULES__
+# Convert to automake conditional values
+__CONDMODULES__
+#----------------------------------------------------------------------
+#
+# Write Output Files
+#
+#----------------------------------------------------------------------
+
+
+AC_SUBST(CPPFLAGS)
+CXXCPPFLAGS="$CPPFLAGS"
+AC_SUBST(CXXCPPFLAGS)
+AC_SUBST(CFLAGS)
+AC_SUBST(CXXFLAGS)
+AC_SUBST(LIBS)
+AC_SUBST(LDFLAGS)
+
+
+CSF_XwLibs_LIB="$X_LIBS"
+CSF_MotifLibs_LIB="$X_LIBS"
+
+AC_SUBST(CSF_SOCKETLibs_LIB)
+AC_SUBST(CSF_FPELibs_LIB)
+AC_SUBST(CSF_OpenGlLibs_INCLUDES)
+AC_SUBST(CSF_OpenGlLibs_LIB)
+AC_SUBST(HAVE_FREETYPE)
+AC_SUBST(CSF_FREETYPE_INCLUDES)
+AC_SUBST(CSF_FREETYPE_LIB)
+AC_SUBST(HAVE_FTGL)
+AC_SUBST(CSF_FTGL_INCLUDES)
+AC_SUBST(CSF_FTGL_LIB)
+AC_SUBST(HAVE_GL2PS)
+AC_SUBST(CSF_GL2PS_INCLUDES)
+AC_SUBST(CSF_GL2PS_LIB)
+AC_SUBST(HAVE_FREEIMAGE)
+AC_SUBST(CSF_FreeImagePlus_INCLUDES)
+AC_SUBST(CSF_FreeImagePlus_LIB)
+AC_SUBST(CSF_advapi32_LIB)
+AC_SUBST(CSF_gdi32_LIB)
+AC_SUBST(CSF_user32_LIB)
+AC_SUBST(CSF_wsock32_LIB)
+AC_SUBST(CSF_XwLibs_LIB)
+AC_SUBST(CSF_MotifLibs_LIB)
+AC_SUBST(CSF_XmuLibs_LIB)
+AC_SUBST(CSF_XmuLibs_INCLUDES)
+AC_SUBST(HAVE_TBB)
+AC_SUBST(CSF_TBB_INCLUDES)
+AC_SUBST(CSF_TBB_LIB)
+AC_SUBST(HAVE_OPENCL)
+AC_SUBST(CSF_OPENCL_INCLUDES)
+AC_SUBST(CSF_OPENCL_LIB)
+AC_SUBST(HAVE_QT)
+AC_SUBST(CSF_QT_INCLUDES)
+AC_SUBST(CSF_QT_LIB)
+AC_SUBST(HAVE_VTK)
+AC_SUBST(CSF_VTK_INCLUDES)
+AC_SUBST(CSF_VTK_LIB)
+
+AC_SUBST(CSF_OPT_INC)
+AC_SUBST(CSF_OPT_LIB)
+AC_SUBST(CSF_OPT_BIN)
+
+echo
+echo "CC       = $CC"
+echo "CXX      = $CXX"
+echo "CFLAGS   = $CFLAGS"
+echo "CXXFLAGS = $CXXFLAGS"
+echo "CPPFLAGS = $CPPFLAGS"
+echo "LDFLAGS  = $LDFLAGS"
+echo 
+echo "3rdparty mandatory products       "
+echo "---------------------------------"
+echo "freetype      : $HAVE_FREETYPE $DISABLE_FREETYPE_REASON"
+echo "tcltk         : $HAVE_TCLTK $DISABLE_TCLTK_REASON"
+echo
+echo "3rdparty optional products       "
+echo "---------------------------------"
+echo "gl2ps         : $HAVE_GL2PS $DISABLE_GL2PS_REASON"
+echo "freeimage     : $HAVE_FREEIMAGE $DISABLE_FREEIMAGE_REASON"
+echo "tbb includes  : $HAVE_TBB_INC $DISABLE_TBB_REASON_INC"
+echo "tbb libraries : $HAVE_TBB $DISABLE_TBB_REASON_LIB"
+echo "opencl        : $HAVE_OPENCL $DISABLE_OPENCL_REASON"
+echo "qt            : $HAVE_QT $DISABLE_QT_REASON"
+echo "vtk           : $HAVE_VTK $DISABLE_VTK_REASON"
+echo
+echo "Component                   Build"
+echo "--------------------------  -----"
+__REPMODULES__
+echo
+
+AC_OUTPUT([Makefile adm/lin/amk/Makefile custom.sh \
+__ACCONFMODULES__])
diff --git a/adm/templates/template.mam b/adm/templates/template.mam
new file mode 100644 (file)
index 0000000..5669bce
--- /dev/null
@@ -0,0 +1,22 @@
+# Makefile.am for Open Cascade toolkit __TKNAM__
+srcdir = @srcdir@
+
+VPATH = @srcdir@ : \
+__VPATH__
+
+AM_CXXFLAGS = __CXXFLAG__
+
+AM_CFLAGS = __CFLAG__
+
+INCLUDES = $(CSF_OPT_INCLUDES) __EXTERNINC__ \
+-I@top_srcdir@/inc \
+__INCLUDES__
+
+lib_LTLIBRARIES=lib__TKNAM__.la
+
+lib__TKNAM___la_LIBADD = $(CSF_OPT_LIBS) \
+__LIBADD__ \
+__EXTERNLIB__
+
+lib__TKNAM___la_SOURCES = \
+__SOURCES__
diff --git a/adm/templates/template.mamx b/adm/templates/template.mamx
new file mode 100644 (file)
index 0000000..da81a60
--- /dev/null
@@ -0,0 +1,10 @@
+# Makefile.am for executable __XQTNAM__
+srcdir = @srcdir@
+
+VPATH = @srcdir@ : \
+@top_srcdir@/src/__XQTNAM__
+
+INCLUDES = $(CSF_OPT_INCLUDES) __EXTERNINC__ \
+-I@top_srcdir@/inc \
+-I@top_srcdir@/src/__XQTNAM__
+
diff --git a/adm/templates/template.plist b/adm/templates/template.plist
new file mode 100644 (file)
index 0000000..9991859
--- /dev/null
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+       <key>SchemeUserState</key>
+       <dict>
+               <key>__TOOLKIT_NAME__.xcscheme</key>
+               <dict>
+                       <key>orderHint</key>
+                       <integer>0</integer>
+               </dict>
+       </dict>
+       <key>SuppressBuildableAutocreation</key>
+       <dict>
+               <key>__TOOLKIT_GUID__</key>
+               <dict>
+                       <key>primary</key>
+                       <true/>
+               </dict>
+       </dict>
+</dict>
+</plist>
diff --git a/adm/templates/template.vc10 b/adm/templates/template.vc10
new file mode 100644 (file)
index 0000000..ee763ae
--- /dev/null
@@ -0,0 +1,255 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>__PROJECT_GUID__</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\..\..\..\win32\vc10\bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\..\..\..\win32\vc10\obj\__TKNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\..\..\..\win32\vc10\bind\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\..\..\..\win32\vc10\objd\__TKNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\..\..\..\win64\vc10\bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\..\..\..\win64\vc10\obj\__TKNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\..\..\..\win64\vc10\bind\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\..\..\..\win64\vc10\objd\__TKNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win32\vc10\bin\__TKNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <AssemblerListingLocation>.\..\..\..\win32\vc10\obj\__TKNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win32\vc10\obj\__TKNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win32\vc10\obj\__TKNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>.\..\..\..\win32\vc10\bin\__TKNAM__.dll</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win32\vc10\lib;$(CSF_OPT_LIB32);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <ProgramDatabaseFile>.\..\..\..\win32\vc10\bin\__TKNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win32\vc10\lib\__TKNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win32\vc10\bind\__TKNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <AssemblerListingLocation>.\..\..\..\win32\vc10\objd\__TKNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win32\vc10\objd\__TKNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win32\vc10\objd\__TKNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>.\..\..\..\win32\vc10\bind\__TKNAM__.dll</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win32\vc10\libd;$(CSF_OPT_LIB32D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>..\..\..\win32\vc10\bind\__TKNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win32\vc10\libd\__TKNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>x64</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win64\vc10\bin\__TKNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>NDEBUG;WIN64;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <AssemblerListingLocation>.\..\..\..\win64\vc10\obj\__TKNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win64\vc10\obj\__TKNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win64\vc10\obj\__TKNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>NDEBUG;WIN64;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>.\..\..\..\win64\vc10\bin\__TKNAM__.dll</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win64\vc10\lib;$(CSF_OPT_LIB64);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <ProgramDatabaseFile>.\..\..\..\win64\vc10\bin\__TKNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win64\vc10\lib\__TKNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>x64</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win64\vc10\bind\__TKNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN64;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <AssemblerListingLocation>.\..\..\..\win64\vc10\objd\__TKNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win64\vc10\objd\__TKNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win64\vc10\objd\__TKNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN64;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>.\..\..\..\win64\vc10\bind\__TKNAM__.dll</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win64\vc10\libd;$(CSF_OPT_LIB64D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>..\..\..\win64\vc10\bind\__TKNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win64\vc10\libd\__TKNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+__FILES__
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="__TKNAM__.rc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
diff --git a/adm/templates/template.vc10x b/adm/templates/template.vc10x
new file mode 100644 (file)
index 0000000..f7ed985
--- /dev/null
@@ -0,0 +1,247 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>__PROJECT_GUID__</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>__CONF__</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>__CONF__</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>__CONF__</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>__CONF__</ConfigurationType>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\..\..\..\win32\vc10\bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\..\..\..\win32\vc10\obj\__XQTNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\..\..\..\win32\vc10\bind\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\..\..\..\win32\vc10\objd\__XQTNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\..\..\..\win64\vc10\bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\..\..\..\win64\vc10\obj\__XQTNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\..\..\..\win64\vc10\bind\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\..\..\..\win64\vc10\objd\__XQTNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win32\vc10\bin\__XQTNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <AssemblerListingLocation>.\..\..\..\win32\vc10\obj\__XQTNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win32\vc10\obj\__XQTNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win32\vc10\obj\__XQTNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;%(AdditionalDependencies)</AdditionalDependencies>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win32\vc10\lib;$(CSF_OPT_LIB32);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <ProgramDatabaseFile>.\..\..\..\win32\vc10\bin\__XQTNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win32\vc10\lib\__XQTNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win32\vc10\bind\__XQTNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <AssemblerListingLocation>.\..\..\..\win32\vc10\objd\__XQTNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win32\vc10\objd\__XQTNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win32\vc10\objd\__XQTNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;%(AdditionalDependencies)</AdditionalDependencies>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win32\vc10\libd;$(CSF_OPT_LIB32D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>..\..\..\win32\vc10\bind\__XQTNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win32\vc10\libd\__XQTNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>x64</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win64\vc10\bin\__XQTNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>NDEBUG;WIN64;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <AssemblerListingLocation>.\..\..\..\win64\vc10\obj\__XQTNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win64\vc10\obj\__XQTNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win64\vc10\obj\__XQTNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>NDEBUG;WIN64;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;%(AdditionalDependencies)</AdditionalDependencies>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win64\vc10\lib;$(CSF_OPT_LIB64);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <ProgramDatabaseFile>.\..\..\..\win64\vc10\bin\__XQTNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win64\vc10\lib\__XQTNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>x64</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win64\vc10\bind\__XQTNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN64;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <AssemblerListingLocation>.\..\..\..\win64\vc10\objd\__XQTNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win64\vc10\objd\__XQTNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win64\vc10\objd\__XQTNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN64;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;%(AdditionalDependencies)</AdditionalDependencies>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win64\vc10\libd;$(CSF_OPT_LIB64D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>..\..\..\win64\vc10\bind\__XQTNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win64\vc10\libd\__XQTNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+__FILES__  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
diff --git a/adm/templates/template.vc11 b/adm/templates/template.vc11
new file mode 100644 (file)
index 0000000..5c09f22
--- /dev/null
@@ -0,0 +1,257 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>__PROJECT_GUID__</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v110</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v110</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v110</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v110</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\..\..\..\win32\vc11\bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\..\..\..\win32\vc11\obj\__TKNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\..\..\..\win32\vc11\bind\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\..\..\..\win32\vc11\objd\__TKNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\..\..\..\win64\vc11\bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\..\..\..\win64\vc11\obj\__TKNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\..\..\..\win64\vc11\bind\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\..\..\..\win64\vc11\objd\__TKNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win32\vc11\bin\__TKNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <AssemblerListingLocation>.\..\..\..\win32\vc11\obj\__TKNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win32\vc11\obj\__TKNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win32\vc11\obj\__TKNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>.\..\..\..\win32\vc11\bin\__TKNAM__.dll</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win32\vc11\lib;$(CSF_OPT_LIB32);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <ProgramDatabaseFile>.\..\..\..\win32\vc11\bin\__TKNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win32\vc11\lib\__TKNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win32\vc11\bind\__TKNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <AssemblerListingLocation>.\..\..\..\win32\vc11\objd\__TKNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win32\vc11\objd\__TKNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win32\vc11\objd\__TKNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>.\..\..\..\win32\vc11\bind\__TKNAM__.dll</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win32\vc11\libd;$(CSF_OPT_LIB32D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>..\..\..\win32\vc11\bind\__TKNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win32\vc11\libd\__TKNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>x64</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win64\vc11\bin\__TKNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>NDEBUG;WIN64;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <AssemblerListingLocation>.\..\..\..\win64\vc11\obj\__TKNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win64\vc11\obj\__TKNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win64\vc11\obj\__TKNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>NDEBUG;WIN64;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>.\..\..\..\win64\vc11\bin\__TKNAM__.dll</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win64\vc11\lib;$(CSF_OPT_LIB64);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <ProgramDatabaseFile>.\..\..\..\win64\vc11\bin\__TKNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win64\vc11\lib\__TKNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>x64</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win64\vc11\bind\__TKNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN64;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <AssemblerListingLocation>.\..\..\..\win64\vc11\objd\__TKNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win64\vc11\objd\__TKNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win64\vc11\objd\__TKNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN64;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>.\..\..\..\win64\vc11\bind\__TKNAM__.dll</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win64\vc11\libd;$(CSF_OPT_LIB64D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>..\..\..\win64\vc11\bind\__TKNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win64\vc11\libd\__TKNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+__FILES__
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="__TKNAM__.rc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
diff --git a/adm/templates/template.vc11x b/adm/templates/template.vc11x
new file mode 100644 (file)
index 0000000..17cc49f
--- /dev/null
@@ -0,0 +1,245 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>__PROJECT_GUID__</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>__CONF__</ConfigurationType>
+    <PlatformToolset>v110</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>__CONF__</ConfigurationType>
+    <PlatformToolset>v110</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>__CONF__</ConfigurationType>
+    <PlatformToolset>v110</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>__CONF__</ConfigurationType>
+    <PlatformToolset>v110</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\..\..\..\win32\vc11\bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\..\..\..\win32\vc11\obj\__XQTNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\..\..\..\win32\vc11\bind\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\..\..\..\win32\vc11\objd\__XQTNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\..\..\..\win64\vc11\bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\..\..\..\win64\vc11\obj\__XQTNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\..\..\..\win64\vc11\bind\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\..\..\..\win64\vc11\objd\__XQTNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win32\vc11\bin\__XQTNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <AssemblerListingLocation>.\..\..\..\win32\vc11\obj\__XQTNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win32\vc11\obj\__XQTNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win32\vc11\obj\__XQTNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;%(AdditionalDependencies)</AdditionalDependencies>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win32\vc11\lib;$(CSF_OPT_LIB32);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <ProgramDatabaseFile>.\..\..\..\win32\vc11\bin\__XQTNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win32\vc11\lib\__XQTNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win32\vc11\bind\__XQTNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <AssemblerListingLocation>.\..\..\..\win32\vc11\objd\__XQTNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win32\vc11\objd\__XQTNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win32\vc11\objd\__XQTNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;%(AdditionalDependencies)</AdditionalDependencies>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win32\vc11\libd;$(CSF_OPT_LIB32D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>..\..\..\win32\vc11\bind\__XQTNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win32\vc11\libd\__XQTNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>x64</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win64\vc11\bin\__XQTNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>NDEBUG;WIN64;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <AssemblerListingLocation>.\..\..\..\win64\vc11\obj\__XQTNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win64\vc11\obj\__XQTNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win64\vc11\obj\__XQTNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>NDEBUG;WIN64;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;%(AdditionalDependencies)</AdditionalDependencies>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win64\vc11\lib;$(CSF_OPT_LIB64);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <ProgramDatabaseFile>.\..\..\..\win64\vc11\bin\__XQTNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win64\vc11\lib\__XQTNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>x64</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win64\vc11\bind\__XQTNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN64;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <AssemblerListingLocation>.\..\..\..\win64\vc11\objd\__XQTNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win64\vc11\objd\__XQTNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win64\vc11\objd\__XQTNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN64;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;%(AdditionalDependencies)</AdditionalDependencies>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win64\vc11\libd;$(CSF_OPT_LIB64D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>..\..\..\win64\vc11\bind\__XQTNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win64\vc11\libd\__XQTNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+__FILES__  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
diff --git a/adm/templates/template.vc12 b/adm/templates/template.vc12
new file mode 100644 (file)
index 0000000..6e180d9
--- /dev/null
@@ -0,0 +1,257 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>__PROJECT_GUID__</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\..\..\..\win32\vc12\bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\..\..\..\win32\vc12\obj\__TKNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\..\..\..\win32\vc12\bind\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\..\..\..\win32\vc12\objd\__TKNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\..\..\..\win64\vc12\bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\..\..\..\win64\vc12\obj\__TKNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\..\..\..\win64\vc12\bind\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\..\..\..\win64\vc12\objd\__TKNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win32\vc12\bin\__TKNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <AssemblerListingLocation>.\..\..\..\win32\vc12\obj\__TKNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win32\vc12\obj\__TKNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win32\vc12\obj\__TKNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>.\..\..\..\win32\vc12\bin\__TKNAM__.dll</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win32\vc12\lib;$(CSF_OPT_LIB32);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <ProgramDatabaseFile>.\..\..\..\win32\vc12\bin\__TKNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win32\vc12\lib\__TKNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win32\vc12\bind\__TKNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <AssemblerListingLocation>.\..\..\..\win32\vc12\objd\__TKNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win32\vc12\objd\__TKNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win32\vc12\objd\__TKNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>.\..\..\..\win32\vc12\bind\__TKNAM__.dll</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win32\vc12\libd;$(CSF_OPT_LIB32D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>..\..\..\win32\vc12\bind\__TKNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win32\vc12\libd\__TKNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>x64</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win64\vc12\bin\__TKNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>NDEBUG;WIN64;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <AssemblerListingLocation>.\..\..\..\win64\vc12\obj\__TKNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win64\vc12\obj\__TKNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win64\vc12\obj\__TKNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>NDEBUG;WIN64;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>.\..\..\..\win64\vc12\bin\__TKNAM__.dll</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win64\vc12\lib;$(CSF_OPT_LIB64);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <ProgramDatabaseFile>.\..\..\..\win64\vc12\bin\__TKNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win64\vc12\lib\__TKNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>x64</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win64\vc12\bind\__TKNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN64;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <AssemblerListingLocation>.\..\..\..\win64\vc12\objd\__TKNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win64\vc12\objd\__TKNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win64\vc12\objd\__TKNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <FloatingPointModel>Precise</FloatingPointModel>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN64;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;ws2_32.lib;vfw32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>.\..\..\..\win64\vc12\bind\__TKNAM__.dll</OutputFile>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win64\vc12\libd;$(CSF_OPT_LIB64D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>..\..\..\win64\vc12\bind\__TKNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win64\vc12\libd\__TKNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+__FILES__
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="__TKNAM__.rc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
diff --git a/adm/templates/template.vc12x b/adm/templates/template.vc12x
new file mode 100644 (file)
index 0000000..97bfe27
--- /dev/null
@@ -0,0 +1,245 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>__PROJECT_GUID__</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>__CONF__</ConfigurationType>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>__CONF__</ConfigurationType>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>__CONF__</ConfigurationType>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>__CONF__</ConfigurationType>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\..\..\..\win32\vc12\bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\..\..\..\win32\vc12\obj\__XQTNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\..\..\..\win32\vc12\bind\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\..\..\..\win32\vc12\objd\__XQTNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\..\..\..\win64\vc12\bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\..\..\..\win64\vc12\obj\__XQTNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\..\..\..\win64\vc12\bind\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\..\..\..\win64\vc12\objd\__XQTNAM__\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win32\vc12\bin\__XQTNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <AssemblerListingLocation>.\..\..\..\win32\vc12\obj\__XQTNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win32\vc12\obj\__XQTNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win32\vc12\obj\__XQTNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;%(AdditionalDependencies)</AdditionalDependencies>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win32\vc12\lib;$(CSF_OPT_LIB32);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <ProgramDatabaseFile>.\..\..\..\win32\vc12\bin\__XQTNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win32\vc12\lib\__XQTNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win32\vc12\bind\__XQTNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <AssemblerListingLocation>.\..\..\..\win32\vc12\objd\__XQTNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win32\vc12\objd\__XQTNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win32\vc12\objd\__XQTNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;%(AdditionalDependencies)</AdditionalDependencies>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win32\vc12\libd;$(CSF_OPT_LIB32D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>..\..\..\win32\vc12\bind\__XQTNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win32\vc12\libd\__XQTNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>x64</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win64\vc12\bin\__XQTNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>NDEBUG;WIN64;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <AssemblerListingLocation>.\..\..\..\win64\vc12\obj\__XQTNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win64\vc12\obj\__XQTNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win64\vc12\obj\__XQTNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>NDEBUG;WIN64;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;%(AdditionalDependencies)</AdditionalDependencies>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win64\vc12\lib;$(CSF_OPT_LIB64);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <ProgramDatabaseFile>.\..\..\..\win64\vc12\bin\__XQTNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win64\vc12\lib\__XQTNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>x64</TargetEnvironment>
+      <TypeLibraryName>.\..\..\..\win64\vc12\bind\__XQTNAM__.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>__TKINC__;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>Disabled</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN64;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>Async</ExceptionHandling>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <AssemblerListingLocation>.\..\..\..\win64\vc12\objd\__XQTNAM__/</AssemblerListingLocation>
+      <ObjectFileName>.\..\..\..\win64\vc12\objd\__XQTNAM__/</ObjectFileName>
+      <ProgramDataBaseFileName>.\..\..\..\win64\vc12\objd\__XQTNAM__/</ProgramDataBaseFileName>
+      <WarningLevel>Level4</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+      <DisableSpecificWarnings>4996;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>..\..\..\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>DEB;_DEBUG;WIN64;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>__TKDEP__;%(AdditionalDependencies)</AdditionalDependencies>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\..\..\win64\vc12\libd;$(CSF_OPT_LIB64D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>..\..\..\win64\vc12\bind\__XQTNAM__.pdb</ProgramDatabaseFile>
+      <SubSystem>Console</SubSystem>
+      <ImportLibrary>..\..\..\win64\vc12\libd\__XQTNAM__.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+__FILES__  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
diff --git a/adm/templates/template.vc7 b/adm/templates/template.vc7
new file mode 100644 (file)
index 0000000..0ffd6e3
--- /dev/null
@@ -0,0 +1,160 @@
+<?xml version="1.0" encoding="windows-1251"?>
+<VisualStudioProject
+       ProjectType="Visual C++"
+       Version="7.10"
+       Name="__TKNAM__"
+       SccProjectName=""
+       SccLocalPath="">
+       <Platforms>
+               <Platform
+                       Name="Win32"/>
+       </Platforms>
+       <Configurations>
+               <Configuration
+                       Name="Release|Win32"
+                       OutputDirectory=".\..\..\..\win32\vc7\bin"
+                       IntermediateDirectory=".\..\..\..\win32\vc7\obj\__TKNAM__"
+                       ConfigurationType="2"
+                       UseOfMFC="0"
+                       ATLMinimizesCRunTimeLibraryUsage="FALSE">
+                       <Tool
+                               Name="VCCLCompilerTool"
+                               AdditionalIncludeDirectories="__TKINC__;$(CSF_OPT_INC)"
+                               Optimization="2"
+                               InlineFunctionExpansion="1"
+                               PreprocessorDefinitions="NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               StringPooling="TRUE"
+                               RuntimeLibrary="2"
+                               EnableFunctionLevelLinking="TRUE"
+                               PrecompiledHeaderFile=".\..\..\..\win32\vc7\obj\__TKNAM__\__TKNAM__.pch"
+                               AssemblerListingLocation=".\..\..\..\win32\vc7\obj\__TKNAM__/"
+                               ObjectFile=".\..\..\..\win32\vc7\obj\__TKNAM__/"
+                               ProgramDataBaseFileName=".\..\..\..\win32\vc7\obj\__TKNAM__/"
+                               WarningLevel="4"
+                               SuppressStartupBanner="TRUE"/>
+                       <Tool
+                               Name="VCCustomBuildTool"/>
+                       <Tool
+                               Name="VCLinkerTool"
+                               AdditionalDependencies="__TKDEP__ opengl32.lib glu32.lib ws2_32.lib vfw32.lib odbc32.lib odbccp32.lib"
+                               OutputFile=".\..\..\..\win32\vc7\bin\__TKNAM__.dll"
+                               LinkIncremental="1"
+                               SuppressStartupBanner="TRUE"
+                               AdditionalLibraryDirectories="..\..\..\win32\vc7\lib;$(CSF_OPT_LIB32)"
+                               ProgramDatabaseFile=".\..\..\..\win32\vc7\bin\__TKNAM__.pdb"
+                               SubSystem="2"
+                               ImportLibrary="..\..\..\win32\vc7\lib\__TKNAM__.lib"
+                               TargetMachine="1"/>
+                       <Tool
+                               Name="VCMIDLTool"
+                               PreprocessorDefinitions="NDEBUG"
+                               MkTypLibCompatible="TRUE"
+                               SuppressStartupBanner="TRUE"
+                               TargetEnvironment="1"
+                               TypeLibraryName=".\..\..\..\win32\vc7\bin\__TKNAM__.tlb"
+                               HeaderFileName=""/>
+                       <Tool
+                               Name="VCPostBuildEventTool"/>
+                       <Tool
+                               Name="VCPreBuildEventTool"/>
+                       <Tool
+                               Name="VCPreLinkEventTool"/>
+                       <Tool
+                               Name="VCResourceCompilerTool"
+                               AdditionalIncludeDirectories="..\..\..\inc;$(CSF_OPT_INC)"
+                               PreprocessorDefinitions="NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               Culture="1036"/>
+                       <Tool
+                               Name="VCWebServiceProxyGeneratorTool"/>
+                       <Tool
+                               Name="VCXMLDataGeneratorTool"/>
+                       <Tool
+                               Name="VCWebDeploymentTool"/>
+                       <Tool
+                               Name="VCManagedWrapperGeneratorTool"/>
+                       <Tool
+                               Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+               </Configuration>
+               <Configuration
+                       Name="Debug|Win32"
+                       OutputDirectory=".\..\..\..\win32\vc7\bind"
+                       IntermediateDirectory=".\..\..\..\win32\vc7\objd\__TKNAM__"
+                       ConfigurationType="2"
+                       UseOfMFC="0"
+                       ATLMinimizesCRunTimeLibraryUsage="FALSE"
+                       ManagedExtensions="FALSE"
+                       WholeProgramOptimization="FALSE">
+                       <Tool
+                               Name="VCCLCompilerTool"
+                               AdditionalIncludeDirectories="__TKINC__;$(CSF_OPT_INC)"
+                               Optimization="0"
+                               InlineFunctionExpansion="1"
+                               PreprocessorDefinitions="DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+        BasicRuntimeChecks="3"
+                               RuntimeLibrary="3"
+                               PrecompiledHeaderFile=".\..\..\..\win32\vc7\objd\__TKNAM__\__TKNAM__.pch"
+                               AssemblerListingLocation=".\..\..\..\win32\vc7\objd\__TKNAM__/"
+                               ObjectFile=".\..\..\..\win32\vc7\objd\__TKNAM__/"
+                               ProgramDataBaseFileName=".\..\..\..\win32\vc7\objd\__TKNAM__/"
+                               WarningLevel="4"
+                               SuppressStartupBanner="TRUE"
+                               Detect64BitPortabilityProblems="FALSE"
+                               DebugInformationFormat="3"
+                               CompileAs="0"/>
+                       <Tool
+                               Name="VCCustomBuildTool"/>
+                       <Tool
+                               Name="VCLinkerTool"
+                               AdditionalDependencies="__TKDEP__ opengl32.lib glu32.lib ws2_32.lib vfw32.lib odbc32.lib odbccp32.lib"
+                               OutputFile=".\..\..\..\win32\vc7\bind\__TKNAM__.dll"
+                               LinkIncremental="1"
+                               SuppressStartupBanner="TRUE"
+                               AdditionalLibraryDirectories="..\..\..\win32\vc7\libd;$(CSF_OPT_LIB32D)"
+                               GenerateDebugInformation="TRUE"
+                               ProgramDatabaseFile="..\..\..\win32\vc7\bind\__TKNAM__.pdb"
+                               SubSystem="2"
+                               ImportLibrary="..\..\..\win32\vc7\libd\__TKNAM__.lib"/>
+                       <Tool
+                               Name="VCMIDLTool"
+                               PreprocessorDefinitions="_DEBUG"
+                               MkTypLibCompatible="TRUE"
+                               SuppressStartupBanner="TRUE"
+                               TargetEnvironment="1"
+                               TypeLibraryName=".\..\..\..\win32\vc7\bind\__TKNAM__.tlb"
+                               HeaderFileName=""/>
+                       <Tool
+                               Name="VCPostBuildEventTool"/>
+                       <Tool
+                               Name="VCPreBuildEventTool"/>
+                       <Tool
+                               Name="VCPreLinkEventTool"/>
+                       <Tool
+                               Name="VCResourceCompilerTool"
+                               AdditionalIncludeDirectories="..\..\..\inc;$(CSF_OPT_INC)"
+                               PreprocessorDefinitions="DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               Culture="1036"/>
+                       <Tool
+                               Name="VCWebServiceProxyGeneratorTool"/>
+                       <Tool
+                               Name="VCXMLDataGeneratorTool"/>
+                       <Tool
+                               Name="VCWebDeploymentTool"/>
+                       <Tool
+                               Name="VCManagedWrapperGeneratorTool"/>
+                       <Tool
+                               Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+               </Configuration>
+       </Configurations>
+       <References>
+       </References>
+       <Files>
+               <Filter
+                       Name="Source files"
+                       Filter="">
+__FILES__
+                       <File RelativePath="__TKNAM__.rc"></File>
+               </Filter>
+       </Files>
+       <Globals>
+       </Globals>
+</VisualStudioProject>
diff --git a/adm/templates/template.vc7x b/adm/templates/template.vc7x
new file mode 100644 (file)
index 0000000..821035a
--- /dev/null
@@ -0,0 +1,152 @@
+<?xml version="1.0" encoding="windows-1251"?>
+<VisualStudioProject
+       ProjectType="Visual C++"
+       Version="7.10"
+       Name="__XQTNAM__"
+       ProjectGUID="{193A5B07-7F8B-4280-9F4E-32D5F326DFC5}"
+       SccProjectName=""
+       SccLocalPath="">
+       <Platforms>
+               <Platform
+                       Name="Win32"/>
+       </Platforms>
+       <Configurations>
+               <Configuration
+                       Name="Debug|Win32"
+                       OutputDirectory=".\..\..\..\win32\vc7\bind"
+                       IntermediateDirectory=".\..\..\..\win32\vc7\objd\__XQTNAM__"
+                       ConfigurationType="__CONF__"
+                       UseOfMFC="0"
+                       ATLMinimizesCRunTimeLibraryUsage="FALSE">
+                       <Tool
+                               Name="VCCLCompilerTool"
+                               AdditionalIncludeDirectories="__TKINC__;$(CSF_OPT_INC)"
+                               Optimization="0"
+                               PreprocessorDefinitions="WIN32;DEB;_DEBUG;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               BasicRuntimeChecks="3"
+                               RuntimeLibrary="3"
+                               AssemblerListingLocation=".\..\..\..\win32\vc7\objd\__XQTNAM__/"
+                               ObjectFile=".\..\..\..\win32\vc7\objd\__XQTNAM__/"
+                               ProgramDataBaseFileName=".\..\..\..\win32\vc7\objd\__XQTNAM__/"
+                               WarningLevel="4"
+                               SuppressStartupBanner="TRUE"
+                               DebugInformationFormat="3"/>
+                       <Tool
+                               Name="VCCustomBuildTool"/>
+                       <Tool
+                               Name="VCLinkerTool"
+                               AdditionalDependencies="__TKDEP__"
+                               LinkIncremental="1"
+                               SuppressStartupBanner="TRUE"
+                               AdditionalLibraryDirectories="..\..\..\win32\vc7\libd;$(CSF_OPT_LIB32D)"
+                               GenerateDebugInformation="TRUE"
+                               ProgramDatabaseFile=".\..\..\..\win32\vc7\bind\__XQTNAM__.pdb"
+                               SubSystem="1"
+                               ImportLibrary="..\..\..\win32\vc7\libd\__XQTNAM__.lib"
+                               TargetMachine="1"/>
+                       <Tool
+                               Name="VCMIDLTool"
+                               PreprocessorDefinitions="_DEBUG"
+                               MkTypLibCompatible="TRUE"
+                               SuppressStartupBanner="TRUE"
+                               TargetEnvironment="1"
+                               TypeLibraryName=".\..\..\..\win32\vc7\bind\__XQTNAM__.tlb"
+                               HeaderFileName=""/>
+                       <Tool
+                               Name="VCPostBuildEventTool"/>
+                       <Tool
+                               Name="VCPreBuildEventTool"/>
+                       <Tool
+                               Name="VCPreLinkEventTool"/>
+                       <Tool
+                               Name="VCResourceCompilerTool"
+                               AdditionalIncludeDirectories="..\..\..\inc;$(CSF_OPT_INC)"
+                               PreprocessorDefinitions="WIN32;DEB;_DEBUG;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               Culture="1033"/>
+                       <Tool
+                               Name="VCWebServiceProxyGeneratorTool"/>
+                       <Tool
+                               Name="VCXMLDataGeneratorTool"/>
+                       <Tool
+                               Name="VCWebDeploymentTool"/>
+                       <Tool
+                               Name="VCManagedWrapperGeneratorTool"/>
+                       <Tool
+                               Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+               </Configuration>
+               <Configuration
+                       Name="Release|Win32"
+                       OutputDirectory=".\..\..\..\win32\vc7\bin"
+                       IntermediateDirectory=".\..\..\..\win32\vc7\obj\__XQTNAM__"
+                       ConfigurationType="__CONF__"
+                       UseOfMFC="0"
+                       ATLMinimizesCRunTimeLibraryUsage="FALSE">
+                       <Tool
+                               Name="VCCLCompilerTool"
+                               AdditionalIncludeDirectories="__TKINC__;$(CSF_OPT_INC)"
+                               Optimization="2"
+                               InlineFunctionExpansion="1"
+                               PreprocessorDefinitions="WIN32;NDEBUG;No_Exception;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               StringPooling="TRUE"
+                               RuntimeLibrary="2"
+                               EnableFunctionLevelLinking="TRUE"
+                               AssemblerListingLocation=".\..\..\..\win32\vc7\obj\__XQTNAM__/"
+                               ObjectFile=".\..\..\..\win32\vc7\obj\__XQTNAM__/"
+                               ProgramDataBaseFileName=".\..\..\..\win32\vc7\obj\__XQTNAM__/"
+                               WarningLevel="4"
+                               SuppressStartupBanner="TRUE"/>
+                       <Tool
+                               Name="VCCustomBuildTool"/>
+                       <Tool
+                               Name="VCLinkerTool"
+                               AdditionalDependencies="__TKDEP__"
+                               LinkIncremental="1"
+                               SuppressStartupBanner="TRUE"
+                               AdditionalLibraryDirectories="..\..\..\win32\vc7\lib;$(CSF_OPT_LIB32)"
+                               ProgramDatabaseFile=".\..\..\..\win32\vc7\bin\__XQTNAM__.pdb"
+                               SubSystem="1"
+                               ImportLibrary="..\..\..\win32\vc7\lib\__XQTNAM__.lib"
+                               TargetMachine="1"/>
+                       <Tool
+                               Name="VCMIDLTool"
+                               PreprocessorDefinitions="NDEBUG"
+                               MkTypLibCompatible="TRUE"
+                               SuppressStartupBanner="TRUE"
+                               TargetEnvironment="1"
+                               TypeLibraryName=".\..\..\..\win32\vc7\bin\__XQTNAM__.tlb"
+                               HeaderFileName=""/>
+                       <Tool
+                               Name="VCPostBuildEventTool"/>
+                       <Tool
+                               Name="VCPreBuildEventTool"/>
+                       <Tool
+                               Name="VCPreLinkEventTool"/>
+                       <Tool
+                               Name="VCResourceCompilerTool"
+                               AdditionalIncludeDirectories="..\..\..\inc;$(CSF_OPT_INC)"
+                               PreprocessorDefinitions="WIN32;NDEBUG;No_Exception;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               Culture="1033"/>
+                       <Tool
+                               Name="VCWebServiceProxyGeneratorTool"/>
+                       <Tool
+                               Name="VCXMLDataGeneratorTool"/>
+                       <Tool
+                               Name="VCWebDeploymentTool"/>
+                       <Tool
+                               Name="VCManagedWrapperGeneratorTool"/>
+                       <Tool
+                               Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+               </Configuration>
+       </Configurations>
+       <References>
+       </References>
+       <Files>
+               <Filter
+                       Name="Source Files"
+                       Filter="">
+__FILES__
+               </Filter>
+       </Files>
+       <Globals>
+       </Globals>
+</VisualStudioProject>
diff --git a/adm/templates/template.vc8 b/adm/templates/template.vc8
new file mode 100644 (file)
index 0000000..ca5bd7f
--- /dev/null
@@ -0,0 +1,432 @@
+<?xml version="1.0" encoding="windows-1251"?>
+<VisualStudioProject
+       ProjectType="Visual C++"
+       Version="8.00"
+       Name="__TKNAM__"
+       ProjectGUID="__PROJECT_GUID__"
+       >
+       <Platforms>
+               <Platform
+                       Name="Win32"
+               />
+               <Platform
+                       Name="x64"
+               />
+       </Platforms>
+       <ToolFiles>
+       </ToolFiles>
+       <Configurations>
+               <Configuration
+                       Name="Release|Win32"
+                       OutputDirectory=".\..\..\..\win32\vc8\bin"
+                       IntermediateDirectory=".\..\..\..\win32\vc8\obj\__TKNAM__"
+                       ConfigurationType="2"
+                       UseOfMFC="0"
+                       ATLMinimizesCRunTimeLibraryUsage="false"
+                       >
+                       <Tool
+                               Name="VCPreBuildEventTool"
+                       />
+                       <Tool
+                               Name="VCCustomBuildTool"
+                       />
+                       <Tool
+                               Name="VCXMLDataGeneratorTool"
+                       />
+                       <Tool
+                               Name="VCWebServiceProxyGeneratorTool"
+                       />
+                       <Tool
+                               Name="VCMIDLTool"
+                               PreprocessorDefinitions="NDEBUG"
+                               MkTypLibCompatible="true"
+                               SuppressStartupBanner="true"
+                               TargetEnvironment="1"
+                               TypeLibraryName=".\..\..\..\win32\vc8\bin\__TKNAM__.tlb"
+                               HeaderFileName=""
+                       />
+                       <Tool
+                               Name="VCCLCompilerTool"
+                               AdditionalIncludeDirectories="__TKINC__;$(CSF_OPT_INC)"
+                               Optimization="2"
+                               InlineFunctionExpansion="1"
+                               PreprocessorDefinitions="NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               StringPooling="true"
+                               ExceptionHandling="2"
+                               RuntimeLibrary="2"
+                               EnableFunctionLevelLinking="true"
+                               FloatingPointModel="0"
+                               PrecompiledHeaderFile=".\..\..\..\win32\vc8\obj\__TKNAM__\__TKNAM__.pch"
+                               AssemblerListingLocation=".\..\..\..\win32\vc8\obj\__TKNAM__/"
+                               ObjectFile=".\..\..\..\win32\vc8\obj\__TKNAM__/"
+                               ProgramDataBaseFileName=".\..\..\..\win32\vc8\obj\__TKNAM__/"
+                               WarningLevel="4"
+                               SuppressStartupBanner="true"
+                               DisableSpecificWarnings="4996"
+                               EnableEnhancedInstructionSet="2"
+                       />
+                       <Tool
+                               Name="VCManagedResourceCompilerTool"
+                       />
+                       <Tool
+                               Name="VCResourceCompilerTool"
+                               AdditionalIncludeDirectories="..\..\..\inc;$(CSF_OPT_INC)"
+                               PreprocessorDefinitions="NDEBUG;WIN32;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               Culture="1036"
+                       />
+                       <Tool
+                               Name="VCPreLinkEventTool"
+                       />
+                       <Tool
+                               Name="VCLinkerTool"
+                               AdditionalDependencies="__TKDEP__ opengl32.lib glu32.lib ws2_32.lib vfw32.lib odbc32.lib odbccp32.lib"
+                               OutputFile=".\..\..\..\win32\vc8\bin\__TKNAM__.dll"
+                               LinkIncremental="1"
+                               SuppressStartupBanner="true"
+                               AdditionalLibraryDirectories="..\..\..\win32\vc8\lib;$(CSF_OPT_LIB32)"
+                               ProgramDatabaseFile=".\..\..\..\win32\vc8\bin\__TKNAM__.pdb"
+                               SubSystem="2"
+                               ImportLibrary="..\..\..\win32\vc8\lib\__TKNAM__.lib"
+                               TargetMachine="1"
+                       />
+                       <Tool
+                               Name="VCALinkTool"
+                       />
+                       <Tool
+                               Name="VCManifestTool"
+                       />
+                       <Tool
+                               Name="VCXDCMakeTool"
+                       />
+                       <Tool
+                               Name="VCBscMakeTool"
+                       />
+                       <Tool
+                               Name="VCFxCopTool"
+                       />
+                       <Tool
+                               Name="VCAppVerifierTool"
+                       />
+                       <Tool
+                               Name="VCWebDeploymentTool"
+                       />
+                       <Tool
+                               Name="VCPostBuildEventTool"
+                       />
+               </Configuration>
+               <Configuration
+                       Name="Debug|Win32"
+                       OutputDirectory=".\..\..\..\win32\vc8\bind"
+                       IntermediateDirectory=".\..\..\..\win32\vc8\objd\__TKNAM__"
+                       ConfigurationType="2"
+                       UseOfMFC="0"
+                       ATLMinimizesCRunTimeLibraryUsage="false"
+                       ManagedExtensions="0"
+                       >
+                       <Tool
+                               Name="VCPreBuildEventTool"
+                       />
+                       <Tool
+                               Name="VCCustomBuildTool"
+                       />
+                       <Tool
+                               Name="VCXMLDataGeneratorTool"
+                       />
+                       <Tool
+                               Name="VCWebServiceProxyGeneratorTool"
+                       />
+                       <Tool
+                               Name="VCMIDLTool"
+                               PreprocessorDefinitions="_DEBUG"
+                               MkTypLibCompatible="true"
+                               SuppressStartupBanner="true"
+                               TargetEnvironment="1"
+                               TypeLibraryName=".\..\..\..\win32\vc8\bind\__TKNAM__.tlb"
+                               HeaderFileName=""
+                       />
+                       <Tool
+                               Name="VCCLCompilerTool"
+                               AdditionalIncludeDirectories="__TKINC__;$(CSF_OPT_INC)"
+                               Optimization="0"
+                               InlineFunctionExpansion="1"
+                               PreprocessorDefinitions="DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               ExceptionHandling="2"
+                               BasicRuntimeChecks="3"
+                               RuntimeLibrary="3"
+                               FloatingPointModel="0"
+                               PrecompiledHeaderFile=".\..\..\..\win32\vc8\objd\__TKNAM__\__TKNAM__.pch"
+                               AssemblerListingLocation=".\..\..\..\win32\vc8\objd\__TKNAM__/"
+                               ObjectFile=".\..\..\..\win32\vc8\objd\__TKNAM__/"
+                               ProgramDataBaseFileName=".\..\..\..\win32\vc8\objd\__TKNAM__/"
+                               WarningLevel="4"
+                               SuppressStartupBanner="true"
+                               Detect64BitPortabilityProblems="false"
+                               DebugInformationFormat="3"
+                               CompileAs="0"
+                               DisableSpecificWarnings="4996"
+                               EnableEnhancedInstructionSet="2"
+                       />
+                       <Tool
+                               Name="VCManagedResourceCompilerTool"
+                       />
+                       <Tool
+                               Name="VCResourceCompilerTool"
+                               AdditionalIncludeDirectories="..\..\..\inc;$(CSF_OPT_INC)"
+                               PreprocessorDefinitions="DEB;_DEBUG;WIN32;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               Culture="1036"
+                       />
+                       <Tool
+                               Name="VCPreLinkEventTool"
+                       />
+                       <Tool
+                               Name="VCLinkerTool"
+                               AdditionalDependencies="__TKDEP__ opengl32.lib glu32.lib ws2_32.lib vfw32.lib odbc32.lib odbccp32.lib"
+                               OutputFile=".\..\..\..\win32\vc8\bind\__TKNAM__.dll"
+                               LinkIncremental="1"
+                               SuppressStartupBanner="true"
+                               AdditionalLibraryDirectories="..\..\..\win32\vc8\libd;$(CSF_OPT_LIB32D)"
+                               GenerateDebugInformation="true"
+                               ProgramDatabaseFile="..\..\..\win32\vc8\bind\__TKNAM__.pdb"
+                               SubSystem="2"
+                               ImportLibrary="..\..\..\win32\vc8\libd\__TKNAM__.lib"
+                               TargetMachine="1"
+                       />
+                       <Tool
+                               Name="VCALinkTool"
+                       />
+                       <Tool
+                               Name="VCManifestTool"
+                       />
+                       <Tool
+                               Name="VCXDCMakeTool"
+                       />
+                       <Tool
+                               Name="VCBscMakeTool"
+                       />
+                       <Tool
+                               Name="VCFxCopTool"
+                       />
+                       <Tool
+                               Name="VCAppVerifierTool"
+                       />
+                       <Tool
+                               Name="VCWebDeploymentTool"
+                       />
+                       <Tool
+                               Name="VCPostBuildEventTool"
+                       />
+               </Configuration>
+               <Configuration
+                       Name="Release|x64"
+                       OutputDirectory=".\..\..\..\win64\vc8\bin"
+                       IntermediateDirectory=".\..\..\..\win64\vc8\obj\__TKNAM__"
+                       ConfigurationType="2"
+                       UseOfMFC="0"
+                       ATLMinimizesCRunTimeLibraryUsage="false"
+                       >
+                       <Tool
+                               Name="VCPreBuildEventTool"
+                       />
+                       <Tool
+                               Name="VCCustomBuildTool"
+                       />
+                       <Tool
+                               Name="VCXMLDataGeneratorTool"
+                       />
+                       <Tool
+                               Name="VCWebServiceProxyGeneratorTool"
+                       />
+                       <Tool
+                               Name="VCMIDLTool"
+                               PreprocessorDefinitions="NDEBUG"
+                               MkTypLibCompatible="true"
+                               SuppressStartupBanner="true"
+                               TargetEnvironment="1"
+                               TypeLibraryName=".\..\..\..\win64\vc8\bin\__TKNAM__.tlb"
+                               HeaderFileName=""
+                       />
+                       <Tool
+                               Name="VCCLCompilerTool"
+                               AdditionalOptions="/favor:blend"
+                               AdditionalIncludeDirectories="__TKINC__;$(CSF_OPT_INC)"
+                               Optimization="2"
+                               InlineFunctionExpansion="1"
+                               PreprocessorDefinitions="NDEBUG;WIN64;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               StringPooling="true"
+                               ExceptionHandling="2"
+                               RuntimeLibrary="2"
+                               EnableFunctionLevelLinking="true"
+                               FloatingPointModel="0"
+                               PrecompiledHeaderFile=".\..\..\..\win64\vc8\obj\__TKNAM__\__TKNAM__.pch"
+                               AssemblerListingLocation=".\..\..\..\win64\vc8\obj\__TKNAM__/"
+                               ObjectFile=".\..\..\..\win64\vc8\obj\__TKNAM__/"
+                               ProgramDataBaseFileName=".\..\..\..\win64\vc8\obj\__TKNAM__/"
+                               WarningLevel="4"
+                               SuppressStartupBanner="true"
+                               DisableSpecificWarnings="4996"
+                       />
+                       <Tool
+                               Name="VCManagedResourceCompilerTool"
+                       />
+                       <Tool
+                               Name="VCResourceCompilerTool"
+                               AdditionalIncludeDirectories="..\..\..\inc;$(CSF_OPT_INC)"
+                               PreprocessorDefinitions="NDEBUG;WIN64;_WINDOWS;WNT;No_Exception;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               Culture="1036"
+                       />
+                       <Tool
+                               Name="VCPreLinkEventTool"
+                       />
+                       <Tool
+                               Name="VCLinkerTool"
+                               AdditionalDependencies="__TKDEP__ opengl32.lib glu32.lib ws2_32.lib vfw32.lib odbc32.lib odbccp32.lib"
+                               OutputFile=".\..\..\..\win64\vc8\bin\__TKNAM__.dll"
+                               LinkIncremental="1"
+                               SuppressStartupBanner="true"
+                               AdditionalLibraryDirectories="..\..\..\win64\vc8\lib;$(CSF_OPT_LIB64)"
+                               ProgramDatabaseFile=".\..\..\..\win64\vc8\bin\__TKNAM__.pdb"
+                               SubSystem="2"
+                               ImportLibrary="..\..\..\win64\vc8\lib\__TKNAM__.lib"
+                               TargetMachine="17"
+                       />
+                       <Tool
+                               Name="VCALinkTool"
+                       />
+                       <Tool
+                               Name="VCManifestTool"
+                       />
+                       <Tool
+                               Name="VCXDCMakeTool"
+                       />
+                       <Tool
+                               Name="VCBscMakeTool"
+                       />
+                       <Tool
+                               Name="VCFxCopTool"
+                       />
+                       <Tool
+                               Name="VCAppVerifierTool"
+                       />
+                       <Tool
+                               Name="VCWebDeploymentTool"
+                       />
+                       <Tool
+                               Name="VCPostBuildEventTool"
+                       />
+               </Configuration>
+               <Configuration
+                       Name="Debug|x64"
+                       OutputDirectory=".\..\..\..\win64\vc8\bind"
+                       IntermediateDirectory=".\..\..\..\win64\vc8\objd\__TKNAM__"
+                       ConfigurationType="2"
+                       UseOfMFC="0"
+                       ATLMinimizesCRunTimeLibraryUsage="false"
+                       ManagedExtensions="0"
+                       >
+                       <Tool
+                               Name="VCPreBuildEventTool"
+                       />
+                       <Tool
+                               Name="VCCustomBuildTool"
+                       />
+                       <Tool
+                               Name="VCXMLDataGeneratorTool"
+                       />
+                       <Tool
+                               Name="VCWebServiceProxyGeneratorTool"
+                       />
+                       <Tool
+                               Name="VCMIDLTool"
+                               PreprocessorDefinitions="_DEBUG"
+                               MkTypLibCompatible="true"
+                               SuppressStartupBanner="true"
+                               TargetEnvironment="1"
+                               TypeLibraryName=".\..\..\..\win64\vc8\bind\__TKNAM__.tlb"
+                               HeaderFileName=""
+                       />
+                       <Tool
+                               Name="VCCLCompilerTool"
+                               AdditionalOptions="/favor:blend"
+                               AdditionalIncludeDirectories="__TKINC__;$(CSF_OPT_INC)"
+                               Optimization="0"
+                               InlineFunctionExpansion="1"
+                               PreprocessorDefinitions="DEB;_DEBUG;WIN64;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               ExceptionHandling="2"
+                               BasicRuntimeChecks="3"
+                               RuntimeLibrary="3"
+                               FloatingPointModel="0"
+                               PrecompiledHeaderFile=".\..\..\..\win64\vc8\objd\__TKNAM__\__TKNAM__.pch"
+                               AssemblerListingLocation=".\..\..\..\win64\vc8\objd\__TKNAM__/"
+                               ObjectFile=".\..\..\..\win64\vc8\objd\__TKNAM__/"
+                               ProgramDataBaseFileName=".\..\..\..\win64\vc8\objd\__TKNAM__/"
+                               WarningLevel="4"
+                               SuppressStartupBanner="true"
+                               Detect64BitPortabilityProblems="false"
+                               DebugInformationFormat="3"
+                               CompileAs="0"
+                               DisableSpecificWarnings="4996"
+                       />
+                       <Tool
+                               Name="VCManagedResourceCompilerTool"
+                       />
+                       <Tool
+                               Name="VCResourceCompilerTool"
+                               AdditionalIncludeDirectories="..\..\..\inc;$(CSF_OPT_INC)"
+                               PreprocessorDefinitions="DEB;_DEBUG;WIN64;_WINDOWS;WNT;CSFDB;$(CSF_DEFINES)__TKDEFS__"
+                               Culture="1036"
+                       />
+                       <Tool
+