diff --git a/CMakeLists.txt b/CMakeLists.txt --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -168,34 +168,9 @@ # 5. estimate which of the products/features can be build by internal deps # get the special macros -include(CalligraProductSetMacros) include(MacroJPEG) include(GenerateTestExportHeader) - -# get the definitions of products, features and product sets -include(KritaProducts.cmake) - -set(PRODUCTSET_DEFAULT "ALL") -# temporary migration support -if (CREATIVEONLY) - set(WARN_ABOUT_CREATIVEONLY TRUE) - set(PRODUCTSET_DEFAULT "CREATIVE") -endif () - -if(NOT PRODUCTSET) - set(PRODUCTSET ${PRODUCTSET_DEFAULT} CACHE STRING "Set of products/features to build" FORCE) -endif() - -if (RELEASE_BUILD) - set(CALLIGRA_SHOULD_BUILD_STAGING FALSE) -else () - set(CALLIGRA_SHOULD_BUILD_STAGING TRUE) -endif () - -# finally choose products/features to build -calligra_set_productset(${PRODUCTSET}) - ######################## ######################### ## Look for KDE and Qt ## @@ -574,15 +549,6 @@ endif() set(CMAKE_MODULE_PATH ${OLD_CMAKE_MODULE_PATH} ) -## -## Test for Xinput -## -if(NOT WIN32 AND NOT APPLE) - set(REQUIRED_Xinput_FOUND ${X11_Xinput_FOUND}) -else() - set(REQUIRED_Xinput_FOUND TRUE) -endif() - add_definitions(${QT_DEFINITIONS} ${QT_QTDBUS_DEFINITIONS}) if(WIN32) @@ -662,63 +628,12 @@ ${CMAKE_BINARY_DIR}/libs/version ) - ################################################### -#################################################### -## Detect which products/features can be compiled ## -#################################################### -################################################### - -calligra_drop_product_on_bad_condition( APP_KRITA - EIGEN3_FOUND "Eigen devel not found" - EXIV2_FOUND "libexiv2 devel not found" - HAVE_REQUIRED_LCMS_VERSION "lcms devel not found" - Boost_SYSTEM_FOUND "boost-system devel not found" - REQUIRED_Xinput_FOUND "Xinput devel not found " -) - -############################################# -#### Backward compatibility BUILD_x=off #### -############################################# - -# workaround: disable directly all products which might be activated by internal -# dependencies, but belong to scope of old flag -calligra_drop_products_on_old_flag(krita APP_KRITA) - -############################################# -#### Temporarily broken products #### -############################################# - -# If a product does not build due to some temporary brokeness disable it here, -# by calling calligra_disable_product with the product id and the reason, -# e.g.: -# calligra_disable_product(APP_KEXI "isn't buildable at the moment") - -############################################# -#### Calculate buildable products #### -############################################# - -calligra_drop_unbuildable_products() - - ################### -#################### -## Subdirectories ## -#################### -################### - -if(SHOULD_BUILD_APP_KRITA) - add_subdirectory(krita) -endif() +feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES) -# non-app directories are moved here because they can depend on SHOULD_BUILD_{appname} variables set above add_subdirectory(libs) add_subdirectory(plugins) - -add_subdirectory( benchmarks ) - -feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES) - -calligra_product_deps_report("product_deps") -calligra_log_should_build() +add_subdirectory(benchmarks) +add_subdirectory(krita) configure_file(KoConfig.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/KoConfig.h ) configure_file(config_convolution.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config_convolution.h) diff --git a/KritaProducts.cmake b/KritaProducts.cmake deleted file mode 100644 --- a/KritaProducts.cmake +++ /dev/null @@ -1,250 +0,0 @@ -### DEFINITION OF PRODUCTS, FEATURES AND PRODUCTSETS -#################################################### - -# When building Krita a lot of different things are created and installed. To -# describe them and their internal dependencies the concepts of "product", -# "feature" and "product set" are used. - -# A "product" is the smallest functional unit which can be created in the build -# and which is useful on its own when installed. Examples are e.g. libraries, -# plugins or executables. Products have external and internal required -# dependencies at build-time. Internal dependencies are noted in terms of other -# products or features (see below) and could be e.g. other libraries to link -# against or build tools needed to generate source files. -# A product gets defined by setting an identifier, a descriptive fullname and -# the needed internal build-time requirements. Any other product or feature -# listed as requirement must have been defined before. - -# A "feature" is not a standalone product, but adds abilities to one or multiple -# given products. One examples is e.g. scriptability. Features have external and -# internal required dependencies at build-time. Internal dependencies are noted -# in terms of other products or features and could be e.g. other libraries to -# link against or build tools needed to generate source files. -# A feature gets defined by setting an identifier, a descriptive fullname and -# the needed internal build-time requirements. Any other product or feature -# listed as requirement must have been defined before. - -# A "productset" is a selection of products and features which should be build -# together. The products and features can be either essential or optional to the -# set. If essential (REQUIRES), the whole productset will not be build if a -# product or feature is missing another internal or external dependency. If -# optional (OPTIONAL), the rest of the set will still be build in that case. -# The products and features to include in a set can be listed directly or -# indirectly: they can be named explicitely, but also by including other -# productsets in a set, whose products and features will then be part of the -# first set as well. -# Products, features and productsets can be listed as dependencies in multiple -# product sets. As with dependencies for products or features, they must have -# been defined before. - -# Products, features and product sets are in the same namespace, so a given -# identifier can be only used either for a product or for a feature or for a -# product set. - -# The ids of products and features (but not sets) are used to generate cmake -# variables SHOULD_BUILD_${ID}, which then are used to control what is build and -# how. - - -############################################# -#### Product definitions #### -############################################# - -# For defining new products see end of this file, "How to add another product?" - -# IDEA: also add headers/sdk for all the libs ("_DEVEL"?) -# IDEA: note external deps for products, so they are only checked if needed -# There can be required or optional external deps, required will also result -# in automatic disabling of product building -# TODO: some products have multiple optional requirements, but need at least one. -# See APP_CONVERTER, FILEMANAGER_* - -# building tools - -# Calligra-independent utility libs -calligra_define_product(LIB_KOVECTORIMAGE "libkovectorimage") - -# calligra libs -calligra_define_product(LIB_CALLIGRA "Calligra core libs" REQUIRES ) - -# features - -# plugins -calligra_define_product(PLUGIN_TEXTSHAPE "Text shape plugin" REQUIRES LIB_CALLIGRA) - -# parts - -# apps -calligra_define_product(APP_KRITA "Krita app (for Desktop)" REQUIRES LIB_CALLIGRA) - -# extras - -# more plugins -calligra_define_product(PLUGIN_COLORENGINES "Colorengine plugins" REQUIRES LIB_CALLIGRA) -calligra_define_product(PLUGIN_ARTISTICTEXTSHAPE "Artistic shape plugin" REQUIRES LIB_CALLIGRA) -calligra_define_product(PLUGIN_DOCKERS "Default dockers plugin" REQUIRES LIB_CALLIGRA) -calligra_define_product(PLUGIN_DEFAULTTOOLS "Default Flake tools plugin" REQUIRES LIB_CALLIGRA) -calligra_define_product(PLUGIN_PATHSHAPES "Path shape plugins" REQUIRES LIB_CALLIGRA) -calligra_define_product(PLUGIN_VECTORSHAPE "Vectorgraphic shape plugin" REQUIRES LIB_CALLIGRA LIB_KOVECTORIMAGE) - -# staging plugins - -############################################# -#### Product set definitions #### -############################################# - -# For defining new productsets see end of this file, -# "How to add another productset?" - -calligra_define_productset(KRITA "Full Krita" - REQUIRES - APP_KRITA - OPTIONAL - # plugins - PLUGIN_ARTISTICTEXTSHAPE - PLUGIN_COLORENGINES - PLUGIN_DEFAULTTOOLS - PLUGIN_DOCKERS - PLUGIN_PATHSHAPES - PLUGIN_TEXTSHAPE - PLUGIN_VECTORSHAPE -) - -# How to add another product? -# =========================== -# -# 1. Define the product by a call of calligra_define_product, -# e.g. -# -# calligra_define_product(MYPRODUCT "title of product") -# -# For the product id use a proper prefix (LIB_, PLUGIN_, FILTER_, APP_, PART_, -# ...), whatever is appropriate. -# -# 2. Extend that call with a REQUIRES argument section, if the product has -# hard internal build-time dependencies on other products or features. -# Products/features that are listed as dependencies have to be defined before -# (see also the API doc in cmake/modules/CalligraProductSetMacros.cmake) -# E.g. -# -# calligra_define_product(MYPRODUCT "title of product" REQUIRES P1 P2) -# -# 3. Add a rule when to not build the product, in the section "Detect which -# products/features can be compiled" of the toplevel CMakeLists.txt. Each -# product should have their own boolean expression when to set the build flag -# to FALSE, e.g. -# -# if (PLATFORMX OR NOT EXTERNAL_DEP_X_FOUND) -# set(SHOULD_BUILD_MYPRODUCT FALSE) -# endif () -# -# 4. Wrap everything belonging to the product with the build flag of the product. -# Ideally this is done around subdirectory inclusions, results in easier code. -# e.g. -# -# if (SHOULD_BUILD_MYPRODUCT) -# add_subdirectory(myproduct) -# endif () -# -# 5. Tag the product as STAGING, if it is not yet ready for release, but already -# integrated in the master branch, e.g. -# -# calligra_define_product(MYPRODUCT "title of product" STAGING REQUIRES P1) -# -# 6. Add the product to all products, features and product sets which have this -# product as REQUIRED or OPTIONAL dependency. -# -# -# How to add another feature? -# =========================== -# -# 1. Define the feature by a call of calligra_define_feature, -# e.g. -# -# calligra_define_feature(MYFEATURE "title of feature") -# -# For the feature id use a proper prefix (FEATURE_, ...), whatever is -# appropriate. -# -# 2. Extend that call with a REQUIRES argument section, if the feature has -# hard internal build-time dependencies on other products or features. -# Products or features that are listed as dependencies have to be defined -# before -# (see also the API doc in cmake/modules/CalligraProductSetMacros.cmake) -# E.g. -# -# calligra_define_feature(MYFEATURE "title of feature" REQUIRES P1 F1) -# -# 3. Add a rule when to not build the feature, in the section "Detect which -# products/features can be compiled" of the toplevel CMakeLists.txt. Each -# feature should have their own boolean expression when to set the build flag -# to FALSE, e.g. -# -# if (PLATFORMX OR NOT EXTERNAL_DEP_X_FOUND) -# set(SHOULD_BUILD_MYFEATURE FALSE) -# endif () -# -# 4. Wrap everything belonging to the feature with the build flag of the feature. -# Ideally this is done around subdirectory inclusions, results in easier code. -# e.g. -# -# if (SHOULD_BUILD_MYFEATURE) -# add_subdirectory(myproduct) -# endif () -# -# 5. Tag the feature as STAGING, if it is not yet ready for release, but already -# integrated in the master branch, e.g. -# -# calligra_define_product(MYFEATURE "title of feature" STAGING REQUIRES P1 F1) -# -# 6. Add the feature to all products, features and product sets which have this -# product as REQUIRED or OPTIONAL dependency. -# -# -# How to add another productset? -# ============================== -# -# There are two possible places to put a productset definition. The first is to -# add it to this file, which should be done for more generic sets that are -# useful for many people. The second is a file of its own, in the directory -# "cmake/productsets", which should be done for more special ones or for those -# which should not be added to the repository. -# The file must be named with the name of the productset in lowercase and have -# the extension ".cmake". -# -# 1. Define the productset by a call of calligra_define_productset, -# e.g. -# -# calligra_define_productset(MYPRODUCTSET "title of productset") -# -# 2. Extend that call with REQUIRES or OPTIONAL argument sections, if the productset -# has hard or soft internal dependencies on other products, features or -# productsets. -# Products, features or productsets that are listed as dependencies have to -# be defined before -# (see also the API doc in cmake/modules/CalligraProductSetMacros.cmake) -# E.g. -# -# calligra_define_productset(MYPRODUCT "title of product" -# REQUIRES P1 P2 F1 PS1 -# OPTIONAL P3 F2 PS2) -# -# 3. Add the productset to all product sets which have this product set as -# REQUIRED or OPTIONAL dependency. -# -# Example for a file-based productset definition: -# You want a productset "MYWORDS". For that you add a file named -# "mywords.cmake" into the directory "cmake/productsets", with the content: -# --- 8< --- -# calligra_define_productset(MYWORDS "My Words" -# REQUIRES -# APP_WORDS -# PLUGIN_DEFAULTTOOLS -# PLUGIN_DOCKERS -# PLUGIN_PATHSHAPES -# PLUGIN_VARIABLES -# PLUGIN_TEXTSHAPE -# PLUGIN_PLUGINSHAPE -# PLUGIN_FORMULASHAPE -# ) -# --- 8< --- diff --git a/cmake/modules/CalligraProductSetMacros.cmake b/cmake/modules/CalligraProductSetMacros.cmake deleted file mode 100644 --- a/cmake/modules/CalligraProductSetMacros.cmake +++ /dev/null @@ -1,503 +0,0 @@ -# Copyright (c) 2013-2014 Friedrich W. H. Kossebau -# -# Redistribution and use is allowed according to the terms of the BSD license. -# For details see the accompanying COPYING-CMAKE-SCRIPTS file. - -# Global variables -# CALLIGRA_SHOULD_BUILD_PRODUCTS - list of requested products by the user -# CALLIGRA_NEEDED_PRODUCTS - list of internal needed products -# CALLIGRA_WANTED_PRODUCTS - list of internal wanted products -# CALLIGRA_STAGING_PRODUCTS - list of products only in staging mode -# temporary during qt5 port, remove after: -# CALLIGRA_UNPORTED_PRODUCTS - list of products not yet ported -# SHOULD_BUILD_${product_id} - boolean if product should be build - - -macro(calligra_disable_product _product_id _reason) - if (NOT DEFINED SHOULD_BUILD_${_product_id}) - message(FATAL_ERROR "Unknown product: ${_product_id}") - endif (NOT DEFINED SHOULD_BUILD_${_product_id}) - - set(SHOULD_BUILD_${_product_id} FALSE) - if (DEFINED BUILD_${_product_id}_DISABLE_REASON) - set(BUILD_${_product_id}_DISABLE_REASON "${BUILD_${_product_id}_DISABLE_REASON} / ") - endif (DEFINED BUILD_${_product_id}_DISABLE_REASON) - set(BUILD_${_product_id}_DISABLE_REASON "${BUILD_${_product_id}_DISABLE_REASON}${_reason}") -endmacro() - -# Usage: -# calligra_drop_product_on_bad_condition( -# NAME_OF_BOOL_VAR1 REASON_TEXT_FOR_DROPPING_ON_FALSE1 -# NAME_OF_BOOL_VAR2 REASON_TEXT_FOR_DROPPING_ON_FALSE2 -# ... -# ) -macro(calligra_drop_product_on_bad_condition _product_id) - if (NOT DEFINED SHOULD_BUILD_${_product_id}) - message(FATAL_ERROR "Unknown product: ${_product_id}") - endif (NOT DEFINED SHOULD_BUILD_${_product_id}) - - set(_current_flag) - foreach(_arg ${ARGN}) - if(DEFINED _current_flag) - if(NOT ${_current_flag}) - calligra_disable_product(${_product_id} ${_arg}) - endif() - set(_current_flag) - else() - set(_current_flag ${_arg}) - endif() - endforeach(_arg) - if(DEFINED _current_flag) - message(FATAL_ERROR "Bad number of arguments for calligra_drop_product_on_bad_condition(${_product_id} ...)") - endif() -endmacro() - -macro(calligra_set_shouldbuild_dependentproduct _product_id _dep_product_id) - # if not already enabled, enable - if (NOT SHOULD_BUILD_${_dep_product_id}) - list(APPEND CALLIGRA_NEEDED_PRODUCTS ${_dep_product_id}) - set(SHOULD_BUILD_${_dep_product_id} TRUE) - if (DEFINED CALLIGRA_PRODUCT_${_dep_product_id}_needed_dependencies OR - DEFINED CALLIGRA_PRODUCT_${_dep_product_id}_wanted_dependencies) - calligra_set_shouldbuild_productdependencies(${_dep_product_id} - "${CALLIGRA_PRODUCT_${_dep_product_id}_needed_dependencies}" - "${CALLIGRA_PRODUCT_${_dep_product_id}_wanted_dependencies}") - endif (DEFINED CALLIGRA_PRODUCT_${_dep_product_id}_needed_dependencies OR - DEFINED CALLIGRA_PRODUCT_${_dep_product_id}_wanted_dependencies) - endif (NOT SHOULD_BUILD_${_dep_product_id}) -endmacro() - - -macro(calligra_set_shouldbuild_productdependencies _product_id _productset_id_needed_dependencies _productset_id_wanted_dependencies) - # activate all needed products and note the dependency - foreach(_dep_product_id ${_productset_id_needed_dependencies}) - list(APPEND CALLIGRA_PRODUCT_${_dep_product_id}_dependents ${_product_id}) - calligra_set_shouldbuild_dependentproduct(${_product_id} ${_dep_product_id}) - endforeach(_dep_product_id) - - # activate all wanted products - foreach(_dep_product_id ${_productset_id_wanted_dependencies}) - calligra_set_shouldbuild_dependentproduct(${_product_id} ${_dep_product_id}) - endforeach(_dep_product_id) -endmacro() - - -macro(calligra_drop_unbuildable_products) - # temporary during qt5 port, remove after - if(NOT BUILD_UNPORTED) - foreach(_product_id ${CALLIGRA_UNPORTED_PRODUCTS}) - calligra_disable_product(${_product_id} "Not yet ported to Qt5/KF5") - endforeach(_product_id) - endif(NOT BUILD_UNPORTED) - - # first drop all staging products if not enabled - if(NOT CALLIGRA_SHOULD_BUILD_STAGING) - foreach(_product_id ${CALLIGRA_STAGING_PRODUCTS}) - calligra_disable_product(${_product_id} "Not ready for release") - endforeach(_product_id) - endif(NOT CALLIGRA_SHOULD_BUILD_STAGING) - - # can assume calligra_all_products has products in down-up order - # 1. check all wanted products and see if they will be built, - # if not then drop their required products - # TODO! - # 2. check all products if they can be built, if not disable build of depending - foreach(_product_id ${CALLIGRA_ALL_PRODUCTS}) - if(NOT SHOULD_BUILD_${_product_id}) - if(DEFINED CALLIGRA_PRODUCT_${_product_id}_dependents) - foreach(_dependent_product_id ${CALLIGRA_PRODUCT_${_product_id}_dependents}) - calligra_disable_product(${_dependent_product_id} "Required internal dependency missing: ${_product_id}") - endforeach(_dependent_product_id ${CALLIGRA_PRODUCT_${_dep_product_id}_dependents}) - endif(DEFINED CALLIGRA_PRODUCT_${_product_id}_dependents) - endif(NOT SHOULD_BUILD_${_product_id}) - endforeach(_product_id) -endmacro() - -# backward compatibility: BUILD_app as option or passed as cmake parameter can overwrite product set -# and disable a product if set to FALSE (TRUE was ignored) -macro(calligra_drop_products_on_old_flag _build_id) - string(TOLOWER "${_build_id}" lowercase_build_id) - if (DEFINED BUILD_${lowercase_build_id} AND NOT BUILD_${lowercase_build_id}) - foreach(_product_id ${ARGN}) - if (NOT DEFINED SHOULD_BUILD_${_product_id}) - message(FATAL_ERROR "Unknown product: ${_product_id}") - endif (NOT DEFINED SHOULD_BUILD_${_product_id}) - calligra_disable_product(${_product_id} "Disabled by cmake parameter") - endforeach(_product_id) - endif (DEFINED BUILD_${lowercase_build_id} AND NOT BUILD_${lowercase_build_id}) -endmacro() - -macro(calligra_set_productset _productset_string) - set(CALLIGRA_SHOULD_BUILD_PRODUCTS "") - # turn into list, _productset_string is not yet one - set(_productset_ids ${_productset_string}) - separate_arguments(_productset_ids) - set(_productset_list "") - # _product_id could be a product, feature or product set (predefined or from file) - foreach(_product_id ${_productset_ids}) - # be gracefull and compare the productset id case insensitive - string(TOUPPER "${_product_id}" _uppercase_product_id) - - if(_uppercase_product_id STREQUAL "ALL") - list( APPEND CALLIGRA_SHOULD_BUILD_PRODUCTS ${CALLIGRA_ALL_PRODUCTS}) - elseif(DEFINED SHOULD_BUILD_${_uppercase_product_id}) - list( APPEND CALLIGRA_SHOULD_BUILD_PRODUCTS ${_uppercase_product_id}) - else() - # also expects a productset definition filename in all lowercase - string(TOLOWER "${_product_id}" _lowercase_productset_id) - set(_productset_filename "${CMAKE_SOURCE_DIR}/cmake/productsets/${_lowercase_productset_id}.cmake") - - if (NOT EXISTS "${_productset_filename}") - message(FATAL_ERROR "Unknown product, feature or product set: ${_product_id}") - endif (NOT EXISTS "${_productset_filename}") - - # include the productset definition - include(${_productset_filename}) - if(NOT CALLIGRA_PRODUCTSET_${_uppercase_product_id}) - message(FATAL_ERROR "Product set file \"${_productset_filename}\" did not define a productset named \"${_uppercase_product_id}\".") - endif() - - list( APPEND CALLIGRA_SHOULD_BUILD_PRODUCTS ${_uppercase_product_id}) - endif() - list( APPEND _productset_list ${_uppercase_product_id}) - endforeach(_product_id) - - string(REPLACE ";" " " _productset_list "${_productset_list}") - set(CALLIGRA_NEEDED_PRODUCTS "") - - message(STATUS "-------------------------------------------------------------------" ) - message(STATUS "Configured with product set \"${_productset_list}\"") - message(STATUS "-------------------------------------------------------------------" ) - - # backward compatibility: BUILD_app as option or passed as cmake parameter can overwrite product set - # and disable a product if set to FALSE (TRUE was ignored) - foreach(_product_id ${CALLIGRA_ALL_PRODUCTS}) - string(TOLOWER "${_product_id}" lowercase_product_id) - if (DEFINED BUILD_${lowercase_product_id}) - if(NOT BUILD_${lowercase_product_id}) - list(FIND CALLIGRA_SHOULD_BUILD_PRODUCTS ${_product_id} _index) - # remove from product set, if part - if(NOT _index EQUAL -1) - list(REMOVE_AT CALLIGRA_SHOULD_BUILD_PRODUCTS ${_index}) - endif(NOT _index EQUAL -1) - endif(NOT BUILD_${lowercase_product_id}) - endif (DEFINED BUILD_${lowercase_product_id}) - endforeach(_product_id ${CALLIGRA_ALL_PRODUCTS}) - - # mark all products of the set as SHOULD_BUILD - foreach(_product_id ${CALLIGRA_SHOULD_BUILD_PRODUCTS}) - # check that this product is actually existing - if (NOT DEFINED SHOULD_BUILD_${_product_id}) - message(FATAL_ERROR "Unknown product: ${_product_id}") - endif (NOT DEFINED SHOULD_BUILD_${_product_id}) - - # mark product as should build, also all dependencies - set(SHOULD_BUILD_${_product_id} TRUE) - if (DEFINED CALLIGRA_PRODUCT_${_product_id}_needed_dependencies OR - DEFINED CALLIGRA_PRODUCT_${_product_id}_wanted_dependencies) - calligra_set_shouldbuild_productdependencies(${_product_id} - "${CALLIGRA_PRODUCT_${_product_id}_needed_dependencies}" - "${CALLIGRA_PRODUCT_${_product_id}_wanted_dependencies}") - endif (DEFINED CALLIGRA_PRODUCT_${_product_id}_needed_dependencies OR - DEFINED CALLIGRA_PRODUCT_${_product_id}_wanted_dependencies) - endforeach(_product_id) -endmacro() - - -# Usage: -# calligra_define_product( -# [NAME] -# [STAGING] -# [REQUIRES ...] -# ) -macro(calligra_define_product _product_id) - # default product name to id, empty deps - set(_product_name "${_product_id}") - set(_needed_dep_product_ids) - - if(DEFINED SHOULD_BUILD_${_product_id}) - message(FATAL_ERROR "Product \"${_product_id}\" already defined, as \"${CALLIGRA_PRODUCT_${_product_id}_name}\".") - endif(DEFINED SHOULD_BUILD_${_product_id}) - - # parse arguments: two states, "name" or "requires" - set(_current_arg_type "name") - foreach(_arg ${ARGN}) - if(${_arg} STREQUAL "NAME") - set(_current_arg_type "name") - elseif(${_arg} STREQUAL "REQUIRES") - set(_current_arg_type "requires") - else(${_arg} STREQUAL "NAME") - if(${_current_arg_type} STREQUAL "name") - if(${_arg} STREQUAL "STAGING") - list(APPEND CALLIGRA_STAGING_PRODUCTS ${_product_id}) - elseif(${_arg} STREQUAL "UNPORTED") - # temporary during qt5 port, remove after - list(APPEND CALLIGRA_UNPORTED_PRODUCTS ${_product_id}) - else(${_arg} STREQUAL "STAGING") - set(_product_name "${_arg}") - endif(${_arg} STREQUAL "STAGING") - elseif(${_current_arg_type} STREQUAL "requires") - # check that the dependency is actually existing - if(NOT DEFINED SHOULD_BUILD_${_arg}) - message(FATAL_ERROR "Unknown product/feature listed as dependency for \"${_product_id}\": \"${_arg}\"") - elseif(CALLIGRA_PRODUCTSET_${_arg}) - message(FATAL_ERROR "Productset cannot be a dependency for \"${_product_id}\": \"${_arg}\"") - endif() - list(APPEND _needed_dep_product_ids "${_arg}") - endif(${_current_arg_type} STREQUAL "name") - endif(${_arg} STREQUAL "NAME") - endforeach(_arg) - - # set product vars - set(SHOULD_BUILD_${_product_id} FALSE) - set(CALLIGRA_PRODUCT_${_product_id}_name "${_product_name}") - set(CALLIGRA_PRODUCT_${_product_id}_needed_dependencies ${_needed_dep_product_ids}) - list(APPEND CALLIGRA_ALL_PRODUCTS ${_product_id}) -endmacro(calligra_define_product) - - -# Usage: -# calligra_define_feature( -# [NAME] -# [STAGING] -# [REQUIRES ...] -# ) -macro(calligra_define_feature _product_id) - # default product name to id, empty deps - set(_product_name "${_product_id}") - set(_needed_dep_product_ids) - - if(DEFINED SHOULD_BUILD_${_product_id}) - message(FATAL_ERROR "Feature \"${_product_id}\" already defined, as \"${CALLIGRA_PRODUCT_${_product_id}_name}\".") - endif(DEFINED SHOULD_BUILD_${_product_id}) - - # parse arguments: two states, "name" or "requires" - set(_current_arg_type "name") - foreach(_arg ${ARGN}) - if(${_arg} STREQUAL "NAME") - set(_current_arg_type "name") - elseif(${_arg} STREQUAL "REQUIRES") - set(_current_arg_type "requires") - else(${_arg} STREQUAL "NAME") - if(${_current_arg_type} STREQUAL "name") - if(${_arg} STREQUAL "STAGING") - list(APPEND CALLIGRA_STAGING_PRODUCTS ${_product_id}) - elseif(${_arg} STREQUAL "UNPORTED") - # temporary during qt5 port, remove after - list(APPEND CALLIGRA_UNPORTED_PRODUCTS ${_product_id}) - else(${_arg} STREQUAL "STAGING") - set(_product_name "${_arg}") - endif(${_arg} STREQUAL "STAGING") - elseif(${_current_arg_type} STREQUAL "requires") - # check that the dependency is actually existing - if(NOT DEFINED SHOULD_BUILD_${_arg}) - message(FATAL_ERROR "Unknown product/feature listed as dependency for \"${_product_id}\": \"${_arg}\"") - elseif(CALLIGRA_PRODUCTSET_${_arg}) - message(FATAL_ERROR "Productset cannot be a dependency for \"${_product_id}\": \"${_arg}\"") - endif() - list(APPEND _needed_dep_product_ids "${_arg}") - endif(${_current_arg_type} STREQUAL "name") - endif(${_arg} STREQUAL "NAME") - endforeach(_arg) - - # set product vars - set(SHOULD_BUILD_${_product_id} FALSE) - set(CALLIGRA_PRODUCT_${_product_id}_name "${_product_name}") - set(CALLIGRA_PRODUCT_${_product_id}_needed_dependencies ${_needed_dep_product_ids}) - list(APPEND CALLIGRA_ALL_PRODUCTS ${_product_id}) -endmacro(calligra_define_feature) - - -# Usage: -# calligra_define_productset( -# [NAME] -# [REQUIRES ... ...] -# [OPTIONAL ... ...] -# ) -macro(calligra_define_productset _product_id) - # default product name to id, empty deps - set(_product_name "${_product_id}") - set(_needed_dep_product_ids) - set(_wanted_dep_product_ids) - - if(DEFINED SHOULD_BUILD_${_product_id}) - message(FATAL_ERROR "Productset \"${_product_id}\" already defined, as \"${CALLIGRA_PRODUCT_${_product_id}_name}\".") - endif(DEFINED SHOULD_BUILD_${_product_id}) - - # parse arguments: three states, "name", "requires" or "optional" - set(_current_arg_type "name") - foreach(_arg ${ARGN}) - if(${_arg} STREQUAL "NAME") - set(_current_arg_type "name") - elseif(${_arg} STREQUAL "REQUIRES") - set(_current_arg_type "requires") - elseif(${_arg} STREQUAL "OPTIONAL") - set(_current_arg_type "optional") - else(${_arg} STREQUAL "NAME") - if(${_current_arg_type} STREQUAL "name") - set(_product_name "${_arg}") - elseif(${_current_arg_type} STREQUAL "requires") - # check that the dependency is actually existing - if(NOT DEFINED SHOULD_BUILD_${_arg}) - message(FATAL_ERROR "Unknown product(set)/feature listed as dependency for \"${_product_id}\": \"${_arg}\"") - endif(NOT DEFINED SHOULD_BUILD_${_arg}) - list(APPEND _needed_dep_product_ids "${_arg}") - elseif(${_current_arg_type} STREQUAL "optional") - # check that the dependency is actually existing - if(NOT DEFINED SHOULD_BUILD_${_arg}) - message(FATAL_ERROR "Unknown product(set)/feature listed as dependency for \"${_product_id}\": \"${_arg}\"") - endif(NOT DEFINED SHOULD_BUILD_${_arg}) - list(APPEND _wanted_dep_product_ids "${_arg}") - endif(${_current_arg_type} STREQUAL "name") - endif(${_arg} STREQUAL "NAME") - endforeach(_arg) - - # set product(set) vars - set(SHOULD_BUILD_${_product_id} FALSE) - set(CALLIGRA_PRODUCT_${_product_id}_name "${_product_name}") - set(CALLIGRA_PRODUCTSET_${_product_id} TRUE) - set(CALLIGRA_PRODUCT_${_product_id}_needed_dependencies ${_needed_dep_product_ids}) - set(CALLIGRA_PRODUCT_${_product_id}_wanted_dependencies ${_wanted_dep_product_ids}) - list(APPEND CALLIGRA_ALL_PRODUCTS ${_product_id}) -endmacro(calligra_define_productset) - - -macro(calligra_log_should_build) - # find what products will be built and which not - set(_built_product_ids "") - set(_not_built_product_ids "") - set(_built_dependency_product_ids "") - set(_not_built_dependency_product_ids "") - - foreach(_product_id ${CALLIGRA_ALL_PRODUCTS}) - list(FIND CALLIGRA_SHOULD_BUILD_PRODUCTS ${_product_id} _index) - if(NOT _index EQUAL -1) - if(SHOULD_BUILD_${_product_id}) - list(APPEND _built_product_ids ${_product_id}) - else(SHOULD_BUILD_${_product_id}) - list(APPEND _not_built_product_ids ${_product_id}) - endif(SHOULD_BUILD_${_product_id}) - else(NOT _index EQUAL -1) - if(SHOULD_BUILD_${_product_id}) - list(APPEND _built_dependency_product_ids ${_product_id}) - else(SHOULD_BUILD_${_product_id}) - list(FIND CALLIGRA_NEEDED_PRODUCTS ${_product_id} _index2) - if(NOT _index2 EQUAL -1) - list(APPEND _not_built_dependency_product_ids ${_product_id}) - endif(NOT _index2 EQUAL -1) - endif(SHOULD_BUILD_${_product_id}) - endif(NOT _index EQUAL -1) - endforeach(_product_id) - - if(NOT _built_dependency_product_ids STREQUAL "") - message(STATUS "------ The following required product(set)s/features will be built -------") - foreach(_product_id ${_built_dependency_product_ids}) - if (DEFINED CALLIGRA_PRODUCT_${_product_id}_dependents) - set(dependents " [[needed by: ${CALLIGRA_PRODUCT_${_product_id}_dependents}]]") - else (DEFINED CALLIGRA_PRODUCT_${_product_id}_dependents) - set(dependents "") - endif (DEFINED CALLIGRA_PRODUCT_${_product_id}_dependents) - - message(STATUS "${_product_id}: ${CALLIGRA_PRODUCT_${_product_id}_name}${dependents}" ) - endforeach(_product_id) - message(STATUS "") - endif(NOT _built_dependency_product_ids STREQUAL "") - if(NOT _not_built_dependency_product_ids STREQUAL "") - message(STATUS "---- The following required product(set)s/features can NOT be built ------") - foreach(_product_id ${_not_built_dependency_product_ids}) - if (DEFINED CALLIGRA_PRODUCT_${_product_id}_dependents) - set(dependents " [[needed by: ${CALLIGRA_PRODUCT_${_product_id}_dependents}]]") - else (DEFINED CALLIGRA_PRODUCT_${_product_id}_dependents) - set(dependents "") - endif (DEFINED CALLIGRA_PRODUCT_${_product_id}_dependents) - - message(STATUS "${_product_id}: ${CALLIGRA_PRODUCT_${_product_id}_name}${dependents} | ${BUILD_${_product_id}_DISABLE_REASON}" ) - endforeach(_product_id) - message(STATUS "") - endif(NOT _not_built_dependency_product_ids STREQUAL "") - message(STATUS "------ The following product(set)s/features will be built ---------") - foreach(_product_id ${_built_product_ids}) - message(STATUS "${_product_id}: ${CALLIGRA_PRODUCT_${_product_id}_name}" ) - endforeach(_product_id) - if(NOT _not_built_product_ids STREQUAL "") - message(STATUS "\n------ The following product(set)s/features can NOT be built ------") - foreach(_product_id ${_not_built_product_ids}) - message(STATUS "${_product_id}: ${CALLIGRA_PRODUCT_${_product_id}_name} | ${BUILD_${_product_id}_DISABLE_REASON}" ) - endforeach(_product_id) - endif(NOT _not_built_product_ids STREQUAL "") - message(STATUS "-------------------------------------------------------------------" ) -endmacro(calligra_log_should_build) - - -macro(calligra_product_deps_report_stylebybuild _output _product_id) - if(SHOULD_BUILD_${_product_id}) - set(${_output} "filled") - else() - set(${_output} "solid") - endif() -endmacro(calligra_product_deps_report_stylebybuild) - -# Usage: -# calligra_product_deps_report() -macro(calligra_product_deps_report _filename) - set(_dot "${_dot}# This is a graphviz file. It shows the internal product dependencies of Calligra.\n") - set(_dot "${_dot}# dot -Tsvg ${_filename}.dot > ${_filename}.svg\n") - set(_dot "${_dot}# dot -Tpng ${_filename}.dot > ${_filename}.png\n") - set(_dot "${_dot}digraph calligra {\n") - set(_dot "${_dot}node [colorscheme=set312]\;\n") # pastel19, set312 or accent8 - set(_dot "${_dot}rankdir=LR\;\n") - - foreach(_product_id ${CALLIGRA_ALL_PRODUCTS}) - set(_color 11) - set(_shape "box") - set(_style "") - - if(CALLIGRA_PRODUCTSET_${_product_id}) - set(_color 1) - set(_shape "folder") - elseif(_product_id MATCHES "^LIB_") - set(_color 2) - set(_shape "box") - elseif(_product_id MATCHES "^FILTER_") - set(_color 3) - set(_shape "component") - elseif(_product_id MATCHES "^PLUGIN_") - set(_color 4) - set(_shape "component") - elseif(_product_id MATCHES "^PART_") - set(_color 5) - set(_shape "component") - elseif(_product_id MATCHES "^APP_") - set(_color 6) - set(_shape "box") - set(_style "rounded,") - elseif(_product_id MATCHES "^BUILDUTIL_") - set(_color 7) - set(_shape "diamond") - set(_style "rounded,") - elseif(_product_id MATCHES "^FEATURE_") - set(_color 8) - elseif(_product_id MATCHES "^OKULAR_") - set(_color 9) - set(_shape "component") - elseif(_product_id MATCHES "^FILEMANAGER_") - set(_color 10) - set(_shape "box") - endif() - - calligra_product_deps_report_stylebybuild(_stylebybuild ${_product_id}) - - set(_dot "${_dot}\"${_product_id}\" [fillcolor=${_color}, shape=${_shape}, style=\"${_style}${_stylebybuild}\"];\n") - - foreach(_dependent_product_id ${CALLIGRA_PRODUCT_${_product_id}_needed_dependencies}) - set(_edges "${_edges}\"${_product_id}\" -> \"${_dependent_product_id}\"\;\n") - endforeach(_dependent_product_id) - foreach(_dependent_product_id ${CALLIGRA_PRODUCT_${_product_id}_wanted_dependencies}) - set(_edges "${_edges}\"${_product_id}\" -> \"${_dependent_product_id}\" [style=dashed]\;\n") - endforeach(_dependent_product_id) - endforeach(_product_id) - - set(_dot "${_dot}${_edges}") - set(_dot "${_dot}}\n") - file(WRITE ${CMAKE_BINARY_DIR}/${_filename}.dot ${_dot}) -endmacro(calligra_product_deps_report) diff --git a/libs/CMakeLists.txt b/libs/CMakeLists.txt --- a/libs/CMakeLists.txt +++ b/libs/CMakeLists.txt @@ -14,7 +14,4 @@ add_subdirectory( color ) add_subdirectory( image ) add_subdirectory( ui ) - -if (SHOULD_BUILD_LIB_KOVECTORIMAGE) - add_subdirectory( vectorimage ) -endif () +add_subdirectory( vectorimage ) diff --git a/plugins/flake/CMakeLists.txt b/plugins/flake/CMakeLists.txt --- a/plugins/flake/CMakeLists.txt +++ b/plugins/flake/CMakeLists.txt @@ -1,15 +1,4 @@ -if (SHOULD_BUILD_PLUGIN_ARTISTICTEXTSHAPE) - add_subdirectory( artistictextshape ) -endif () - -if (SHOULD_BUILD_PLUGIN_PATHSHAPES) - add_subdirectory( pathshapes ) -endif () - -if (SHOULD_BUILD_PLUGIN_TEXTSHAPE) - add_subdirectory( textshape ) -endif() - -if (SHOULD_BUILD_PLUGIN_VECTORSHAPE) - add_subdirectory( vectorshape ) -endif () +add_subdirectory( artistictextshape ) +add_subdirectory( pathshapes ) +add_subdirectory( textshape ) +add_subdirectory( vectorshape ) diff --git a/plugins/impex/ora/CMakeLists.txt b/plugins/impex/ora/CMakeLists.txt --- a/plugins/impex/ora/CMakeLists.txt +++ b/plugins/impex/ora/CMakeLists.txt @@ -26,7 +26,4 @@ install( PROGRAMS krita_ora.desktop DESTINATION ${XDG_APPS_INSTALL_DIR}) -if(SHOULD_BUILD_FILEMANAGER_THUMBNAIL) - install( FILES krita_ora_thumbnail.desktop DESTINATION ${SERVICES_INSTALL_DIR}) -endif() - +install( FILES krita_ora_thumbnail.desktop DESTINATION ${SERVICES_INSTALL_DIR})