diff --git a/CMakeLists.txt b/CMakeLists.txt index a85373670..d806c186f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -97,7 +97,18 @@ if( APPLE ) endif() # Add our module path -set( CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake-proxies/cmake-modules) +# CMAKE_BINARY_DIR is required for Conan to work +set( AUDACITY_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake-proxies/cmake-modules") +set( CMAKE_MODULE_PATH + ${AUDACITY_MODULE_PATH} + ${CMAKE_BINARY_DIR} + ${CMAKE_MODULE_PATH} +) + +set( CMAKE_PREFIX_PATH + ${CMAKE_BINARY_DIR} + ${CMAKE_PREFIX_PATH} +) # This "is a good thing" but greatly increases link time on Linux #set( CMAKE_INTERPROCEDURAL_OPTIMIZATION ON ) @@ -116,6 +127,9 @@ if( CCACHE_PROGRAM ) set_property( GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}" ) endif() +# Define option() prefix +set( _OPT "audacity_" ) + # Our very own project project( Audacity ) @@ -125,7 +139,7 @@ include( AudacityFunctions ) # Allow user to globally set the library preference cmd_option( ${_OPT}lib_preference "Library preference [system (if available), local]" - "local" + "system" STRINGS "system" "local" ) @@ -215,9 +229,6 @@ endif() message( STATUS " Current Commit: ${GIT_COMMIT_SHORT}" ) message( STATUS ) -# Define option() prefix -set( _OPT "audacity_" ) - # Organize subdirectories/targets into folders for the IDEs set_property( GLOBAL PROPERTY USE_FOLDERS ON ) @@ -437,6 +448,7 @@ find_package( Python3 ) if( Python3_FOUND ) set( PYTHON "${Python3_EXECUTABLE}" ) elseif( CMAKE_SYSTEM_NAME MATCHES "Windows" ) + # This is an odd case now, as Conan requires Python as well nuget_package( pkgdir "python3" "3.7.7" ) file( TO_NATIVE_PATH "${pkgdir}/tools/python.exe" PYTHON ) endif() @@ -447,6 +459,10 @@ include( "src/Experimental.cmake" ) # Add our children add_subdirectory( "cmake-proxies" ) + +# Conan uses find_package and does not set GLOBAL flag +resolve_conan_dependencies() + add_subdirectory( "help" ) add_subdirectory( "images" ) add_subdirectory( "libraries" ) diff --git a/cmake-proxies/CMakeLists.txt b/cmake-proxies/CMakeLists.txt index 6b09cc606..74d609ef2 100644 --- a/cmake-proxies/CMakeLists.txt +++ b/cmake-proxies/CMakeLists.txt @@ -1,22 +1,96 @@ -# Allow user to globally set the library preference -cmd_option( ${_OPT}lib_preference - "Library preference [system (if available), local]" - "system" - STRINGS "system" "local" +add_conan_lib( + ZLIB + zlib/1.2.11 + REQUIRED + PGK_CONFIG "zlib >= 1.2.11" + INTERFACE_NAME ZLIB::ZLIB + OPTION_NAME zlib + CONAN_OPTIONS + zlib:shared=True ) -# Special mode, that will force dependencies to the packages provided by system unless they were set to local explicitly. -cmd_option( ${_OPT}obey_system_dependencies - "Use system packages to satisfy dependencies" - Off +add_conan_lib( + expat + expat/2.2.9 + REQUIRED + PGK_CONFIG "expat >= 2.1.0" + CONAN_OPTIONS + expat:shared=True ) +set(wx_zlib "zlib") +set(wx_png "libpng") + +if (${_OPT}use_zlib STREQUAL "system") + set(wx_zlib "sys") + # To prevent linking conflicts - we need to use system libpng as well. + # wxWdigets will attempt to resolve it using find_package + set(wx_png "sys") +endif() + +set(wx_expat "expat") + +if (${_OPT}use_expat STREQUAL "system") + set(wx_expat "sys") +endif() + +add_conan_lib( + wxWidgets + wxwidgets/3.1.3-audacity + REQUIRED + ALWAYS_ALLOW_CONAN_FALLBACK + OPTION_NAME wxwidgets + FIND_PACKAGE_OPTIONS COMPONENTS adv base core html qa xml net + INTERFACE_NAME wxwidgets::wxwidgets + CONAN_OPTIONS + wxwidgets:shared=True + wxwidgets:zlib=${wx_zlib} + wxwidgets:expat=${wx_expat} + wxwidgets:compatibility=3.0 + wxwidgets:png=${wx_png} + wxwidgets:tiff=off + wxwidgets:secretstore=False + wxwidgets:opengl=False + wxwidgets:propgrid=False + wxwidgets:ribbon=False + wxwidgets:richtext=False + wxwidgets:stc=False + wxwidgets:webview=False + wxwidgets:help=False + wxwidgets:html_help=False + wxwidgets:fs_inet=False + wxwidgets:protocol=False +) + +add_conan_lib( + libmp3lame + libmp3lame/3.100 + REQUIRED + INTERFACE_NAME libmp3lame::libmp3lame + PGK_CONFIG "lame >= 3.100" +) + +add_conan_lib( + libid3tag + libid3tag/0.15.1b + OPTION_NAME id3tag + HAS_ONLY_DEBUG_RELEASE + PGK_CONFIG "id3tag >= 0.15.1b" +) + +add_conan_lib( + libmad + libmad/0.15.1b + OPTION_NAME mad + HAS_ONLY_DEBUG_RELEASE + PGK_CONFIG "mad >= 0.15.1b" +) + +set_conan_vars_to_parent() + # Required libraries # # directory option symbol req chk version -addlib( wxWidgets wxwidgets WX YES NO "" ) # must be first -addlib( expat expat EXPAT YES YES "expat >= 2.1.0" ) -addlib( lame lame LAME YES YES "lame >= 3.100" ) addlib( libsndfile sndfile SNDFILE YES YES "sndfile >= 1.0.28" ) addlib( libsoxr soxr SOXR YES YES "soxr >= 0.1.1" ) addlib( portaudio-v19 portaudio PORTAUDIO YES YES "" ) @@ -26,8 +100,6 @@ addlib( sqlite sqlite SQLITE YES YES "sqlite3 >= 3.32. # # directory option symbol req chk version addlib( ffmpeg ffmpeg FFMPEG NO NO "libavcodec >= 51.53" "libavformat >= 52.12" "libavutil >= 52.66" ) -addlib( libid3tag id3tag LIBID3TAG NO YES "id3tag >= 0.15.1b" ) -addlib( libmad mad LIBMAD NO YES "mad >= 0.15.1b" ) addlib( libnyquist nyquist NYQUIST NO YES "" ) addlib( libvamp vamp VAMP NO YES "vamp >= 2.5" "vamp-hostsdk >= 2.5" ) addlib( libogg ogg LIBOGG NO YES "ogg >= 1.3.1" ) @@ -53,4 +125,3 @@ addlib( portsmf portsmf PORTSMF NO YES "portSMF >= 0.1" addlib( libsbsms sbsms SBSMS NO YES "sbsms >= 2.2.0" ) addlib( soundtouch soundtouch SOUNDTOUCH NO YES "soundtouch >= 1.7.1" ) addlib( twolame twolame LIBTWOLAME NO YES "twolame >= 0.3.13" ) - diff --git a/cmake-proxies/cmake-modules/AudacityDependencies.cmake b/cmake-proxies/cmake-modules/AudacityDependencies.cmake new file mode 100644 index 000000000..f5200f010 --- /dev/null +++ b/cmake-proxies/cmake-modules/AudacityDependencies.cmake @@ -0,0 +1,269 @@ +# Load Conan +include( conan ) + +conan_add_remote(NAME audacity + URL https://artifactory.audacityteam.org/artifactory/api/conan/conan-local + VERIFY_SSL True +) + +set( CONAN_BUILD_REQUIRES ) +set( CONAN_REQUIRES ) +set( CONAN_PACKAGE_OPTIONS ) +set( CONAN_ONLY_DEBUG_RELEASE ) +set( CONAN_CONFIG_OPTIONS ) +set( CONAN_RESOLVE_LIST ) + +# Add a Conan dependency +# Example usage: +# add_conan_lib( +# wxWdidget +# wxwidgets/3.1.3-audacity +# OPTION_NAME wxwidgets +# SYMBOL WXWIDGET +# REQUIRED +# ALWAYS_ALLOW_CONAN_FALLBACK +# PGK_CONFIG "wxwidgets >= 3.1.3" +# FIND_PACKAGE_OPTIONS COMPONENTS adv base core html qa xml +# INTERFACE_NAME wxwidgets::wxwidgets +# HAS_ONLY_DEBUG_RELEASE +# CONAN_OPTIONS +# wxwidgets:shared=True +# ) + + +function (add_conan_lib package conan_package_name ) + # Extract the list of packages from the function args + list( SUBLIST ARGV 2 -1 options ) + + set( list_mode on ) + set( current_var "conan_package_options" ) + + set( option_name_base ${package} ) + set( allow_find_package off ) + set( find_package_options ) + set( conan_package_options ) + set( required off ) + set( pkg_config_options ) + set( system_only ${${_OPT}obey_system_dependencies}) + set( interface_name "${package}::${package}") + + # Parse function arguments + + foreach( opt IN LISTS options ) + if( opt STREQUAL "FIND_PACKAGE_OPTIONS" ) + set( list_mode on ) + set( allow_find_package on ) + set( current_var "find_package_options" ) + elseif ( opt STREQUAL "CONAN_OPTIONS" ) + set( list_mode on ) + set( current_var "conan_package_options" ) + elseif ( opt STREQUAL "PGK_CONFIG" ) + set( list_mode on ) + set( current_var "pkg_config_options" ) + elseif ( opt STREQUAL "OPTION_NAME" ) + set( list_mode off ) + set( current_var "option_name_base" ) + elseif ( opt STREQUAL "SYMBOL" ) + set( list_mode off ) + set( current_var "symbol" ) + elseif ( opt STREQUAL "INTERFACE_NAME" ) + set( list_mode off ) + set( current_var "interface_name" ) + elseif ( opt STREQUAL "REQUIRED" ) + set( required on ) + elseif ( opt STREQUAL "ALWAYS_ALLOW_CONAN_FALLBACK" ) + set( system_only off ) + elseif ( opt STREQUAL "HAS_ONLY_DEBUG_RELEASE" ) + set ( only_debug_release on ) + else() + if( list_mode ) + list( APPEND ${current_var} ${opt} ) + else() + set (${current_var} ${opt}) + endif() + endif() + endforeach() + + if( NOT DEFINED symbol ) + string( TOUPPER "${option_name_base}" symbol) + endif() + + # Generate CMake option + set( option_name ${_OPT}use_${option_name_base} ) + + set( option_desc "local" ) + + if( pkg_config_options OR allow_find_package ) + set( sysopt "system" ) + string( PREPEND option_desc "system (if available), " ) + set( default "${${_OPT}lib_preference}" ) + else() + set( default "local" ) + endif() + + if( NOT required ) + set( reqopt "off" ) + string( APPEND option_desc ", off" ) + endif() + + cmd_option( ${option_name} + "Use ${option_name_base} library [${option_desc}]" + "${default}" + STRINGS ${sysopt} "local" ${reqopt} + ) + + # Early bail out + if( ${option_name} STREQUAL "off" ) + + message( STATUS "========== ${option_name_base} disabled ==========" ) + + set( USE_${symbol} OFF CACHE INTERNAL "" FORCE ) + + return() + endif() + + # Let the Audacity target know that this library will be used + set( USE_${symbol} ON CACHE INTERNAL "" FORCE ) + + if ( TARGET "${package}" ) + return() + endif() + + if( ${option_name} STREQUAL "system" ) + if( pkg_config_options ) + pkg_check_modules( PKG_${package} ${pkg_config_options} ) + + if( PKG_${package}_FOUND ) + message( STATUS "Using '${package}' system library" ) + + # Create the target interface library + add_library( ${interface_name} INTERFACE IMPORTED GLOBAL) + + # Retrieve the package information + get_package_interface( PKG_${package} ) + + # And add it to our target + target_include_directories( ${interface_name} INTERFACE ${INCLUDES} ) + target_link_libraries( ${interface_name} INTERFACE ${LIBRARIES} ) + + message(STATUS "Added inteface ${interface_name} ${INCLUDES} ${LIBRARIES}") + return() + endif() + endif() + + if( allow_find_package ) + find_package( ${package} QUIET ${find_package_options} ) + + if ( ${package}_FOUND ) + message( STATUS "Using '${package}' system library" ) + return() + endif() + endif() + + if( system_only ) + message( FATAL_ERROR "Failed to find the system package ${package}" ) + else() + set( ${option_name} "local" ) + set_property( CACHE ${option_name} PROPERTY VALUE "local" ) + endif() + endif() + + list( APPEND CONAN_REQUIRES ${conan_package_name} ) + list( APPEND CONAN_PACKAGE_OPTIONS ${conan_package_options} ) + list( APPEND CONAN_RESOLVE_LIST ${package} ) + + if ( only_debug_release ) + message( STATUS "${package} only has Debug and Release versions" ) + list( APPEND CONAN_ONLY_DEBUG_RELEASE ${package}) + endif() + + set( CONAN_REQUIRES ${CONAN_REQUIRES} PARENT_SCOPE ) + set( CONAN_PACKAGE_OPTIONS ${CONAN_PACKAGE_OPTIONS} PARENT_SCOPE ) + set( CONAN_RESOLVE_LIST ${CONAN_RESOLVE_LIST} PARENT_SCOPE ) + set( CONAN_ONLY_DEBUG_RELEASE ${CONAN_ONLY_DEBUG_RELEASE} PARENT_SCOPE ) + + message (STATUS "Adding Conan dependency ${package}") +endfunction() + +macro( set_conan_vars_to_parent ) + set( CONAN_REQUIRES ${CONAN_REQUIRES} PARENT_SCOPE ) + set( CONAN_PACKAGE_OPTIONS ${CONAN_PACKAGE_OPTIONS} PARENT_SCOPE ) + set( CONAN_RESOLVE_LIST ${CONAN_RESOLVE_LIST} PARENT_SCOPE ) + set( CONAN_BUILD_REQUIRES ${CONAN_BUILD_REQUIRES} PARENT_SCOPE ) + set( CONAN_ONLY_DEBUG_RELEASE ${CONAN_ONLY_DEBUG_RELEASE} PARENT_SCOPE ) +endmacro() + +function ( _conan_install build_type ) + conan_cmake_configure ( + REQUIRES ${CONAN_REQUIRES} + GENERATORS cmake_find_package_multi + BUILD_REQUIRES ${CONAN_BUILD_REQUIRES} + ${CONAN_CONFIG_OPTIONS} + IMPORTS "bin, *.dll -> ./bin/shared/${build_type} @ keep_path=False" + IMPORTS "lib, *.dll -> ./bin/shared/${build_type} @ keep_path=False" + IMPORTS "lib, *.dylib -> ./lib/shared/${build_type} @ keep_path=False" + IMPORTS "lib, *.so* -> ./lib/shared/${build_type} @ keep_path=False" + OPTIONS ${CONAN_PACKAGE_OPTIONS} + ) + + message(STATUS "Configuring packages for ${build_type}") + + conan_cmake_autodetect(settings BUILD_TYPE ${build_type}) + + if( CMAKE_SYSTEM_NAME MATCHES "Darwin" ) + # We have no AppleSilicon support yet + list( APPEND settings "arch=x86_64" ) + list (APPEND settings "os.version=${CMAKE_OSX_DEPLOYMENT_TARGET}") + endif() + + if (build_type MATCHES "MinSizeRel|RelWithDebInfo") + message(STATUS "Release only libraries: ${CONAN_ONLY_DEBUG_RELEASE}") + + foreach( package ${CONAN_ONLY_DEBUG_RELEASE} ) + list( APPEND settings "${package}:build_type=Release") + endforeach() + endif() + + + conan_cmake_install(PATH_OR_REFERENCE . + BUILD missing + SETTINGS ${settings} + ) +endfunction() + +macro( resolve_conan_dependencies ) + message(STATUS + "Executing Conan: \ + REQUIRES ${CONAN_REQUIRES} + GENERATORS cmake_find_package_multi + BUILD_REQUIRES ${CONAN_BUILD_REQUIRES} + ${CONAN_CONFIG_OPTIONS} + OPTIONS ${CONAN_PACKAGE_OPTIONS} + ") + + if(MSVC OR XCODE) + foreach(TYPE ${CMAKE_CONFIGURATION_TYPES}) + _conan_install(${TYPE}) + endforeach() + else() + _conan_install(${CMAKE_BUILD_TYPE}) + endif() + + list( REMOVE_DUPLICATES CONAN_REQUIRES ) + + foreach( package ${CONAN_RESOLVE_LIST} ) + message(STATUS "Resolving Conan library ${package}") + + find_package(${package} CONFIG) + + if (NOT ${package}_FOUND) + message( FATAL_ERROR "Failed to find the conan package ${package}" ) + endif() + endforeach() + + file(GLOB dependency_helpers "${AUDACITY_MODULE_PATH}/dependencies/*.cmake") + + foreach(f ${dependency_helpers}) + include(${f}) + endforeach() +endmacro() diff --git a/cmake-proxies/cmake-modules/CopyLibs.cmake b/cmake-proxies/cmake-modules/CopyLibs.cmake index ddb5d9ae6..ec0f74fed 100644 --- a/cmake-proxies/cmake-modules/CopyLibs.cmake +++ b/cmake-proxies/cmake-modules/CopyLibs.cmake @@ -7,7 +7,7 @@ # DST destination directory # message( "==================================================================" ) -message( "Copying wxWidgets libraries:" ) +message( "Copying shared libraries:" ) message( "==================================================================" ) # list command no longer ignores empty elements. @@ -39,48 +39,57 @@ function( gather_libs src ) execute( output cmd /k dumpbin /dependents ${src} ) foreach( line ${output} ) - if( line MATCHES "^ *wx.*\\.dll" ) - set( lib ${WXWIN}/${line} ) + set( lib ${WXWIN}/${line} ) + if( EXISTS "${lib}" ) list( APPEND libs ${lib} ) gather_libs( ${lib} ) endif() endforeach() elseif( CMAKE_HOST_SYSTEM_NAME MATCHES "Darwin" ) + message(STATUS "Checking ${src} for libraries...") + execute( output otool -L ${src} ) - get_filename_component( libname "${src}" NAME ) - - if( libname MATCHES ".*dylib" ) - string( PREPEND libname "${DST}/" ) - else() - set( libname "${src}" ) - endif() - + set( libname "${src}" ) + foreach( line ${output} ) - if( line MATCHES "^.*libwx.*\\.dylib " ) + if( line MATCHES "^.*\\.dylib " ) string( REGEX REPLACE "dylib .*" "dylib" line "${line}" ) - if( NOT line STREQUAL "${src}" AND NOT line MATCHES "@executable" ) - set( lib ${line} ) + set( lib "${WXWIN}/${line}" ) + + if( NOT lib STREQUAL "${src}" AND NOT line MATCHES "@executable" AND EXISTS "${lib}") + message(STATUS "\tProcessing ${lib}...") list( APPEND libs ${lib} ) get_filename_component( refname "${lib}" NAME ) - list( APPEND postcmds "sh -c 'install_name_tool -change ${lib} @executable_path/../Frameworks/${refname} ${libname}'" ) + + message(STATUS "\t\tAdding ${refname} to ${src}") + + list( APPEND postcmds "sh -c 'install_name_tool -change ${refname} @executable_path/../Frameworks/${refname} ${src}'" ) gather_libs( ${lib} ) endif() endif() endforeach() elseif( CMAKE_HOST_SYSTEM_NAME MATCHES "Linux" ) + message(STATUS "Executing LD_LIBRARY_PATH='${WXWIN}' ldd ${src}") + execute( output sh -c "LD_LIBRARY_PATH='${WXWIN}' ldd ${src}" ) get_filename_component( libname "${src}" NAME ) foreach( line ${output} ) - if( line MATCHES ".*libwx.*" ) - string( REGEX REPLACE ".* => (.*) \\(.*$" "\\1" line "${line}" ) + message (STATUS "\tChecking ${line}...") + + string( REGEX REPLACE "(.*) => .* \\(.*$" "\\1" line "${line}" ) + + set(line "${WXWIN}/${line}") + + if (EXISTS "${line}") + message (STATUS "\tAdding ${line}...") set( lib ${line} ) @@ -88,6 +97,7 @@ function( gather_libs src ) gather_libs( ${lib} ) endif() + endforeach() endif() @@ -97,9 +107,7 @@ endfunction() gather_libs( "${SRC}" ) -list( REMOVE_DUPLICATES libs ) - -file( INSTALL ${libs} DESTINATION ${DST} FOLLOW_SYMLINK_CHAIN ) +list( REMOVE_DUPLICATES postcmds ) foreach( cmd ${postcmds} ) execute_process( @@ -109,3 +117,5 @@ foreach( cmd ${postcmds} ) ) endforeach() +list( REMOVE_DUPLICATES libs ) +file( INSTALL ${libs} DESTINATION ${DST} FOLLOW_SYMLINK_CHAIN ) diff --git a/cmake-proxies/cmake-modules/conan.cmake b/cmake-proxies/cmake-modules/conan.cmake new file mode 100644 index 000000000..cabb352ff --- /dev/null +++ b/cmake-proxies/cmake-modules/conan.cmake @@ -0,0 +1,902 @@ +# The MIT License (MIT) + +# Copyright (c) 2018 JFrog + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + + +# This file comes from: https://github.com/conan-io/cmake-conan. Please refer +# to this repository for issues and documentation. + +# Its purpose is to wrap and launch Conan C/C++ Package Manager when cmake is called. +# It will take CMake current settings (os, compiler, compiler version, architecture) +# and translate them to conan settings for installing and retrieving dependencies. + +# It is intended to facilitate developers building projects that have conan dependencies, +# but it is only necessary on the end-user side. It is not necessary to create conan +# packages, in fact it shouldn't be use for that. Check the project documentation. + +# version: 0.17.0-dev + +include(CMakeParseArguments) + +function(_get_msvc_ide_version result) + set(${result} "" PARENT_SCOPE) + if(NOT MSVC_VERSION VERSION_LESS 1400 AND MSVC_VERSION VERSION_LESS 1500) + set(${result} 8 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1500 AND MSVC_VERSION VERSION_LESS 1600) + set(${result} 9 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1600 AND MSVC_VERSION VERSION_LESS 1700) + set(${result} 10 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1700 AND MSVC_VERSION VERSION_LESS 1800) + set(${result} 11 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1800 AND MSVC_VERSION VERSION_LESS 1900) + set(${result} 12 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1900 AND MSVC_VERSION VERSION_LESS 1910) + set(${result} 14 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1910 AND MSVC_VERSION VERSION_LESS 1920) + set(${result} 15 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1920 AND MSVC_VERSION VERSION_LESS 1930) + set(${result} 16 PARENT_SCOPE) + else() + message(FATAL_ERROR "Conan: Unknown MSVC compiler version [${MSVC_VERSION}]") + endif() +endfunction() + +macro(_conan_detect_build_type) + conan_parse_arguments(${ARGV}) + + if(ARGUMENTS_BUILD_TYPE) + set(_CONAN_SETTING_BUILD_TYPE ${ARGUMENTS_BUILD_TYPE}) + elseif(CMAKE_BUILD_TYPE) + set(_CONAN_SETTING_BUILD_TYPE ${CMAKE_BUILD_TYPE}) + else() + message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE (-DCMAKE_BUILD_TYPE=Release)") + endif() + + string(TOUPPER ${_CONAN_SETTING_BUILD_TYPE} _CONAN_SETTING_BUILD_TYPE_UPPER) + if (_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "DEBUG") + set(_CONAN_SETTING_BUILD_TYPE "Debug") + elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELEASE") + set(_CONAN_SETTING_BUILD_TYPE "Release") + elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELWITHDEBINFO") + set(_CONAN_SETTING_BUILD_TYPE "RelWithDebInfo") + elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "MINSIZEREL") + set(_CONAN_SETTING_BUILD_TYPE "MinSizeRel") + endif() +endmacro() + +macro(_conan_check_system_name) + #handle -s os setting + if(CMAKE_SYSTEM_NAME AND NOT CMAKE_SYSTEM_NAME STREQUAL "Generic") + #use default conan os setting if CMAKE_SYSTEM_NAME is not defined + set(CONAN_SYSTEM_NAME ${CMAKE_SYSTEM_NAME}) + if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin") + set(CONAN_SYSTEM_NAME Macos) + endif() + if(${CMAKE_SYSTEM_NAME} STREQUAL "QNX") + set(CONAN_SYSTEM_NAME Neutrino) + endif() + set(CONAN_SUPPORTED_PLATFORMS Windows Linux Macos Android iOS FreeBSD WindowsStore WindowsCE watchOS tvOS FreeBSD SunOS AIX Arduino Emscripten Neutrino) + list (FIND CONAN_SUPPORTED_PLATFORMS "${CONAN_SYSTEM_NAME}" _index) + if (${_index} GREATER -1) + #check if the cmake system is a conan supported one + set(_CONAN_SETTING_OS ${CONAN_SYSTEM_NAME}) + else() + message(FATAL_ERROR "cmake system ${CONAN_SYSTEM_NAME} is not supported by conan. Use one of ${CONAN_SUPPORTED_PLATFORMS}") + endif() + endif() +endmacro() + +macro(_conan_check_language) + get_property(_languages GLOBAL PROPERTY ENABLED_LANGUAGES) + if (";${_languages};" MATCHES ";CXX;") + set(LANGUAGE CXX) + set(USING_CXX 1) + elseif (";${_languages};" MATCHES ";C;") + set(LANGUAGE C) + set(USING_CXX 0) + else () + message(FATAL_ERROR "Conan: Neither C or C++ was detected as a language for the project. Unabled to detect compiler version.") + endif() +endmacro() + +macro(_conan_detect_compiler) + + conan_parse_arguments(${ARGV}) + + if(ARGUMENTS_ARCH) + set(_CONAN_SETTING_ARCH ${ARGUMENTS_ARCH}) + endif() + + if (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL GNU) + # using GCC + # TODO: Handle other params + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(COMPILER_VERSION ${MAJOR}.${MINOR}) + if(${MAJOR} GREATER 4) + set(COMPILER_VERSION ${MAJOR}) + endif() + set(_CONAN_SETTING_COMPILER gcc) + set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION}) + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Intel) + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(COMPILER_VERSION ${MAJOR}.${MINOR}) + set(_CONAN_SETTING_COMPILER intel) + set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION}) + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL AppleClang) + # using AppleClang + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(_CONAN_SETTING_COMPILER apple-clang) + set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR}) + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Clang) + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(_CONAN_SETTING_COMPILER clang) + set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR}) + if(APPLE) + cmake_policy(GET CMP0025 APPLE_CLANG_POLICY) + if(NOT APPLE_CLANG_POLICY STREQUAL NEW) + message(STATUS "Conan: APPLE and Clang detected. Assuming apple-clang compiler. Set CMP0025 to avoid it") + set(_CONAN_SETTING_COMPILER apple-clang) + endif() + endif() + if(${_CONAN_SETTING_COMPILER} STREQUAL clang AND ${MAJOR} GREATER 7) + set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}) + endif() + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif(${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL MSVC) + set(_VISUAL "Visual Studio") + _get_msvc_ide_version(_VISUAL_VERSION) + if("${_VISUAL_VERSION}" STREQUAL "") + message(FATAL_ERROR "Conan: Visual Studio not recognized") + else() + set(_CONAN_SETTING_COMPILER ${_VISUAL}) + set(_CONAN_SETTING_COMPILER_VERSION ${_VISUAL_VERSION}) + endif() + + if(NOT _CONAN_SETTING_ARCH) + if (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "64") + set(_CONAN_SETTING_ARCH x86_64) + elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "^ARM") + message(STATUS "Conan: Using default ARM architecture from MSVC") + set(_CONAN_SETTING_ARCH armv6) + elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "86") + set(_CONAN_SETTING_ARCH x86) + else () + message(FATAL_ERROR "Conan: Unknown MSVC architecture [${MSVC_${LANGUAGE}_ARCHITECTURE_ID}]") + endif() + endif() + + conan_cmake_detect_vs_runtime(_vs_runtime ${ARGV}) + message(STATUS "Conan: Detected VS runtime: ${_vs_runtime}") + set(_CONAN_SETTING_COMPILER_RUNTIME ${_vs_runtime}) + + if (CMAKE_GENERATOR_TOOLSET) + set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET}) + elseif(CMAKE_VS_PLATFORM_TOOLSET AND (CMAKE_GENERATOR STREQUAL "Ninja")) + set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET}) + endif() + else() + message(FATAL_ERROR "Conan: compiler setup not recognized") + endif() + +endmacro() + +function(conan_cmake_settings result) + #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER}) + #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER_ID}) + #message(STATUS "VERSION " ${CMAKE_CXX_COMPILER_VERSION}) + #message(STATUS "FLAGS " ${CMAKE_LANG_FLAGS}) + #message(STATUS "LIB ARCH " ${CMAKE_CXX_LIBRARY_ARCHITECTURE}) + #message(STATUS "BUILD TYPE " ${CMAKE_BUILD_TYPE}) + #message(STATUS "GENERATOR " ${CMAKE_GENERATOR}) + #message(STATUS "GENERATOR WIN64 " ${CMAKE_CL_64}) + + message(STATUS "Conan: Automatic detection of conan settings from cmake") + + conan_parse_arguments(${ARGV}) + + _conan_detect_build_type(${ARGV}) + + _conan_check_system_name() + + _conan_check_language() + + _conan_detect_compiler(${ARGV}) + + # If profile is defined it is used + if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND ARGUMENTS_DEBUG_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_DEBUG_PROFILE}) + elseif(CMAKE_BUILD_TYPE STREQUAL "Release" AND ARGUMENTS_RELEASE_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_RELEASE_PROFILE}) + elseif(CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo" AND ARGUMENTS_RELWITHDEBINFO_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_RELWITHDEBINFO_PROFILE}) + elseif(CMAKE_BUILD_TYPE STREQUAL "MinSizeRel" AND ARGUMENTS_MINSIZEREL_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_MINSIZEREL_PROFILE}) + elseif(ARGUMENTS_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_PROFILE}) + endif() + + foreach(ARG ${_APPLIED_PROFILES}) + set(_SETTINGS ${_SETTINGS} -pr=${ARG}) + endforeach() + foreach(ARG ${ARGUMENTS_PROFILE_BUILD}) + conan_check(VERSION 1.24.0 REQUIRED DETECT_QUIET) + set(_SETTINGS ${_SETTINGS} -pr:b=${ARG}) + endforeach() + + if(NOT _SETTINGS OR ARGUMENTS_PROFILE_AUTO STREQUAL "ALL") + set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version + compiler.runtime compiler.libcxx compiler.toolset) + endif() + + # remove any manually specified settings from the autodetected settings + foreach(ARG ${ARGUMENTS_SETTINGS}) + string(REGEX MATCH "[^=]*" MANUAL_SETTING "${ARG}") + message(STATUS "Conan: ${MANUAL_SETTING} was added as an argument. Not using the autodetected one.") + list(REMOVE_ITEM ARGUMENTS_PROFILE_AUTO "${MANUAL_SETTING}") + endforeach() + + # Automatic from CMake + foreach(ARG ${ARGUMENTS_PROFILE_AUTO}) + string(TOUPPER ${ARG} _arg_name) + string(REPLACE "." "_" _arg_name ${_arg_name}) + if(_CONAN_SETTING_${_arg_name}) + set(_SETTINGS ${_SETTINGS} -s ${ARG}=${_CONAN_SETTING_${_arg_name}}) + endif() + endforeach() + + foreach(ARG ${ARGUMENTS_SETTINGS}) + set(_SETTINGS ${_SETTINGS} -s ${ARG}) + endforeach() + + message(STATUS "Conan: Settings= ${_SETTINGS}") + + set(${result} ${_SETTINGS} PARENT_SCOPE) +endfunction() + + +function(conan_cmake_detect_unix_libcxx result) + # Take into account any -stdlib in compile options + get_directory_property(compile_options DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_OPTIONS) + string(GENEX_STRIP "${compile_options}" compile_options) + + # Take into account any _GLIBCXX_USE_CXX11_ABI in compile definitions + get_directory_property(defines DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_DEFINITIONS) + string(GENEX_STRIP "${defines}" defines) + + foreach(define ${defines}) + if(define MATCHES "_GLIBCXX_USE_CXX11_ABI") + if(define MATCHES "^-D") + set(compile_options ${compile_options} "${define}") + else() + set(compile_options ${compile_options} "-D${define}") + endif() + endif() + endforeach() + + # add additional compiler options ala cmRulePlaceholderExpander::ExpandRuleVariable + set(EXPAND_CXX_COMPILER ${CMAKE_CXX_COMPILER}) + if(CMAKE_CXX_COMPILER_ARG1) + # CMake splits CXX="foo bar baz" into CMAKE_CXX_COMPILER="foo", CMAKE_CXX_COMPILER_ARG1="bar baz" + # without this, ccache, winegcc, or other wrappers might lose all their arguments + separate_arguments(SPLIT_CXX_COMPILER_ARG1 NATIVE_COMMAND ${CMAKE_CXX_COMPILER_ARG1}) + list(APPEND EXPAND_CXX_COMPILER ${SPLIT_CXX_COMPILER_ARG1}) + endif() + + if(CMAKE_CXX_COMPILE_OPTIONS_TARGET AND CMAKE_CXX_COMPILER_TARGET) + # without --target= we may be calling the wrong underlying GCC + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}") + endif() + + if(CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN AND CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN) + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}") + endif() + + if(CMAKE_CXX_COMPILE_OPTIONS_SYSROOT) + # without --sysroot= we may find the wrong #include <string> + if(CMAKE_SYSROOT_COMPILE) + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT_COMPILE}") + elseif(CMAKE_SYSROOT) + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}") + endif() + endif() + + separate_arguments(SPLIT_CXX_FLAGS NATIVE_COMMAND ${CMAKE_CXX_FLAGS}) + + if(CMAKE_OSX_SYSROOT) + set(xcode_sysroot_option "--sysroot=${CMAKE_OSX_SYSROOT}") + endif() + + execute_process( + COMMAND ${CMAKE_COMMAND} -E echo "#include <string>" + COMMAND ${EXPAND_CXX_COMPILER} ${SPLIT_CXX_FLAGS} -x c++ ${xcode_sysroot_option} ${compile_options} -E -dM - + OUTPUT_VARIABLE string_defines + ) + + if(string_defines MATCHES "#define __GLIBCXX__") + # Allow -D_GLIBCXX_USE_CXX11_ABI=ON/OFF as argument to cmake + if(DEFINED _GLIBCXX_USE_CXX11_ABI) + if(_GLIBCXX_USE_CXX11_ABI) + set(${result} libstdc++11 PARENT_SCOPE) + return() + else() + set(${result} libstdc++ PARENT_SCOPE) + return() + endif() + endif() + + if(string_defines MATCHES "#define _GLIBCXX_USE_CXX11_ABI 1\n") + set(${result} libstdc++11 PARENT_SCOPE) + else() + # Either the compiler is missing the define because it is old, and so + # it can't use the new abi, or the compiler was configured to use the + # old abi by the user or distro (e.g. devtoolset on RHEL/CentOS) + set(${result} libstdc++ PARENT_SCOPE) + endif() + else() + set(${result} libc++ PARENT_SCOPE) + endif() +endfunction() + +function(conan_cmake_detect_vs_runtime result) + + conan_parse_arguments(${ARGV}) + if(ARGUMENTS_BUILD_TYPE) + set(build_type "${ARGUMENTS_BUILD_TYPE}") + elseif(CMAKE_BUILD_TYPE) + set(build_type "${CMAKE_BUILD_TYPE}") + else() + message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE (-DCMAKE_BUILD_TYPE=Release)") + endif() + + if(build_type) + string(TOUPPER "${build_type}" build_type) + endif() + set(variables CMAKE_CXX_FLAGS_${build_type} CMAKE_C_FLAGS_${build_type} CMAKE_CXX_FLAGS CMAKE_C_FLAGS) + foreach(variable ${variables}) + if(NOT "${${variable}}" STREQUAL "") + string(REPLACE " " ";" flags "${${variable}}") + foreach (flag ${flags}) + if("${flag}" STREQUAL "/MD" OR "${flag}" STREQUAL "/MDd" OR "${flag}" STREQUAL "/MT" OR "${flag}" STREQUAL "/MTd") + string(SUBSTRING "${flag}" 1 -1 runtime) + set(${result} "${runtime}" PARENT_SCOPE) + return() + endif() + endforeach() + endif() + endforeach() + if("${build_type}" STREQUAL "DEBUG") + set(${result} "MDd" PARENT_SCOPE) + else() + set(${result} "MD" PARENT_SCOPE) + endif() +endfunction() + +function(_collect_settings result) + set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version + compiler.runtime compiler.libcxx compiler.toolset) + foreach(ARG ${ARGUMENTS_PROFILE_AUTO}) + string(TOUPPER ${ARG} _arg_name) + string(REPLACE "." "_" _arg_name ${_arg_name}) + if(_CONAN_SETTING_${_arg_name}) + set(detected_setings ${detected_setings} ${ARG}=${_CONAN_SETTING_${_arg_name}}) + endif() + endforeach() + set(${result} ${detected_setings} PARENT_SCOPE) +endfunction() + +function(conan_cmake_autodetect detected_settings ${ARGV}) + _conan_detect_build_type(${ARGV}) + _conan_check_system_name() + _conan_check_language() + _conan_detect_compiler(${ARGV}) + _collect_settings(collected_settings) + set(${detected_settings} ${collected_settings} PARENT_SCOPE) +endfunction() + +macro(conan_parse_arguments) + set(options BASIC_SETUP CMAKE_TARGETS UPDATE KEEP_RPATHS NO_LOAD NO_OUTPUT_DIRS OUTPUT_QUIET NO_IMPORTS SKIP_STD) + set(oneValueArgs CONANFILE ARCH BUILD_TYPE INSTALL_FOLDER CONAN_COMMAND) + set(multiValueArgs DEBUG_PROFILE RELEASE_PROFILE RELWITHDEBINFO_PROFILE MINSIZEREL_PROFILE + PROFILE REQUIRES OPTIONS IMPORTS SETTINGS BUILD ENV GENERATORS PROFILE_AUTO + INSTALL_ARGS CONFIGURATION_TYPES PROFILE_BUILD BUILD_REQUIRES) + cmake_parse_arguments(ARGUMENTS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) +endmacro() + +function(old_conan_cmake_install) + # Calls "conan install" + # Argument BUILD is equivalant to --build={missing, PkgName,...} or + # --build when argument is 'BUILD all' (which builds all packages from source) + # Argument CONAN_COMMAND, to specify the conan path, e.g. in case of running from source + # cmake does not identify conan as command, even if it is +x and it is in the path + conan_parse_arguments(${ARGV}) + + if(CONAN_CMAKE_MULTI) + set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake_multi) + else() + set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake) + endif() + + set(CONAN_BUILD_POLICY "") + foreach(ARG ${ARGUMENTS_BUILD}) + if(${ARG} STREQUAL "all") + set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build) + break() + else() + set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build=${ARG}) + endif() + endforeach() + if(ARGUMENTS_CONAN_COMMAND) + set(CONAN_CMD ${ARGUMENTS_CONAN_COMMAND}) + else() + conan_check(REQUIRED) + endif() + set(CONAN_OPTIONS "") + if(ARGUMENTS_CONANFILE) + if(IS_ABSOLUTE ${ARGUMENTS_CONANFILE}) + set(CONANFILE ${ARGUMENTS_CONANFILE}) + else() + set(CONANFILE ${CMAKE_CURRENT_SOURCE_DIR}/${ARGUMENTS_CONANFILE}) + endif() + else() + set(CONANFILE ".") + endif() + foreach(ARG ${ARGUMENTS_OPTIONS}) + set(CONAN_OPTIONS ${CONAN_OPTIONS} -o=${ARG}) + endforeach() + if(ARGUMENTS_UPDATE) + set(CONAN_INSTALL_UPDATE --update) + endif() + if(ARGUMENTS_NO_IMPORTS) + set(CONAN_INSTALL_NO_IMPORTS --no-imports) + endif() + set(CONAN_INSTALL_FOLDER "") + if(ARGUMENTS_INSTALL_FOLDER) + set(CONAN_INSTALL_FOLDER -if=${ARGUMENTS_INSTALL_FOLDER}) + endif() + foreach(ARG ${ARGUMENTS_GENERATORS}) + set(CONAN_GENERATORS ${CONAN_GENERATORS} -g=${ARG}) + endforeach() + foreach(ARG ${ARGUMENTS_ENV}) + set(CONAN_ENV_VARS ${CONAN_ENV_VARS} -e=${ARG}) + endforeach() + set(conan_args install ${CONANFILE} ${settings} ${CONAN_ENV_VARS} ${CONAN_GENERATORS} ${CONAN_BUILD_POLICY} ${CONAN_INSTALL_UPDATE} ${CONAN_INSTALL_NO_IMPORTS} ${CONAN_OPTIONS} ${CONAN_INSTALL_FOLDER} ${ARGUMENTS_INSTALL_ARGS}) + + string (REPLACE ";" " " _conan_args "${conan_args}") + message(STATUS "Conan executing: ${CONAN_CMD} ${_conan_args}") + + if(ARGUMENTS_OUTPUT_QUIET) + execute_process(COMMAND ${CONAN_CMD} ${conan_args} + RESULT_VARIABLE return_code + OUTPUT_VARIABLE conan_output + ERROR_VARIABLE conan_output + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + else() + execute_process(COMMAND ${CONAN_CMD} ${conan_args} + RESULT_VARIABLE return_code + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + endif() + + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan install failed='${return_code}'") + endif() + +endfunction() + +function(conan_cmake_install) + if(DEFINED CONAN_COMMAND) + set(CONAN_CMD ${CONAN_COMMAND}) + else() + conan_check(REQUIRED) + endif() + + set(installOptions UPDATE NO_IMPORTS OUTPUT_QUIET ERROR_QUIET) + set(installOneValueArgs PATH_OR_REFERENCE REFERENCE REMOTE LOCKFILE LOCKFILE_OUT LOCKFILE_NODE_ID INSTALL_FOLDER) + set(installMultiValueArgs GENERATOR BUILD ENV ENV_HOST ENV_BUILD OPTIONS_HOST OPTIONS OPTIONS_BUILD PROFILE + PROFILE_HOST PROFILE_BUILD SETTINGS SETTINGS_HOST SETTINGS_BUILD) + cmake_parse_arguments(ARGS "${installOptions}" "${installOneValueArgs}" "${installMultiValueArgs}" ${ARGN}) + foreach(arg ${installOptions}) + if(ARGS_${arg}) + set(${arg} ${${arg}} ${ARGS_${arg}}) + endif() + endforeach() + foreach(arg ${installOneValueArgs}) + if(DEFINED ARGS_${arg}) + if("${arg}" STREQUAL "REMOTE") + set(flag "--remote") + elseif("${arg}" STREQUAL "LOCKFILE") + set(flag "--lockfile") + elseif("${arg}" STREQUAL "LOCKFILE_OUT") + set(flag "--lockfile-out") + elseif("${arg}" STREQUAL "LOCKFILE_NODE_ID") + set(flag "--lockfile-node-id") + elseif("${arg}" STREQUAL "INSTALL_FOLDER") + set(flag "--install-folder") + endif() + set(${arg} ${${arg}} ${flag} ${ARGS_${arg}}) + endif() + endforeach() + foreach(arg ${installMultiValueArgs}) + if(DEFINED ARGS_${arg}) + if("${arg}" STREQUAL "GENERATOR") + set(flag "--generator") + elseif("${arg}" STREQUAL "BUILD") + set(flag "--build") + elseif("${arg}" STREQUAL "ENV") + set(flag "--env") + elseif("${arg}" STREQUAL "ENV_HOST") + set(flag "--env:host") + elseif("${arg}" STREQUAL "ENV_BUILD") + set(flag "--env:build") + elseif("${arg}" STREQUAL "OPTIONS") + set(flag "--options") + elseif("${arg}" STREQUAL "OPTIONS_HOST") + set(flag "--options:host") + elseif("${arg}" STREQUAL "OPTIONS_BUILD") + set(flag "--options:build") + elseif("${arg}" STREQUAL "PROFILE") + set(flag "--profile") + elseif("${arg}" STREQUAL "PROFILE_HOST") + set(flag "--profile:host") + elseif("${arg}" STREQUAL "PROFILE_BUILD") + set(flag "--profile:build") + elseif("${arg}" STREQUAL "SETTINGS") + set(flag "--settings") + elseif("${arg}" STREQUAL "SETTINGS_HOST") + set(flag "--settings:host") + elseif("${arg}" STREQUAL "SETTINGS_BUILD") + set(flag "--settings:build") + endif() + list(LENGTH ARGS_${arg} numargs) + foreach(item ${ARGS_${arg}}) + if(${item} STREQUAL "all" AND ${arg} STREQUAL "BUILD") + set(${arg} "--build") + break() + endif() + set(${arg} ${${arg}} ${flag} ${item}) + endforeach() + endif() + endforeach() + if(DEFINED UPDATE) + set(UPDATE --update) + endif() + if(DEFINED NO_IMPORTS) + set(NO_IMPORTS --no-imports) + endif() + set(install_args install ${PATH_OR_REFERENCE} ${REFERENCE} ${UPDATE} ${NO_IMPORTS} ${REMOTE} ${LOCKFILE} ${LOCKFILE_OUT} ${LOCKFILE_NODE_ID} ${INSTALL_FOLDER} + ${GENERATOR} ${BUILD} ${ENV} ${ENV_HOST} ${ENV_BUILD} ${OPTIONS} ${OPTIONS_HOST} ${OPTIONS_BUILD} + ${PROFILE} ${PROFILE_HOST} ${PROFILE_BUILD} ${SETTINGS} ${SETTINGS_HOST} ${SETTINGS_BUILD}) + + string(REPLACE ";" " " _install_args "${install_args}") + message(STATUS "Conan executing: ${CONAN_CMD} ${_install_args}") + + if(ARGS_OUTPUT_QUIET) + set(OUTPUT_OPT OUTPUT_QUIET) + endif() + if(ARGS_ERROR_QUIET) + set(ERROR_OPT ERROR_QUIET) + endif() + + execute_process(COMMAND ${CONAN_CMD} ${install_args} + RESULT_VARIABLE return_code + ${OUTPUT_OPT} + ${ERROR_OPT} + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + + if(NOT "${return_code}" STREQUAL "0") + if (ARGS_ERROR_QUIET) + message(WARNING "Conan install failed='${return_code}'") + else() + message(FATAL_ERROR "Conan install failed='${return_code}'") + endif() + endif() + +endfunction() + +function(conan_cmake_setup_conanfile) + conan_parse_arguments(${ARGV}) + if(ARGUMENTS_CONANFILE) + get_filename_component(_CONANFILE_NAME ${ARGUMENTS_CONANFILE} NAME) + # configure_file will make sure cmake re-runs when conanfile is updated + configure_file(${ARGUMENTS_CONANFILE} ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk COPYONLY) + file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk) + else() + conan_cmake_generate_conanfile(ON ${ARGV}) + endif() +endfunction() + +function(conan_cmake_configure) + conan_cmake_generate_conanfile(OFF ${ARGV}) +endfunction() + +# Generate, writing in disk a conanfile.txt with the requires, options, and imports +# specified as arguments +# This will be considered as temporary file, generated in CMAKE_CURRENT_BINARY_DIR) +function(conan_cmake_generate_conanfile DEFAULT_GENERATOR) + + conan_parse_arguments(${ARGV}) + + set(_FN "${CMAKE_CURRENT_BINARY_DIR}/conanfile.txt") + file(WRITE ${_FN} "") + + if(DEFINED ARGUMENTS_REQUIRES) + file(APPEND ${_FN} "[requires]\n") + foreach(REQUIRE ${ARGUMENTS_REQUIRES}) + file(APPEND ${_FN} ${REQUIRE} "\n") + endforeach() + endif() + + if (DEFAULT_GENERATOR OR DEFINED ARGUMENTS_GENERATORS) + file(APPEND ${_FN} "[generators]\n") + if (DEFAULT_GENERATOR) + file(APPEND ${_FN} "cmake\n") + endif() + if (DEFINED ARGUMENTS_GENERATORS) + foreach(GENERATOR ${ARGUMENTS_GENERATORS}) + file(APPEND ${_FN} ${GENERATOR} "\n") + endforeach() + endif() + endif() + + if(DEFINED ARGUMENTS_BUILD_REQUIRES) + file(APPEND ${_FN} "[build_requires]\n") + foreach(BUILD_REQUIRE ${ARGUMENTS_BUILD_REQUIRES}) + file(APPEND ${_FN} ${BUILD_REQUIRE} "\n") + endforeach() + endif() + + if(DEFINED ARGUMENTS_IMPORTS) + file(APPEND ${_FN} "[imports]\n") + foreach(IMPORTS ${ARGUMENTS_IMPORTS}) + file(APPEND ${_FN} ${IMPORTS} "\n") + endforeach() + endif() + + if(DEFINED ARGUMENTS_OPTIONS) + file(APPEND ${_FN} "[options]\n") + foreach(OPTION ${ARGUMENTS_OPTIONS}) + file(APPEND ${_FN} ${OPTION} "\n") + endforeach() + endif() + +endfunction() + + +macro(conan_load_buildinfo) + if(CONAN_CMAKE_MULTI) + set(_CONANBUILDINFO conanbuildinfo_multi.cmake) + else() + set(_CONANBUILDINFO conanbuildinfo.cmake) + endif() + if(ARGUMENTS_INSTALL_FOLDER) + set(_CONANBUILDINFOFOLDER ${ARGUMENTS_INSTALL_FOLDER}) + else() + set(_CONANBUILDINFOFOLDER ${CMAKE_CURRENT_BINARY_DIR}) + endif() + # Checks for the existence of conanbuildinfo.cmake, and loads it + # important that it is macro, so variables defined at parent scope + if(EXISTS "${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO}") + message(STATUS "Conan: Loading ${_CONANBUILDINFO}") + include(${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO}) + else() + message(FATAL_ERROR "${_CONANBUILDINFO} doesn't exist in ${CMAKE_CURRENT_BINARY_DIR}") + endif() +endmacro() + + +macro(conan_cmake_run) + conan_parse_arguments(${ARGV}) + + if(ARGUMENTS_CONFIGURATION_TYPES AND NOT CMAKE_CONFIGURATION_TYPES) + message(WARNING "CONFIGURATION_TYPES should only be specified for multi-configuration generators") + elseif(ARGUMENTS_CONFIGURATION_TYPES AND ARGUMENTS_BUILD_TYPE) + message(WARNING "CONFIGURATION_TYPES and BUILD_TYPE arguments should not be defined at the same time.") + endif() + + if(CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE AND NOT CONAN_EXPORTED + AND NOT ARGUMENTS_BUILD_TYPE) + set(CONAN_CMAKE_MULTI ON) + if (NOT ARGUMENTS_CONFIGURATION_TYPES) + set(ARGUMENTS_CONFIGURATION_TYPES "Release;Debug") + endif() + message(STATUS "Conan: Using cmake-multi generator") + else() + set(CONAN_CMAKE_MULTI OFF) + endif() + + if(NOT CONAN_EXPORTED) + conan_cmake_setup_conanfile(${ARGV}) + if(CONAN_CMAKE_MULTI) + foreach(CMAKE_BUILD_TYPE ${ARGUMENTS_CONFIGURATION_TYPES}) + set(ENV{CONAN_IMPORT_PATH} ${CMAKE_BUILD_TYPE}) + conan_cmake_settings(settings ${ARGV}) + old_conan_cmake_install(SETTINGS ${settings} ${ARGV}) + endforeach() + set(CMAKE_BUILD_TYPE) + else() + conan_cmake_settings(settings ${ARGV}) + old_conan_cmake_install(SETTINGS ${settings} ${ARGV}) + endif() + endif() + + if (NOT ARGUMENTS_NO_LOAD) + conan_load_buildinfo() + endif() + + if(ARGUMENTS_BASIC_SETUP) + foreach(_option CMAKE_TARGETS KEEP_RPATHS NO_OUTPUT_DIRS SKIP_STD) + if(ARGUMENTS_${_option}) + if(${_option} STREQUAL "CMAKE_TARGETS") + list(APPEND _setup_options "TARGETS") + else() + list(APPEND _setup_options ${_option}) + endif() + endif() + endforeach() + conan_basic_setup(${_setup_options}) + endif() +endmacro() + +macro(conan_check) + # Checks conan availability in PATH + # Arguments REQUIRED, DETECT_QUIET and VERSION are optional + # Example usage: + # conan_check(VERSION 1.0.0 REQUIRED) + set(options REQUIRED DETECT_QUIET) + set(oneValueArgs VERSION) + cmake_parse_arguments(CONAN "${options}" "${oneValueArgs}" "" ${ARGN}) + if(NOT CONAN_DETECT_QUIET) + message(STATUS "Conan: checking conan executable") + endif() + + find_program(CONAN_CMD conan) + if(NOT CONAN_CMD AND CONAN_REQUIRED) + message(FATAL_ERROR "Conan executable not found! Please install conan.") + endif() + if(NOT CONAN_DETECT_QUIET) + message(STATUS "Conan: Found program ${CONAN_CMD}") + endif() + execute_process(COMMAND ${CONAN_CMD} --version + RESULT_VARIABLE return_code + OUTPUT_VARIABLE CONAN_VERSION_OUTPUT + ERROR_VARIABLE CONAN_VERSION_OUTPUT) + + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan --version failed='${return_code}'") + endif() + + if(NOT CONAN_DETECT_QUIET) + string(STRIP "${CONAN_VERSION_OUTPUT}" _CONAN_VERSION_OUTPUT) + message(STATUS "Conan: Version found ${_CONAN_VERSION_OUTPUT}") + endif() + + if(DEFINED CONAN_VERSION) + string(REGEX MATCH ".*Conan version ([0-9]+\\.[0-9]+\\.[0-9]+)" FOO + "${CONAN_VERSION_OUTPUT}") + if(${CMAKE_MATCH_1} VERSION_LESS ${CONAN_VERSION}) + message(FATAL_ERROR "Conan outdated. Installed: ${CMAKE_MATCH_1}, \ + required: ${CONAN_VERSION}. Consider updating via 'pip \ + install conan==${CONAN_VERSION}'.") + endif() + endif() +endmacro() + +function(conan_add_remote) + # Adds a remote + # Arguments URL and NAME are required, INDEX, COMMAND and VERIFY_SSL are optional + # Example usage: + # conan_add_remote(NAME bincrafters INDEX 1 + # URL https://api.bintray.com/conan/bincrafters/public-conan + # VERIFY_SSL True) + set(oneValueArgs URL NAME INDEX COMMAND VERIFY_SSL) + cmake_parse_arguments(CONAN "" "${oneValueArgs}" "" ${ARGN}) + + if(DEFINED CONAN_INDEX) + set(CONAN_INDEX_ARG "-i ${CONAN_INDEX}") + endif() + if(DEFINED CONAN_COMMAND) + set(CONAN_CMD ${CONAN_COMMAND}) + else() + conan_check(REQUIRED DETECT_QUIET) + endif() + set(CONAN_VERIFY_SSL_ARG "True") + if(DEFINED CONAN_VERIFY_SSL) + set(CONAN_VERIFY_SSL_ARG ${CONAN_VERIFY_SSL}) + endif() + message(STATUS "Conan: Adding ${CONAN_NAME} remote repository (${CONAN_URL}) verify ssl (${CONAN_VERIFY_SSL_ARG})") + execute_process(COMMAND ${CONAN_CMD} remote add ${CONAN_NAME} ${CONAN_INDEX_ARG} -f ${CONAN_URL} ${CONAN_VERIFY_SSL_ARG} + RESULT_VARIABLE return_code) + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan remote failed='${return_code}'") + endif() +endfunction() + +macro(conan_config_install) + # install a full configuration from a local or remote zip file + # Argument ITEM is required, arguments TYPE, SOURCE, TARGET and VERIFY_SSL are optional + # Example usage: + # conan_config_install(ITEM https://github.com/conan-io/cmake-conan.git + # TYPE git SOURCE source-folder TARGET target-folder VERIFY_SSL false) + set(oneValueArgs ITEM TYPE SOURCE TARGET VERIFY_SSL) + set(multiValueArgs ARGS) + cmake_parse_arguments(CONAN "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + find_program(CONAN_CMD conan) + if(NOT CONAN_CMD AND CONAN_REQUIRED) + message(FATAL_ERROR "Conan executable not found!") + endif() + + if(DEFINED CONAN_VERIFY_SSL) + set(CONAN_VERIFY_SSL_ARG "--verify-ssl=${CONAN_VERIFY_SSL}") + endif() + + if(DEFINED CONAN_TYPE) + set(CONAN_TYPE_ARG "--type=${CONAN_TYPE}") + endif() + + if(DEFINED CONAN_ARGS) + set(CONAN_ARGS_ARGS "--args=\"${CONAN_ARGS}\"") + endif() + + if(DEFINED CONAN_SOURCE) + set(CONAN_SOURCE_ARGS "--source-folder=${CONAN_SOURCE}") + endif() + + if(DEFINED CONAN_TARGET) + set(CONAN_TARGET_ARGS "--target-folder=${CONAN_TARGET}") + endif() + + set (CONAN_CONFIG_INSTALL_ARGS ${CONAN_VERIFY_SSL_ARG} + ${CONAN_TYPE_ARG} + ${CONAN_ARGS_ARGS} + ${CONAN_SOURCE_ARGS} + ${CONAN_TARGET_ARGS}) + + message(STATUS "Conan: Installing config from ${CONAN_ITEM}") + execute_process(COMMAND ${CONAN_CMD} config install ${CONAN_ITEM} ${CONAN_CONFIG_INSTALL_ARGS} + RESULT_VARIABLE return_code) + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan config failed='${return_code}'") + endif() +endmacro() diff --git a/cmake-proxies/cmake-modules/dependencies/wxwidgets.cmake b/cmake-proxies/cmake-modules/dependencies/wxwidgets.cmake new file mode 100644 index 000000000..cd4cda4ef --- /dev/null +++ b/cmake-proxies/cmake-modules/dependencies/wxwidgets.cmake @@ -0,0 +1,94 @@ +if( ${_OPT}use_wxwidgets STREQUAL "system" ) + if( NOT TARGET wxwidgets::wxwidgets ) + add_library( wxwidgets::wxwidgets INTERFACE IMPORTED GLOBAL) + endif() + + if( NOT TARGET wxwidgets::base ) + add_library( wxwidgets::base ALIAS wxwidgets::wxwidgets ) + endif() + + if( NOT TARGET wxwidgets::core ) + add_library( wxwidgets::core ALIAS wxwidgets::wxwidgets ) + endif() + + if( NOT TARGET wxwidgets::html ) + add_library( wxwidgets::html ALIAS wxwidgets::wxwidgets ) + endif() + + if( NOT TARGET wxwidgets::xml ) + add_library( wxwidgets::xml ALIAS wxwidgets::wxwidgets ) + endif() + + if( NOT TARGET wxwidgets::xrc ) + add_library( wxwidgets::xrc ALIAS wxwidgets::wxwidgets ) + endif() + + if( NOT TARGET wxwidgets::qa ) + add_library( wxwidgets::qa ALIAS wxwidgets::wxwidgets ) + endif() + + if( NOT TARGET wxwidgets::aui ) + add_library( wxwidgets::aui ALIAS wxwidgets::wxwidgets ) + endif() + + if( NOT TARGET wxwidgets::adv ) + add_library( wxwidgets::adv ALIAS wxwidgets::wxwidgets ) + endif() + + if( NOT TARGET wxwidgets::wxwidgets ) + add_library( wxwidgets::wxwidgets ALIAS wxwidgets::wxwidgets ) + endif() + + if( wxWidgets_INCLUDE_DIRS_NO_SYSTEM ) + target_include_directories( wxwidgets::wxwidgets INTERFACE ${wxWidgets_INCLUDE_DIRS_NO_SYSTEM} ) + else() + target_include_directories( wxwidgets::wxwidgets INTERFACE ${wxWidgets_INCLUDE_DIRS} ) + endif() + + target_compile_definitions( wxwidgets::wxwidgets INTERFACE + ${wxWidgets_DEFINITIONS_GENERAL} + $<$<CONFIG:Debug>: + ${wxWidgets_DEFINITIONS_DEBUG} + > + $<$<NOT:$<CONFIG:Debug>>: + ${wxWidgets_DEFINITIONS_OPTIMIZED} + > + ) + + target_link_directories( wxwidgets::wxwidgets INTERFACE + $<$<PLATFORM_ID:Windows>: + ${wxWidgets_LIB_DIR} + > + ) + + target_link_libraries( wxwidgets::wxwidgets INTERFACE + ${wxWidgets_LIBRARIES} + $<$<NOT:$<PLATFORM_ID:Windows>>: + z + > + ) + + set( toolkit "${wxWidgets_LIBRARIES}" ) + + if( "${toolkit}" MATCHES ".*gtk2.*" ) + set( gtk gtk+-2.0 ) + set( glib glib-2.0 ) + elseif( "${toolkit}" MATCHES ".*gtk3.*" ) + set( gtk gtk+-3.0 ) + set( glib glib-2.0 ) + elseif( "${toolkit}" MATCHES ".*gtk4.*" ) + set( gtk gtk+-4.0 ) + set( glib glib-2.0 ) + endif() +endif() + +if( NOT CMAKE_SYSTEM_NAME MATCHES "Windows|Darwin" ) + + if( NOT DEFINED gtk ) + set( gtk gtk+-2.0 ) + set( glib glib-2.0 ) + endif() + + pkg_check_modules( GTK REQUIRED IMPORTED_TARGET GLOBAL ${gtk} ) + pkg_check_modules( GLIB REQUIRED IMPORTED_TARGET GLOBAL ${glib} ) +endif() diff --git a/cmake-proxies/cmake-modules/dependencies/zlib.cmake b/cmake-proxies/cmake-modules/dependencies/zlib.cmake new file mode 100644 index 000000000..b546d4c89 --- /dev/null +++ b/cmake-proxies/cmake-modules/dependencies/zlib.cmake @@ -0,0 +1,39 @@ +# ZLib is a very popular library to use. +# Some of the dependecies do not check for the system libraries, +# which can be problematic. +# We need to call find_package once again. +if (${_OPT}use_zlib STREQUAL "system") + message(STATUS "Fixing up ZLib mess...") + + find_package(ZLIB REQUIRED) + + set_target_properties(ZLIB::ZLIB PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${ZLIB_INCLUDE_DIRS}") + + if(ZLIB_LIBRARY_RELEASE) + set_property(TARGET ZLIB::ZLIB APPEND PROPERTY + IMPORTED_CONFIGURATIONS RELEASE) + + set_property(TARGET ZLIB::ZLIB + PROPERTY INTERFACE_LINK_LIBRARIES + "${ZLIB_LIBRARY_RELEASE}" + ) + endif() + + if(ZLIB_LIBRARY_DEBUG) + set_property(TARGET ZLIB::ZLIB APPEND PROPERTY + IMPORTED_CONFIGURATIONS DEBUG) + + set_property(TARGET ZLIB::ZLIB + PROPERTY INTERFACE_LINK_LIBRARIES + "${ZLIB_LIBRARY_DEBUG}" + ) + endif() + + if(NOT ZLIB_LIBRARY_RELEASE AND NOT ZLIB_LIBRARY_DEBUG) + set_property(TARGET ZLIB::ZLIB + PROPERTY INTERFACE_LINK_LIBRARIES + "${ZLIB_LIBRARY}" + ) + endif() +endif() diff --git a/cmake-proxies/libid3tag/CMakeLists.txt b/cmake-proxies/libid3tag/CMakeLists.txt index cbc6de2ac..681bba790 100644 --- a/cmake-proxies/libid3tag/CMakeLists.txt +++ b/cmake-proxies/libid3tag/CMakeLists.txt @@ -27,7 +27,6 @@ list( APPEND SOURCES list( APPEND INCLUDES PRIVATE ${_PRVDIR} - $<$<PLATFORM_ID:Windows>:$ENV{WXWIN}/src/zlib> PUBLIC ${TARGET_ROOT} ) @@ -39,7 +38,7 @@ list( APPEND OPTIONS list( APPEND LIBRARIES PRIVATE - wxWidgets + ) configure_file( config.h.in private/config.h ) diff --git a/linux/build-environment/Dockerfile b/linux/build-environment/Dockerfile index cc9159e0b..b33431687 100644 --- a/linux/build-environment/Dockerfile +++ b/linux/build-environment/Dockerfile @@ -56,6 +56,8 @@ RUN apt-get install -y \ libssl-dev \ libcurl4-openssl-dev +RUN apt-get install -y libpng-dev + WORKDIR /audacity COPY ["build_audacity.sh", "/audacity/"] diff --git a/linux/build-environment/build_audacity.sh b/linux/build-environment/build_audacity.sh index 3dd3d6ea6..e5fb5f3c7 100644 --- a/linux/build-environment/build_audacity.sh +++ b/linux/build-environment/build_audacity.sh @@ -38,6 +38,12 @@ cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release \ -Daudacity_use_twolame=system \ ../audacity +exit_status=$? + +if [ $exit_status -ne 0 ]; then + exit $exit_status +fi + make -j`nproc` cd bin/Release diff --git a/src/AboutDialog.cpp b/src/AboutDialog.cpp index 798e9ee8a..8a49ee573 100644 --- a/src/AboutDialog.cpp +++ b/src/AboutDialog.cpp @@ -62,7 +62,7 @@ hold information about one contributor to Audacity. // RevisionIdent.h may contain #defines like these ones: //#define REV_LONG "28864acb238cb3ca71dda190a2d93242591dd80e" //#define REV_TIME "Sun Apr 12 12:40:22 2015 +0100" -#include <RevisionIdent.h> +#include "RevisionIdent.h" #ifndef REV_TIME #define REV_TIME "unknown date and time" diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index e6dd6cf03..d07f60a94 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -21,12 +21,13 @@ if( GIT_FOUND ) add_custom_target( version COMMAND - ${CMAKE_COMMAND} -D GIT=${GIT_EXECUTABLE} - -D _PRVDIR=${_PRVDIR} - -P ${CMAKE_MODULE_PATH}/Version.cmake + ${CMAKE_COMMAND} -D GIT="${GIT_EXECUTABLE}" + -D "_PRVDIR=${_PRVDIR}" + -P "${AUDACITY_MODULE_PATH}/Version.cmake" WORKING_DIRECTORY ${topdir} ) + add_dependencies( ${TARGET} version ) endif() @@ -40,6 +41,17 @@ if( CMAKE_SYSTEM_NAME MATCHES "Darwin" ) set( USE_AUDIO_UNITS ${${_OPT}use_audio_units} CACHE INTERNAL "" ) endif() +# Detect, which version of FileDialog to use for +# We always assume that GTK is used on platforms other than Windows and macOS, +# as there is no other implementation avalaible now +if( CMAKE_SYSTEM_NAME MATCHES "Darwin" ) + set( wxIS_MAC on ) +elseif( CMAKE_SYSTEM_NAME MATCHES "Windows" ) + set ( wxIS_WIN on ) +else() + set ( wxIS_GTK on) +endif() + # Handle Ladspa option cmd_option( ${_OPT}use_ladspa @@ -1054,17 +1066,18 @@ list( APPEND LDFLAGS list( APPEND LIBRARIES PUBLIC ${CMAKE_REQUIRED_LIBRARIES} - wxWidgets - expat - lame + ZLIB::ZLIB + wxwidgets::wxwidgets + expat::expat + libmp3lame::libmp3lame libsndfile libsoxr portaudio-v19 sqlite $<$<BOOL:${USE_FFMPEG}>:ffmpeg> - $<$<BOOL:${USE_LIBID3TAG}>:libid3tag> + $<$<BOOL:${USE_LIBID3TAG}>:libid3tag::libid3tag> $<$<BOOL:${USE_LIBFLAC}>:libflac> - $<$<BOOL:${USE_LIBMAD}>:libmad> + $<$<BOOL:${USE_LIBMAD}>:libmad::libmad> $<$<BOOL:${USE_LIBOGG}>:libogg> $<$<BOOL:${USE_LIBVORBIS}>:libvorbis> $<$<BOOL:${USE_LIBTWOLAME}>:twolame> @@ -1115,15 +1128,9 @@ if( CMAKE_SYSTEM_NAME MATCHES "Windows" ) ) # Copy over the wxWidgets DLLs - if( ${_OPT}use_wxwidgets STREQUAL "system" ) - set( wxlibs "$ENV{WXWIN}" ) - else() - set( wxlibs "${CMAKE_BINARY_DIR}" ) - endif() # Convert the paths to native - file( TO_NATIVE_PATH "${_INTDIR}/dlls" dlls ) - file( TO_NATIVE_PATH "${wxWidgets_LIB_DIR}" libdir ) + file( TO_NATIVE_PATH "${CMAKE_BINARY_DIR}/bin/shared" libdir ) file( TO_NATIVE_PATH "${_EXEDIR}" exedir ) # Copy the required wxWidgets libs into the bundle @@ -1133,8 +1140,8 @@ if( CMAKE_SYSTEM_NAME MATCHES "Windows" ) COMMAND ${CMAKE_COMMAND} -D SRC="${_EXEDIR}/Audacity.exe" -D DST="${_EXEDIR}" - -D WXWIN="${libdir}" - -P ${CMAKE_MODULE_PATH}/CopyLibs.cmake + -D WXWIN="${libdir}/$<CONFIG>/" + -P ${AUDACITY_MODULE_PATH}/CopyLibs.cmake POST_BUILD ) @@ -1218,7 +1225,8 @@ elseif( CMAKE_SYSTEM_NAME MATCHES "Darwin" ) COMMAND ${CMAKE_COMMAND} -D SRC="${_EXEDIR}/Audacity" -D DST="${_PKGLIB}" - -P ${CMAKE_MODULE_PATH}/CopyLibs.cmake + -D WXWIN="${CMAKE_BINARY_DIR}/lib/shared/$<CONFIG>" + -P ${AUDACITY_MODULE_PATH}/CopyLibs.cmake POST_BUILD ) @@ -1283,8 +1291,8 @@ else() COMMAND ${CMAKE_COMMAND} -D SRC="${_EXEDIR}/audacity" -D DST="${_DEST}/${_PKGLIB}" - -D WXWIN="${WXWIN}" - -P ${CMAKE_MODULE_PATH}/CopyLibs.cmake + -D WXWIN="${CMAKE_BINARY_DIR}/lib/shared/$<CONFIG>" + -P ${AUDACITY_MODULE_PATH}/CopyLibs.cmake POST_BUILD ) endif()