Browse Source

CMake: overhaul and improve scripts

- Bump minimum required version and
make use of more modern language features
- Rely more on target_...() commands to establish dependency
relationships between targets rather than directory property commands
- Improve libtorrent package discovery
- Enable and handle application features more explicitly
- Improve user-facing output
- Fix various compilation issues on Windows (MSVC and MinGW) and macOS
- Improve handling of translations
- Add explanatory comments where relevant
- Make CMake scripts fully independent of qmake files/details
- Remove old functions/macros
adaptive-webui-19844
FranciscoPombal 5 years ago
parent
commit
46123b9989
  1. 94
      CMakeLists.txt
  2. 22
      cmake/Modules/CompileFeature.cmake
  3. 355
      cmake/Modules/DeployQt5.cmake
  4. 14
      cmake/Modules/FeatureOptionsSetup.cmake
  5. 129
      cmake/Modules/FindLibtorrentRasterbar.cmake
  6. 4
      cmake/Modules/FindSystemd.cmake
  7. 24
      cmake/Modules/FunctionQbtCXXCompilerAndModeCheck.cmake
  8. 28
      cmake/Modules/FunctionReadVersion.cmake
  9. 36
      cmake/Modules/MacroConfigureMSVCRuntime.cmake
  10. 28
      cmake/Modules/MacroLinkQtComponents.cmake
  11. 102
      cmake/Modules/MacroQbtCommonConfig.cmake
  12. 69
      cmake/Modules/MacroQbtCompilerSettings.cmake
  13. 17
      cmake/Modules/QbtTargetSources.cmake
  14. 48
      cmake/Modules/QbtTranslations.cmake
  15. 21
      cmake/Modules/bundle.cmake
  16. 11
      cmake/Modules/winconf-mingw.cmake
  17. 7
      cmake/Modules/winconf-msvc.cmake
  18. 102
      cmake/Modules/winconf.cmake
  19. 8
      dist/CMakeLists.txt
  20. 62
      dist/unix/CMakeLists.txt
  21. 5
      dist/windows/CMakeLists.txt
  22. 105
      src/CMakeLists.txt
  23. 225
      src/app/CMakeLists.txt
  24. 31
      src/base/CMakeLists.txt
  25. 13
      src/config.h.cmakein
  26. 61
      src/gui/CMakeLists.txt
  27. 2
      src/gui/rss/articlelistwidget.cpp
  28. 66
      src/webui/CMakeLists.txt

94
CMakeLists.txt

@ -1,71 +1,51 @@
cmake_minimum_required(VERSION 3.16 FATAL_ERROR) cmake_minimum_required(VERSION 3.16 FATAL_ERROR) # Policies <= CMP0097 default to NEW
message(AUTHOR_WARNING "If the build fails, please try the autotools/qmake method.")
if (POLICY CMP0074)
cmake_policy(SET CMP0074 NEW)
endif()
# TODO: fix the macOS bundle stuff
if (POLICY CMP0080)
cmake_policy(SET CMP0080 OLD)
endif()
list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules) list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules)
include(FunctionReadVersion)
read_version("${CMAKE_CURRENT_SOURCE_DIR}/version.pri" VER_MAJOR VER_MINOR VER_BUGFIX VER_BUILD VER_STATUS)
# message(STATUS "Project version is: ${VER_MAJOR}.${VER_MINOR}.${VER_BUGFIX}.${VER_BUILD} (${VER_STATUS})")
project(qBittorrent VERSION ${VER_MAJOR}.${VER_MINOR}.${VER_BUGFIX}.${VER_BUILD})
# check for invalid compiler version/CXX standard as early as possible
include(FunctionQbtCXXCompilerAndModeCheck)
qbt_minimum_cxx_mode_check(14)
message(STATUS "Building in C++${CMAKE_CXX_STANDARD} mode.\n"
"Make sure libtorrent was built with the same C++ mode for ABI compatibility.")
set(PROJECT_VERSION "${VER_MAJOR}.${VER_MINOR}.${VER_BUGFIX}")
if (NOT VER_BUILD EQUAL 0)
set(PROJECT_VERSION "${PROJECT_VERSION}.${VER_BUILD}")
endif()
set(PROJECT_VERSION "${PROJECT_VERSION}${VER_STATUS}") project(qBittorrent
VERSION 4.3.0.0
add_definitions(-DQBT_VERSION_MAJOR=${VER_MAJOR}) DESCRIPTION "The qBittorrent BitTorrent client"
add_definitions(-DQBT_VERSION_MINOR=${VER_MINOR}) HOMEPAGE_URL "https://www.qbittorrent.org/"
add_definitions(-DQBT_VERSION_BUGFIX=${VER_BUGFIX}) LANGUAGES CXX
add_definitions(-DQBT_VERSION_BUILD=${VER_BUILD}) )
add_definitions(-DQBT_VERSION="v${PROJECT_VERSION}")
add_definitions(-DQBT_VERSION_2="${PROJECT_VERSION}")
include(GNUInstallDirs)
include(FeatureSummary)
# use CONFIG mode first in find_package
set(CMAKE_FIND_PACKAGE_PREFER_CONFIG ON)
# version requirements # version requirements
set(requiredBoostVersion 1.40) set(requiredBoostVersion 1.40)
set(requiredQtVersion 5.9.0) set(requiredQtVersion 5.9.0)
set(requiredOpensslVersion 1.0) set(requiredOpenSSLVersion 1.0)
set(requiredLibtorrentVersion 1.2) set(requiredLibtorrentVersion 1.2.0)
set(requiredZlibVersion 1.2.5.2)
if (WIN32) # features (some are platform-specific)
include(winconf) include(FeatureSummary)
include(FeatureOptionsSetup)
feature_option(STACKTRACE "Enable stacktraces" ON)
feature_option(GUI "Build GUI application" ON)
feature_option(WEBUI "Enables built-in HTTP server for headless use" ON)
feature_option(VERBOSE_CONFIGURE "Show information about PACKAGES_FOUND and PACKAGES_NOT_FOUND in the configure output (only useful for debugging the CMake build scripts)" OFF)
if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
feature_option_dependent(DBUS
"Enables support for notifications and power-management features on Linux via D-Bus"
ON "GUI" OFF
)
feature_option_dependent(SYSTEMD
"Install systemd service file to a directory manually overridable with Systemd_SERVICES_INSTALL_DIR"
OFF "NOT GUI" OFF
)
elseif (MSVC)
feature_option(MSVC_RUNTIME_DYNAMIC "Use MSVC dynamic runtime library (-MD) instead of static (-MT)" OFF)
endif() endif()
set(QBT_VER_STATUS "alpha1" CACHE STRING "Project status version. Should be empty for release builds.")
# we need options here, at the top level, because they are used not only in "src" subdir, but in the "dist" dir too include(GNUInstallDirs)
include(CompileFeature)
optional_compile_definitions(STACKTRACE FEATURE DESCRIPTION "Enable stacktraces"
DEFAULT ON ENABLED STACKTRACE)
optional_compile_definitions(GUI FEATURE DESCRIPTION "Build GUI application"
DEFAULT ON DISABLED DISABLE_GUI)
optional_compile_definitions(WEBUI FEATURE DESCRIPTION "Enables built-in HTTP server for headless use"
DEFAULT ON DISABLED DISABLE_WEBUI)
add_subdirectory(src) add_subdirectory(src)
add_subdirectory(dist) add_subdirectory(dist)
feature_summary(DESCRIPTION "\nConfiguration results:" WHAT ALL) if (VERBOSE_CONFIGURE)
feature_summary(WHAT ALL)
else()
feature_summary(WHAT ENABLED_FEATURES DISABLED_FEATURES)
endif()

22
cmake/Modules/CompileFeature.cmake

@ -1,22 +0,0 @@
# Helper function for coupling add_feature_info(), option(), and add_definitions()
function(optional_compile_definitions _name)
set(options FEATURE)
set(oneValueArgs DESCRIPTION DEFAULT)
set(multiValueArgs ENABLED DISABLED)
cmake_parse_arguments(OCD "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
option(${_name} "${OCD_DESCRIPTION}" ${OCD_DEFAULT})
if (${${_name}})
set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" APPEND PROPERTY COMPILE_DEFINITIONS ${OCD_ENABLED})
else()
set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" APPEND PROPERTY COMPILE_DEFINITIONS ${OCD_DISABLED})
endif()
if(${OCD_FEATURE})
add_feature_info(${_name} ${_name} "${OCD_DESCRIPTION}")
endif()
endfunction()
macro(feature_option _name _description _default)
option(${_name} "${_description}" ${_default})
add_feature_info(${_name} ${_name} "${_description}")
endmacro()

355
cmake/Modules/DeployQt5.cmake

@ -1,355 +0,0 @@
# Borrowed from Avogadro project (https://github.com/OpenChemistry/avogadroapp)
#.rst:
# DeployQt5
# ---------
#
# Functions to help assemble a standalone Qt5 executable.
#
# A collection of CMake utility functions useful for deploying Qt5
# executables.
#
# The following functions are provided by this module:
#
# ::
#
# write_qt5_conf
# resolve_qt5_paths
# fixup_qt5_executable
# install_qt5_plugin_path
# install_qt5_plugin
# install_qt5_executable
#
# Requires CMake 2.8.9 or greater because Qt 5 does.
# Also depends on BundleUtilities.cmake.
#
# ::
#
# WRITE_QT5_CONF(<qt_conf_dir> <qt_conf_contents>)
#
# Writes a qt.conf file with the <qt_conf_contents> into <qt_conf_dir>.
#
# ::
#
# RESOLVE_QT5_PATHS(<paths_var> [<executable_path>])
#
# Loop through <paths_var> list and if any don't exist resolve them
# relative to the <executable_path> (if supplied) or the
# CMAKE_INSTALL_PREFIX.
#
# ::
#
# FIXUP_QT5_EXECUTABLE(<executable> [<qtplugins> <libs> <dirs> <plugins_dir> <request_qt_conf>])
#
# Copies Qt plugins, writes a Qt configuration file (if needed) and
# fixes up a Qt5 executable using BundleUtilities so it is standalone
# and can be drag-and-drop copied to another machine as long as all of
# the system libraries are compatible.
#
# <executable> should point to the executable to be fixed-up.
#
# <qtplugins> should contain a list of the names or paths of any Qt
# plugins to be installed.
#
# <libs> will be passed to BundleUtilities and should be a list of any
# already installed plugins, libraries or executables to also be
# fixed-up.
#
# <dirs> will be passed to BundleUtilities and should contain and
# directories to be searched to find library dependencies.
#
# <plugins_dir> allows an custom plugins directory to be used.
#
# <request_qt_conf> will force a qt.conf file to be written even if not
# needed.
#
# ::
#
# INSTALL_QT5_PLUGIN_PATH(plugin executable copy installed_plugin_path_var <plugins_dir> <component> <configurations>)
#
# Install (or copy) a resolved <plugin> to the default plugins directory
# (or <plugins_dir>) relative to <executable> and store the result in
# <installed_plugin_path_var>.
#
# If <copy> is set to TRUE then the plugins will be copied rather than
# installed. This is to allow this module to be used at CMake time
# rather than install time.
#
# If <component> is set then anything installed will use this COMPONENT.
#
# ::
#
# INSTALL_QT5_PLUGIN(plugin executable copy installed_plugin_path_var <plugins_dir> <component>)
#
# Install (or copy) an unresolved <plugin> to the default plugins
# directory (or <plugins_dir>) relative to <executable> and store the
# result in <installed_plugin_path_var>. See documentation of
# INSTALL_QT5_PLUGIN_PATH.
#
# ::
#
# INSTALL_QT5_EXECUTABLE(<executable> [<qtplugins> <libs> <dirs> <plugins_dir> <request_qt_conf> <component>])
#
# Installs Qt plugins, writes a Qt configuration file (if needed) and
# fixes up a Qt5 executable using BundleUtilities so it is standalone
# and can be drag-and-drop copied to another machine as long as all of
# the system libraries are compatible. The executable will be fixed-up
# at install time. <component> is the COMPONENT used for bundle fixup
# and plugin installation. See documentation of FIXUP_QT5_BUNDLE.
#=============================================================================
# Copyright 2011 Mike McQuaid <mike@mikemcquaid.com>
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
# The functions defined in this file depend on the fixup_bundle function
# (and others) found in BundleUtilities.cmake
include(BundleUtilities)
set(DeployQt5_cmake_dir "${CMAKE_CURRENT_LIST_DIR}")
set(DeployQt5_apple_plugins_dir "PlugIns")
function(write_qt5_conf qt_conf_dir qt_conf_contents)
set(qt_conf_path "${qt_conf_dir}/qt.conf")
message(STATUS "Writing ${qt_conf_path}")
file(WRITE "${qt_conf_path}" "${qt_conf_contents}")
endfunction()
function(resolve_qt5_paths paths_var)
set(executable_path ${ARGV1})
set(paths_resolved)
foreach(path ${${paths_var}})
if(EXISTS "${path}")
list(APPEND paths_resolved "${path}")
else()
if(${executable_path})
list(APPEND paths_resolved "${executable_path}/${path}")
else()
list(APPEND paths_resolved "\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${path}")
endif()
endif()
endforeach()
set(${paths_var} ${paths_resolved} PARENT_SCOPE)
endfunction()
function(fixup_qt5_executable executable)
set(qtplugins ${ARGV1})
set(libs ${ARGV2})
set(dirs ${ARGV3})
set(plugins_dir ${ARGV4})
set(request_qt_conf ${ARGV5})
message(STATUS "fixup_qt5_executable")
message(STATUS " executable='${executable}'")
message(STATUS " qtplugins='${qtplugins}'")
message(STATUS " libs='${libs}'")
message(STATUS " dirs='${dirs}'")
message(STATUS " plugins_dir='${plugins_dir}'")
message(STATUS " request_qt_conf='${request_qt_conf}'")
if(QT_LIBRARY_DIR)
list(APPEND dirs "${QT_LIBRARY_DIR}")
endif()
if(QT_BINARY_DIR)
list(APPEND dirs "${QT_BINARY_DIR}")
endif()
if(APPLE)
set(qt_conf_dir "${executable}/Contents/Resources")
set(executable_path "${executable}")
set(write_qt_conf TRUE)
if(NOT plugins_dir)
set(plugins_dir "${DeployQt5_apple_plugins_dir}")
endif()
else()
get_filename_component(executable_path "${executable}" PATH)
if(NOT executable_path)
set(executable_path ".")
endif()
set(qt_conf_dir "${executable_path}")
set(write_qt_conf ${request_qt_conf})
endif()
foreach(plugin ${qtplugins})
set(installed_plugin_path "")
install_qt5_plugin("${plugin}" "${executable}" 1 installed_plugin_path)
list(APPEND libs ${installed_plugin_path})
endforeach()
foreach(lib ${libs})
if(NOT EXISTS "${lib}")
message(FATAL_ERROR "Library does not exist: ${lib}")
endif()
endforeach()
resolve_qt5_paths(libs "${executable_path}")
if(write_qt_conf)
set(qt_conf_contents "[Paths]\nPlugins = ${plugins_dir}")
write_qt5_conf("${qt_conf_dir}" "${qt_conf_contents}")
endif()
fixup_bundle("${executable}" "${libs}" "${dirs}")
endfunction()
function(install_qt5_plugin_path plugin executable copy installed_plugin_path_var)
set(plugins_dir ${ARGV4})
set(component ${ARGV5})
set(configurations ${ARGV6})
if(EXISTS "${plugin}")
if(APPLE)
if(NOT plugins_dir)
set(plugins_dir "${DeployQt5_apple_plugins_dir}")
endif()
set(plugins_path "${executable}/Contents/${plugins_dir}")
else()
get_filename_component(plugins_path "${executable}" PATH)
if(NOT plugins_path)
set(plugins_path ".")
endif()
if(plugins_dir)
set(plugins_path "${plugins_path}/${plugins_dir}")
endif()
endif()
set(plugin_group "")
get_filename_component(plugin_path "${plugin}" PATH)
get_filename_component(plugin_parent_path "${plugin_path}" PATH)
get_filename_component(plugin_parent_dir_name "${plugin_parent_path}" NAME)
get_filename_component(plugin_name "${plugin}" NAME)
string(TOLOWER "${plugin_parent_dir_name}" plugin_parent_dir_name)
if("${plugin_parent_dir_name}" STREQUAL "plugins")
get_filename_component(plugin_group "${plugin_path}" NAME)
set(${plugin_group_var} "${plugin_group}")
endif()
set(plugins_path "${plugins_path}/${plugin_group}")
if(${copy})
file(MAKE_DIRECTORY "${plugins_path}")
file(COPY "${plugin}" DESTINATION "${plugins_path}")
else()
if(configurations AND (CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE))
set(configurations CONFIGURATIONS ${configurations})
else()
unset(configurations)
endif()
install(FILES "${plugin}" DESTINATION "${plugins_path}" ${configurations} ${component})
endif()
set(${installed_plugin_path_var} "${plugins_path}/${plugin_name}" PARENT_SCOPE)
endif()
endfunction()
function(install_qt5_plugin plugin executable copy installed_plugin_path_var)
set(plugins_dir ${ARGV4})
set(component ${ARGV5})
if(EXISTS "${plugin}")
install_qt5_plugin_path("${plugin}" "${executable}" "${copy}" "${installed_plugin_path_var}" "${plugins_dir}" "${component}")
else()
string(TOUPPER "QT_${plugin}_PLUGIN" plugin_var)
set(plugin_release_var "${plugin_var}_RELEASE")
set(plugin_debug_var "${plugin_var}_DEBUG")
set(plugin_release "${${plugin_release_var}}")
set(plugin_debug "${${plugin_debug_var}}")
if(DEFINED "${plugin_release_var}" AND DEFINED "${plugin_debug_var}" AND NOT EXISTS "${plugin_release}" AND NOT EXISTS "${plugin_debug}")
message(WARNING "Qt plugin \"${plugin}\" not recognized or found.")
endif()
if(NOT EXISTS "${${plugin_debug_var}}")
set(plugin_debug "${plugin_release}")
endif()
if(CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE)
install_qt5_plugin_path("${plugin_release}" "${executable}" "${copy}" "${installed_plugin_path_var}_release" "${plugins_dir}" "${component}" "Release|RelWithDebInfo|MinSizeRel")
install_qt5_plugin_path("${plugin_debug}" "${executable}" "${copy}" "${installed_plugin_path_var}_debug" "${plugins_dir}" "${component}" "Debug")
if(CMAKE_BUILD_TYPE MATCHES "^Debug$")
set(${installed_plugin_path_var} ${${installed_plugin_path_var}_debug})
else()
set(${installed_plugin_path_var} ${${installed_plugin_path_var}_release})
endif()
else()
install_qt5_plugin_path("${plugin_release}" "${executable}" "${copy}" "${installed_plugin_path_var}" "${plugins_dir}" "${component}")
endif()
endif()
set(${installed_plugin_path_var} ${${installed_plugin_path_var}} PARENT_SCOPE)
endfunction()
function(install_qt5_executable executable)
set(qtplugins ${ARGV1})
set(libs ${ARGV2})
set(dirs ${ARGV3})
set(plugins_dir ${ARGV4})
set(request_qt_conf ${ARGV5})
set(component ${ARGV6})
if(QT_LIBRARY_DIR)
list(APPEND dirs "${QT_LIBRARY_DIR}")
endif()
if(QT_BINARY_DIR)
list(APPEND dirs "${QT_BINARY_DIR}")
endif()
if(TARGET Qt5::Core)
get_property(_locCore TARGET Qt5::Core PROPERTY LOCATION_RELEASE)
get_filename_component(_loc ${_locCore} DIRECTORY)
message(STATUS "Adding Qt 5 directory: ${_loc}")
list(APPEND dirs "${_loc}")
else()
message(FATAL_ERROR "No Qt5::Core target found, ensure it is available")
endif()
if(component)
set(component COMPONENT ${component})
else()
unset(component)
endif()
get_filename_component(executable_absolute "${executable}" ABSOLUTE)
if(EXISTS "${QT_QTCORE_LIBRARY_RELEASE}")
gp_file_type("${executable_absolute}" "${QT_QTCORE_LIBRARY_RELEASE}" qtcore_type)
elseif(EXISTS "${QT_QTCORE_LIBRARY_DEBUG}")
gp_file_type("${executable_absolute}" "${QT_QTCORE_LIBRARY_DEBUG}" qtcore_type)
endif()
if(qtcore_type STREQUAL "system")
set(qt_plugins_dir "")
endif()
if(QT_IS_STATIC)
message(WARNING "Qt built statically: not installing plugins.")
else()
if(APPLE)
get_property(loc TARGET Qt5::QCocoaIntegrationPlugin
PROPERTY LOCATION_RELEASE)
install_qt5_plugin("${loc}" "${executable}" 0 installed_plugin_paths
"PlugIns" "${component}")
list(APPEND libs ${installed_plugin_paths})
elseif(WIN32)
get_property(loc TARGET Qt5::QWindowsIntegrationPlugin
PROPERTY LOCATION_RELEASE)
install_qt5_plugin("${loc}" "${executable}" 0 installed_plugin_paths
"" "${component}")
list(APPEND libs ${installed_plugin_paths})
endif()
foreach(plugin ${qtplugins})
set(installed_plugin_paths "")
install_qt5_plugin("${plugin}" "${executable}" 0 installed_plugin_paths "${plugins_dir}" "${component}")
list(APPEND libs ${installed_plugin_paths})
endforeach()
endif()
resolve_qt5_paths(libs "")
install(CODE
"include(\"${DeployQt5_cmake_dir}/DeployQt5.cmake\")
set(BU_CHMOD_BUNDLE_ITEMS TRUE)
fixup_qt5_executable(\"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${executable}\" \"\" \"${libs}\" \"${dirs}\" \"${plugins_dir}\" \"${request_qt_conf}\")"
${component}
)
endfunction()

14
cmake/Modules/FeatureOptionsSetup.cmake

@ -0,0 +1,14 @@
# Helper functions for coupling add_feature_info() or CMAKE_DEPENDENT_OPTION() and option()
function(feature_option _name _description _default)
string(CONCAT _desc "${_description} (default: ${_default})")
option("${_name}" "${_desc}" "${_default}")
add_feature_info("${_name}" "${_name}" "${_desc}")
endfunction()
include(CMakeDependentOption)
function(feature_option_dependent _name _description _default_opt _dependency _default_dep_not_sat)
string(CONCAT _desc "${_description} (default: ${_default_opt}; depends on condition: ${_dependency})")
CMAKE_DEPENDENT_OPTION("${_name}" "${_desc}" "${_default_opt}" "${_dependency}" "${_default_dep_not_sat}")
add_feature_info("${_name}" "${_name}" "${_desc}")
endfunction()

129
cmake/Modules/FindLibtorrentRasterbar.cmake

@ -1,129 +0,0 @@
# - Try to find libtorrent-rasterbar
#
# If not using pkg-config, you can pre-set LibtorrentRasterbar_CUSTOM_DEFINITIONS
# for definitions unrelated to Boost's separate compilation (which are already
# decided by the LibtorrentRasterbar_USE_STATIC_LIBS variable).
#
# Once done this will define
# LibtorrentRasterbar_FOUND - System has libtorrent-rasterbar
# LibtorrentRasterbar_INCLUDE_DIRS - The libtorrent-rasterbar include directories
# LibtorrentRasterbar_LIBRARIES - The libraries needed to use libtorrent-rasterbar
# LibtorrentRasterbar_DEFINITIONS - Compiler switches required for using libtorrent-rasterbar
# LibtorrentRasterbar_OPENSSL_ENABLED - libtorrent-rasterbar uses and links against OpenSSL
find_package(Threads REQUIRED)
find_package(PkgConfig QUIET)
macro(_detect_boost_components _outComponets librariesList)
string(REGEX MATCHALL "boost_[a-z_]+[-a-z]*" _boost_libraries "${librariesList}")
string(REGEX REPLACE "boost_([a-z_]+)[-a-z]*" "\\1" ${_outComponets} "${_boost_libraries}")
endmacro()
if(PKG_CONFIG_FOUND)
pkg_check_modules(PC_LIBTORRENT_RASTERBAR QUIET libtorrent-rasterbar)
endif()
if(LibtorrentRasterbar_USE_STATIC_LIBS)
set(LibtorrentRasterbar_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX})
endif()
if(PC_LIBTORRENT_RASTERBAR_FOUND)
set(LibtorrentRasterbar_DEFINITIONS ${PC_LIBTORRENT_RASTERBAR_CFLAGS})
else()
if(LibtorrentRasterbar_CUSTOM_DEFINITIONS)
set(LibtorrentRasterbar_DEFINITIONS ${LibtorrentRasterbar_CUSTOM_DEFINITIONS})
else()
# Without pkg-config, we can't possibly figure out the correct build flags.
# libtorrent is very picky about those. Let's take a set of defaults and
# hope that they apply. If not, you the user are on your own.
set(LibtorrentRasterbar_DEFINITIONS
-DTORRENT_USE_LIBCRYPTO
# TODO: remove the following define as it is not used since OpenSSL >= 1.1
-DTORRENT_USE_OPENSSL
-DBOOST_ASIO_ENABLE_CANCELIO
-DUNICODE -D_UNICODE -D_FILE_OFFSET_BITS=64)
endif()
if(NOT LibtorrentRasterbar_USE_STATIC_LIBS)
list(APPEND LibtorrentRasterbar_DEFINITIONS
-DTORRENT_LINKING_SHARED
-DBOOST_SYSTEM_DYN_LINK)
endif()
endif()
message(STATUS "libtorrent definitions: ${LibtorrentRasterbar_DEFINITIONS}")
find_path(LibtorrentRasterbar_INCLUDE_DIR libtorrent
HINTS ${PC_LIBTORRENT_RASTERBAR_INCLUDEDIR} ${PC_LIBTORRENT_RASTERBAR_INCLUDE_DIRS}
PATH_SUFFIXES libtorrent-rasterbar)
find_library(LibtorrentRasterbar_LIBRARY NAMES torrent-rasterbar libtorrent
HINTS ${PC_LIBTORRENT_RASTERBAR_LIBDIR} ${PC_LIBTORRENT_RASTERBAR_LIBRARY_DIRS})
if(LibtorrentRasterbar_USE_STATIC_LIBS)
set(CMAKE_FIND_LIBRARY_SUFFIXES ${LibtorrentRasterbar_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES})
endif()
set(LibtorrentRasterbar_LIBRARIES ${LibtorrentRasterbar_LIBRARY} ${CMAKE_THREAD_LIBS_INIT})
set(LibtorrentRasterbar_INCLUDE_DIRS ${LibtorrentRasterbar_INCLUDE_DIR})
# Without pkg-config, we can't possibly figure out the correct boost dependencies
if (LibtorrentRasterbar_CUSTOM_BOOST_DEPENDENCIES)
set(_boost_components "${LibtorrentRasterbar_CUSTOM_BOOST_DEPENDENCIES}")
else(LibtorrentRasterbar_CUSTOM_BOOST_DEPENDENCIES)
if(PC_LIBTORRENT_RASTERBAR_FOUND)
_detect_boost_components(_boost_components "${PC_LIBTORRENT_RASTERBAR_LIBRARIES}")
else()
# all possible boost dependencies
set(_boost_components
date_time
system
chrono
random
thread
)
endif()
endif(LibtorrentRasterbar_CUSTOM_BOOST_DEPENDENCIES)
list(SORT _boost_components)
message(STATUS "Libtorrent Boost dependencies: ${_boost_components}")
find_package(Boost REQUIRED COMPONENTS ${_boost_components})
set(LibtorrentRasterbar_LIBRARIES ${LibtorrentRasterbar_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
foreach(_boost_cmpnt IN LISTS _boost_components)
list(APPEND LibtorrentRasterbar_LIBRARIES "Boost::${_boost_cmpnt}")
endforeach(_boost_cmpnt)
set(LibtorrentRasterbar_INCLUDE_DIRS ${LibtorrentRasterbar_INCLUDE_DIRS})
list(FIND LibtorrentRasterbar_DEFINITIONS -DTORRENT_USE_OPENSSL LibtorrentRasterbar_ENCRYPTION_INDEX)
if(LibtorrentRasterbar_ENCRYPTION_INDEX GREATER -1)
find_package(OpenSSL REQUIRED)
set(LibtorrentRasterbar_LIBRARIES ${LibtorrentRasterbar_LIBRARIES} OpenSSL::SSL OpenSSL::Crypto)
list(APPEND LibtorrentRasterbar_INCLUDE_DIRS "${OPENSSL_INCLUDE_DIR}")
set(LibtorrentRasterbar_OPENSSL_ENABLED ON)
endif()
include(FindPackageHandleStandardArgs)
# handle the QUIETLY and REQUIRED arguments and set LibtorrentRasterbar_FOUND to TRUE
# if all listed variables are TRUE
find_package_handle_standard_args(LibtorrentRasterbar DEFAULT_MSG
LibtorrentRasterbar_LIBRARY
LibtorrentRasterbar_INCLUDE_DIR)
mark_as_advanced(LibtorrentRasterbar_INCLUDE_DIR LibtorrentRasterbar_LIBRARY
LibtorrentRasterbar_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES
LibtorrentRasterbar_ENCRYPTION_INDEX)
if (LibtorrentRasterbar_FOUND AND NOT TARGET LibtorrentRasterbar::torrent-rasterbar)
add_library(LibtorrentRasterbar::torrent-rasterbar UNKNOWN IMPORTED)
set_target_properties(LibtorrentRasterbar::torrent-rasterbar PROPERTIES
IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
IMPORTED_LOCATION "${LibtorrentRasterbar_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${LibtorrentRasterbar_INCLUDE_DIRS}"
INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${LibtorrentRasterbar_INCLUDE_DIRS}"
INTERFACE_LINK_LIBRARIES "${LibtorrentRasterbar_LIBRARIES}"
INTERFACE_COMPILE_OPTIONS "${LibtorrentRasterbar_DEFINITIONS}"
)
endif()

4
cmake/Modules/FindSystemd.cmake

@ -8,7 +8,7 @@ find_package(PkgConfig QUIET REQUIRED)
if (NOT SYSTEMD_FOUND) if (NOT SYSTEMD_FOUND)
pkg_check_modules(SYSTEMD "systemd") pkg_check_modules(SYSTEMD "systemd")
endif(NOT SYSTEMD_FOUND) endif()
if (SYSTEMD_FOUND AND "${SYSTEMD_SERVICES_INSTALL_DIR}" STREQUAL "") if (SYSTEMD_FOUND AND "${SYSTEMD_SERVICES_INSTALL_DIR}" STREQUAL "")
execute_process(COMMAND ${PKG_CONFIG_EXECUTABLE} execute_process(COMMAND ${PKG_CONFIG_EXECUTABLE}
@ -23,4 +23,4 @@ endif()
if (SYSTEMD_FOUND) if (SYSTEMD_FOUND)
message(STATUS "systemd services install dir: ${SYSTEMD_SERVICES_INSTALL_DIR}") message(STATUS "systemd services install dir: ${SYSTEMD_SERVICES_INSTALL_DIR}")
endif(SYSTEMD_FOUND) endif()

24
cmake/Modules/FunctionQbtCXXCompilerAndModeCheck.cmake

@ -1,24 +0,0 @@
# Function for ensuring the build does not use a lower than the required minimum C++ mode, _min_std.
# It fails the build if:
# - the compiler does not fully support _min_std
# - the user specified a mode lower than _min_std via the CMAKE_CXX_STANDARD variable
# If both checks are successful, it sets the following variables at the PARENT_SCOPE:
# - CMAKE_CXX_STANDARD with the value _min_std, if it was not already set to a value >= _min_std
# - CMAKE_CXX_STANDARD_REQUIRED with the value ON
function(qbt_minimum_cxx_mode_check _min_std)
# ensure the compiler fully supports the minimum required C++ mode.
if(NOT CMAKE_CXX${_min_std}_STANDARD__HAS_FULL_SUPPORT)
message(FATAL_ERROR "${PROJECT_NAME} requires a compiler with full C++${_min_std} support")
endif()
# now we know that the compiler fully supports the minimum required C++ mode,
# but we must still prevent the user or compiler from forcing/defaulting to an insufficient C++ mode
if(NOT CMAKE_CXX_STANDARD)
set(CMAKE_CXX_STANDARD ${_min_std} PARENT_SCOPE)
elseif((CMAKE_CXX_STANDARD VERSION_LESS ${_min_std}) OR (CMAKE_CXX_STANDARD VERSION_EQUAL 98))
message(FATAL_ERROR "${PROJECT_NAME} has to be built with at least C++${_min_std} mode.")
endif()
set(CMAKE_CXX_STANDARD_REQUIRED ON PARENT_SCOPE)
endfunction()

28
cmake/Modules/FunctionReadVersion.cmake

@ -1,28 +0,0 @@
# function for parsing version variables that are set in version.pri file
# the version identifiers there are defined as follows:
# VER_MAJOR = 3
# VER_MINOR = 4
# VER_BUGFIX = 0
# VER_BUILD = 0
# VER_STATUS = alpha
function(read_version priFile outMajor outMinor outBugfix outBuild outStatus)
file(STRINGS ${priFile} _priFileContents REGEX "^VER_.+")
# message(STATUS "version.pri version contents: ${_priFileContents}")
# the _priFileContents variable contains something like the following:
# VER_MAJOR = 3;VER_MINOR = 4;VER_BUGFIX = 0;VER_BUILD = 0;VER_STATUS = alpha # Should be empty for stable releases!
set(_regex "VER_MAJOR += +([0-9]+);VER_MINOR += +([0-9]+);VER_BUGFIX += +([0-9]+);VER_BUILD += +([0-9]+);VER_STATUS += +([0-9A-Za-z]+)?")
# note quotes around _regex, they are needed because the variable contains semicolons
string(REGEX MATCH "${_regex}" _tmp "${_priFileContents}")
if (NOT _tmp)
message(FATAL_ERROR "Could not detect project version number from ${priFile}")
endif()
# message(STATUS "Matched version string: ${_tmp}")
set(${outMajor} ${CMAKE_MATCH_1} PARENT_SCOPE)
set(${outMinor} ${CMAKE_MATCH_2} PARENT_SCOPE)
set(${outBugfix} ${CMAKE_MATCH_3} PARENT_SCOPE)
set(${outBuild} ${CMAKE_MATCH_4} PARENT_SCOPE)
set(${outStatus} ${CMAKE_MATCH_5} PARENT_SCOPE)
endfunction()

36
cmake/Modules/MacroConfigureMSVCRuntime.cmake

@ -1,36 +0,0 @@
macro(configure_msvc_runtime)
# Default to statically-linked runtime.
if("${MSVC_RUNTIME}" STREQUAL "")
set(MSVC_RUNTIME "static")
endif()
# Set compiler options.
set(variables
CMAKE_C_FLAGS_DEBUG
CMAKE_C_FLAGS_MINSIZEREL
CMAKE_C_FLAGS_RELEASE
CMAKE_C_FLAGS_RELWITHDEBINFO
CMAKE_CXX_FLAGS_DEBUG
CMAKE_CXX_FLAGS_MINSIZEREL
CMAKE_CXX_FLAGS_RELEASE
CMAKE_CXX_FLAGS_RELWITHDEBINFO
)
if(${MSVC_RUNTIME} STREQUAL "static")
message(STATUS
"MSVC -> forcing use of statically-linked runtime."
)
foreach(variable ${variables})
if(${variable} MATCHES "/MD")
string(REGEX REPLACE "/MD" "/MT" ${variable} "${${variable}}")
endif()
endforeach()
else()
message(STATUS
"MSVC -> forcing use of dynamically-linked runtime."
)
foreach(variable ${variables})
if(${variable} MATCHES "/MT")
string(REGEX REPLACE "/MT" "/MD" ${variable} "${${variable}}")
endif()
endforeach()
endif()
endmacro()

28
cmake/Modules/MacroLinkQtComponents.cmake

@ -1,28 +0,0 @@
# - macro similar to target_link_libraries, which links Qt components
# names of the components are passed in Qt4/Qt5 agnostic way (Core, DBus, Xml...)
# and the macro links Qt4 ones if QT4_FOUND is set or Qt5 ones if not
macro (target_link_qt_components target)
if (QT4_FOUND)
foreach(_cmp ${ARGN})
if ("${_cmp}" STREQUAL "PRIVATE" OR
"${_cmp}" STREQUAL "PUBLIC" OR
"${_cmp}" STREQUAL "INTERFACE")
list(APPEND _QT_CMPNTS "${_cmp}")
else()
list(APPEND _QT_CMPNTS "Qt4::Qt${_cmp}")
endif()
endforeach()
else (QT4_FOUND)
foreach(_cmp ${ARGN})
if ("${_cmp}" STREQUAL "PRIVATE" OR
"${_cmp}" STREQUAL "PUBLIC" OR
"${_cmp}" STREQUAL "INTERFACE")
list(APPEND _QT_CMPNTS "${_cmp}")
else()
list(APPEND _QT_CMPNTS "Qt5::${_cmp}")
endif()
endforeach()
endif (QT4_FOUND)
target_link_libraries(${target} ${_QT_CMPNTS})
endmacro()

102
cmake/Modules/MacroQbtCommonConfig.cmake

@ -0,0 +1,102 @@
# Set common variables and create some interface-only library targets
# that some or all other targets will link to, either directly or transitively,
# to consume common compile options/definitions
macro(qbt_common_config)
# treat value specified by the CXX_STANDARD target property as a requirement by default
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# these definitions are only needed for calls to
# lt::generate_fingerprint and for the qbittorrent.rc file on Windows
add_library(qbt_version_definitions INTERFACE)
target_compile_definitions(qbt_version_definitions INTERFACE
QBT_VERSION_MAJOR=${qBittorrent_VERSION_MAJOR}
QBT_VERSION_MINOR=${qBittorrent_VERSION_MINOR}
QBT_VERSION_BUGFIX=${qBittorrent_VERSION_PATCH}
QBT_VERSION_BUILD=${qBittorrent_VERSION_TWEAK}
)
add_library(qbt_common_cfg INTERFACE)
# Full C++ 14 support is required
# See also https://cmake.org/cmake/help/latest/prop_gbl/CMAKE_CXX_KNOWN_FEATURES.html
# for a breakdown of the features that CMake recognizes for each C++ standard
target_compile_features(qbt_common_cfg INTERFACE
cxx_std_14
cxx_aggregate_default_initializers
cxx_attribute_deprecated
cxx_binary_literals
cxx_contextual_conversions
cxx_decltype_auto
cxx_digit_separators
cxx_generic_lambdas
cxx_lambda_init_captures
cxx_relaxed_constexpr
cxx_return_type_deduction
cxx_variable_templates
)
set(QBT_FULL_VERSION "${qBittorrent_VERSION}${QBT_VER_STATUS}")
target_compile_definitions(qbt_common_cfg INTERFACE
QBT_VERSION="v${QBT_FULL_VERSION}"
QBT_VERSION_2="${QBT_FULL_VERSION}"
QT_DEPRECATED_WARNINGS
QT_NO_CAST_TO_ASCII
QT_NO_CAST_FROM_BYTEARRAY
QT_USE_QSTRINGBUILDER
QT_STRICT_ITERATORS
$<$<NOT:$<CONFIG:Debug>>:QT_NO_DEBUG_OUTPUT>
)
if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
target_compile_definitions(qbt_common_cfg INTERFACE
NTDDI_VERSION=0x06010000
_WIN32_WINNT=0x0601
_WIN32_IE=0x0601
WIN32_LEAN_AND_MEAN
NOMINMAX
UNICODE
_UNICODE
)
endif()
if ((CXX_COMPILER_ID STREQUAL "GNU") OR (CXX_COMPILER_ID STREQUAL "Clang") OR (CXX_COMPILER_ID STREQUAL "AppleClang"))
target_compile_options(qbt_common_cfg INTERFACE
-Wall
-Wextra
-Wcast-qual
-Wcast-align
-Winvalid-pch
-Woverloaded-virtual
-Wold-style-cast
-Wnon-virtual-dtor
-pedantic
-pedantic-errors
)
# Clang 11 still doesn't support -Wstrict-null-sentinel
include(CheckCXXCompilerFlag)
check_cxx_compiler_flag(-Wstrict-null-sentinel SNS_SUPPORT)
if (SNS_SUPPORT)
target_compile_options(qbt_common_cfg INTERFACE -Wstrict-null-sentinel)
endif()
endif()
if (MINGW)
target_link_options(qbt_common_cfg INTERFACE $<$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>:LINKER:--dynamicbase>)
endif()
if (MSVC_RUNTIME_DYNAMIC)
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
else()
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
endif()
if (CMAKE_GENERATOR MATCHES "Visual Studio")
target_compile_options(qbt_common_cfg INTERFACE /MP)
endif()
endmacro(qbt_common_config)

69
cmake/Modules/MacroQbtCompilerSettings.cmake

@ -1,69 +0,0 @@
# Sets cache variable QBT_ADDITIONAL_FLAGS and QBT_ADDITONAL_CXX_FLAGS to list of additional
# compiler flags for C and C++ (QBT_ADDITIONAL_FLAGS) and for C++ only (QBT_ADDITONAL_CXX_FLAGS)
# and appends them to CMAKE_XXX_FLAGS variables.
# It could use add_compile_options(), but then it is needed to use generator expressions,
# and most interesting of them are not compatible with Visual Studio :(
macro(qbt_set_compiler_options)
# if (NOT QBT_ADDITIONAL_FLAGS)
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
#-Wshadow -Wconversion ?
set(_GCC_COMMON_C_AND_CXX_FLAGS "-Wall -Wextra"
"-Wcast-qual -Wcast-align"
"-Winvalid-pch -Wno-long-long"
#"-fstack-protector-all"
#"-Werror -Wno-error=deprecated-declarations"
)
set(_GCC_COMMON_CXX_FLAGS "-fexceptions -frtti"
"-Woverloaded-virtual -Wold-style-cast"
"-Wnon-virtual-dtor"
#"-Weffc++"
#"-Werror -Wno-error=cpp"
# we should modify code to make these ones obsolete
#"-Wno-error=sign-conversion -Wno-error=float-equal"
)
include(CheckCXXCompilerFlag)
# check for -pedantic
check_cxx_compiler_flag(-pedantic _PEDANTIC_IS_SUPPORTED)
if (_PEDANTIC_IS_SUPPORTED)
list(APPEND _GCC_COMMON_CXX_FLAGS "-pedantic -pedantic-errors")
else (_PEDANTIC_IS_SUPPORTED)
list(APPEND _GCC_COMMON_CXX_FLAGS "-Wpedantic")
endif (_PEDANTIC_IS_SUPPORTED)
if (CMAKE_SYSTEM_NAME MATCHES Linux)
add_definitions(-D_DEFAULT_SOURCE)
endif()
# Clang 5.0 still doesn't support -Wstrict-null-sentinel
if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
check_cxx_compiler_flag(-Wstrict-null-sentinel _STRICT_NULL_SENTINEL_IS_SUPPORTED)
if (_STRICT_NULL_SENTINEL_IS_SUPPORTED)
list(APPEND _GCC_COMMON_CXX_FLAGS "-Wstrict-null-sentinel")
endif (_STRICT_NULL_SENTINEL_IS_SUPPORTED)
# Code should be improved to render this not needed
list(APPEND _GCC_COMMON_CXX_FLAGS "-Wno-error=unused-function")
else ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
# GCC supports it
list(APPEND _GCC_COMMON_CXX_FLAGS "-Wstrict-null-sentinel")
endif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
string(REPLACE ";" " " _GCC_COMMON_C_AND_CXX_FLAGS_STRING "${_GCC_COMMON_C_AND_CXX_FLAGS}")
string(REPLACE ";" " " _GCC_COMMON_CXX_FLAGS_STRING "${_GCC_COMMON_CXX_FLAGS}")
string(APPEND CMAKE_C_FLAGS " ${_GCC_COMMON_C_AND_CXX_FLAGS_STRING}")
string(APPEND CMAKE_CXX_FLAGS " ${_GCC_COMMON_C_AND_CXX_FLAGS_STRING} ${_GCC_COMMON_CXX_FLAGS_STRING}")
endif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
set(QBT_ADDITIONAL_FLAGS "/wd4251 /wd4275 /wd4290" CACHE STRING "Additional qBittorent compile flags")
endif ()
string(APPEND CMAKE_C_FLAGS " ${QBT_ADDITIONAL_FLAGS}")
string(APPEND CMAKE_CXX_FLAGS " ${QBT_ADDITIONAL_FLAGS}")
# endif (NOT QBT_ADDITIONAL_FLAGS)
endmacro(qbt_set_compiler_options)

17
cmake/Modules/QbtTargetSources.cmake

@ -1,17 +0,0 @@
# a helper function which appends source to the target
# sources file names are relative to the the target source dir
function (qbt_target_sources _target _scope)
get_target_property(targetSourceDir ${_target} SOURCE_DIR)
set(sourcesRelative "")
foreach(source IN ITEMS ${ARGN})
if(IS_ABSOLUTE "${source}")
set(sourceAbsolutePath "${source}")
else()
get_filename_component(sourceAbsolutePath "${source}" ABSOLUTE)
endif()
file(RELATIVE_PATH sourceRelativePath "${targetSourceDir}" "${sourceAbsolutePath}")
list(APPEND sourcesRelative "${sourceRelativePath}")
endforeach()
target_sources(${_target} ${_scope} "${sourcesRelative}")
endfunction(qbt_target_sources)

48
cmake/Modules/QbtTranslations.cmake

@ -1,48 +0,0 @@
# macros to handle translation files
# qbt_add_translations(<target> QRC_FILE <filename> TS_FILES <filenames>)
# handles out of source builds for Qt resource files that include translations
# The function generates translations out of the supplied list of .ts files in the build directory,
# copies the .qrc file there, calls qt5_add_resources() adds its output to the target sources list.
function(qbt_add_translations _target)
set(oneValueArgs QRC_FILE)
set(multiValueArgs TS_FILES)
cmake_parse_arguments(QBT_TR "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
get_target_property(_binaryDir ${_target} BINARY_DIR)
if (NOT QBT_TR_QRC_FILE)
message(FATAL_ERROR "QRC file is empty")
endif()
if (NOT QBT_TR_TS_FILES)
message(FATAL_ERROR "TS_FILES files are empty")
endif()
if(IS_ABSOLUTE "${QBT_TR_QRC_FILE}")
file(RELATIVE_PATH _qrcToTs "${CMAKE_CURRENT_SOURCE_DIR}" "${QBT_TR_QRC_FILE}")
else()
set(_qrcToTs "${QBT_TR_QRC_FILE}")
endif()
get_filename_component(_qrcToTsDir "${_qrcToTs}" DIRECTORY)
get_filename_component(_qmFilesBinaryDir "${CMAKE_CURRENT_BINARY_DIR}/${_qrcToTsDir}" ABSOLUTE)
# to make qt5_add_translation() work as we need
set_source_files_properties(${QBT_TR_TS_FILES} PROPERTIES OUTPUT_LOCATION "${_qmFilesBinaryDir}")
qt5_add_translation(_qmFiles ${QBT_TR_TS_FILES})
set(_qrc_dest_dir "${_binaryDir}/${_qrcToTsDir}")
set(_qrc_dest_file "${_binaryDir}/${QBT_TR_QRC_FILE}")
message(STATUS "copying ${QBT_TR_QRC_FILE} to ${_qrc_dest_dir}")
file(COPY ${QBT_TR_QRC_FILE} DESTINATION ${_qrc_dest_dir})
set_source_files_properties("${_qrc_dest_file}" PROPERTIES
GENERATED True
OBJECT_DEPENDS "${_qmFiles}")
# With AUTORCC enabled rcc is ran by cmake before language files are generated,
# and thus we call rcc explicitly
qt5_add_resources(_resources "${_qrc_dest_file}")
target_sources(${_target} PRIVATE "${_resources}")
endfunction()

21
cmake/Modules/bundle.cmake

@ -1,21 +0,0 @@
set(BU_CHMOD_BUNDLE_ITEMS ON)
include(DeployQt5)
set(plugins "")
get_property(svgIconPluginLocation TARGET Qt5::QSvgIconPlugin
PROPERTY LOCATION_RELEASE)
list(APPEND plugins "${svgIconPluginLocation}")
get_property(svgPluginLocation TARGET Qt5::QSvgPlugin
PROPERTY LOCATION_RELEASE)
list(APPEND plugins "${svgPluginLocation}")
set(sfx "")
if(APPLE)
set(sfx ".app")
elseif(WIN32)
set(sfx "${CMAKE_EXECUTABLE_SUFFIX}")
endif()
get_target_property(exe qBittorrent OUTPUT_NAME)
install_qt5_executable("${exe}${sfx}" "${plugins}" "" "" "")

11
cmake/Modules/winconf-mingw.cmake

@ -1,11 +0,0 @@
if (("${CMAKE_BUILD_TYPE}" STREQUAL "Debug") OR ("${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo"))
link_libraries(-Wl,--dynamicbase)
endif ()
list(APPEND LibtorrentRasterbar_CUSTOM_DEFINITIONS
-D_FILE_OFFSET_BITS=64
-D__USE_W32_SOCKETS)
# libraries from winconf.pri
link_libraries(advapi32 iphlpapi ole32 shell32 user32 wsock32 ws2_32)

7
cmake/Modules/winconf-msvc.cmake

@ -1,7 +0,0 @@
include(MacroConfigureMSVCRuntime)
set(MSVC_RUNTIME "dynamic")
configure_msvc_runtime()
# libraries from winconf.pri
link_libraries(advapi32 crypt32 Iphlpapi ole32 shell32 User32)

102
cmake/Modules/winconf.cmake

@ -1,102 +0,0 @@
# Settings for compiling qBittorrent on Windows
list(APPEND CMAKE_LIBRARY_PATH "$ENV{LIB}")
set(LibtorrentRasterbar_CUSTOM_DEFINITIONS
-DBOOST_ASIO_DISABLE_CONNECTEX
-DBOOST_EXCEPTION_DISABLE
-DTORRENT_USE_LIBCRYPTO
# TODO: remove the following define as it is not used since OpenSSL >= 1.1
-DTORRENT_USE_OPENSSL
# TODO: remove the following define as it is not used since libtorrent >= 1.2
-DTORRENT_DISABLE_RESOLVE_COUNTRIES
)
set(LibtorrentRasterbar_CUSTOM_BOOST_DEPENDENCIES system)
# If you want to link with static version of libtorrent
#set(LibtorrentRasterbar_USE_STATIC_LIBS True)
#list(APPEND LibtorrentRasterbar_CUSTOM_DEFINITIONS
# -DBOOST_SYSTEM_STATIC_LINK=1)
# and boost
#set(Boost_USE_STATIC_LIBS True)
#set(Boost_USE_STATIC_RUNTIME True)
add_definitions(
-DNTDDI_VERSION=0x06010000
-D_WIN32_WINNT=0x0601
-D_WIN32_IE=0x0601
-DUNICODE
-D_UNICODE
-DWIN32
-D_WIN32
-DWIN32_LEAN_AND_MEAN
-D_CRT_SECURE_NO_DEPRECATE
-D_SCL_SECURE_NO_DEPRECATE
-DNOMINMAX
-DBOOST_ALL_NO_LIB
)
# Enable if libtorrent was built with this flag defined
#list(APPEND LibtorrentRasterbar_CUSTOM_DEFINITIONS -DTORRENT_NO_DEPRECATE)
if (("${CMAKE_BUILD_TYPE}" STREQUAL "Debug") OR ("${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo"))
list(APPEND LibtorrentRasterbar_CUSTOM_DEFINITIONS
-DTORRENT_DEBUG)
else ()
add_definitions(-DNDEBUG)
endif ()
# Here we assume that all required libraries are installed into the same prefix
# with usual unix subdirectories (bin, lib, include)
# if so, we just need to set CMAKE_SYSTEM_PREFIX_PATH
# If it is not the case, individual paths need to be specified manually (see below)
set(COMMON_INSTALL_PREFIX "c:/usr" CACHE PATH "Prefix used to install all the required libraries")
list(APPEND CMAKE_SYSTEM_PREFIX_PATH "${COMMON_INSTALL_PREFIX}")
# If two version of Qt are installed, separate prefixes are needed most likely
set(QT5_INSTALL_PREFIX "${COMMON_INSTALL_PREFIX}/lib/qt5" CACHE PATH "Prefix where Qt5 is installed")
# it is safe to set Qt dirs even if their files are directly in the prefix
set(Qt5_DIR "${QT5_INSTALL_PREFIX}/lib/cmake/Qt5")
# And now we can set specific values for the Boost and libtorrent libraries.
# The following values are generated from the paths listed above just for an example
# they have to be set to actual locations
# Boost
# set(BOOST_ROOT "${COMMON_INSTALL_PREFIX}")
# set(Boost_version_suffix "1_59")
# if a link like boost-version/boost -> boost was created or the boost directory was renamed in the same way,
# the following needs adjustment
# set(BOOST_INCLUDEDIR "${COMMON_INSTALL_PREFIX}/include/boost-${Boost_version_suffix}")
# set(BOOST_LIBRARYDIR "${COMMON_INSTALL_PREFIX}/lib/")
# libtorrent
# set(PC_LIBTORRENT_RASTERBAR_INCLUDEDIR "${COMMON_INSTALL_PREFIX}")
# set(PC_LIBTORRENT_RASTERBAR_LIBDIR "${COMMON_INSTALL_PREFIX}/lib")
set(AUTOGEN_TARGETS_FOLDER "generated")
set(CMAKE_INSTALL_BINDIR ".")
# Test 32/64 bits
if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
message(STATUS "Target is 64 bits")
if (WIN32)
set(WINXXBITS Win64)
endif(WIN32)
else("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
message(STATUS "Target is 32 bits")
if (WIN32)
set(WINXXBITS Win32)
endif(WIN32)
endif("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
if (MSVC)
include(winconf-msvc)
else (MSVC)
include(winconf-mingw)
endif (MSVC)

8
dist/CMakeLists.txt vendored

@ -1,9 +1,7 @@
find_package(Qt5Widgets ${requiredQtVersion}) # to conditionally install desktop-related files if (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
if (APPLE)
add_subdirectory(mac) add_subdirectory(mac)
elseif (UNIX) elseif (UNIX AND (NOT APPLE))
add_subdirectory(unix) add_subdirectory(unix)
elseif (WIN32) elseif (CMAKE_SYSTEM_NAME STREQUAL "Windows")
add_subdirectory(windows) add_subdirectory(windows)
endif() endif()

62
dist/unix/CMakeLists.txt vendored

@ -1,48 +1,56 @@
if (NOT Qt5Widgets_FOUND) if (SYSTEMD)
feature_option(SYSTEMD "Install systemd service file (headless only)" OFF) if (NOT SYSTEMD_SERVICES_INSTALL_DIR)
if (SYSTEMD)
if (NOT Systemd_SERVICES_INSTALL_DIR)
find_package(Systemd) find_package(Systemd)
if (NOT Systemd_FOUND) if (NOT SYSTEMD_FOUND)
message(FATAL_ERROR "Could not locate systemd services install dir." message(
" Either pass -DSystemd_SERVICES_INSTALL_DIR=/path/to/systemd/services option or install systemd pkg-config") FATAL_ERROR
endif(NOT Systemd_FOUND) "Could not locate systemd services install dir."
endif(NOT Systemd_SERVICES_INSTALL_DIR) " Either pass the -DSYSTEMD_SERVICES_INSTALL_DIR=/path/to/systemd/services option"
" or install systemd pkg-config"
)
endif()
endif()
set(EXPAND_BINDIR ${CMAKE_INSTALL_FULL_BINDIR}) set(EXPAND_BINDIR ${CMAKE_INSTALL_FULL_BINDIR})
configure_file(systemd/qbittorrent-nox@.service.in ${CMAKE_CURRENT_BINARY_DIR}/qbittorrent-nox@.service @ONLY) configure_file(systemd/qbittorrent-nox@.service.in ${CMAKE_CURRENT_BINARY_DIR}/qbittorrent-nox@.service @ONLY)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/qbittorrent-nox@.service install(FILES "${CMAKE_CURRENT_BINARY_DIR}/qbittorrent-nox@.service"
DESTINATION ${Systemd_SERVICES_INSTALL_DIR} DESTINATION ${SYSTEMD_SERVICES_INSTALL_DIR}
COMPONENT data) COMPONENT data
endif(SYSTEMD) )
endif() endif()
if (Qt5Widgets_FOUND) if (GUI)
list(APPEND MAN_FILES ${qBittorrent_SOURCE_DIR}/doc/qbittorrent.1) list(APPEND MAN_FILES ${PROJECT_SOURCE_DIR}/doc/qbittorrent.1)
else (Qt5Widgets_FOUND) else()
list(APPEND MAN_FILES ${qBittorrent_SOURCE_DIR}/doc/qbittorrent-nox.1) list(APPEND MAN_FILES ${PROJECT_SOURCE_DIR}/doc/qbittorrent-nox.1)
endif (Qt5Widgets_FOUND) endif()
install(FILES ${MAN_FILES} install(FILES ${MAN_FILES}
DESTINATION ${CMAKE_INSTALL_MANDIR}/man1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1
COMPONENT doc) COMPONENT doc
)
if (Qt5Widgets_FOUND) if (GUI)
install(DIRECTORY menuicons/ install(DIRECTORY menuicons/
DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/icons/hicolor DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/icons/hicolor
FILES_MATCHING PATTERN "*.png") COMPONENT data
FILES_MATCHING PATTERN "*.png"
)
install(FILES org.qbittorrent.qBittorrent.desktop install(FILES org.qbittorrent.qBittorrent.desktop
DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/applications/ DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/applications/
COMPONENT data) COMPONENT data
)
install(FILES org.qbittorrent.qBittorrent.appdata.xml install(FILES org.qbittorrent.qBittorrent.appdata.xml
DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/metainfo/ DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/metainfo/
COMPONENT data) COMPONENT data
)
install(FILES install(FILES
${qBittorrent_SOURCE_DIR}/src/icons/qbittorrent-tray.svg ${PROJECT_SOURCE_DIR}/src/icons/qbittorrent-tray.svg
${qBittorrent_SOURCE_DIR}/src/icons/qbittorrent-tray-dark.svg ${PROJECT_SOURCE_DIR}/src/icons/qbittorrent-tray-dark.svg
${qBittorrent_SOURCE_DIR}/src/icons/qbittorrent-tray-light.svg ${PROJECT_SOURCE_DIR}/src/icons/qbittorrent-tray-light.svg
DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/icons/hicolor/scalable/status DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/icons/hicolor/scalable/status
COMPONENT data) COMPONENT data
)
endif() endif()

5
dist/windows/CMakeLists.txt vendored

@ -1 +1,4 @@
install(FILES qt.conf DESTINATION ${CMAKE_INSTALL_BINDIR}) install(FILES qt.conf
DESTINATION ${CMAKE_INSTALL_BINDIR}
COMPONENT runtime
)

105
src/CMakeLists.txt

@ -1,62 +1,75 @@
include(MacroQbtCompilerSettings) if (UNIX AND (NOT APPLE) AND (NOT CYGWIN))
qbt_set_compiler_options() find_package(LibtorrentRasterbar QUIET ${requiredLibtorrentVersion} COMPONENTS torrent-rasterbar)
if (NOT LibtorrentRasterbar_FOUND)
include(QbtTargetSources) include(FindPkgConfig)
pkg_check_modules(LIBTORRENT_RASTERBAR IMPORTED_TARGET GLOBAL "libtorrent-rasterbar>=${requiredLibtorrentVersion}")
find_package(Boost ${requiredBoostVersion} REQUIRED) if (NOT LIBTORRENT_RASTERBAR_FOUND)
find_package(LibtorrentRasterbar ${requiredLibtorrentVersion} REQUIRED) message(
find_package(OpenSSL ${requiredOpensslVersion} REQUIRED) FATAL_ERROR
"Package LibtorrentRasterbar >= ${requiredLibtorrentVersion} not found"
if (Boost_VERSION_STRING VERSION_LESS 1.60.0) " with CMake or pkg-config.\n- Set LibtorrentRasterbar_DIR to a directory containing"
add_definitions(-DBOOST_NO_CXX11_RVALUE_REFERENCES) " a LibtorrentRasterbarConfig.cmake file or add the installation prefix of LibtorrentRasterbar"
" to CMAKE_PREFIX_PATH.\n- Alternatively, make sure there is a valid libtorrent-rasterbar.pc"
" file in your system's pkg-config search paths (use the system environment variable PKG_CONFIG_PATH"
" to specify additional search paths if needed)."
)
endif()
add_library(LibtorrentRasterbar::torrent-rasterbar ALIAS PkgConfig::LIBTORRENT_RASTERBAR)
# force a fake package to show up in the feature summary
set_property(GLOBAL APPEND PROPERTY
PACKAGES_FOUND
"LibtorrentRasterbar via pkg-config (required version >= ${requiredLibtorrentVersion})"
)
set_package_properties("LibtorrentRasterbar via pkg-config (required version >= ${requiredLibtorrentVersion})"
PROPERTIES
TYPE REQUIRED
)
else()
set_package_properties(LibtorrentRasterbar PROPERTIES TYPE REQUIRED)
endif()
else()
find_package(LibtorrentRasterbar ${requiredLibtorrentVersion} REQUIRED COMPONENTS torrent-rasterbar)
endif() endif()
# force variable type so that it always shows up in ccmake/cmake-gui frontends
set_property(CACHE LibtorrentRasterbar_DIR PROPERTY TYPE PATH)
find_package(Boost ${requiredBoostVersion} REQUIRED COMPONENTS system)
find_package(OpenSSL ${requiredOpenSSLVersion} REQUIRED)
find_package(ZLIB ${requiredZlibVersion} REQUIRED)
find_package(Qt5 ${requiredQtVersion} REQUIRED COMPONENTS Core Network Xml LinguistTools) find_package(Qt5 ${requiredQtVersion} REQUIRED COMPONENTS Core Network Xml LinguistTools)
if (GUI) if (DBUS)
find_package(Qt5Widgets ${requiredQtVersion} REQUIRED) find_package(Qt5 ${requiredQtVersion} REQUIRED COMPONENTS DBus)
find_package(Qt5DBus ${requiredQtVersion}) set_package_properties(Qt5DBus PROPERTIES
endif()
set_package_properties(Qt5DBus PROPERTIES
DESCRIPTION "Qt5 module for inter-process communication over the D-Bus protocol" DESCRIPTION "Qt5 module for inter-process communication over the D-Bus protocol"
PURPOSE "Enables communication with other system components (e.g. notification service) via D-Bus. " PURPOSE "Required by the DBUS feature"
TYPE RECOMMENDED )
)
set(CMAKE_AUTOMOC True)
list(APPEND CMAKE_AUTORCC_OPTIONS -compress 9 -threshold 5)
if (APPLE)
# Workaround CMake bug (autogen does not pass required parameters to moc)
# Relevant issue: https://gitlab.kitware.com/cmake/cmake/issues/18041
list(APPEND CMAKE_AUTOMOC_MOC_OPTIONS -DQ_OS_MACOS -DQ_OS_DARWIN)
endif() endif()
include_directories(${CMAKE_CURRENT_SOURCE_DIR}) # automatically call Qt moc, rcc and uic as needed for all targets by default
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOUIC ON)
# defines # create interface-only target libraries with common compile options/definitions to link to
add_definitions(-DQT_DEPRECATED_WARNINGS) include(MacroQbtCommonConfig)
add_definitions(-DQT_NO_CAST_TO_ASCII) qbt_common_config()
add_definitions(-DQT_NO_CAST_FROM_BYTEARRAY)
add_definitions(-DQT_USE_QSTRINGBUILDER)
add_definitions(-DQT_STRICT_ITERATORS)
if (CMAKE_BUILD_TYPE MATCHES "Debug") # include directories - ideally, would be done per target instead of global directory scope
message(STATUS "Project is built in DEBUG mode.") include_directories(${CMAKE_CURRENT_SOURCE_DIR})
else()
message(STATUS "Project is built in RELEASE mode.")
message(STATUS "Disabling debug output.")
add_definitions(-DQT_NO_DEBUG_OUTPUT)
endif()
configure_file(config.h.cmakein ${CMAKE_CURRENT_BINARY_DIR}/config.h)
add_subdirectory(app)
add_subdirectory(base) add_subdirectory(base)
if (GUI) if (GUI)
find_package(Qt5 ${requiredQtVersion} REQUIRED COMPONENTS Widgets Svg)
if (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
find_package(Qt5 ${requiredQtVersion} REQUIRED COMPONENTS MacExtras)
elseif (CMAKE_SYSTEM_NAME STREQUAL "Windows")
find_package(Qt5 ${requiredQtVersion} REQUIRED COMPONENTS WinExtras)
endif()
add_subdirectory(gui) add_subdirectory(gui)
endif () endif()
if (WEBUI) if (WEBUI)
add_subdirectory(webui) add_subdirectory(webui)
endif() endif()
add_subdirectory(app)

225
src/app/CMakeLists.txt

@ -1,4 +1,32 @@
add_executable(qBittorrent # Generate and configure translation files
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
# Based on https://gist.github.com/giraldeau/546ba5512a74dfe9d8ea0862d66db412
file(GLOB QBT_TS_FILES "${qBittorrent_SOURCE_DIR}/src/lang/*.ts")
set_source_files_properties(${QBT_TS_FILES} PROPERTIES OUTPUT_LOCATION "${qBittorrent_BINARY_DIR}/src/lang")
qt5_add_translation(QBT_QM_FILES ${QBT_TS_FILES})
configure_file("${qBittorrent_SOURCE_DIR}/src/lang/lang.qrc" "${qBittorrent_BINARY_DIR}/src/lang/lang.qrc" COPYONLY)
if (WEBUI)
file(GLOB QBT_WEBUI_TS_FILES "${qBittorrent_SOURCE_DIR}/src/webui/www/translations/*.ts")
set_source_files_properties(${QBT_WEBUI_TS_FILES}
PROPERTIES OUTPUT_LOCATION "${qBittorrent_BINARY_DIR}/src/webui/www/translations")
qt5_add_translation(QBT_WEBUI_QM_FILES ${QBT_WEBUI_TS_FILES})
configure_file("${qBittorrent_SOURCE_DIR}/src/webui/www/translations/webui_translations.qrc"
"${qBittorrent_BINARY_DIR}/src/webui/www/translations/webui_translations.qrc" COPYONLY)
endif()
FILE(GLOB QT_TRANSLATIONS "${qBittorrent_SOURCE_DIR}/dist/qt-translations/qtbase_*.qm")
foreach(EXTRA_TRANSLATION IN ITEMS "fa" "gl" "lt" "pt" "sl" "sv" "zh_CN")
list(APPEND QT_TRANSLATIONS "${qBittorrent_SOURCE_DIR}/dist/qt-translations/qt_${EXTRA_TRANSLATION}.qm")
endforeach()
# Executable target configuration
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
add_executable(qbt_app)
target_sources(qbt_app PRIVATE
# headers # headers
application.h application.h
applicationinstancemanager.h applicationinstancemanager.h
@ -15,148 +43,135 @@ add_executable(qBittorrent
main.cpp main.cpp
qtlocalpeer/qtlocalpeer.cpp qtlocalpeer/qtlocalpeer.cpp
upgrade.cpp upgrade.cpp
)
target_include_directories(qBittorrent PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
target_link_libraries(qBittorrent PRIVATE qbt_base)
set_target_properties(qBittorrent # resources
PROPERTIES "${qBittorrent_SOURCE_DIR}/src/icons/icons.qrc"
AUTOUIC True "${qBittorrent_SOURCE_DIR}/src/searchengine/searchengine.qrc"
AUTORCC True ${QBT_QM_FILES}
MACOSX_BUNDLE True "${qBittorrent_BINARY_DIR}/src/lang/lang.qrc" # yes, it's supposed to be "*_BINARY_DIR"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
) )
# translations target_link_libraries(qbt_app PRIVATE
include(QbtTranslations) qbt_base
qbt_version_definitions
)
file(GLOB QBT_TS_FILES ../lang/*.ts) set_target_properties(qbt_app PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
qbt_add_translations(qBittorrent QRC_FILE "../lang/lang.qrc" TS_FILES ${QBT_TS_FILES})
if (WEBUI) # Additional platform specific configuration
file(GLOB QBT_WEBUI_TS_FILES ../webui/www/translations/*.ts) # -----------------------------------------------------------------------------
qbt_add_translations(qBittorrent QRC_FILE "../webui/www/translations/webui_translations.qrc" TS_FILES ${QBT_WEBUI_TS_FILES}) # -----------------------------------------------------------------------------
endif() set_source_files_properties(${QT_TRANSLATIONS} PROPERTIES MACOSX_PACKAGE_LOCATION translations)
set_source_files_properties(
set(QBT_APP_RESOURCES "${qBittorrent_SOURCE_DIR}/dist/mac/qt.conf"
../icons/icons.qrc "${qBittorrent_SOURCE_DIR}/dist/mac/qBitTorrentDocument.icns"
../searchengine/searchengine.qrc "${qBittorrent_SOURCE_DIR}/dist/mac/qbittorrent_mac.icns"
PROPERTIES
MACOSX_PACKAGE_LOCATION Resources
) )
# With AUTORCC rcc is ran by cmake before language files are generated, if (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
# and thus we call rcc explicitly # substitute @EXECUTABLE@ in dist/mac/Info.plist
qt5_add_resources(QBT_APP_RESOURCE_SOURCE ${QBT_APP_RESOURCES}) get_target_property(EXECUTABLE qbt_app OUTPUT_NAME)
configure_file(${qBittorrent_SOURCE_DIR}/dist/mac/Info.plist
if (WIN32) ${qBittorrent_BINARY_DIR}/dist/mac/pregen.plist @ONLY)
file(GENERATE
OUTPUT ${qBittorrent_BINARY_DIR}/dist/mac/Info.plist
INPUT ${qBittorrent_BINARY_DIR}/dist/mac/pregen.plist
)
set_target_properties(qbt_app PROPERTIES
MACOSX_BUNDLE ON
MACOSX_BUNDLE_BUNDLE_NAME "${EXECUTABLE}"
MACOSX_BUNDLE_INFO_PLIST ${qBittorrent_BINARY_DIR}/dist/mac/Info.plist
)
target_sources(qbt_app PRIVATE
${QT_TRANSLATIONS}
${qBittorrent_SOURCE_DIR}/dist/mac/qt.conf
${qBittorrent_SOURCE_DIR}/dist/mac/qBitTorrentDocument.icns
${qBittorrent_SOURCE_DIR}/dist/mac/qbittorrent_mac.icns
)
elseif (CMAKE_SYSTEM_NAME STREQUAL "Windows")
set_target_properties(qbt_app PROPERTIES WIN32_EXECUTABLE ON)
if (MINGW) if (MINGW)
target_sources(qBittorrent PRIVATE ../qbittorrent_mingw.rc) target_sources(qbt_app PRIVATE ${qBittorrent_SOURCE_DIR}/src/qbittorrent_mingw.rc)
else() else()
target_sources(qBittorrent PRIVATE ../qbittorrent.rc) target_sources(qbt_app PRIVATE ${qBittorrent_SOURCE_DIR}/src/qbittorrent.rc)
endif() endif()
target_sources(qbt_app PRIVATE ${qBittorrent_SOURCE_DIR}/src/qbittorrent.exe.manifest)
target_sources(qBittorrent PRIVATE ../qbittorrent.exe.manifest)
endif() endif()
# Additional feature dependent configuration
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
if (STACKTRACE) if (STACKTRACE)
if (UNIX) target_compile_definitions(qbt_app PRIVATE STACKTRACE)
target_sources(qBittorrent PRIVATE stacktrace.h)
else() if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
target_sources(qBittorrent PRIVATE stacktrace_win.h) target_sources(qbt_app PRIVATE stacktrace_win.h)
if (GUI) if (GUI)
target_sources(qBittorrent PRIVATE stacktracedialog.cpp stacktracedialog.h) target_sources(qbt_app PRIVATE
stacktracedialog.h
stacktracedialog.cpp
stacktracedialog.ui
)
endif() endif()
# i686 arch on Windows requires frame pointer preservation
if (MSVC) if (MSVC)
if (NOT "${WINXXBITS}" STREQUAL "Win64") target_compile_options(qbt_app PRIVATE /Zi)
# i686 arch requires frame pointer preservation target_link_options(qbt_app PUBLIC LINKER:/DEBUG)
add_compile_options(-Oy-) if (CMAKE_SIZEOF_VOID_P EQUAL 4)
target_compile_options(qbt_app PRIVATE /Oy)
endif() endif()
add_compile_options(-Zi)
target_link_libraries(qBittorrent PUBLIC dbghelp -DEBUG)
else() else()
if (NOT "${WINXXBITS}" STREQUAL "Win64") if (CMAKE_SIZEOF_VOID_P EQUAL 4)
add_compile_options(-fno-omit-frame-pointer) target_compile_options(qbt_app PRIVATE -fno-omit-frame-pointer)
endif() endif()
target_link_libraries(qBittorrent PUBLIC dbghelp -Wl,--export-all-symbols)
endif() endif()
target_link_libraries(qbt_app PUBLIC dbghelp)
else()
target_sources(qbt_app PRIVATE stacktrace.h)
endif() endif()
endif() endif()
if (GUI) if (GUI)
target_link_libraries(qBittorrent PRIVATE qbt_gui) set_target_properties(qbt_app PROPERTIES OUTPUT_NAME qbittorrent)
set_target_properties(qBittorrent target_link_libraries(qbt_app PRIVATE qbt_gui)
PROPERTIES
OUTPUT_NAME qbittorrent
WIN32_EXECUTABLE True
)
else() else()
set_target_properties(qBittorrent set_target_properties(qbt_app PROPERTIES OUTPUT_NAME qbittorrent-nox)
PROPERTIES
OUTPUT_NAME qbittorrent-nox
)
endif() endif()
if (WEBUI) if (WEBUI)
target_link_libraries(qBittorrent PRIVATE qbt_webui) target_sources(qbt_app PRIVATE
endif() ${QBT_WEBUI_QM_FILES}
${qBittorrent_BINARY_DIR}/src/webui/www/translations/webui_translations.qrc # yes, it's supposed to be "*_BINARY_DIR"
# we have to include resources into the bundle
if (APPLE)
set(OSX_RES_SRC_DIR "${qBittorrent_SOURCE_DIR}/dist/mac")
list(APPEND QBT_APP_RESOURCE_SOURCE
"${OSX_RES_SRC_DIR}/qt.conf"
"${OSX_RES_SRC_DIR}/qBitTorrentDocument.icns"
"${OSX_RES_SRC_DIR}/qbittorrent_mac.icns")
set_source_files_properties(
"${OSX_RES_SRC_DIR}/qt.conf"
"${OSX_RES_SRC_DIR}/qBitTorrentDocument.icns"
"${OSX_RES_SRC_DIR}/qbittorrent_mac.icns"
PROPERTIES
MACOSX_PACKAGE_LOCATION Resources)
set(QT_TR_DIR "${qBittorrent_SOURCE_DIR}/dist/qt-translations")
FILE(GLOB QT_TRANSLATIONS "${QT_TR_DIR}/qtbase_*.qm")
list(APPEND QT_TRANSLATIONS
${QT_TR_DIR}/qt_fa.qm
${QT_TR_DIR}/qt_gl.qm
${QT_TR_DIR}/qt_lt.qm
${QT_TR_DIR}/qt_pt.qm
${QT_TR_DIR}/qt_sl.qm
${QT_TR_DIR}/qt_sv.qm
${QT_TR_DIR}/qt_zh_CN.qm
) )
list(APPEND QBT_APP_RESOURCE_SOURCE ${QT_TRANSLATIONS}) target_link_libraries(qbt_app PRIVATE qbt_webui)
set_source_files_properties(${QT_TRANSLATIONS} PROPERTIES MACOSX_PACKAGE_LOCATION translations)
endif() endif()
target_sources(qBittorrent PRIVATE ${QBT_QM_FILES} ${QBT_APP_RESOURCE_SOURCE}) if (GUI)
if ((CMAKE_SYSTEM_NAME STREQUAL "Windows") OR (CMAKE_SYSTEM_NAME STREQUAL "Darwin"))
get_target_property(QBT_EXECUTABLE_NAME qBittorrent OUTPUT_NAME) qt5_import_plugins(qbt_app
INCLUDE Qt5::QSvgIconPlugin
if (APPLE) INCLUDE Qt5::QSvgPlugin
set(qbt_BUNDLE_NAME ${QBT_EXECUTABLE_NAME})
# substitute @EXECUTABLE@ in dist/mac/Info.plist
set(EXECUTABLE ${qbt_BUNDLE_NAME})
configure_file(${qBittorrent_SOURCE_DIR}/dist/mac/Info.plist ${qBittorrent_BINARY_DIR}/dist/mac/Info.plist @ONLY)
set_target_properties(qBittorrent PROPERTIES
MACOSX_BUNDLE_BUNDLE_NAME "${qbt_BUNDLE_NAME}"
MACOSX_BUNDLE_INFO_PLIST ${qBittorrent_BINARY_DIR}/dist/mac/Info.plist
) )
endif()
endif() endif()
# installation # Installation
install(TARGETS qBittorrent # -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
install(TARGETS qbt_app
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
BUNDLE DESTINATION . BUNDLE DESTINATION .
COMPONENT runtime COMPONENT runtime
) )
if (GUI AND APPLE) if (MSVC)
find_package(Qt5Svg REQUIRED) install(FILES $<TARGET_PDB_FILE:qbt_app>
include(bundle) DESTINATION ${CMAKE_INSTALL_BINDIR}
OPTIONAL
)
endif() endif()

31
src/base/CMakeLists.txt

@ -1,5 +1,3 @@
find_package(ZLIB 1.2.5.2 REQUIRED)
add_library(qbt_base STATIC add_library(qbt_base STATIC
# headers # headers
algorithm.h algorithm.h
@ -162,18 +160,35 @@ add_library(qbt_base STATIC
target_link_libraries(qbt_base target_link_libraries(qbt_base
PRIVATE PRIVATE
ZLIB::ZLIB ZLIB::ZLIB
qbt_version_definitions
PUBLIC PUBLIC
LibtorrentRasterbar::torrent-rasterbar LibtorrentRasterbar::torrent-rasterbar
Qt5::Core Qt5::Network Qt5::Xml Qt5::Core Qt5::Network Qt5::Xml
qbt_common_cfg
) )
if (Qt5DBus_FOUND) if (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
target_link_libraries(qbt_base PRIVATE Qt5::DBus)
endif()
if (APPLE)
find_library(IOKit_LIBRARY IOKit) find_library(IOKit_LIBRARY IOKit)
find_library(Carbon_LIBRARY Carbon) find_library(Carbon_LIBRARY Carbon)
find_library(AppKit_LIBRARY AppKit) find_library(AppKit_LIBRARY AppKit)
target_link_libraries(qbt_base PRIVATE ${Carbon_LIBRARY} ${IOKit_LIBRARY} ${AppKit_LIBRARY})
target_link_libraries(qbt_base PRIVATE
${AppKit_LIBRARY}
${Carbon_LIBRARY}
${IOKit_LIBRARY}
)
elseif (CMAKE_SYSTEM_NAME STREQUAL "Windows")
target_link_libraries(qbt_base PRIVATE Iphlpapi)
endif()
if (NOT GUI)
target_compile_definitions(qbt_base PUBLIC DISABLE_GUI)
endif()
if (NOT WEBUI)
target_compile_definitions(qbt_base PUBLIC DISABLE_WEBUI)
endif()
if (DBUS)
target_link_libraries(qbt_base PUBLIC Qt5::DBus)
endif() endif()

13
src/config.h.cmakein

@ -1,13 +0,0 @@
#cmakedefine QBT_USE_GUI
#ifndef QBT_USE_GUI
#define DISABLE_GUI
#endif
#cmakedefine QBT_USE_WEBUI
#ifndef QBT_USE_WEBUI
#define DISABLE_WEBUI
#endif
#cmakedefine STACKTRACE_WIN

61
src/gui/CMakeLists.txt

@ -1,6 +1,3 @@
set(CMAKE_AUTORCC True)
set(CMAKE_AUTOUIC True)
add_library(qbt_gui STATIC add_library(qbt_gui STATIC
# headers # headers
aboutdialog.h aboutdialog.h
@ -180,6 +177,7 @@ add_library(qbt_gui STATIC
rss/rsswidget.ui rss/rsswidget.ui
search/pluginselectdialog.ui search/pluginselectdialog.ui
search/pluginsourcedialog.ui search/pluginsourcedialog.ui
search/searchjobwidget.ui
search/searchwidget.ui search/searchwidget.ui
shutdownconfirmdialog.ui shutdownconfirmdialog.ui
speedlimitdialog.ui speedlimitdialog.ui
@ -188,48 +186,47 @@ add_library(qbt_gui STATIC
torrentcreatordialog.ui torrentcreatordialog.ui
trackerentriesdialog.ui trackerentriesdialog.ui
updownratiodialog.ui updownratiodialog.ui
# resources
about.qrc
) )
if (WIN32 OR APPLE) target_sources(qbt_gui INTERFACE about.qrc)
target_sources(qbt_gui PRIVATE programupdater.h programupdater.cpp)
endif()
if (UNIX AND Qt5DBus_FOUND) target_link_libraries(qbt_gui
target_link_libraries(qbt_gui PRIVATE Qt5::DBus) PRIVATE
qbt_base
PUBLIC
Qt5::Gui Qt5::Widgets
)
if (DBUS)
target_sources(qbt_gui PRIVATE target_sources(qbt_gui PRIVATE
qtnotify/notifications.h qtnotify/notifications.h
qtnotify/notifications.cpp qtnotify/notifications.cpp
)
find_package(X11)
if (X11_FOUND)
target_sources(qbt_gui PRIVATE
powermanagement/powermanagement_x11.h powermanagement/powermanagement_x11.h
powermanagement/powermanagement_x11.cpp powermanagement/powermanagement_x11.cpp
) )
endif()
endif() endif()
target_include_directories(qbt_gui PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) if ((CMAKE_SYSTEM_NAME STREQUAL "Windows") OR (CMAKE_SYSTEM_NAME STREQUAL "Darwin"))
target_sources(qbt_gui PRIVATE
target_link_libraries(qbt_gui programupdater.h
PRIVATE programupdater.cpp
qbt_base )
PUBLIC endif()
Qt5::Gui Qt5::Widgets
)
if (APPLE) if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
target_sources(qbt_gui PRIVATE macutilities.h macutilities.mm) target_link_libraries(qbt_gui PRIVATE
find_package(Qt5 ${requiredQtVersion} REQUIRED COMPONENTS MacExtras) Qt5::WinExtras
target_link_libraries(qbt_gui PRIVATE Qt5::MacExtras objc) PowrProf
)
endif() endif()
if (WIN32) if (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
find_package(Qt5 ${requiredQtVersion} REQUIRED COMPONENTS WinExtras) target_sources(qbt_gui PRIVATE
target_link_libraries(qbt_gui PRIVATE Qt5::WinExtras PowrProf) macutilities.h
macutilities.mm
)
target_link_libraries(qbt_gui PRIVATE
Qt5::MacExtras
objc
)
endif() endif()

2
src/gui/rss/articlelistwidget.cpp

@ -33,7 +33,7 @@
#include "base/global.h" #include "base/global.h"
#include "base/rss/rss_article.h" #include "base/rss/rss_article.h"
#include "base/rss/rss_item.h" #include "base/rss/rss_item.h"
#include "uithememanager.h" #include "gui/uithememanager.h"
ArticleListWidget::ArticleListWidget(QWidget *parent) ArticleListWidget::ArticleListWidget(QWidget *parent)
: QListWidget(parent) : QListWidget(parent)

66
src/webui/CMakeLists.txt

@ -1,38 +1,38 @@
add_library(qbt_webui STATIC add_library(qbt_webui STATIC
# headers # headers
api/apicontroller.h api/apicontroller.h
api/apierror.h api/apierror.h
api/appcontroller.h api/appcontroller.h
api/authcontroller.h api/authcontroller.h
api/freediskspacechecker.h api/freediskspacechecker.h
api/isessionmanager.h api/isessionmanager.h
api/logcontroller.h api/logcontroller.h
api/rsscontroller.h api/rsscontroller.h
api/searchcontroller.h api/searchcontroller.h
api/synccontroller.h api/synccontroller.h
api/torrentscontroller.h api/torrentscontroller.h
api/transfercontroller.h api/transfercontroller.h
api/serialize/serialize_torrent.h api/serialize/serialize_torrent.h
webapplication.h webapplication.h
webui.h webui.h
# sources # sources
api/apicontroller.cpp api/apicontroller.cpp
api/apierror.cpp api/apierror.cpp
api/appcontroller.cpp api/appcontroller.cpp
api/authcontroller.cpp api/authcontroller.cpp
api/freediskspacechecker.cpp api/freediskspacechecker.cpp
api/logcontroller.cpp api/logcontroller.cpp
api/rsscontroller.cpp api/rsscontroller.cpp
api/searchcontroller.cpp api/searchcontroller.cpp
api/synccontroller.cpp api/synccontroller.cpp
api/torrentscontroller.cpp api/torrentscontroller.cpp
api/transfercontroller.cpp api/transfercontroller.cpp
api/serialize/serialize_torrent.cpp api/serialize/serialize_torrent.cpp
webapplication.cpp webapplication.cpp
webui.cpp webui.cpp
) )
qbt_target_sources(qBittorrent PRIVATE www/webui.qrc) target_sources(qbt_webui INTERFACE www/webui.qrc)
target_link_libraries(qbt_webui PUBLIC qbt_base) target_link_libraries(qbt_webui PRIVATE qbt_base)

Loading…
Cancel
Save