初始化内容

third/OpenMesh/cmake-library/VCI/MSVCMacros.cmake

@@ -0,0 +1,20 @@
+
+if(MSVC_MACROS_INCLUDED)
+  return()
+endif(MSVC_MACROS_INCLUDED)
+set(MSVC_MACROS_INCLUDED TRUE)
+
+set (MSVC_GROUPING ON CACHE BOOL "Group Files by folder structure on MSVC.")
+
+# Enable project folders to group targets in solution folders on MSVC.
+if(${MSVC_GROUPING})
+set_property(GLOBAL PROPERTY USE_FOLDERS ON) 
+endif(${MSVC_GROUPING})
+
+MACRO (GROUP_PROJECT targetname groupname)
+if(${MSVC_GROUPING})
+set_target_properties(${targetname} 
+   PROPERTIES 
+   FOLDER "${groupname}")
+endif(${MSVC_GROUPING})
+ENDMACRO (GROUP_PROJECT)

third/OpenMesh/cmake-library/VCI/VCICommon.cmake

@@ -0,0 +1,337 @@
+include (MSVCMacros)
+include (VCIPaths)
+
+if (EXISTS ${CMAKE_SOURCE_DIR}/${CMAKE_PROJECT_NAME}.cmake)
+  include (${CMAKE_SOURCE_DIR}/${CMAKE_PROJECT_NAME}.cmake)
+endif ()
+
+# prevent build in source directory
+
+# add option to disable in-source build
+option (
+  BLOCK_IN_SOURCE_BUILD
+  "Disable building inside the source tree"
+  ON
+)
+
+if ( BLOCK_IN_SOURCE_BUILD )
+  if ("${CMAKE_BINARY_DIR}" STREQUAL "${CMAKE_SOURCE_DIR}")
+      message (SEND_ERROR "Building in the source directory is not supported.")
+      message (FATAL_ERROR "Please remove the created \"CMakeCache.txt\" file, the \"CMakeFiles\" directory and create a build directory and call \"${CMAKE_COMMAND} <path to the sources>\".")
+  endif ("${CMAKE_BINARY_DIR}" STREQUAL "${CMAKE_SOURCE_DIR}")
+endif()
+
+# allow only Debug, Release and RelWithDebInfo builds
+set (CMAKE_CONFIGURATION_TYPES "Debug;Release;RelWithDebInfo" CACHE STRING "")
+mark_as_advanced (CMAKE_CONFIGURATION_TYPES)
+
+# set Debus as default build target
+if (NOT CMAKE_BUILD_TYPE)
+  set (CMAKE_BUILD_TYPE Debug CACHE STRING
+      "Choose the type of build, options are: Debug, Release."
+      FORCE)
+endif ()
+
+# create our output directroy
+if (NOT EXISTS ${CMAKE_BINARY_DIR}/Build)
+  file (MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/Build)
+endif ()
+
+# set directory structures for the different platforms
+if (CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
+  set (VCI_PROJECT_DATADIR ".")
+  set (VCI_PROJECT_LIBDIR "lib")
+  set (VCI_PROJECT_BINDIR ".")
+  set (VCI_PROJECT_PLUGINDIR "Plugins")
+  if (NOT EXISTS ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_LIBDIR})
+    file (MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_LIBDIR})
+  endif ()
+elseif (APPLE)
+  set (VCI_PROJECT_DATADIR "share/${CMAKE_PROJECT_NAME}")
+  set (VCI_PROJECT_LIBDIR "lib${LIB_SUFFIX}")
+  set (CMAKE_LIBRARY_OUTPUT_DIR "${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_LIBDIR}")
+  set (VCI_PROJECT_PLUGINDIR "${VCI_PROJECT_LIBDIR}/plugins")
+  set (VCI_PROJECT_BINDIR "bin")
+else ()
+  set (VCI_PROJECT_DATADIR "share/${CMAKE_PROJECT_NAME}")
+  set (VCI_PROJECT_LIBDIR "lib${LIB_SUFFIX}")
+  set (VCI_PROJECT_PLUGINDIR "${VCI_PROJECT_LIBDIR}/plugins")
+  set (VCI_PROJECT_BINDIR "bin")
+endif ()
+
+# allow a project to modify the directories
+if (COMMAND vci_modify_project_dirs)
+  vci_modify_project_dirs ()
+endif ()
+
+if (NOT EXISTS ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_DATADIR})
+ file (MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_DATADIR})
+endif ()
+
+
+# sets default build properties
+macro (vci_set_target_props target)
+  if (WIN32)
+    set_target_properties (
+      ${target} PROPERTIES
+      BUILD_WITH_INSTALL_RPATH 1
+      SKIP_BUILD_RPATH 0
+    )
+  elseif (APPLE AND NOT VCI_PROJECT_MACOS_BUNDLE)
+    # save rpath
+    set_target_properties (
+      ${target} PROPERTIES
+      INSTALL_RPATH "@executable_path/../${VCI_PROJECT_LIBDIR}"
+      MACOSX_RPATH 1
+      #BUILD_WITH_INSTALL_RPATH 1
+      SKIP_BUILD_RPATH 0
+    )  
+  elseif (NOT APPLE)
+
+    set_target_properties (
+      ${target} PROPERTIES
+      INSTALL_RPATH "$ORIGIN/../${VCI_PROJECT_LIBDIR}"
+      BUILD_WITH_INSTALL_RPATH 1
+      SKIP_BUILD_RPATH 0
+      RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_BINDIR}"
+      LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_LIBDIR}"
+    )
+  endif ()
+endmacro ()
+
+include (AddFileDependencies)
+include (VCICompiler)
+
+# define INCLUDE_TEMPLATES for everything we build
+add_definitions (-DINCLUDE_TEMPLATES)
+
+# unsets the given variable
+macro (vci_unset var)
+    set (${var} "" CACHE INTERNAL "")
+endmacro ()
+
+# sets the given variable
+macro (vci_set var value)
+    set (${var} ${value} CACHE INTERNAL "")
+endmacro ()
+
+# test for OpenMP
+macro (vci_openmp)
+  if (NOT OPENMP_FOUND)
+     find_package(OpenMP)
+     if (OPENMP_FOUND)
+       set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+       set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
+       add_definitions(-DUSE_OPENMP)
+
+       # export includes and libraries for usage within openflipper plugins
+       set(OPENMP_INCLUDE_DIRS ${OpenMP_CXX_INCLUDE_DIR})
+       set(OPENMP_LIBRARIES ${OpenMP_libomp_LIBRARY})        
+    endif()
+  endif()
+endmacro ()
+
+
+# append all files with extension "ext" in the "dirs" directories to "ret"
+# excludes all files starting with a '.' (dot)
+macro (vci_append_files ret ext)
+  foreach (_dir ${ARGN})
+    file (GLOB _files "${_dir}/${ext}")
+    foreach (_file ${_files})
+      get_filename_component (_filename ${_file} NAME)
+      if (_filename MATCHES "^[.]")
+	list (REMOVE_ITEM _files ${_file})
+      endif ()
+    endforeach ()
+    list (APPEND ${ret} ${_files})
+  endforeach ()
+endmacro ()
+
+# append all files with extension "ext" in the "dirs" directories and its subdirectories to "ret"
+# excludes all files starting with a '.' (dot)
+macro (vci_append_files_recursive ret ext)
+  foreach (_dir ${ARGN})
+    file (GLOB_RECURSE _files "${_dir}/${ext}")
+    foreach (_file ${_files})
+      get_filename_component (_filename ${_file} NAME)
+      if (_filename MATCHES "^[.]")
+  list (REMOVE_ITEM _files ${_file})
+      endif ()
+    endforeach ()
+    list (APPEND ${ret} ${_files})
+  endforeach ()
+endmacro ()
+
+# get all files in directory, but ignore svn
+macro (vci_get_files_in_dir ret dir)
+  file (GLOB_RECURSE __files RELATIVE "${dir}" "${dir}/*")
+  foreach (_file ${__files})
+    if ( (NOT _file MATCHES ".*svn.*") AND (NOT _file MATCHES ".DS_Store") )
+      list (APPEND ${ret} "${_file}")
+    endif ()
+  endforeach ()
+endmacro ()
+
+# drop all "*T.cc" files from list
+macro (vci_drop_templates list)
+  foreach (_file ${${list}})
+    if (_file MATCHES "T.cc$")
+      set_source_files_properties(${_file} PROPERTIES HEADER_FILE_ONLY TRUE)
+      message("Deprecated naming scheme! The file ${_file} ends with T.cc indicating it is a template only implementation file. Please rename to T_impl.hh to avoid problems with several IDEs.")
+    endif ()
+  endforeach ()
+endmacro ()
+
+# copy the whole directory without svn files
+function (vci_copy_after_build target src dst)
+  vci_unset (_files)
+  vci_get_files_in_dir (_files ${src})
+  foreach (_file ${_files})
+    add_custom_command(TARGET ${target} POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -E copy_if_different "${src}/${_file}" "${dst}/${_file}"
+    )
+  endforeach ()
+endfunction ()
+
+# install the whole directory without svn files
+function (vci_install_dir src dst)
+  vci_unset (_files)
+  vci_get_files_in_dir (_files ${src})
+  foreach (_file ${_files})
+    get_filename_component (_file_PATH ${_file} PATH)
+    install(FILES "${src}/${_file}"
+      DESTINATION "${dst}/${_file_PATH}"
+    )
+  endforeach ()
+endfunction ()
+
+# extended version of add_executable that also copies output to out Build directory
+function (vci_add_executable _target)
+  add_executable (${_target} ${ARGN})
+
+  # set common target properties defined in common.cmake
+  vci_set_target_props (${_target})
+
+  if (NOT VCI_COMMON_DO_NOT_COPY_POST_BUILD)
+    if (WIN32 OR (APPLE AND NOT VCI_PROJECT_MACOS_BUNDLE))
+      add_custom_command (TARGET ${_target} POST_BUILD
+                          COMMAND ${CMAKE_COMMAND} -E
+                          copy_if_different
+                            $<TARGET_FILE:${_target}>
+                            ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_BINDIR}/$<TARGET_FILE_NAME:${_target}>)
+    endif (WIN32 OR (APPLE AND NOT VCI_PROJECT_MACOS_BUNDLE))
+  endif()
+  
+  if (NOT VCI_PROJECT_MACOS_BUNDLE OR NOT APPLE)
+    install (TARGETS ${_target} DESTINATION ${VCI_PROJECT_BINDIR})
+  endif ()
+endfunction ()
+
+# extended version of add_library that also copies output to out Build directory
+function (vci_add_library _target _libtype)
+
+  if (${_libtype} STREQUAL SHAREDANDSTATIC)
+    set (_type SHARED)
+    if (NOT WIN32 OR MINGW)
+      set (_and_static 1)
+    else ()
+      set (_and_static 0)
+    endif ()    
+  else ()
+    set (_type ${_libtype})
+    set (_and_static 0)
+  endif ()
+
+  add_library (${_target} ${_type} ${ARGN} )
+
+  # set common target properties defined in common.cmake
+  vci_set_target_props (${_target})
+
+  if (_and_static)
+    add_library (${_target}Static STATIC ${ARGN})
+
+    # set common target properties defined in common.cmake
+    vci_set_target_props (${_target}Static)
+
+    set_target_properties(${_target}Static PROPERTIES OUTPUT_NAME ${_target})
+    
+    if (NOT APPLE)
+      set_target_properties (${_target}Static PROPERTIES 
+                             LIBRARY_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
+                            )
+    endif ()
+  endif ()
+
+  if (NOT VCI_COMMON_DO_NOT_COPY_POST_BUILD)
+    if ( (WIN32 AND MSVC) OR (APPLE AND NOT VCI_PROJECT_MACOS_BUNDLE))
+      if (${_type} STREQUAL SHARED)
+        add_custom_command (TARGET ${_target} POST_BUILD
+                            COMMAND ${CMAKE_COMMAND} -E
+                            copy_if_different
+                              $<TARGET_FILE:${_target}>
+                              ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_LIBDIR}/$<TARGET_FILE_NAME:${_target}>)
+      add_custom_command (TARGET ${_target} POST_BUILD
+                            COMMAND ${CMAKE_COMMAND} -E
+                            copy_if_different
+                              $<TARGET_LINKER_FILE:${_target}>
+                              ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_LIBDIR}/$<TARGET_LINKER_FILE_NAME:${_target}>)
+      elseif (${_type} STREQUAL MODULE)
+        if (NOT EXISTS ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_PLUGINDIR})
+          file (MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_PLUGINDIR})
+        endif ()
+        add_custom_command (TARGET ${_target} POST_BUILD
+                            COMMAND ${CMAKE_COMMAND} -E
+                            copy_if_different
+                              $<TARGET_FILE:${_target}>
+                              ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_PLUGINDIR}/$<TARGET_FILE_NAME:${_target}>)
+      elseif (${_type} STREQUAL STATIC)
+      add_custom_command (TARGET ${_target} POST_BUILD
+                            COMMAND ${CMAKE_COMMAND} -E
+                            copy_if_different
+                              $<TARGET_FILE:${_target}>
+                              ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_LIBDIR}/$<TARGET_FILE_NAME:${_target}>)
+    endif()
+
+
+    # make an extra copy for windows into the binary directory
+      if (${_type} STREQUAL SHARED AND WIN32)
+        add_custom_command (TARGET ${_target} POST_BUILD
+                            COMMAND ${CMAKE_COMMAND} -E
+                            copy_if_different
+                              $<TARGET_FILE:${_target}>
+                              ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_BINDIR}/$<TARGET_FILE_NAME:${_target}>)
+    endif ()
+
+    endif( (WIN32 AND MSVC) OR (APPLE AND NOT VCI_PROJECT_MACOS_BUNDLE))
+
+    if (_and_static)
+      add_custom_command (TARGET ${_target}Static POST_BUILD
+                          COMMAND ${CMAKE_COMMAND} -E
+                          copy_if_different
+                            $<TARGET_FILE:${_target}Static>
+                            ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_LIBDIR}/$<TARGET_FILE_NAME:${_target}Static>)
+
+    endif ()
+  endif ()
+ 
+
+  # Block installation of libraries by setting VCI_NO_LIBRARY_INSTALL
+  if ( NOT VCI_NO_LIBRARY_INSTALL )
+    if (NOT VCI_PROJECT_MACOS_BUNDLE OR NOT APPLE)
+      if (${_type} STREQUAL SHARED OR ${_type} STREQUAL STATIC )
+        install (TARGETS ${_target}
+                 RUNTIME DESTINATION ${VCI_PROJECT_BINDIR}
+                 LIBRARY DESTINATION ${VCI_PROJECT_LIBDIR}
+                 ARCHIVE DESTINATION ${VCI_PROJECT_LIBDIR})
+        if (_and_static)
+          install (TARGETS ${_target}Static
+                   DESTINATION ${VCI_PROJECT_LIBDIR})
+        endif ()
+      elseif (${_type} STREQUAL MODULE)
+        install (TARGETS ${_target} DESTINATION ${VCI_PROJECT_PLUGINDIR})
+      endif ()
+    endif ()
+  endif()
+
+endfunction ()
+

third/OpenMesh/cmake-library/VCI/VCICompiler.cmake

@@ -0,0 +1,212 @@
+################################################################################
+# Custom settings for compiler flags and similar
+################################################################################
+
+if ( WIN32 )
+  ################################################################################
+  # Windows large memory support
+  ################################################################################
+  if ( NOT DEFINED WINDOWS_LARGE_MEMORY_SUPPORT )
+    set( WINDOWS_LARGE_MEMORY_SUPPORT true CACHE BOOL "Enable or disable binary support for large memory" )
+  endif()
+  
+  set( ADDITIONAL_CMAKE_EXE_LINKER_FLAGS )
+  set( ADDITIONAL_CMAKE_SHARED_LINKER_FLAGS )
+  set( ADDITIONAL_CMAKE_MODULE_LINKER_FLAGS )
+  
+  if ( WINDOWS_LARGE_MEMORY_SUPPORT )
+    if (MSVC)
+	  list(APPEND ADDITIONAL_CMAKE_EXE_LINKER_FLAGS       "/LARGEADDRESSAWARE" )
+	  list(APPEND ADDITIONAL_CMAKE_SHARED_LINKER_FLAGS    "/LARGEADDRESSAWARE" )
+	  list(APPEND ADDITIONAL_CMAKE_MODULE_LINKER_FLAGS    "/LARGEADDRESSAWARE" )
+    endif()  
+  endif()
+  
+  
+  foreach( flag ${ADDITIONAL_CMAKE_EXE_LINKER_FLAGS} )
+    if( NOT CMAKE_EXE_LINKER_FLAGS MATCHES "${flag}" )
+      set( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${flag} ")
+    endif()
+  endforeach()
+  
+  foreach( flag ${ADDITIONAL_CMAKE_SHARED_LINKER_FLAGS} )
+    if( NOT CMAKE_SHARED_LINKER_FLAGS MATCHES "${flag}" )
+      set( CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${flag} ")
+    endif()
+  endforeach()
+  
+  foreach( flag ${ADDITIONAL_CMAKE_MODULE_LINKER_FLAGS} )
+    if( NOT CMAKE_MODULE_LINKER_FLAGS MATCHES "${flag}" )
+      set( CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${flag} ")
+    endif()
+  endforeach()
+
+endif( WIN32 )
+
+if (UNIX)
+
+  set ( ADDITIONAL_CXX_FLAGS )
+  set ( ADDITIONAL_CXX_DEBUG_FLAGS )
+  set ( ADDITIONAL_CXX_RELEASE_FLAGS )
+  set ( ADDITIONAL_CXX_RELWITHDEBINFO_FLAGS )
+  
+  set ( ADDITIONAL_C_FLAGS )
+  set ( ADDITIONAL_C_DEBUG_FLAGS )
+  set ( ADDITIONAL_C_RELEASE_FLAGS )
+  set ( ADDITIONAL_C_RELWITHDEBINFO_FLAGS )
+
+  ################################################################################
+  # Defaults
+  ################################################################################
+
+  # add our standard flags for Template inclusion
+  list(APPEND ADDITIONAL_CXX_FLAGS          "-DINCLUDE_TEMPLATES" )
+  list(APPEND ADDITIONAL_C_FLAGS            "-DINCLUDE_TEMPLATES" )
+  
+  ################################################################################
+  # OS Defines
+  ################################################################################  
+
+  if (APPLE)
+    add_definitions( -DARCH_DARWIN )
+  endif()
+  
+  ################################################################################
+  # Build/Release Defines
+  ################################################################################
+  IF( NOT CMAKE_SYSTEM MATCHES "SunOS*")
+    list(APPEND ADDITIONAL_CXX_DEBUG_FLAGS          "-DDEBUG" )
+    list(APPEND ADDITIONAL_CXX_RELEASE_FLAGS        "-DNDEBUG" )
+    list(APPEND ADDITIONAL_CXX_RELWITHDEBINFO_FLAGS "-DDEBUG" )    
+    
+    list(APPEND ADDITIONAL_C_DEBUG_FLAGS            "-DDEBUG" )
+    list(APPEND ADDITIONAL_C_RELEASE_FLAGS          "-DNDEBUG" )
+    list(APPEND ADDITIONAL_C_RELWITHDEBINFO_FLAGS   "-DDEBUG" )
+  ENDIF()  
+  
+  ################################################################################
+  # Warnings
+  ################################################################################
+  
+  # Add the standard compiler warnings
+  if ( NOT COMPILER_WARNINGS )
+   
+    IF ( APPLE  )
+      # Skip unused parameters as it has to be used for the documentation via doxygen and the interfaces
+      set ( COMPILER_WARNINGS "-W" "-Wall" "-Wno-unused" "-Wextra" "-Wno-non-virtual-dtor" "-Wno-unused-parameter" "-Wno-variadic-macros" CACHE STRINGLIST "This list contains the warning flags used during compilation " )
+    elseif ("${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}" MATCHES ".*clang")
+      set ( COMPILER_WARNINGS "-W" "-Wall" "-Wextra" "-Wno-non-virtual-dtor" "-Wno-unused-parameter" "-Wno-variadic-macros" CACHE STRINGLIST "This list contains the warning flags used during compilation " )
+    ELSEIF ( CMAKE_SYSTEM MATCHES "SunOS*" )
+      set ( COMPILER_WARNINGS "" CACHE STRINGLIST "This list contains the warning flags used during compilation " )
+    ELSE ()
+      set ( COMPILER_WARNINGS "-W" "-Wall" "-Wno-unused" "-Wextra" "-Wno-variadic-macros" CACHE STRINGLIST "This list contains the warning flags used during compilation " )
+  ENDIF()
+
+  endif ( NOT COMPILER_WARNINGS )
+
+  list(APPEND ADDITIONAL_CXX_FLAGS          ${COMPILER_WARNINGS} )
+  list(APPEND ADDITIONAL_C_FLAGS            ${COMPILER_WARNINGS} )
+
+
+  if ("${CMAKE_CXX_COMPILER}" MATCHES "Clang")
+      list(APPEND ADDITIONAL_CXX_FLAGS "-Weverything")
+      list(APPEND ADDITIONAL_CXX_FLAGS "-Wno-c++98-compat")
+      list(APPEND ADDITIONAL_CXX_FLAGS "-Wno-c++98-compat-pedantic")
+      list(APPEND ADDITIONAL_CXX_FLAGS "-Wno-padded")
+      list(APPEND ADDITIONAL_CXX_FLAGS "-Wno-old-style-cast")
+      list(APPEND ADDITIONAL_CXX_FLAGS "-Wno-documentation-unknown-command")
+      list(APPEND ADDITIONAL_CXX_FLAGS "-Wno-unreachable-code-return")
+      # enable later:
+      list(APPEND ADDITIONAL_CXX_FLAGS "-Wno-sign-conversion")
+      list(APPEND ADDITIONAL_CXX_FLAGS "-Wno-deprecated")
+      list(APPEND ADDITIONAL_CXX_FLAGS "-Wno-weak-vtables")
+  endif()
+  
+  ################################################################################
+  # STL Vector checks
+  ################################################################################
+  
+  # Pre initialize stl vector check variable
+  if ( NOT STL_VECTOR_CHECKS )
+    set ( STL_VECTOR_CHECKS false CACHE BOOL "Include full stl vector checks in debug mode (This option is only used in debug Mode!)" )
+  endif ( NOT STL_VECTOR_CHECKS )
+  
+  # Add a flag to check stl vectors
+  if ( STL_VECTOR_CHECKS AND NOT CMAKE_SYSTEM MATCHES "SunOS*"  )
+    list(APPEND ADDITIONAL_CXX_DEBUG_FLAGS          "-D_GLIBCXX_DEBUG" )
+    list(APPEND ADDITIONAL_CXX_DEBUG_FLAGS          "-D_GLIBCXX_DEBUG_PEDANTIC")
+    list(APPEND ADDITIONAL_CXX_RELEASE_FLAGS        "-D_GLIBCXX_DEBUG" )
+    list(APPEND ADDITIONAL_CXX_RELEASE_FLAGS        "-D_GLIBCXX_DEBUG_PEDANTIC")
+    list(APPEND ADDITIONAL_CXX_RELWITHDEBINFO_FLAGS "-D_GLIBCXX_DEBUG" )
+    list(APPEND ADDITIONAL_CXX_RELWITHDEBINFO_FLAGS "-D_GLIBCXX_DEBUG_PEDANTIC")
+    
+    list(APPEND ADDITIONAL_C_DEBUG_FLAGS            "-D_GLIBCXX_DEBUG" )
+    list(APPEND ADDITIONAL_C_DEBUG_FLAGS            "-D_GLIBCXX_DEBUG_PEDANTIC")
+    list(APPEND ADDITIONAL_C_RELEASE_FLAGS          "-D_GLIBCXX_DEBUG" )
+    list(APPEND ADDITIONAL_C_RELEASE_FLAGS          "-D_GLIBCXX_DEBUG_PEDANTIC")
+    list(APPEND ADDITIONAL_C_RELWITHDEBINFO_FLAGS   "-D_GLIBCXX_DEBUG" )
+    list(APPEND ADDITIONAL_C_RELWITHDEBINFO_FLAGS   "-D_GLIBCXX_DEBUG_PEDANTIC")
+  endif()
+
+  ################################################################################
+  # Process the additional flags:
+  ################################################################################
+
+  cmake_policy(SET CMP0057 NEW) 
+
+  get_property(languages GLOBAL PROPERTY ENABLED_LANGUAGES)
+
+  IF ( "CXX" IN_LIST languages  )
+    # Add the debug flags
+    foreach( flag ${ADDITIONAL_CXX_FLAGS} ${ADDITIONAL_CXX_DEBUG_FLAGS} )
+      list (FIND ${CMAKE_CXX_FLAGS_DEBUG} ${flag} _index)
+      if (${_index} EQUAL -1)
+        set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${flag} ")
+      endif()
+    endforeach()
+
+    # Add the release flags
+    foreach( flag ${ADDITIONAL_CXX_FLAGS} ${ADDITIONAL_CXX_RELEASE_FLAGS} )
+      list (FIND ${CMAKE_CXX_FLAGS_RELEASE} ${flag} _index)
+      if (${_index} EQUAL -1)
+        set( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${flag} ")
+      endif()
+    endforeach()
+
+    # Add the release with debug info flags
+    foreach( flag ${ADDITIONAL_CXX_FLAGS} ${ADDITIONAL_CXX_RELWITHDEBINFO_FLAGS} )
+      list (FIND ${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${flag} _index)
+      if (${_index} EQUAL -1)
+        set( CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${flag} ")
+      endif()
+    endforeach()
+  ENDIF()
+
+
+  IF ( "C" IN_LIST languages  )
+    # Add the debug flags
+    foreach( flag ${ADDITIONAL_C_FLAGS} ${ADDITIONAL_C_DEBUG_FLAGS} )
+      list (FIND ${CMAKE_C_FLAGS_DEBUG} ${flag} _index)
+      if (${_index} EQUAL -1)
+        set( CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${flag} ")
+      endif()
+    endforeach()
+
+    # Add the release flags
+    foreach( flag ${ADDITIONAL_C_FLAGS} ${ADDITIONAL_C_RELEASE_FLAGS} )
+        list (FIND ${CMAKE_C_FLAGS_RELEASE} ${flag} _index)
+      if (${_index} EQUAL -1)
+        set( CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${flag} ")
+      endif()
+    endforeach()
+
+    # Add the release with debug info flags
+    foreach( flag ${ADDITIONAL_C_FLAGS} ${ADDITIONAL_C_RELWITHDEBINFO_FLAGS} )
+      list (FIND ${CMAKE_C_FLAGS_RELWITHDEBINFO} ${flag} _index)
+      if (${_index} EQUAL -1)
+        set( CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} ${flag} ")
+      endif()
+    endforeach()
+
+  endif()
+endif ()

third/OpenMesh/cmake-library/VCI/VCIDoxygen.cmake

@@ -0,0 +1,179 @@
+# -helper macro to add a "doc" target with CMake build system. 
+# and configure doxy.config.in to doxy.config
+#
+# target "doc" allows building the documentation with doxygen/dot on WIN32 and Linux
+# Creates .chm windows help file if MS HTML help workshop 
+# (available from http://msdn.microsoft.com/workshop/author/htmlhelp)
+# is installed with its DLLs in PATH.
+#
+#
+# Please note, that the tools, e.g.:
+# doxygen, dot, latex, dvips, makeindex, gswin32, etc.
+# must be in path.
+#
+# Note about Visual Studio Projects: 
+# MSVS hast its own path environment which may differ from the shell.
+# See "Menu Tools/Options/Projects/VC++ Directories" in VS 7.1
+#
+# author Jan Woetzel 2004-2006
+# www.mip.informatik.uni-kiel.de/~jw
+
+if ( NOT DOXYGEN_FOUND)
+  FIND_PACKAGE(Doxygen)
+endif()
+
+IF (DOXYGEN_FOUND)
+
+  # click+jump in Emacs and Visual Studio (for doxy.config) (jw)
+  IF    (CMAKE_BUILD_TOOL MATCHES "(msdev|devenv)")
+    SET(DOXY_WARN_FORMAT "\"$file($line) : $text \"")
+  ELSE  (CMAKE_BUILD_TOOL MATCHES "(msdev|devenv)")
+    SET(DOXY_WARN_FORMAT "\"$file:$line: $text \"")
+  ENDIF (CMAKE_BUILD_TOOL MATCHES "(msdev|devenv)")
+  
+  # we need latex for doxygen because of the formulas
+  FIND_PACKAGE(LATEX)
+  IF    (NOT LATEX_COMPILER)
+    MESSAGE(STATUS "latex command LATEX_COMPILER not found but usually required. You will probably get warnings and user inetraction on doxy run.")
+  ENDIF (NOT LATEX_COMPILER)
+  IF    (NOT MAKEINDEX_COMPILER)
+    MESSAGE(STATUS "makeindex command MAKEINDEX_COMPILER not found but usually required.")
+  ENDIF (NOT MAKEINDEX_COMPILER)
+  IF    (NOT DVIPS_CONVERTER)
+    MESSAGE(STATUS "dvips command DVIPS_CONVERTER not found but usually required.")
+  ENDIF (NOT DVIPS_CONVERTER)
+  
+  # This macro generates a new doc target. vci_create_doc_target( targetName [directory with the doxy.config.in] [dependency])
+  # if no parameter is used except the target, a target of the given name will be created from the current source directories doxyfile and added as a dependency to the doc target
+  # The first additional parameter is used to specify a directory where the doxyfile will be used
+  # The second parameter defines a target, that will depend on the newly generated one. (Default is doc)
+  macro (vci_create_doc_target target)
+
+    set( DOC_DIRECTORY  "${CMAKE_CURRENT_SOURCE_DIR}" )
+    set( DOC_DEPENDENCY "doc")
+
+    # collect arguments
+    if ( ${ARGC} EQUAL 2)
+      set( DOC_DIRECTORY "${ARGV1}" )
+    elseif ( ${ARGC} EQUAL 3)
+      set( DOC_DIRECTORY  "${ARGV1}" )
+      set( DOC_DEPENDENCY "${ARGV2}" )
+    elseif( $ARGC GREATER 3 )
+      set( DOC_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" )
+      # failed as we do not know how to handle the parameters
+      MESSAGE(SEND_ERROR "Unknown parameter for vci_create_doc_target!")
+    endif()
+
+    if("${DOC_DEPENDENCY}" STREQUAL "doc")
+      #generate the global doc target (but only once!)
+      if ( NOT TARGET doc )
+        ADD_CUSTOM_TARGET( doc )
+        SET_TARGET_PROPERTIES( doc PROPERTIES EchoString "Building Documentation"  )
+        GROUP_PROJECT(doc Documentation)
+      endif()
+    endif()
+
+    # If there exists an doxy.config.in, we configure it.
+    IF   (EXISTS "${DOC_DIRECTORY}/doxy.config.in")
+
+      #MESSAGE(STATUS "configured ${DOC_DIRECTORY}/doxy.config.in --> ${CMAKE_CURRENT_BINARY_DIR}/doxy.config")
+      CONFIGURE_FILE(${DOC_DIRECTORY}/doxy.config.in
+                     ${CMAKE_CURRENT_BINARY_DIR}/doxy.config
+                     @ONLY )
+      # use (configured) doxy.config from (out of place) BUILD tree:
+      SET(DOXY_CONFIG "${CMAKE_CURRENT_BINARY_DIR}/doxy.config")
+
+    ELSE (EXISTS "${DOC_DIRECTORY}/doxy.config.in")
+
+      # use static hand-edited doxy.config from SOURCE tree:
+      SET(DOXY_CONFIG "${DOC_DIRECTORY}/doxy.config")
+
+      IF   (EXISTS "${DOC_DIRECTORY}/doxy.config")
+
+        MESSAGE(STATUS "WARNING: using existing ${DOC_DIRECTORY}/doxy.config instead of configuring from doxy.config.in file.")
+
+      ELSE (EXISTS "${DOC_DIRECTORY}/doxy.config")
+
+        IF   (EXISTS "${CMAKE_MODULE_PATH}/doxy.config.in")
+          # using template doxy.config.in
+          #MESSAGE(STATUS "configured ${CMAKE_CMAKE_MODULE_PATH}/doxy.config.in --> ${CMAKE_CURRENT_BINARY_DIR}/doxy.config")
+          CONFIGURE_FILE(${CMAKE_MODULE_PATH}/doxy.config.in
+            ${CMAKE_CURRENT_BINARY_DIR}/doxy.config
+            @ONLY )
+          SET(DOXY_CONFIG "${CMAKE_CURRENT_BINARY_DIR}/doxy.config")
+
+        ELSE (EXISTS "${CMAKE_MODULE_PATH}/doxy.config.in")
+
+          # failed completely...
+          MESSAGE(SEND_ERROR "Please create ${DOC_DIRECTORY}/doxy.config.in (or doxy.config as fallback)")
+
+        ENDIF(EXISTS "${CMAKE_MODULE_PATH}/doxy.config.in")
+
+      ENDIF(EXISTS "${DOC_DIRECTORY}/doxy.config")
+    ENDIF(EXISTS "${DOC_DIRECTORY}/doxy.config.in")
+
+    ADD_CUSTOM_TARGET(${target} ${DOXYGEN_EXECUTABLE} ${DOXY_CONFIG})
+    # Group by folders on MSVC
+    GROUP_PROJECT( ${target} "Documentation")
+
+    add_dependencies( ${DOC_DEPENDENCY} ${target} )
+
+#     # Add winhelp target only once!
+#     GET_TARGET_PROPERTY(target_location winhelp EchoString)
+#     if ( NOT target_location STREQUAL "Building Windows Documentation" )
+#       ADD_CUSTOM_TARGET( winhelp )
+#       SET_TARGET_PROPERTIES( winhelp PROPERTIES EchoString "Building Windows Documentation"  )
+#     endif()
+
+    # create a windows help .chm file using hhc.exe
+    # HTMLHelp DLL must be in path!
+    # fallback: use hhw.exe interactively
+#     IF    (WIN32)
+#       FIND_PACKAGE(HTMLHelp)
+#       IF   (HTML_HELP_COMPILER)
+#         SET (TMP "${CMAKE_CURRENT_BINARY_DIR}\\Doc\\html\\index.hhp")
+#         STRING(REGEX REPLACE "[/]" "\\\\" HHP_FILE ${TMP} )
+#         # MESSAGE(SEND_ERROR "DBG  HHP_FILE=${HHP_FILE}")
+#         ADD_CUSTOM_TARGET(winhelp-${target} ${HTML_HELP_COMPILER} ${HHP_FILE})
+#         ADD_DEPENDENCIES (winhelp-${target} ${target})
+#
+#         add_dependencies(winhelp winhelp-${target})
+#
+#
+#         IF (NOT TARGET_DOC_SKIP_INSTALL)
+#         # install windows help?
+#         # determine useful name for output file
+#         # should be project and version unique to allow installing
+#         # multiple projects into one global directory
+#         IF   (EXISTS "${PROJECT_BINARY_DIR}/Doc/html/index.chm")
+#           IF   (PROJECT_NAME)
+#             SET(OUT "${PROJECT_NAME}")
+#           ELSE (PROJECT_NAME)
+#             SET(OUT "Documentation") # default
+#           ENDIF(PROJECT_NAME)
+#           IF   (${PROJECT_NAME}_VERSION_MAJOR)
+#             SET(OUT "${OUT}-${${PROJECT_NAME}_VERSION_MAJOR}")
+#             IF   (${PROJECT_NAME}_VERSION_MINOR)
+#               SET(OUT  "${OUT}.${${PROJECT_NAME}_VERSION_MINOR}")
+#               IF   (${PROJECT_NAME}_VERSION_PATCH)
+#                 SET(OUT "${OUT}.${${PROJECT_NAME}_VERSION_PATCH}")
+#               ENDIF(${PROJECT_NAME}_VERSION_PATCH)
+#             ENDIF(${PROJECT_NAME}_VERSION_MINOR)
+#           ENDIF(${PROJECT_NAME}_VERSION_MAJOR)
+#           # keep suffix
+#           SET(OUT  "${OUT}.chm")
+#
+#           #MESSAGE("DBG ${PROJECT_BINARY_DIR}/Doc/html/index.chm \n${OUT}")
+#           # create target used by install and package commands
+#           INSTALL(FILES "${PROJECT_BINARY_DIR}/Doc/html/index.chm"
+#             DESTINATION "doc"
+#             RENAME "${OUT}"
+#           )
+#         ENDIF(EXISTS "${PROJECT_BINARY_DIR}/Doc/html/index.chm")
+#         ENDIF(NOT TARGET_DOC_SKIP_INSTALL)
+#
+#       ENDIF(HTML_HELP_COMPILER)
+#       # MESSAGE(SEND_ERROR "HTML_HELP_COMPILER=${HTML_HELP_COMPILER}")
+#     ENDIF (WIN32)
+  endmacro ()
+ENDIF(DOXYGEN_FOUND)

third/OpenMesh/cmake-library/VCI/VCIOutput.cmake

@@ -0,0 +1,53 @@
+# fill string with spaces
+macro (vci_format_string str length return)
+    string (LENGTH "${str}" _str_len)
+    math (EXPR _add_chr "${length} - ${_str_len}")
+    set (${return} "${str}")
+    while (_add_chr GREATER 0)
+        set (${return} "${${return}} ")
+        math (EXPR _add_chr "${_add_chr} - 1")
+    endwhile ()
+endmacro ()
+
+# print message with color escape sequences if CMAKE_COLOR_MAKEFILE is set
+string (ASCII 27 _escape)
+function (vci_color_message _str)
+    if (CMAKE_COLOR_MAKEFILE AND NOT WIN32)
+        message (${_str})
+    else ()
+        string (REGEX REPLACE "${_escape}.[0123456789;]*m" "" __str ${_str})
+        message (${__str})
+    endif ()
+endfunction ()
+
+# info header
+function (vci_print_configure_header _id _name)
+    vci_format_string ("${_name}" 40 _project)
+    if ( ${_id}_VERSION )
+        vci_format_string ("${${_id}_VERSION}" 40 _version)
+    else()
+        vci_format_string ("${PROJECT_VERSION}" 40 _version)
+    endif()
+    vci_color_message ("\n${_escape}[40;37m************************************************************${_escape}[0m")
+    vci_color_message ("${_escape}[40;37m* ${_escape}[1;31mVCI ${_escape}[0;40;34mBuildsystem${_escape}[0m${_escape}[40;37m                                          *${_escape}[0m")
+    vci_color_message ("${_escape}[40;37m*                                                          *${_escape}[0m")
+    vci_color_message ("${_escape}[40;37m* Package : ${_escape}[32m${_project} ${_escape}[37m      *${_escape}[0m")
+    vci_color_message ("${_escape}[40;37m* Version : ${_escape}[32m${_version} ${_escape}[37m      *${_escape}[0m")
+
+    if ( NOT WIN32 )
+      # Just artistic. remove 2 spaces for release to make it look nicer ;-)
+      if (${CMAKE_BUILD_TYPE} MATCHES "Debug")    
+         vci_color_message ("${_escape}[40;37m* Type    : ${_escape}[32m${CMAKE_BUILD_TYPE} ${_escape}[37m                                         *${_escape}[0m")
+      else()
+         vci_color_message ("${_escape}[40;37m* Type    : ${_escape}[32m${CMAKE_BUILD_TYPE} ${_escape}[37m                                       *${_escape}[0m")
+      endif()
+    endif()
+
+    vci_color_message ("${_escape}[40;37m************************************************************${_escape}[0m")
+endfunction ()
+
+# info line
+function (vci_print_configure_footer)
+    vci_color_message ("${_escape}[40;37m************************************************************${_escape}[0m\n")
+endfunction ()
+

third/OpenMesh/cmake-library/VCI/VCIPaths.cmake

@@ -0,0 +1,46 @@
+################################################################################
+# Custom search paths for libraries
+################################################################################
+
+if ( WIN32 )
+
+  find_path(VCI_WINDOWS_LIBS_DIR general/README.md
+    DOC "Default library search dir for on windows."
+    HINTS "C:/libs/"
+          "D:/libs/"
+          "E:/libs/"
+          "R:/libs/")
+
+  if (VCI_WINDOWS_LIBS_DIR)
+    # add path to general libs
+    list(APPEND CMAKE_PREFIX_PATH "${VCI_WINDOWS_LIBS_DIR}/general/")
+
+    # add path for Visual Studio specific libraries
+    # TODO: remove VS_SEARCH_PATH when the finders do not depend on it anymore
+    if ( CMAKE_GENERATOR MATCHES "^Visual Studio 11.*Win64" )
+      list(APPEND CMAKE_PREFIX_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2012/x64/")
+      SET(VS_SEARCH_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2012/x64/")
+    elseif ( CMAKE_GENERATOR MATCHES "^Visual Studio 11.*" )
+      list(APPEND CMAKE_PREFIX_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2012/x32/")
+      SET(VS_SEARCH_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2012/x32/")
+    elseif ( CMAKE_GENERATOR MATCHES "^Visual Studio 12.*Win64" )
+      list(APPEND CMAKE_PREFIX_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2013/x64/")
+      SET(VS_SEARCH_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2013/x64/")
+    elseif ( CMAKE_GENERATOR MATCHES "^Visual Studio 12.*" )
+      list(APPEND CMAKE_PREFIX_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2013/x32/")
+      SET(VS_SEARCH_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2013/x32/")
+    elseif ( CMAKE_GENERATOR MATCHES "^Visual Studio 14.*Win64" )
+      list(APPEND CMAKE_PREFIX_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2015/x64/")
+      SET(VS_SEARCH_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2015/x64/")
+    elseif ( CMAKE_GENERATOR MATCHES "^Visual Studio 14.*" )
+      list(APPEND CMAKE_PREFIX_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2015/x32/")
+      SET(VS_SEARCH_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2015/x32/")
+    elseif ( CMAKE_GENERATOR MATCHES "^Visual Studio 15.*Win64" )
+      list(APPEND CMAKE_PREFIX_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2017/x64/")
+      SET(VS_SEARCH_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2017/x64/")
+    elseif ( CMAKE_GENERATOR MATCHES "^Visual Studio 15.*" )
+      list(APPEND CMAKE_PREFIX_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2017/x32/")
+      SET(VS_SEARCH_PATH "${VCI_WINDOWS_LIBS_DIR}/vs2017/x32/")
+    endif()
+  endif()
+endif( WIN32 )

third/OpenMesh/cmake-library/VCI/VCIQt.cmake

@@ -0,0 +1,319 @@
+#unset cached qt variables which are set by all qt versions. version is the major number of the qt version (e.g. 4 or 5, not 4.8)
+macro (vci_unset_qt_shared_variables version)
+  if (VCI_INTERNAL_QT_LAST_VERSION)
+    if (NOT ${VCI_INTERNAL_QT_LAST_VERSION} EQUAL ${version})
+      unset(QT_BINARY_DIR)
+      unset(QT_PLUGINS_DIR)
+      unset(VCI_INTERNAL_QT_LAST_VERSION)
+    endif()
+  endif()
+  set (VCI_INTERNAL_QT_LAST_VERSION "${version}" CACHE INTERNAL "Qt Version, which was used on the last time")
+endmacro()
+
+
+# Macro to help find qt
+#
+# Input Variables used:
+# QT_INSTALL_PATH : Path to a qt installation which contains lib and include folder (If not given, automatic search is active)
+# QT_VERSION : (5/6) Default to qt 5 or 6
+# QT_REQUIRED_PACKAGES : Required qt packages
+# QT5_REQUIRED_PACKAGES : Required qt packages specific to qt5 only
+# QT6_REQUIRED_PACKAGES : Required qt packages specific to qt6 only
+#
+# QT5_FOUND : Qt5 found
+# QT6_FOUND : Qt6 found
+# QT_FOUND : Any qt found?
+#
+macro (vci_qt)
+
+  if(POLICY CMP0020)
+    # Automatically link Qt executables to qtmain target on Windows
+    cmake_policy(SET CMP0020 NEW)
+  endif(POLICY CMP0020)
+
+  set (QT_INSTALL_PATH "" CACHE PATH "Path to Qt directory which contains lib and include folder")
+
+  if (EXISTS "${QT_INSTALL_PATH}")
+    set (CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH};${QT_INSTALL_PATH}")
+    set (QT_INSTALL_PATH_EXISTS TRUE)
+  else()
+    set (QT_INSTALL_PATH_EXISTS FALSE)
+  endif(EXISTS "${QT_INSTALL_PATH}")
+
+  set(QT_FINDER_FLAGS "" CACHE STRING "Flags for the Qt finder e.g.
+                                                       NO_DEFAULT_PATH if no system installed Qt shall be found")
+
+  # compute default search paths
+  set(SUPPORTED_QT_VERSIONS 6.2.2 6.2.1 6.1.2 6.0.4 6.0.3 5.15.2 5.12.2 5.11.3 5.11 5.10 5.9 5.8 5.7 5.6)
+  if (NOT QT_INSTALL_PATH_EXISTS)
+    message("-- No QT path specified (or does not exist) - searching in common locations...")
+    foreach (suffix gcc_64 clang_64)
+      foreach(version ${SUPPORTED_QT_VERSIONS})
+        foreach(prefix ~/sw/Qt ~/Qt)
+          # default institute qt path
+          list(APPEND QT_DEFAULT_PATH "${prefix}/${version}/${suffix}")
+          set (CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH};${prefix}/${version}/${suffix}")
+        endforeach()
+      endforeach()
+    endforeach()
+  endif()
+
+  # QtX11Extras only on Linux
+  #if(NOT WIN32 AND NOT APPLE)
+  #  list(APPEND QT_REQUIRED_PACKAGES X11Extras)
+  #endif()
+
+  # search for qt5 and qt6 installations offering requested components
+  set(QT_VERSION "5" CACHE STRING "Override default qt version preference of qt6.")
+  set(QT_DEFAULT_MAJOR_VERSION ${QT_VERSION})
+
+  # find qt
+  find_package (Qt${QT_DEFAULT_MAJOR_VERSION} COMPONENTS ${QT_REQUIRED_PACKAGES} PATHS ${QT_DEFAULT_PATH} ${QT_FINDER_FLAGS})
+
+  # find version specific components
+  if (Qt${QT_DEFAULT_MAJOR_VERSION}_FOUND AND QT${QT_DEFAULT_MAJOR_VERSION}_REQUIRED_PACKAGES)
+    find_package (Qt${QT_DEFAULT_MAJOR_VERSION} COMPONENTS ${QT${QT_DEFAULT_MAJOR_VERSION}_REQUIRED_PACKAGES} PATHS ${QT_DEFAULT_PATH} ${QT_FINDER_FLAGS})
+  endif()
+
+  # set helpers
+  set(QT6_FOUND ${Qt6_FOUND})
+  set(QT5_FOUND ${Qt5_FOUND})
+  if (QT6_FOUND OR QT5_FOUND)
+    set(Qt_FOUND 1)
+  else()
+    set(Qt_FOUND 0)
+  endif()
+  set(QT_FOUND ${Qt_FOUND})
+
+  # Use qt without version
+  if (NOT QT_FOUND)
+    set(QT_DEFAULT_MAJOR_VERSION 0)
+  endif()
+
+  # output some info
+  if (QT5_FOUND)
+    message("-- Found QT5")
+  endif()
+  if (QT6_FOUND)
+    message("-- Found QT6")
+  endif()
+
+  if (NOT QT_FOUND)
+    message("QT not found.")
+  endif()
+
+  if(QT_FOUND)
+    if(Qt${QT_DEFAULT_MAJOR_VERSION}_VERSION) # use the new version variable if it is set
+      set(Qt_VERSION_STRING ${Qt${QT_DEFAULT_MAJOR_VERSION}_VERSION})
+    endif()
+
+    message("-- Using QT${QT_DEFAULT_MAJOR_VERSION} (${Qt_VERSION_STRING})")
+
+    set(QT_TARGET "Qt${QT_DEFAULT_MAJOR_VERSION}")
+
+    string(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1"
+      QT_VERSION_MAJOR "${Qt_VERSION_STRING}")
+    string(REGEX REPLACE "^[0-9]+\\.([0-9]+)\\.[0-9]+.*" "\\1"
+      QT_VERSION_MINOR "${Qt_VERSION_STRING}")
+    string(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1"
+      QT_VERSION_PATCH "${Qt_VERSION_STRING}")
+
+    vci_unset_qt_shared_variables(${QT_DEFAULT_MAJOR_VERSION})
+
+    add_compile_definitions(QT_VERSION_MAJOR=${QT_VERSION_MAJOR})
+    add_compile_definitions(QT_VERSION_MINOR=${QT_VERSION_MINOR})
+    add_compile_definitions(QT_VERSION_PATCH=${QT_VERSION_PATCH})
+
+    if (QT5_FOUND)
+      #set plugin dir
+      list(GET Qt5Gui_PLUGINS 0 _plugin)
+      if (_plugin)
+        get_target_property(_plugin_full ${_plugin} LOCATION)
+        get_filename_component(_plugin_dir ${_plugin_full} PATH)
+        set (QT_PLUGINS_DIR "${_plugin_dir}/../" CACHE PATH "Path to the qt plugin directory")
+      elseif(QT_INSTALL_PATH_EXISTS)
+        set (QT_PLUGINS_DIR "${QT_INSTALL_PATH}/plugins/" CACHE PATH "Path to the qt plugin directory")
+      elseif()
+        set (QT_PLUGINS_DIR "QT_PLUGIN_DIR_NOT_FOUND" CACHE PATH "Path to the qt plugin directory")
+      endif(_plugin)
+	endif()
+	
+	if (QT6_FOUND)
+	    #TODO : FInd a cleaner solution!!!!
+		
+	    get_target_property(_QT_BINARY_DIR "Qt${QT_DEFAULT_MAJOR_VERSION}::uic" LOCATION)
+		get_filename_component(_QT_BINARY_DIR "${_QT_BINARY_DIR}" DIRECTORY)
+		set (QT_PLUGINS_DIR "${_QT_BINARY_DIR}/../plugins" CACHE PATH "Path to the qt plugin directory")      
+	endif()
+	
+	
+	
+    # set binary dir for fixupbundle
+    if(QT_INSTALL_PATH_EXISTS)
+      set(_QT_BINARY_DIR "${QT_INSTALL_PATH}/bin")
+    else()
+      get_target_property(_QT_BINARY_DIR "Qt${QT_DEFAULT_MAJOR_VERSION}::uic" LOCATION)
+      get_filename_component(_QT_BINARY_DIR ${_QT_BINARY_DIR} PATH)
+    endif(QT_INSTALL_PATH_EXISTS)
+
+    set (QT_BINARY_DIR "${_QT_BINARY_DIR}" CACHE PATH "Qt binary Directory")
+    mark_as_advanced(QT_BINARY_DIR)
+
+    set (CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+
+    foreach(QT_PACKAGE IN LISTS QT_REQUIRED_PACKAGES)
+      include_directories(${Qt${QT_DEFAULT_MAJOR_VERSION}${QT_PACKAGE}_INCLUDE_DIRS})
+      # add_definitions(${Qt${QT_DEFAULT_MAJOR_VERSION}${QT_PACKAGE}_DEFINITIONS})
+      list(APPEND QT_LIBRARIES ${Qt${QT_DEFAULT_MAJOR_VERSION}${QT_PACKAGE}_LIBRARIES})
+    endforeach()
+
+    if (QT${QT_DEFAULT_MAJOR_VERSION}_REQUIRED_PACKAGES)
+      foreach(QT_PACKAGE IN LISTS QT${QT_DEFAULT_MAJOR_VERSION}_REQUIRED_PACKAGES)
+        include_directories(${Qt${QT_DEFAULT_MAJOR_VERSION}${QT_PACKAGE}_INCLUDE_DIRS})
+        # add_definitions(${Qt${QT_DEFAULT_MAJOR_VERSION}${QT_PACKAGE}_DEFINITIONS})
+        list(APPEND QT_LIBRARIES ${Qt${QT_DEFAULT_MAJOR_VERSION}${QT_PACKAGE}_LIBRARIES})
+      endforeach()
+    endif()
+
+    if(NOT MSVC)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
+    endif()
+
+    if(MSVC)
+      set(QT_LIBRARIES ${QT_LIBRARIES} ${Qt_QTMAIN_LIBRARIES})
+    endif()
+
+    #adding QT_NO_DEBUG to all release modes.
+    #  Note: for multi generators like msvc you cannot set this definition depending of
+    #  the current build type, because it may change in the future inside the ide and not via cmake
+    if (MSVC_IDE)
+      set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /DQT_NO_DEBUG")
+      set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /DQT_NO_DEBUG")
+
+      set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_RELEASE} /DQT_NO_DEBUG")
+      set(CMAKE_CXX_FLAGS_MINSITEREL "${CMAKE_C_FLAGS_RELEASE} /DQT_NO_DEBUG")
+
+      set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELEASE} /DQT_NO_DEBUG")
+      set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELEASE} /DQT_NO_DEBUG")
+    else(MSVC_IDE)
+      if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+        add_definitions(-DQT_NO_DEBUG)
+      endif()
+    endif()
+
+  endif ()
+endmacro ()
+
+#generates qt translations
+function (vci_add_translations _target _languages _sources)
+
+  string (TOUPPER ${_target} _TARGET)
+  # generate/use translation files
+  # run with UPDATE_TRANSLATIONS set to on to build qm files
+  option (UPDATE_TRANSLATIONS_${_TARGET} "Update source translation *.ts files (WARNING: make clean will delete the source .ts files! Danger!)")
+
+  set (_new_ts_files)
+  set (_ts_files)
+
+  foreach (lang ${_languages})
+    if (NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/translations/${_target}_${lang}.ts" OR UPDATE_TRANSLATIONS_${_TARGET})
+      list (APPEND _new_ts_files "translations/${_target}_${lang}.ts")
+    else ()
+      list (APPEND _ts_files "translations/${_target}_${lang}.ts")
+    endif ()
+  endforeach ()
+
+  if (QT5_FOUND) 
+    FIND_PACKAGE( Qt5LinguistTools )
+  endif()
+
+  if (QT6_FOUND)
+    FIND_PACKAGE( Qt6LinguistTools )
+  endif()
+
+  # This block contains the translation files that should be updated.
+  # The UPDATE_TRANSLATIONS_${_TARGET} flag has to be set for the update
+  # to be enabled.
+  # Afterwards you can run the target ${_TARGET}_lupdate
+  set (_qm_files)
+  if ( _new_ts_files )
+
+    if ( QT5_FOUND)
+       qt_create_translation(_qm_files ${_sources} ${_new_ts_files})
+    endif()
+
+    if (QT6_FOUND)
+      qt_add_lupdate(${_target}
+                     TS_FILES ${_new_ts_files}
+	             )
+    endif ()
+
+  endif ()
+
+  # Here the list of translation files that will be compiled into
+  # qm files is generated along with the targets.
+  if ( _ts_files )
+    if (QT5_FOUND)
+       qt5_add_translation(_qm_files2 ${_ts_files})
+    endif() 
+    if (QT6_FOUND)
+      qt_add_lrelease(${_target}
+	              TS_FILES ${_ts_files} 
+		      QM_FILES_OUTPUT_VARIABLE _qm_files2)
+    endif()
+    list (APPEND _qm_files ${_qm_files2})
+
+  endif ()
+
+  # create a target for the translation files ( and object files )
+  # Use this target, to update only the translations
+  add_custom_target (tr_${_target} DEPENDS ${_qm_files})
+  GROUP_PROJECT( tr_${_target} "Translations")
+
+  # Build translations with the application
+  add_dependencies(${_target} tr_${_target} )
+
+  if (NOT EXISTS ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_DATADIR}/Translations)
+    file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_DATADIR}/Translations )
+  endif ()
+
+  foreach (_qm ${_qm_files})
+    get_filename_component (_qm_name "${_qm}" NAME)
+    add_custom_command (TARGET tr_${_target} POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -E
+      copy_if_different
+      ${_qm}
+      ${CMAKE_BINARY_DIR}/Build/${VCI_PROJECT_DATADIR}/Translations/${_qm_name})
+  endforeach ()
+
+  if (NOT VCI_PROJECT_MACOS_BUNDLE OR NOT APPLE)
+    install (FILES ${_qm_files} DESTINATION "${VCI_PROJECT_DATADIR}/Translations")
+  endif ()
+endfunction ()
+
+# Function that writes all generated qch files into one Help.qhcp project file
+function (generate_qhp_file files_loc plugin_name)
+
+  set(qhp_file "${files_loc}/${plugin_name}.qhp")
+  # Read in template file
+  file(STRINGS "${CMAKE_SOURCE_DIR}/OpenFlipper/Documentation/QtHelpResources/QtHelpProject.qhp" qhp_template)
+
+  # Initialize new project file
+  file(WRITE ${qhp_file} "")
+  foreach (_line ${qhp_template})
+    string(STRIP ${_line} stripped)
+    if("${stripped}" STREQUAL "files")
+      vci_get_files_in_dir (_files ${files_loc})
+      foreach (_file ${_files})
+        string(REGEX MATCH ".+[.]+((html)|(htm)|(xml))$" fileresult ${_file})
+        string(LENGTH "${fileresult}" len)
+        if(${len} GREATER 0)
+          file(APPEND ${qhp_file} "<file>${_file}</file>\n")
+        endif()
+      endforeach()
+    else()
+      string(REGEX REPLACE "plugin" ${plugin} newline ${_line})
+      file(APPEND ${qhp_file} "${newline}\n")
+    endif()
+  endforeach()
+endfunction()