ViennaPS 4.0.1__cp311-cp311-musllinux_1_1_x86_64.whl

viennaps.libs/cmake/vtk-9.3/FindExprTk.cmake

@@ -0,0 +1,58 @@
+# - Try to find ExprTk lib
+#
+# This module supports requiring a minimum version, e.g. you can do
+#   find_package(ExprTk 2.7)
+# to require version 2.7 or newer of ExprTk.
+#
+# Once done this will define
+#
+#  ExprTk_FOUND - system has exprtk with correct version
+#  ExprTk_INCLUDE_DIRS - the exprtk include directory
+#  ExprTk_VERSION - exprtk version
+#
+# And the following imported target:
+#
+#  ExprTk::ExprTk
+
+find_path(ExprTk_INCLUDE_DIR
+  NAMES exprtk.hpp
+  DOC "Path to ExprTk header")
+mark_as_advanced(ExprTk_INCLUDE_DIR)
+
+if (ExprTk_INCLUDE_DIR)
+  file(STRINGS "${ExprTk_INCLUDE_DIR}/exprtk.hpp" _exprtk_version_header REGEX "\"[0-9.]+\"")
+  set(ExprTk_VERSION)
+  foreach (_exprtk_version_line IN LISTS _exprtk_version_header)
+    if ("${ExprTk_VERSION}" STREQUAL "")
+      string(REGEX MATCH "version = \"(2\.7[0-9.]+)\".*$" _exprtk_version_match "${_exprtk_version_line}")
+      set(ExprTk_VERSION "${CMAKE_MATCH_1}")
+    else ()
+      string(REGEX MATCH "\"([0-9.]+)\".*$" _exprtk_version_match "${_exprtk_version_line}")
+      set(ExprTk_VERSION "${ExprTk_VERSION}${CMAKE_MATCH_1}")
+    endif ()
+    if (_exprtk_version_match MATCHES "\;")
+      break()
+    endif ()
+  endforeach ()
+  if (NOT ExprTk_VERSION)
+    # fallback: version in exprtk.hpp has always started with 2.7
+    set(ExprTk_VERSION "2.7")
+  endif ()
+  unset(_exprtk_version_header)
+  unset(_exprtk_version_line)
+  unset(_exprtk_version_match)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(ExprTk
+  REQUIRED_VARS ExprTk_INCLUDE_DIR
+  VERSION_VAR ExprTk_VERSION)
+
+if (ExprTk_FOUND)
+  set(ExprTk_INCLUDE_DIRS "${ExprTk_INCLUDE_DIR}")
+  if (NOT TARGET ExprTk::ExprTk)
+    add_library(ExprTk::ExprTk INTERFACE IMPORTED)
+    set_target_properties(ExprTk::ExprTk PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES "${ExprTk_INCLUDE_DIR}")
+  endif ()
+endif ()

viennaps.libs/cmake/vtk-9.3/FindFFMPEG.cmake

@@ -0,0 +1,195 @@
+#[==[
+Provides the following variables:
+
+  * `FFMPEG_INCLUDE_DIRS`: Include directories necessary to use FFMPEG.
+  * `FFMPEG_LIBRARIES`: Libraries necessary to use FFMPEG. Note that this only
+    includes libraries for the components requested.
+  * `FFMPEG_VERSION`: The version of FFMPEG found.
+
+The following components are supported:
+
+  * `avcodec`
+  * `avdevice`
+  * `avfilter`
+  * `avformat`
+  * `avresample`
+  * `avutil`
+  * `swresample`
+  * `swscale`
+
+For each component, the following are provided:
+
+  * `FFMPEG_<component>_FOUND`: Libraries for the component.
+  * `FFMPEG_<component>_INCLUDE_DIRS`: Include directories for
+    the component.
+  * `FFMPEG_<component>_LIBRARIES`: Libraries for the component.
+  * `FFMPEG::<component>`: A target to use with `target_link_libraries`.
+
+Note that only components requested with `COMPONENTS` or `OPTIONAL_COMPONENTS`
+are guaranteed to set these variables or provide targets.
+#]==]
+
+function (_ffmpeg_find component headername)
+  find_path("FFMPEG_${component}_INCLUDE_DIR"
+    NAMES
+      "lib${component}/${headername}"
+    PATHS
+      "${FFMPEG_ROOT}/include"
+      ~/Library/Frameworks
+      /Library/Frameworks
+      /usr/local/include
+      /usr/include
+      /sw/include # Fink
+      /opt/local/include # DarwinPorts
+      /opt/csw/include # Blastwave
+      /opt/include
+      /usr/freeware/include
+    PATH_SUFFIXES
+      ffmpeg
+    DOC "FFMPEG's ${component} include directory")
+  mark_as_advanced("FFMPEG_${component}_INCLUDE_DIR")
+
+  # On Windows, static FFMPEG is sometimes built as `lib<name>.a`.
+  if (WIN32)
+    list(APPEND CMAKE_FIND_LIBRARY_SUFFIXES ".a" ".lib")
+    list(APPEND CMAKE_FIND_LIBRARY_PREFIXES "" "lib")
+  endif ()
+
+  find_library("FFMPEG_${component}_LIBRARY"
+    NAMES
+      "${component}"
+    PATHS
+      "${FFMPEG_ROOT}/lib"
+      ~/Library/Frameworks
+      /Library/Frameworks
+      /usr/local/lib
+      /usr/local/lib64
+      /usr/lib
+      /usr/lib64
+      /sw/lib
+      /opt/local/lib
+      /opt/csw/lib
+      /opt/lib
+      /usr/freeware/lib64
+      "${FFMPEG_ROOT}/bin"
+    DOC "FFMPEG's ${component} library")
+  mark_as_advanced("FFMPEG_${component}_LIBRARY")
+
+  if (FFMPEG_${component}_LIBRARY AND FFMPEG_${component}_INCLUDE_DIR)
+    set(_deps_found TRUE)
+    set(_deps_link)
+    foreach (_ffmpeg_dep IN LISTS ARGN)
+      if (TARGET "FFMPEG::${_ffmpeg_dep}")
+        list(APPEND _deps_link "FFMPEG::${_ffmpeg_dep}")
+      else ()
+        set(_deps_found FALSE)
+      endif ()
+    endforeach ()
+    if (_deps_found)
+      if (NOT TARGET "FFMPEG::${component}")
+        add_library("FFMPEG::${component}" UNKNOWN IMPORTED)
+        set_target_properties("FFMPEG::${component}" PROPERTIES
+          IMPORTED_LOCATION "${FFMPEG_${component}_LIBRARY}"
+          INTERFACE_INCLUDE_DIRECTORIES "${FFMPEG_${component}_INCLUDE_DIR}"
+          IMPORTED_LINK_INTERFACE_LIBRARIES "${_deps_link}")
+      endif ()
+      set("FFMPEG_${component}_FOUND" 1
+        PARENT_SCOPE)
+
+      set(version_header_path "${FFMPEG_${component}_INCLUDE_DIR}/lib${component}/version.h")
+      if (EXISTS "${version_header_path}")
+        string(TOUPPER "${component}" component_upper)
+        file(STRINGS "${version_header_path}" version
+          REGEX "#define  *LIB${component_upper}_VERSION_(MAJOR|MINOR|MICRO) ")
+        string(REGEX REPLACE ".*_MAJOR *\([0-9]*\).*" "\\1" major "${version}")
+        string(REGEX REPLACE ".*_MINOR *\([0-9]*\).*" "\\1" minor "${version}")
+        string(REGEX REPLACE ".*_MICRO *\([0-9]*\).*" "\\1" micro "${version}")
+        if (NOT major STREQUAL "" AND
+            NOT minor STREQUAL "" AND
+            NOT micro STREQUAL "")
+          set("FFMPEG_${component}_VERSION" "${major}.${minor}.${micro}"
+            PARENT_SCOPE)
+        endif ()
+      endif ()
+    else ()
+      set("FFMPEG_${component}_FOUND" 0
+        PARENT_SCOPE)
+      set(what)
+      if (NOT FFMPEG_${component}_LIBRARY)
+        set(what "library")
+      endif ()
+      if (NOT FFMPEG_${component}_INCLUDE_DIR)
+        if (what)
+          string(APPEND what " or headers")
+        else ()
+          set(what "headers")
+        endif ()
+      endif ()
+      set("FFMPEG_${component}_NOT_FOUND_MESSAGE"
+        "Could not find the ${what} for ${component}."
+        PARENT_SCOPE)
+    endif ()
+  endif ()
+endfunction ()
+
+_ffmpeg_find(avutil     avutil.h)
+_ffmpeg_find(avresample avresample.h
+  avutil)
+_ffmpeg_find(swresample swresample.h
+  avutil)
+_ffmpeg_find(swscale    swscale.h
+  avutil)
+_ffmpeg_find(avcodec    avcodec.h
+  avutil)
+_ffmpeg_find(avformat   avformat.h
+  avcodec avutil)
+_ffmpeg_find(avfilter   avfilter.h
+  avutil)
+_ffmpeg_find(avdevice   avdevice.h
+  avformat avutil)
+
+if (TARGET FFMPEG::avutil)
+  set(_ffmpeg_version_header_path "${FFMPEG_avutil_INCLUDE_DIR}/libavutil/ffversion.h")
+  if (EXISTS "${_ffmpeg_version_header_path}")
+    file(STRINGS "${_ffmpeg_version_header_path}" _ffmpeg_version
+      REGEX "FFMPEG_VERSION")
+    string(REGEX REPLACE ".*\"n?\(.*\)\"" "\\1" FFMPEG_VERSION "${_ffmpeg_version}")
+    unset(_ffmpeg_version)
+  else ()
+    set(FFMPEG_VERSION FFMPEG_VERSION-NOTFOUND)
+  endif ()
+  unset(_ffmpeg_version_header_path)
+endif ()
+
+set(FFMPEG_INCLUDE_DIRS)
+set(FFMPEG_LIBRARIES)
+set(_ffmpeg_required_vars)
+foreach (_ffmpeg_component IN LISTS FFMPEG_FIND_COMPONENTS)
+  if (TARGET "FFMPEG::${_ffmpeg_component}")
+    set(FFMPEG_${_ffmpeg_component}_INCLUDE_DIRS
+      "${FFMPEG_${_ffmpeg_component}_INCLUDE_DIR}")
+    set(FFMPEG_${_ffmpeg_component}_LIBRARIES
+      "${FFMPEG_${_ffmpeg_component}_LIBRARY}")
+    list(APPEND FFMPEG_INCLUDE_DIRS
+      "${FFMPEG_${_ffmpeg_component}_INCLUDE_DIRS}")
+    list(APPEND FFMPEG_LIBRARIES
+      "${FFMPEG_${_ffmpeg_component}_LIBRARIES}")
+    if (FFMEG_FIND_REQUIRED_${_ffmpeg_component})
+      list(APPEND _ffmpeg_required_vars
+        "FFMPEG_${_ffmpeg_required_vars}_INCLUDE_DIRS"
+        "FFMPEG_${_ffmpeg_required_vars}_LIBRARIES")
+    endif ()
+  endif ()
+endforeach ()
+unset(_ffmpeg_component)
+
+if (FFMPEG_INCLUDE_DIRS)
+  list(REMOVE_DUPLICATES FFMPEG_INCLUDE_DIRS)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(FFMPEG
+  REQUIRED_VARS FFMPEG_INCLUDE_DIRS FFMPEG_LIBRARIES ${_ffmpeg_required_vars}
+  VERSION_VAR FFMPEG_VERSION
+  HANDLE_COMPONENTS)
+unset(_ffmpeg_required_vars)

viennaps.libs/cmake/vtk-9.3/FindFontConfig.cmake

@@ -0,0 +1,30 @@
+# SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+# SPDX-FileCopyrightText: Copyright 2012 Kitware, Inc.
+# SPDX-License-Identifier: BSD-3-Clause 
+# - Find FontConfig library
+# Find the FontConfig includes and library
+# This module defines
+#  FONTCONFIG_INCLUDE_DIR, where to find fontconfig.h
+#  FONTCONFIG_LIBRARIES, libraries to link against to use the FontConfig API.
+#  FONTCONFIG_FOUND, If false, do not try to use FontConfig.
+find_path(FONTCONFIG_INCLUDE_DIR fontconfig/fontconfig.h)
+
+find_library(FONTCONFIG_LIBRARY NAMES fontconfig)
+
+# handle the QUIETLY and REQUIRED arguments and set FONTCONFIG_FOUND to TRUE if
+# all listed variables are TRUE
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(FontConfig DEFAULT_MSG
+  FONTCONFIG_LIBRARY  FONTCONFIG_INCLUDE_DIR)
+
+if(FONTCONFIG_FOUND)
+  if (NOT TARGET FontConfig::FontConfig)
+    add_library(FontConfig::FontConfig UNKNOWN IMPORTED)
+    set_target_properties(FontConfig::FontConfig PROPERTIES
+      IMPORTED_LOCATION "${FONTCONFIG_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${FONTCONFIG_INCLUDE_DIR}")
+  endif ()
+  set( FONTCONFIG_LIBRARIES ${FONTCONFIG_LIBRARY} )
+endif()
+
+mark_as_advanced(FONTCONFIG_INCLUDE_DIR FONTCONFIG_LIBRARY FONTCONFIG_LIBRARIES)

viennaps.libs/cmake/vtk-9.3/FindFreetype.cmake

@@ -0,0 +1,282 @@
+# XXX: Copied from CMake, but includes vtkDetectLibraryType.
+# See https://gitlab.kitware.com/cmake/cmake/-/issues/18564
+
+#[=======================================================================[.rst:
+FindFreetype
+------------
+
+Find the FreeType font renderer includes and library.
+
+Imported Targets
+^^^^^^^^^^^^^^^^
+
+This module defines the following :prop_tgt:`IMPORTED` target:
+
+``Freetype::Freetype``
+  The Freetype ``freetype`` library, if found
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module will set the following variables in your project:
+
+``FREETYPE_FOUND``
+  true if the Freetype headers and libraries were found
+``FREETYPE_INCLUDE_DIRS``
+  directories containing the Freetype headers. This is the
+  concatenation of the variables:
+
+  ``FREETYPE_INCLUDE_DIR_ft2build``
+    directory holding the main Freetype API configuration header
+  ``FREETYPE_INCLUDE_DIR_freetype2``
+    directory holding Freetype public headers
+``FREETYPE_LIBRARIES``
+  the library to link against
+``FREETYPE_VERSION_STRING``
+  the version of freetype found (since CMake 2.8.8)
+
+Hints
+^^^^^
+
+The user may set the environment variable ``FREETYPE_DIR`` to the root
+directory of a Freetype installation.
+#]=======================================================================]
+
+# Created by Eric Wing.
+# Modifications by Alexander Neundorf.
+# This file has been renamed to "FindFreetype.cmake" instead of the correct
+# "FindFreeType.cmake" in order to be compatible with the one from KDE4, Alex.
+
+# Ugh, FreeType seems to use some #include trickery which
+# makes this harder than it should be. It looks like they
+# put ft2build.h in a common/easier-to-find location which
+# then contains a #include to a more specific header in a
+# more specific location (#include <freetype/config/ftheader.h>).
+# Then from there, they need to set a bunch of #define's
+# so you can do something like:
+# #include FT_FREETYPE_H
+# Unfortunately, using CMake's mechanisms like include_directories()
+# wants explicit full paths and this trickery doesn't work too well.
+# I'm going to attempt to cut out the middleman and hope
+# everything still works.
+
+set(_Freetype_args)
+if (Freetype_FIND_QUIETLY)
+  list(APPEND _Freetype_args
+    QUIET)
+endif ()
+if (Freetype_FIND_VERSION)
+  list(APPEND _Freetype_args
+    "${Freetype_FIND_VERSION}")
+  if (Freetype_FIND_VERSION_EXACT)
+    list(APPEND _Freetype_args
+      EXACT)
+  endif ()
+endif ()
+set(_Freetype_component_req)
+set(_Freetype_component_opt)
+foreach (_Freetype_component IN LISTS Freetype_FIND_COMPONENTS)
+  if (Freetype_FIND_REQUIRE_${_Freetype_component})
+    list(APPEND _Freetype_component_req
+      "${_Freetype_component}")
+  else ()
+    list(APPEND _Freetype_component_opt
+      "${_Freetype_component}")
+  endif ()
+endforeach ()
+unset(_Freetype_component)
+if (_Freetype_component_req)
+  list(APPEND _Freetype_args
+    COMPONENTS "${_Freetype_component_req}")
+endif ()
+unset(_Freetype_component_req)
+if (_Freetype_component_opt)
+  list(APPEND _Freetype_args
+    OPTIONAL_COMPONENTS "${_Freetype_component_opt}")
+endif ()
+unset(_Freetype_component_opt)
+find_package(freetype CONFIG ${_Freetype_args})
+unset(_Freetype_args)
+if (freetype_FOUND)
+  if (NOT TARGET Freetype::Freetype)
+    add_library(Freetype::Freetype IMPORTED INTERFACE)
+    set_target_properties(Freetype::Freetype PROPERTIES
+      INTERFACE_LINK_LIBRARIES freetype)
+  endif ()
+  get_property(FREETYPE_INCLUDE_DIRS TARGET freetype PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
+  get_property(FREETYPE_LIBRARIES TARGET freetype PROPERTY INTERFACE_LINK_LIBRARIES)
+  get_property(_Freetype_location TARGET freetype PROPERTY LOCATION)
+  list(APPEND FREETYPE_LIBRARIES
+    "${_Freetype_location}")
+  unset(_Freetype_location)
+  set(Freetype_FOUND 1)
+  set(FREETYPE_VERSION_STRING "${freetype_VERSION}")
+  foreach (_Freetype_component IN LISTS Freetype_FIND_COMPONENTS)
+    set(Freetype_${_Freetype_component}_FOUND "${freetype_${_Freetype_component}_FOUND}")
+  endforeach ()
+  unset(_Freetype_component)
+  return ()
+endif ()
+
+set(FREETYPE_FIND_ARGS
+  HINTS
+    ENV FREETYPE_DIR
+  PATHS
+    ENV GTKMM_BASEPATH
+    [HKEY_CURRENT_USER\\SOFTWARE\\gtkmm\\2.4;Path]
+    [HKEY_LOCAL_MACHINE\\SOFTWARE\\gtkmm\\2.4;Path]
+)
+
+find_path(
+  FREETYPE_INCLUDE_DIR_ft2build
+  ft2build.h
+  ${FREETYPE_FIND_ARGS}
+  PATH_SUFFIXES
+    include/freetype2
+    include
+    freetype2
+)
+
+find_path(
+  FREETYPE_INCLUDE_DIR_freetype2
+  NAMES
+    freetype/config/ftheader.h
+    config/ftheader.h
+  ${FREETYPE_FIND_ARGS}
+  PATH_SUFFIXES
+    include/freetype2
+    include
+    freetype2
+)
+
+if(NOT FREETYPE_LIBRARY)
+  find_library(FREETYPE_LIBRARY_RELEASE
+    NAMES
+      freetype
+      libfreetype
+      freetype219
+    ${FREETYPE_FIND_ARGS}
+    PATH_SUFFIXES
+      lib
+  )
+  find_library(FREETYPE_LIBRARY_DEBUG
+    NAMES
+      freetyped
+      libfreetyped
+      freetype219d
+    ${FREETYPE_FIND_ARGS}
+    PATH_SUFFIXES
+      lib
+  )
+  include(SelectLibraryConfigurations)
+  select_library_configurations(FREETYPE)
+else()
+  # on Windows, ensure paths are in canonical format (forward slahes):
+  file(TO_CMAKE_PATH "${FREETYPE_LIBRARY}" FREETYPE_LIBRARY)
+endif()
+
+unset(FREETYPE_FIND_ARGS)
+
+# set the user variables
+if(FREETYPE_INCLUDE_DIR_ft2build AND FREETYPE_INCLUDE_DIR_freetype2)
+  set(FREETYPE_INCLUDE_DIRS "${FREETYPE_INCLUDE_DIR_ft2build};${FREETYPE_INCLUDE_DIR_freetype2}")
+  list(REMOVE_DUPLICATES FREETYPE_INCLUDE_DIRS)
+endif()
+set(FREETYPE_LIBRARIES "${FREETYPE_LIBRARY}")
+
+if(EXISTS "${FREETYPE_INCLUDE_DIR_freetype2}/freetype/freetype.h")
+  set(FREETYPE_H "${FREETYPE_INCLUDE_DIR_freetype2}/freetype/freetype.h")
+elseif(EXISTS "${FREETYPE_INCLUDE_DIR_freetype2}/freetype.h")
+  set(FREETYPE_H "${FREETYPE_INCLUDE_DIR_freetype2}/freetype.h")
+endif()
+
+if(FREETYPE_INCLUDE_DIR_freetype2 AND FREETYPE_H)
+  file(STRINGS "${FREETYPE_H}" freetype_version_str
+       REGEX "^#[\t ]*define[\t ]+FREETYPE_(MAJOR|MINOR|PATCH)[\t ]+[0-9]+$")
+
+  unset(FREETYPE_VERSION_STRING)
+  foreach(VPART MAJOR MINOR PATCH)
+    foreach(VLINE ${freetype_version_str})
+      if(VLINE MATCHES "^#[\t ]*define[\t ]+FREETYPE_${VPART}[\t ]+([0-9]+)$")
+        set(FREETYPE_VERSION_PART "${CMAKE_MATCH_1}")
+        if(FREETYPE_VERSION_STRING)
+          string(APPEND FREETYPE_VERSION_STRING ".${FREETYPE_VERSION_PART}")
+        else()
+          set(FREETYPE_VERSION_STRING "${FREETYPE_VERSION_PART}")
+        endif()
+        unset(FREETYPE_VERSION_PART)
+      endif()
+    endforeach()
+  endforeach()
+endif()
+
+include(FindPackageHandleStandardArgs)
+
+find_package_handle_standard_args(
+  Freetype
+  REQUIRED_VARS
+    FREETYPE_LIBRARY
+    FREETYPE_INCLUDE_DIRS
+  VERSION_VAR
+    FREETYPE_VERSION_STRING
+)
+
+mark_as_advanced(
+  FREETYPE_INCLUDE_DIR_freetype2
+  FREETYPE_INCLUDE_DIR_ft2build
+)
+
+if(Freetype_FOUND)
+  if(NOT TARGET Freetype::Freetype)
+    include(vtkDetectLibraryType)
+    set(freetype_library_type UNKNOWN)
+    if (FREETYPE_LIBRARY_RELEASE)
+      vtk_detect_library_type(freetype_release_library_type
+        PATH "${FREETYPE_LIBRARY_RELEASE}")
+    endif ()
+    if (FREETYPE_LIBRARY_DEBUG)
+      vtk_detect_library_type(freetype_debug_library_type
+        PATH "${FREETYPE_LIBRARY_DEBUG}")
+    endif ()
+    if (freetype_release_library_type AND freetype_debug_library_type)
+      if (freetype_release_library_type STREQUAL freetype_debug_library_type)
+        set(freetype_library_type "${freetype_release_library_type}")
+      endif ()
+    elseif (freetype_release_library_type)
+      set(freetype_library_type "${freetype_release_library_type}")
+    elseif (freetype_debug_library_type)
+      set(freetype_library_type "${freetype_debug_library_type}")
+    endif ()
+    add_library(Freetype::Freetype "${freetype_library_type}" IMPORTED)
+    unset(freetype_release_library_type)
+    unset(freetype_debug_library_type)
+    unset(freetype_library_type)
+    set_target_properties(Freetype::Freetype PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES "${FREETYPE_INCLUDE_DIRS}")
+
+    if(FREETYPE_LIBRARY_RELEASE)
+      set_property(TARGET Freetype::Freetype APPEND PROPERTY
+        IMPORTED_CONFIGURATIONS RELEASE)
+      set_target_properties(Freetype::Freetype PROPERTIES
+        IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C"
+        IMPORTED_LOCATION_RELEASE "${FREETYPE_LIBRARY_RELEASE}"
+        IMPORTED_IMPLIB_RELEASE "${FREETYPE_LIBRARY_RELEASE}")
+    endif()
+
+    if(FREETYPE_LIBRARY_DEBUG)
+      set_property(TARGET Freetype::Freetype APPEND PROPERTY
+        IMPORTED_CONFIGURATIONS DEBUG)
+      set_target_properties(Freetype::Freetype PROPERTIES
+        IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "C"
+        IMPORTED_LOCATION_DEBUG "${FREETYPE_LIBRARY_DEBUG}"
+        IMPORTED_IMPLIB_DEBUG "${FREETYPE_LIBRARY_DEBUG}")
+    endif()
+
+    if(NOT FREETYPE_LIBRARY_RELEASE AND NOT FREETYPE_LIBRARY_DEBUG)
+      set_target_properties(Freetype::Freetype PROPERTIES
+        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+        IMPORTED_LOCATION "${FREETYPE_LIBRARY}"
+        IMPORTED_IMPLIB "${FREETYPE_LIBRARY}")
+    endif()
+  endif()
+endif()

viennaps.libs/cmake/vtk-9.3/FindGL2PS.cmake

@@ -0,0 +1,38 @@
+find_path(GL2PS_INCLUDE_DIR
+  NAMES gl2ps.h
+  DOC "gl2ps include directories")
+mark_as_advanced(GL2PS_INCLUDE_DIR)
+
+find_library(GL2PS_LIBRARY
+  NAMES gl2ps
+  DOC "gl2ps library")
+mark_as_advanced(GL2PS_LIBRARY)
+
+if (GL2PS_INCLUDE_DIR)
+  file(STRINGS "${GL2PS_INCLUDE_DIR}/gl2ps.h" _gl2ps_version_lines REGEX "#define[ \t]+GL2PS_(MAJOR|MINOR|PATCH)_VERSION[ \t]+")
+  string(REGEX REPLACE ".*GL2PS_MAJOR_VERSION *\([0-9]*\).*" "\\1" _gl2ps_version_major "${_gl2ps_version_lines}")
+  string(REGEX REPLACE ".*GL2PS_MINOR_VERSION *\([0-9]*\).*" "\\1" _gl2ps_version_minor "${_gl2ps_version_lines}")
+  string(REGEX REPLACE ".*GL2PS_PATCH_VERSION *\([0-9]*\).*" "\\1" _gl2ps_version_patch "${_gl2ps_version_lines}")
+  set(GL2PS_VERSION "${_gl2ps_version_major}.${_gl2ps_version_minor}.${_gl2ps_version_patch}")
+  unset(_gl2ps_version_major)
+  unset(_gl2ps_version_minor)
+  unset(_gl2ps_version_patch)
+  unset(_gl2ps_version_lines)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(GL2PS
+  REQUIRED_VARS GL2PS_LIBRARY GL2PS_INCLUDE_DIR
+  VERSION_VAR GL2PS_VERSION)
+
+if (GL2PS_FOUND)
+  set(GL2PS_INCLUDE_DIRS "${GL2PS_INCLUDE_DIR}")
+  set(GL2PS_LIBRARIES "${GL2PS_LIBRARY}")
+
+  if (NOT TARGET GL2PS::GL2PS)
+    add_library(GL2PS::GL2PS UNKNOWN IMPORTED)
+    set_target_properties(GL2PS::GL2PS PROPERTIES
+      IMPORTED_LOCATION "${GL2PS_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${GL2PS_INCLUDE_DIR}")
+  endif ()
+endif ()

viennaps.libs/cmake/vtk-9.3/FindGLEW.cmake

@@ -0,0 +1,28 @@
+find_path(GLEW_INCLUDE_DIR
+  NAMES GL/glew.h
+  DOC "glew include directory")
+mark_as_advanced(GLEW_INCLUDE_DIR)
+find_library(GLEW_LIBRARY
+  NAMES GLEW glew32
+  DOC "glew library")
+mark_as_advanced(GLEW_LIBRARY)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(GLEW REQUIRED_VARS GLEW_LIBRARY GLEW_INCLUDE_DIR)
+
+if (GLEW_FOUND)
+  set(GLEW_INCLUDE_DIRS "${GLEW_INCLUDE_DIR}")
+  set(GLEW_LIBRARIES "${GLEW_LIBRARY}")
+
+  if (NOT TARGET GLEW::GLEW)
+    include(vtkDetectLibraryType)
+    vtk_detect_library_type(glew_library_type
+      PATH "${GLEW_LIBRARY}")
+    add_library(GLEW::GLEW "${glew_library_type}" IMPORTED)
+    unset(glew_library_type)
+    set_target_properties(GLEW::GLEW PROPERTIES
+      IMPORTED_LOCATION "${GLEW_LIBRARY}"
+      IMPORTED_IMPLIB "${GLEW_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${GLEW_INCLUDE_DIR}")
+  endif ()
+endif ()

viennaps.libs/cmake/vtk-9.3/FindJOGL.cmake

@@ -0,0 +1,64 @@
+if (COMMAND "find_jar")
+  set(_jogl_versions
+    ${JOGL_EXTRA_VERSIONS} 2.3.2)
+
+  set(_JOGL_Java_JAR_PATHS)
+  if (DEFINED Java_JAR_PATHS)
+    set(_JOGL_Java_JAR_PATHS "${Java_JAR_PATHS}")
+  endif ()
+
+  foreach (_JOGL_prefix IN ITEMS "${CMAKE_INSTALL_PREFIX}" /usr/local /usr)
+    foreach (_JOGL_libdir IN ITEMS "${CMAKE_INSTALL_LIBDIR}" lib64 lib)
+      list(APPEND Java_JAR_PATHS
+        "${_JOGL_prefix}/${_JOGL_libdir}/java"
+        "${_JOGL_prefix}/${_JOGL_libdir}")
+    endforeach ()
+  endforeach ()
+  list(REMOVE_DUPLICATES Java_JAR_PATHS)
+  unset(_JOGL_libdir)
+  unset(_JOGL_prefix)
+
+  find_jar(JOGL_LIB
+    NAMES jogl-all jogl2
+    PATHS # Abuse the argument parser in `find_jar`
+    PATH_SUFFIXES jogl2
+    VERSIONS ${_jogl_versions}
+    DOC "Path to the JOGL jar")
+  mark_as_advanced(JOGL_LIB)
+
+  find_jar(JOGL_GLUE
+    NAMES gluegen-rt gluegen2-rt
+    VERSIONS ${_jogl_versions}
+    PATHS # Abuse the argument parser in `find_jar`
+    PATH_SUFFIXES gluegen2
+    DOC "Path to the JOGL gluegen jar")
+  mark_as_advanced(JOGL_GLUE)
+
+  set(Java_JAR_PATHS)
+  if (DEFINED _JOGL_Java_JAR_PATHS)
+    set(Java_JAR_PATHS "${_JOGL_Java_JAR_PATHS}")
+  endif ()
+  unset(_JOGL_Java_JAR_PATHS)
+
+  unset(_jogl_versions)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(JOGL
+  REQUIRED_VARS JOGL_LIB JOGL_GLUE)
+
+if (JOGL_FOUND)
+  if (NOT TARGET JOGL::glue)
+    add_library(JOGL::glue STATIC IMPORTED)
+    set_target_properties(JOGL::glue PROPERTIES
+      IMPORTED_LINK_INTERFACE_LANGUAGES Java
+      IMPORTED_LOCATION "${JOGL_GLUE}")
+  endif ()
+  if (NOT TARGET JOGL::JOGL)
+    add_library(JOGL::JOGL STATIC IMPORTED)
+    set_target_properties(JOGL::JOGL PROPERTIES
+      IMPORTED_LINK_INTERFACE_LANGUAGES Java
+      IMPORTED_LOCATION "${JOGL_LIB}"
+      INTERFACE_LINK_LIBRARIES "JOGL::glue")
+  endif ()
+endif ()