mirror of
https://github.com/qgis/QGIS.git
synced 2025-02-25 00:58:06 -05:00
5df9cbc964
Instead of finding Python interpreter, library and framework on Mac, rely upon the reported paths of the interpreter (executable) to decipher whether a framework is being used, then ensure any such framework has its versioned subdirectory Headers used for includes and the base Python library used directly in linking. This removes ambiguity in framework searching, allowing just the PYTHON_EXECUTABLE (user-defined or from FindPythonInterp module) to control which Python is used.
837 lines
35 KiB
CMake
837 lines
35 KiB
CMake
SET(CPACK_PACKAGE_VERSION_MAJOR "2")
|
|
SET(CPACK_PACKAGE_VERSION_MINOR "99")
|
|
SET(CPACK_PACKAGE_VERSION_PATCH "0")
|
|
SET(COMPLETE_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH})
|
|
SET(RELEASE_NAME "Master")
|
|
IF (POLICY CMP0048) # in CMake 3.0.0+
|
|
CMAKE_POLICY (SET CMP0048 OLD) # keep PROJECT() from clearing VERSION variables
|
|
ENDIF (POLICY CMP0048)
|
|
SET(PROJECT_VERSION ${COMPLETE_VERSION})
|
|
PROJECT(qgis${PROJECT_VERSION})
|
|
IF (APPLE)
|
|
SET(QGIS_APP_NAME "QGIS")
|
|
ELSE (APPLE)
|
|
SET(QGIS_APP_NAME "qgis")
|
|
ENDIF (APPLE)
|
|
|
|
# Note the version no is Mmmpp for Major/minor/patch, 0-padded, thus '10100' for 1.1.0
|
|
MATH(EXPR QGIS_VERSION_INT "${CPACK_PACKAGE_VERSION_MAJOR}*10000+${CPACK_PACKAGE_VERSION_MINOR}*100+${CPACK_PACKAGE_VERSION_PATCH}")
|
|
MESSAGE(STATUS "QGIS version: ${COMPLETE_VERSION} ${RELEASE_NAME} (${QGIS_VERSION_INT})")
|
|
|
|
#############################################################
|
|
# CMake settings
|
|
|
|
CMAKE_MINIMUM_REQUIRED(VERSION 2.8.6)
|
|
|
|
SET(CMAKE_COLOR_MAKEFILE ON)
|
|
|
|
# set path to additional CMake modules
|
|
SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
|
|
|
|
# in generated makefiles use relative paths so the project dir is moveable
|
|
# Note commented out since it cause problems but it would be nice to resolve these and enable
|
|
#
|
|
# issue is caused by INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR}) near the end of this file generating incorrect path
|
|
#SET (CMAKE_USE_RELATIVE_PATHS ON)
|
|
|
|
# try to configure and build GRASS plugin by default
|
|
FOREACH (GRASS_SEARCH_VERSION 6 7)
|
|
# For GRASS 6 are used cached variables without version suffix so that existing caches don't have to be reconfigured.
|
|
# Cached variables: WITH_GRASS, WITH_GRASS7, GRASS_PREFIX, GRASS_PREFIX7, GRASS_INCLUDE_DIR, GRASS_INCLUDE_DIR7
|
|
# Everywhere else each variable has version major appended.
|
|
# Normal variables: GRASS_FOUND6, GRASS_FOUND7, GRASS_MAJOR_VERSION6, GRASS_MAJOR_VERSION7, etc.
|
|
# In addition there is also GRASS_FOUND, which is TRUE if at least one version of GRASS was found
|
|
IF (GRASS_SEARCH_VERSION EQUAL 6)
|
|
SET (GRASS_CACHE_VERSION "")
|
|
ELSE (GRASS_SEARCH_VERSION EQUAL 6)
|
|
SET (GRASS_CACHE_VERSION ${GRASS_SEARCH_VERSION})
|
|
ENDIF (GRASS_SEARCH_VERSION EQUAL 6)
|
|
|
|
SET (WITH_GRASS${GRASS_CACHE_VERSION} TRUE CACHE BOOL "Determines whether GRASS ${GRASS_SEARCH_VERSION} plugin should be built")
|
|
IF (WITH_GRASS${GRASS_CACHE_VERSION})
|
|
FIND_PACKAGE(GRASS ${GRASS_SEARCH_VERSION})
|
|
SET (GRASS_PREFIX${GRASS_CACHE_VERSION} ${GRASS_PREFIX${GRASS_SEARCH_VERSION}} CACHE PATH "Path to GRASS ${GRASS_SEARCH_VERSION} base directory")
|
|
ENDIF (WITH_GRASS${GRASS_CACHE_VERSION})
|
|
ENDFOREACH (GRASS_SEARCH_VERSION)
|
|
|
|
SET (WITH_DESKTOP TRUE CACHE BOOL "Determines whether QGIS desktop should be built")
|
|
|
|
# server disabled default because it needs FastCGI (which is optional dependency)
|
|
SET (WITH_SERVER FALSE CACHE BOOL "Determines whether QGIS server should be built")
|
|
IF(WITH_SERVER)
|
|
SET (SERVER_SKIP_ECW FALSE CACHE BOOL "Determines whether QGIS server should disable ECW (ECW in server apps requires a special license)")
|
|
|
|
SET (WITH_SERVER_PLUGINS TRUE CACHE BOOL "Determines whether QGIS server support for python plugins should be built")
|
|
IF(WITH_SERVER_PLUGINS)
|
|
SET(HAVE_SERVER_PYTHON_PLUGINS TRUE)
|
|
ENDIF(WITH_SERVER_PLUGINS)
|
|
ENDIF(WITH_SERVER)
|
|
|
|
# Custom widgets
|
|
SET (WITH_CUSTOM_WIDGETS FALSE CACHE BOOL "Determines whether QGIS custom widgets for Qt Designer should be built")
|
|
|
|
# build our version of astyle
|
|
SET (WITH_ASTYLE FALSE CACHE BOOL "If you plan to contribute you should reindent with scripts/prepare-commit.sh (using 'our' astyle)")
|
|
|
|
# try to configure and build POSTGRESQL support
|
|
SET (WITH_POSTGRESQL TRUE CACHE BOOL "Determines whether POSTGRESQL support should be built")
|
|
IF (WITH_POSTGRESQL)
|
|
SET (POSTGRESQL_PREFIX "" CACHE PATH "Path to POSTGRESQL base directory")
|
|
ENDIF (WITH_POSTGRESQL)
|
|
|
|
SET (WITH_INTERNAL_QEXTSERIALPORT TRUE CACHE BOOL "Use internal build of Qextserialport")
|
|
|
|
SET (WITH_QSPATIALITE FALSE CACHE BOOL "Determines whether QSPATIALITE sql driver should be built")
|
|
|
|
SET (WITH_ORACLE FALSE CACHE BOOL "Determines whether Oracle support should be built")
|
|
IF(WITH_ORACLE)
|
|
SET(HAVE_ORACLE TRUE)
|
|
SET(ORACLE_INCLUDEDIR "" CACHE STRING "Path to OCI headers")
|
|
SET(ORACLE_LIBDIR "" CACHE STRING "Path to OCI libraries")
|
|
ENDIF(WITH_ORACLE)
|
|
|
|
|
|
# try to configure and build python bindings by default
|
|
SET (WITH_BINDINGS TRUE CACHE BOOL "Determines whether python bindings should be built")
|
|
IF (WITH_BINDINGS)
|
|
# By default bindings will be installed only to QGIS directory
|
|
# Someone might want to install it to python site-packages directory
|
|
# as otherwise user has to use PYTHONPATH environemnt variable to add
|
|
# QGIS bindings to package search path
|
|
SET (BINDINGS_GLOBAL_INSTALL FALSE CACHE BOOL "Install bindings to global python directory? (might need root)")
|
|
SET (WITH_STAGED_PLUGINS TRUE CACHE BOOL "Stage-install core Python plugins to run from build directory? (utilities and console are always staged)")
|
|
SET (WITH_PY_COMPILE FALSE CACHE BOOL "Determines whether Python modules in staged or installed locations are byte-compiled")
|
|
# concatenate QScintilla2 API files
|
|
SET (WITH_QSCIAPI TRUE CACHE BOOL "Whether to generate PyQGIS QScintilla2 API file. (For devs) run 'make qsci-pap-src' in between QGIS build and install to regenerate .pap file in source tree for console auto-completion.")
|
|
# keep casual users from updating their source tree via WITH_QSCIAPI
|
|
MARK_AS_ADVANCED (WITH_QSCIAPI)
|
|
ENDIF (WITH_BINDINGS)
|
|
|
|
#BUILD WITH QtMobility by default on android only. Other platform can force it
|
|
IF (ANDROID)
|
|
SET (DEFAULT_WITH_QTMOBILITY TRUE)
|
|
ELSE (ANDROID)
|
|
SET (DEFAULT_WITH_QTMOBILITY FALSE)
|
|
ENDIF (ANDROID)
|
|
SET (WITH_QTMOBILITY ${DEFAULT_WITH_QTMOBILITY} CACHE BOOL "Determines if QtMobility related code should be build (for example internal GPS)")
|
|
|
|
SET (WITH_GLOBE FALSE CACHE BOOL "Determines whether Globe plugin should be built")
|
|
IF (WITH_GLOBE)
|
|
SET(QT_USE_QTOPENGL 1)
|
|
FIND_PACKAGE(OSGEARTH REQUIRED)
|
|
IF (OSGEARTHQT_LIBRARY)
|
|
# following variable is used in qgsconfig.h
|
|
SET(HAVE_OSGEARTHQT TRUE)
|
|
ENDIF (OSGEARTHQT_LIBRARY)
|
|
ENDIF (WITH_GLOBE)
|
|
|
|
# Compile flag. Make it possible to turn it off.
|
|
SET (PEDANTIC TRUE CACHE BOOL "Determines if we should compile in pedantic mode.")
|
|
|
|
# whether unit tests should be build
|
|
SET (ENABLE_TESTS TRUE CACHE BOOL "Build unit tests?")
|
|
|
|
# whether coverage tests should be performed
|
|
SET (ENABLE_COVERAGE FALSE CACHE BOOL "Perform coverage tests?")
|
|
|
|
# whether coverage documentation should be generated
|
|
SET (GENERATE_COVERAGE_DOCS FALSE CACHE BOOL "Generate coverage docs (requires lcov)?")
|
|
|
|
# hide this variable because building of python bindings might fail
|
|
# if set to other directory than expected
|
|
MARK_AS_ADVANCED(LIBRARY_OUTPUT_PATH)
|
|
|
|
IF (MSVC AND CMAKE_GENERATOR MATCHES "NMake")
|
|
# following variable is also used in qgsconfig.h
|
|
SET (USING_NMAKE TRUE)
|
|
ENDIF (MSVC AND CMAKE_GENERATOR MATCHES "NMake")
|
|
|
|
IF (CMAKE_GENERATOR MATCHES "Ninja")
|
|
# following variable is also used in qgsconfig.h
|
|
SET (USING_NINJA TRUE)
|
|
ENDIF (CMAKE_GENERATOR MATCHES "Ninja")
|
|
|
|
#############################################################
|
|
# check if lexer and parser are not missing
|
|
# http://www.mail-archive.com/cmake@cmake.org/msg02861.html
|
|
|
|
INCLUDE(Flex)
|
|
|
|
FIND_FLEX()
|
|
|
|
IF (NOT FLEX_EXECUTABLE)
|
|
MESSAGE(FATAL_ERROR "Couldn't find Flex")
|
|
ENDIF (NOT FLEX_EXECUTABLE)
|
|
|
|
INCLUDE(Bison)
|
|
|
|
FIND_BISON()
|
|
|
|
IF (NOT BISON_EXECUTABLE)
|
|
MESSAGE(FATAL_ERROR "Couldn't find Bison")
|
|
ENDIF (NOT BISON_EXECUTABLE)
|
|
|
|
#############################################################
|
|
# search for dependencies
|
|
|
|
IF(NOT WIN32 AND NOT ANDROID)
|
|
INCLUDE(CheckFunctionExists)
|
|
CHECK_FUNCTION_EXISTS(openpty OPENPTY_IN_LIBC)
|
|
IF(NOT OPENPTY_IN_LIBC)
|
|
SET(CMAKE_REQUIRED_INCLUDES util.h)
|
|
SET(CMAKE_REQUIRED_LIBRARIES util)
|
|
CHECK_FUNCTION_EXISTS(openpty NEED_LIBUTIL)
|
|
IF(NEED_LIBUTIL)
|
|
SET(OPENPTY_LIBRARY util)
|
|
ELSE(NEED_LIBUTIL)
|
|
MESSAGE (SEND_ERROR "openpty not found!")
|
|
ENDIF(NEED_LIBUTIL)
|
|
ENDIF(NOT OPENPTY_IN_LIBC)
|
|
ENDIF(NOT WIN32 AND NOT ANDROID)
|
|
|
|
# required
|
|
FIND_PACKAGE(Proj)
|
|
FIND_PACKAGE(GEOS)
|
|
FIND_PACKAGE(GDAL)
|
|
FIND_PACKAGE(Expat REQUIRED)
|
|
FIND_PACKAGE(Spatialindex REQUIRED)
|
|
FIND_PACKAGE(Qwt REQUIRED)
|
|
|
|
IF (WITH_INTERNAL_QEXTSERIALPORT)
|
|
SET(QEXTSERIALPORT_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/src/core/gps/qextserialport)
|
|
ELSE (WITH_INTERNAL_QEXTSERIALPORT)
|
|
FIND_PACKAGE(Qextserialport REQUIRED)
|
|
ENDIF(WITH_INTERNAL_QEXTSERIALPORT)
|
|
|
|
FIND_PACKAGE(Sqlite3)
|
|
IF (NOT SQLITE3_FOUND)
|
|
MESSAGE (SEND_ERROR "sqlite3 dependency was not found!")
|
|
ENDIF (NOT SQLITE3_FOUND)
|
|
|
|
# optional
|
|
IF (WITH_POSTGRESQL)
|
|
FIND_PACKAGE(Postgres) # PostgreSQL provider
|
|
ENDIF (WITH_POSTGRESQL)
|
|
|
|
FIND_PACKAGE(SpatiaLite REQUIRED)
|
|
|
|
IF(SPATIALITE_VERSION_GE_4_0_0)
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSPATIALITE_VERSION_GE_4_0_0")
|
|
ENDIF(SPATIALITE_VERSION_GE_4_0_0)
|
|
IF(SPATIALITE_VERSION_G_4_1_1)
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSPATIALITE_VERSION_G_4_1_1")
|
|
ENDIF(SPATIALITE_VERSION_G_4_1_1)
|
|
IF(SPATIALITE_HAS_INIT_EX)
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSPATIALITE_HAS_INIT_EX")
|
|
ENDIF(SPATIALITE_HAS_INIT_EX)
|
|
|
|
IF (NOT PROJ_FOUND OR NOT GEOS_FOUND OR NOT GDAL_FOUND)
|
|
MESSAGE (SEND_ERROR "Some dependencies were not found! Proj: ${PROJ_FOUND}, Geos: ${GEOS_FOUND}, GDAL: ${GDAL_FOUND}")
|
|
ENDIF (NOT PROJ_FOUND OR NOT GEOS_FOUND OR NOT GDAL_FOUND)
|
|
|
|
IF (POSTGRES_FOUND)
|
|
# following variable is used in qgsconfig.h
|
|
SET (HAVE_POSTGRESQL TRUE)
|
|
ENDIF (POSTGRES_FOUND)
|
|
|
|
SET (WITH_QTWEBKIT TRUE CACHE BOOL "Enable QtWebkit support")
|
|
IF (WITH_QTWEBKIT)
|
|
ADD_DEFINITIONS(-DWITH_QTWEBKIT)
|
|
MESSAGE(STATUS "Qt WebKit support enabled")
|
|
ELSE (WITH_QTWEBKIT)
|
|
MESSAGE(STATUS "Qt WebKit support DISABLED.")
|
|
ENDIF(WITH_QTWEBKIT)
|
|
#############################################################
|
|
# search for Qt5
|
|
SET(QT_MIN_VERSION 5.2.0)
|
|
FIND_PACKAGE(Qt5Core QUIET)
|
|
FIND_PACKAGE(Qt5Gui REQUIRED)
|
|
FIND_PACKAGE(Qt5Widgets REQUIRED)
|
|
FIND_PACKAGE(Qt5Network REQUIRED)
|
|
FIND_PACKAGE(Qt5Xml REQUIRED)
|
|
FIND_PACKAGE(Qt5Svg REQUIRED)
|
|
FIND_PACKAGE(Qt5Concurrent REQUIRED)
|
|
FIND_PACKAGE(Qt5PrintSupport REQUIRED)
|
|
FIND_PACKAGE(Qt5Positioning)
|
|
IF (WITH_QTWEBKIT)
|
|
FIND_PACKAGE(Qt5WebKit REQUIRED)
|
|
FIND_PACKAGE(Qt5WebKitWidgets REQUIRED)
|
|
ENDIF(WITH_QTWEBKIT)
|
|
FIND_PACKAGE(Qt5Test REQUIRED)
|
|
FIND_PACKAGE(Qt5UiTools REQUIRED)
|
|
FIND_PACKAGE(Qt5Script REQUIRED)
|
|
FIND_PACKAGE(Qt5Sql REQUIRED)
|
|
INCLUDE("cmake/modules/ECMQt4To5Porting.cmake")
|
|
MESSAGE(STATUS "Found Qt version: ${Qt5Core_VERSION_STRING}")
|
|
|
|
IF (WITH_QTMOBILITY)
|
|
FIND_PACKAGE(QtMobility 1.1.0)
|
|
ENDIF (WITH_QTMOBILITY)
|
|
|
|
IF (ANDROID)
|
|
SET (DEFAULT_WITH_TOUCH TRUE)
|
|
ELSE (ANDROID)
|
|
SET (DEFAULT_WITH_TOUCH FALSE)
|
|
ENDIF (ANDROID)
|
|
|
|
#Add a touch mode if Qt has Qt Gestures
|
|
SET (WITH_TOUCH ${DEFAULT_WITH_TOUCH} CACHE BOOL "Determines if touch interface related code should be build")
|
|
|
|
IF (WITH_TOUCH)
|
|
# following variable is used in qgsconfig.h
|
|
SET (HAVE_TOUCH TRUE)
|
|
MESSAGE (STATUS "Touch support enabled")
|
|
ELSE (WITH_TOUCH)
|
|
MESSAGE (STATUS "Touch support disabled")
|
|
ENDIF (WITH_TOUCH)
|
|
|
|
# search for QScintilla2 (C++ lib)
|
|
FIND_PACKAGE(QScintilla REQUIRED)
|
|
|
|
# Master password hash and authentication encryption
|
|
FIND_PACKAGE(QCA REQUIRED)
|
|
# Check for runtime dependency of qca-ossl plugin
|
|
# REQUIRED if unit tests are to be run from build directory
|
|
IF(NOT MSVC)
|
|
include(QCAMacros)
|
|
FIND_QCAOSSL_PLUGIN_CPP(ENABLE_TESTS)
|
|
ENDIF(NOT MSVC)
|
|
|
|
# ModelTest
|
|
SET(ENABLE_MODELTEST FALSE CACHE BOOL "Enable QT ModelTest (not for production)")
|
|
|
|
IF (ENABLE_TESTS)
|
|
SET( QT_USE_QTTEST TRUE )
|
|
ADD_DEFINITIONS(-DENABLE_TESTS)
|
|
ENABLE_TESTING()
|
|
# Adds some testing specific build targets e.g. make Experimental
|
|
INCLUDE(Dart)
|
|
# Define "make check" as alias for "make test" - thanks geos :-)
|
|
add_custom_target(check COMMAND ctest --output-on-failure)
|
|
# Additional test configuration options e.g. max upload size of test report
|
|
CONFIGURE_FILE(
|
|
"${CMAKE_CURRENT_SOURCE_DIR}/cmake_templates/CTestCustom.cmake.in"
|
|
"${CMAKE_CURRENT_BINARY_DIR}/CTestCustom.cmake"
|
|
IMMEDIATE @ONLY)
|
|
# For server side testing we have no X, we can use xfvb as a fake x
|
|
# sudo apt-get install xfvb
|
|
add_custom_target(check-no-x COMMAND xvfb-run --server-args=-screen\ 10\ 1024x768x24 ctest --output-on-failure)
|
|
ENDIF (ENABLE_TESTS)
|
|
|
|
IF (SUPPRESS_QT_WARNINGS)
|
|
# Newer versions of UseQt4.cmake include Qt with -isystem automatically
|
|
# This can be used to force this behavior on older systems
|
|
# Can be removed as soon as Travis-CI updates from precise
|
|
INCLUDE_DIRECTORIES(SYSTEM ${QT_INCLUDE_DIR})
|
|
ENDIF (SUPPRESS_QT_WARNINGS)
|
|
|
|
# Disable automatic conversion from QString to ASCII 8-bit strings (char *)
|
|
# (Keeps code compatible with Qt/Mac/64bit)
|
|
ADD_DEFINITIONS(-DQT_NO_CAST_TO_ASCII)
|
|
|
|
FIND_PROGRAM(QT_LRELEASE_EXECUTABLE
|
|
NAMES lrelease
|
|
PATHS ${QT_BINARY_DIR}
|
|
NO_DEFAULT_PATH
|
|
)
|
|
|
|
#############################################################
|
|
# enable use of c++11 features where available
|
|
# full c++11 support in clang 3.3+: http://clang.llvm.org/cxx_status.html
|
|
# for Mac, this is probably Apple LLVM 4.2 (based on LLVM 3.2svn, in XCode 4.6+)
|
|
# or definitely Apple LLVM 5.0 (based on LLVM 3.3svn, in Xcode 5+):
|
|
# https://gist.github.com/yamaya/2924292
|
|
|
|
SET(CMAKE_CXX_STANDARD 11)
|
|
|
|
#############################################################
|
|
# enable warnings
|
|
|
|
IF (PEDANTIC)
|
|
MESSAGE (STATUS "Pedantic compiler settings enabled")
|
|
IF(MSVC)
|
|
SET(_warnings "")
|
|
IF (NOT USING_NMAKE AND NOT USING_NINJA)
|
|
SET(_warnings "${_warnings} /W4" )
|
|
ENDIF (NOT USING_NMAKE AND NOT USING_NINJA)
|
|
|
|
# disable warnings
|
|
SET(_warnings "${_warnings} /wd4100 ") # unused formal parameters
|
|
SET(_warnings "${_warnings} /wd4127 ") # constant conditional expressions (used in Qt template classes)
|
|
SET(_warnings "${_warnings} /wd4190 ") # 'identifier' has C-linkage specified, but returns UDT 'identifier2' which is incompatible with C
|
|
SET(_warnings "${_warnings} /wd4231 ") # nonstandard extension used : 'identifier' before template explicit instantiation (used in Qt template classes)
|
|
SET(_warnings "${_warnings} /wd4244 ") # conversion from '...' to '...' possible loss of data
|
|
SET(_warnings "${_warnings} /wd4251 ") # needs to have dll-interface to be used by clients of class (occurs in Qt template classes)
|
|
SET(_warnings "${_warnings} /wd4275 ") # non dll-interface class '...' used as base for dll-interface class '...'
|
|
SET(_warnings "${_warnings} /wd4505 ") # unreferenced local function has been removed (QgsRasterDataProvider::extent)
|
|
SET(_warnings "${_warnings} /wd4510 ") # default constructor could not be generated (sqlite3_index_info, QMap)
|
|
SET(_warnings "${_warnings} /wd4512 ") # assignment operator could not be generated (sqlite3_index_info)
|
|
SET(_warnings "${_warnings} /wd4610 ") # user defined constructor required (sqlite3_index_info)
|
|
SET(_warnings "${_warnings} /wd4706 ") # assignment within conditional expression (pal)
|
|
SET(_warnings "${_warnings} /wd4800 ") # 'int' : forcing value to bool 'true' or 'false' (performance warning)
|
|
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${_warnings}")
|
|
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_warnings}")
|
|
ELSE (MSVC)
|
|
# add warnings via flags (not as definitions as on Mac -Wall can not be overridden per language )
|
|
SET(_warnings "-Wall -Wextra -Wno-long-long -Wformat-security -Wno-strict-aliasing")
|
|
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${_warnings}")
|
|
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_warnings}")
|
|
|
|
# Qt produces lots of warnings with strict aliasing (as of Qt 4.4.0 & GCC 4.3)
|
|
# There are redundant declarations in Qt and GDAL
|
|
# ADD_DEFINITIONS( -fstrict-aliasing -Wstrict-aliasing=1 -Wredundant-decls )
|
|
|
|
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
|
|
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-return-type-c-linkage -Wno-overloaded-virtual")
|
|
ENDIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
|
|
|
|
# add any extra CXXFLAGS flags set by user. can be -D CXX_EXTRA_FLAGS or environment variable
|
|
# command line -D option overrides environment variable
|
|
# e.g. useful for suppressing transient upstream warnings in dependencies, like Qt
|
|
SET(CXX_EXTRA_FLAGS "" CACHE STRING "Additional appended CXXFLAGS")
|
|
IF ("${CXX_EXTRA_FLAGS}" STREQUAL "" AND DEFINED $ENV{CXX_EXTRA_FLAGS})
|
|
SET(CXX_EXTRA_FLAGS "$ENV{CXX_EXTRA_FLAGS}")
|
|
ENDIF ("${CXX_EXTRA_FLAGS}" STREQUAL "" AND DEFINED $ENV{CXX_EXTRA_FLAGS})
|
|
IF (NOT "${CXX_EXTRA_FLAGS}" STREQUAL "")
|
|
MESSAGE (STATUS "Appending CXX_EXTRA_FLAGS")
|
|
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_EXTRA_FLAGS}")
|
|
ENDIF (NOT "${CXX_EXTRA_FLAGS}" STREQUAL "")
|
|
ENDIF (MSVC)
|
|
|
|
ENDIF (PEDANTIC)
|
|
|
|
IF (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
|
|
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Qunused-arguments")
|
|
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Qunused-arguments")
|
|
SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Qunused-arguments")
|
|
SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Qunused-arguments")
|
|
SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Qunused-arguments")
|
|
ENDIF (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
|
|
|
|
IF(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)")
|
|
# spatialite crashes on ppc - see bugs.debian.org/603986
|
|
ADD_DEFINITIONS( -fno-strict-aliasing )
|
|
ENDIF(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)")
|
|
|
|
IF (CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo)
|
|
MESSAGE (STATUS "Debug output enabled")
|
|
ADD_DEFINITIONS(-DQGISDEBUG=1)
|
|
ENDIF (CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo)
|
|
|
|
IF(MSVC)
|
|
SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -DQGISDEBUG=1")
|
|
SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DQGISDEBUG=1")
|
|
# disable macros that offend std::numeric_limits<T>::min()/max()
|
|
ADD_DEFINITIONS(-DNOMINMAX)
|
|
ENDIF(MSVC)
|
|
|
|
IF(ENABLE_COVERAGE)
|
|
INCLUDE("cmake/modules/coverage/CodeCoverage.cmake")
|
|
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage --coverage")
|
|
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage --coverage")
|
|
SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage --coverage")
|
|
SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage --coverage")
|
|
SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage --coverage")
|
|
SETUP_TARGET_FOR_COVERAGE(qgis_coverage ctest coverage)
|
|
ENDIF(ENABLE_COVERAGE)
|
|
|
|
#############################################################
|
|
# platform specific stuff
|
|
|
|
IF (WIN32)
|
|
SET (DEFAULT_LIB_SUBDIR lib)
|
|
SET (DEFAULT_LIBEXEC_SUBDIR .)
|
|
SET (DEFAULT_DATA_SUBDIR .)
|
|
SET (DEFAULT_PLUGIN_SUBDIR plugins)
|
|
SET (DEFAULT_INCLUDE_SUBDIR include)
|
|
|
|
IF (MSVC)
|
|
SET (DEFAULT_BIN_SUBDIR bin)
|
|
SET (DEFAULT_CGIBIN_SUBDIR bin)
|
|
# put all the build products into a single directory
|
|
# under build (doesnt affect install target) to make for
|
|
# easier debugging.
|
|
|
|
# Turn on defines for non standard maths stuff
|
|
ADD_DEFINITIONS(-D_USE_MATH_DEFINES)
|
|
|
|
# Turn off deprecation warnings
|
|
ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS)
|
|
ADD_DEFINITIONS(-D_CRT_NONSTDC_NO_WARNINGS)
|
|
|
|
IF (CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo)
|
|
IF (NOT USING_NMAKE AND NOT USING_NINJA)
|
|
MESSAGE (STATUS "Generating browse files")
|
|
ADD_DEFINITIONS( /FR )
|
|
ENDIF (NOT USING_NMAKE AND NOT USING_NINJA)
|
|
ENDIF (CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo)
|
|
|
|
IF (INSTALL_DEPS)
|
|
INSTALL(DIRECTORY ${INSTALL_DEPS} DESTINATION .)
|
|
ENDIF (INSTALL_DEPS)
|
|
ELSE(MSVC)
|
|
SET (DEFAULT_BIN_SUBDIR .)
|
|
SET (DEFAULT_CGIBIN_SUBDIR .)
|
|
ENDIF(MSVC)
|
|
ELSE (WIN32)
|
|
|
|
IF (APPLE)
|
|
IF (POLICY CMP0042) # in CMake 3.0.0+
|
|
SET (CMAKE_MACOSX_RPATH OFF) # otherwise ON by default
|
|
ENDIF (POLICY CMP0042)
|
|
# for Mac OS X, everything is put inside an application bundle
|
|
# save the root install prefix for the app later
|
|
SET (QGIS_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})
|
|
SET (QGIS_MACAPP_PREFIX ${CMAKE_INSTALL_PREFIX}/${QGIS_APP_NAME}.app/Contents)
|
|
# common prefix for components, let cmake handle it
|
|
SET (CMAKE_INSTALL_PREFIX ${QGIS_MACAPP_PREFIX}/MacOS)
|
|
# 4 bundling levels, each includes previous
|
|
# 0 nothing
|
|
# 1 Qt frameworks
|
|
# 2 non-system libraries, "standard"
|
|
# 3 non-system frameworks, "standalone"
|
|
SET (QGIS_MACAPP_BUNDLE 1 CACHE STRING "What to bundle into app package")
|
|
SET (QGIS_MACAPP_BUNDLE_USER "" CACHE STRING "Path to user bundling script")
|
|
SET (QGIS_MACAPP_INSTALL_DEV FALSE CACHE BOOL "Install developer frameworks")
|
|
SET (QGIS_MACAPP_DEV_PREFIX "/Library/Frameworks" CACHE STRING "Path to install developer frameworks")
|
|
# if we have @loader_path, >=OSX 10.5 (darwin 9+)
|
|
IF (CMAKE_SYSTEM_VERSION VERSION_GREATER 9.0.0 OR CMAKE_SYSTEM_VERSION VERSION_EQUAL 9.0.0)
|
|
SET (OSX_HAVE_LOADERPATH 1)
|
|
ELSE ()
|
|
SET (OSX_HAVE_LOADERPATH 0)
|
|
ENDIF ()
|
|
#this will define ${APP_SERVICES_LIBRARY}
|
|
FIND_LIBRARY(APP_SERVICES_LIBRARY ApplicationServices )
|
|
|
|
SET (DEFAULT_BIN_SUBDIR bin)
|
|
SET (QGIS_BIN_SUBDIR_REV ..)
|
|
SET (DEFAULT_CGIBIN_SUBDIR fcgi-bin)
|
|
SET (QGIS_CGIBIN_SUBDIR_REV ..)
|
|
SET (DEFAULT_LIB_SUBDIR lib)
|
|
SET (QGIS_LIB_SUBDIR_REV ..)
|
|
SET (QGIS_FW_SUBDIR ../Frameworks)
|
|
SET (QGIS_FW_SUBDIR_REV ../MacOS)
|
|
SET (DEFAULT_DATA_SUBDIR ../Resources)
|
|
SET (QGIS_DATA_SUBDIR_REV ../MacOS)
|
|
SET (DEFAULT_LIBEXEC_SUBDIR lib/qgis)
|
|
SET (QGIS_LIBEXEC_SUBDIR_REV ../..)
|
|
SET (DEFAULT_PLUGIN_SUBDIR ../PlugIns/qgis)
|
|
SET (QGIS_PLUGIN_SUBDIR_REV ../../MacOS)
|
|
SET (DEFAULT_INCLUDE_SUBDIR include/qgis)
|
|
# path for framework references when running from build directory
|
|
# changed later to reference in-app resources upon install
|
|
SET (CMAKE_INSTALL_NAME_DIR ${CMAKE_BINARY_DIR}/output/lib)
|
|
IF (WITH_GLOBE)
|
|
SET (OSG_PLUGINS_PATH "" CACHE PATH "Path to OSG plugins for bundling")
|
|
ENDIF (WITH_GLOBE)
|
|
# recent cmakes force SDKs, recent SDKs don't have user symlinks
|
|
# need to find non-system frameworks
|
|
# cmake bug #0007250 - CMAKE_SHARED_LINKER_FLAGS ignored when creating
|
|
# a framework, so these need to be manually handled with LINK_FLAGS options
|
|
SET (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -F/Library/Frameworks")
|
|
SET (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -F/Library/Frameworks")
|
|
SET (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -F/Library/Frameworks")
|
|
|
|
ELSE (APPLE)
|
|
# UNIX
|
|
SET (DEFAULT_BIN_SUBDIR bin)
|
|
SET (DEFAULT_CGIBIN_SUBDIR bin)
|
|
SET (DEFAULT_LIB_SUBDIR lib${LIB_SUFFIX})
|
|
SET (DEFAULT_DATA_SUBDIR share/qgis)
|
|
SET (DEFAULT_LIBEXEC_SUBDIR lib${LIB_SUFFIX}/qgis)
|
|
SET (DEFAULT_PLUGIN_SUBDIR lib${LIB_SUFFIX}/qgis/plugins)
|
|
SET (DEFAULT_INCLUDE_SUBDIR include/qgis)
|
|
ENDIF (APPLE)
|
|
|
|
ENDIF (WIN32)
|
|
|
|
IF (ANDROID)
|
|
SET (DEFAULT_PLUGIN_SUBDIR lib)
|
|
SET (DEFAULT_DATA_SUBDIR files/share)
|
|
string(REPLACE "<CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG><TARGET_SONAME>" "" CMAKE_CXX_CREATE_SHARED_MODULE "${CMAKE_CXX_CREATE_SHARED_MODULE}")
|
|
ENDIF (ANDROID)
|
|
|
|
#assume we have escaped compiler directives
|
|
#eventually we want to change this to new
|
|
#since we don't need to jump through so many
|
|
#hoops to escape compiler directives then
|
|
IF(COMMAND cmake_policy)
|
|
cmake_policy(SET CMP0003 NEW)
|
|
cmake_policy(SET CMP0005 OLD)
|
|
IF(NOT "${CMAKE_VERSION}" VERSION_LESS "3.3")
|
|
cmake_policy(SET CMP0063 NEW)
|
|
ENDIF(NOT "${CMAKE_VERSION}" VERSION_LESS "3.3")
|
|
ENDIF(COMMAND cmake_policy)
|
|
|
|
IF (WIN32)
|
|
SET(DLLIMPORT "__declspec(dllimport)")
|
|
SET(DLLEXPORT "__declspec(dllexport)")
|
|
ELSE (WIN32)
|
|
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
|
|
SET(DLLEXPORT "__attribute__ ((visibility (\\\"default\\\")))")
|
|
ELSE()
|
|
SET(DLLEXPORT "")
|
|
ENDIF()
|
|
|
|
IF(PEDANTIC AND NOT APPLE)
|
|
SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
|
|
SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--no-undefined")
|
|
SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--no-undefined")
|
|
ENDIF(PEDANTIC AND NOT APPLE)
|
|
|
|
ENDIF(WIN32)
|
|
|
|
ADD_DEFINITIONS("-DCORE_EXPORT=${DLLIMPORT}")
|
|
ADD_DEFINITIONS("-DGUI_EXPORT=${DLLIMPORT}")
|
|
ADD_DEFINITIONS("-DPYTHON_EXPORT=${DLLIMPORT}")
|
|
ADD_DEFINITIONS("-DANALYSIS_EXPORT=${DLLIMPORT}")
|
|
ADD_DEFINITIONS("-DAPP_EXPORT=${DLLIMPORT}")
|
|
ADD_DEFINITIONS("-DCUSTOMWIDGETS_EXPORT=${DLLIMPORT}")
|
|
ADD_DEFINITIONS("-DSERVER_EXPORT=${DLLIMPORT}")
|
|
|
|
SET(CMAKE_CXX_VISIBILITY_PRESET hidden)
|
|
|
|
#############################################################
|
|
# user-changeable settings which can be used to customize
|
|
# layout of QGIS installation
|
|
# (default values are platform-specific)
|
|
|
|
SET (QGIS_BIN_SUBDIR ${DEFAULT_BIN_SUBDIR} CACHE STRING "Subdirectory where executables will be installed")
|
|
SET (QGIS_CGIBIN_SUBDIR ${DEFAULT_CGIBIN_SUBDIR} CACHE STRING "Subdirectory where CGI executables will be installed")
|
|
SET (QGIS_LIB_SUBDIR ${DEFAULT_LIB_SUBDIR} CACHE STRING "Subdirectory where libraries will be installed")
|
|
SET (QGIS_LIBEXEC_SUBDIR ${DEFAULT_LIBEXEC_SUBDIR} CACHE STRING "Subdirectory where private executables will be installed")
|
|
SET (QGIS_DATA_SUBDIR ${DEFAULT_DATA_SUBDIR} CACHE STRING "Subdirectory where QGIS data will be installed")
|
|
SET (QGIS_PLUGIN_SUBDIR ${DEFAULT_PLUGIN_SUBDIR} CACHE STRING "Subdirectory where plugins will be installed")
|
|
SET (QGIS_INCLUDE_SUBDIR ${DEFAULT_INCLUDE_SUBDIR} CACHE STRING "Subdirectory where header files will be installed")
|
|
|
|
# mark *_SUBDIR variables as advanced as this is not something
|
|
# that an average user would use
|
|
MARK_AS_ADVANCED (QGIS_BIN_SUBDIR QGIS_CGIBIN_SUBDIR QGIS_LIB_SUBDIR QGIS_LIBEXEC_SUBDIR QGIS_DATA_SUBDIR QGIS_PLUGIN_SUBDIR QGIS_INCLUDE_SUBDIR)
|
|
|
|
# full paths for the installation
|
|
SET (QGIS_BIN_DIR ${QGIS_BIN_SUBDIR})
|
|
SET (QGIS_CGIBIN_DIR ${QGIS_CGIBIN_SUBDIR})
|
|
SET (QGIS_LIB_DIR ${QGIS_LIB_SUBDIR})
|
|
SET (QGIS_LIBEXEC_DIR ${QGIS_LIBEXEC_SUBDIR})
|
|
SET (QGIS_DATA_DIR ${QGIS_DATA_SUBDIR})
|
|
SET (QGIS_PLUGIN_DIR ${QGIS_PLUGIN_SUBDIR})
|
|
SET (QGIS_INCLUDE_DIR ${QGIS_INCLUDE_SUBDIR})
|
|
|
|
# set the default locations where the targets (executables, libraries) will land when compiled
|
|
# this is to allow running qgis from the source tree without having to actually do a "make install"
|
|
SET (QGIS_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/output)
|
|
SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${QGIS_OUTPUT_DIRECTORY}/${QGIS_BIN_SUBDIR})
|
|
SET (CMAKE_LIBRARY_OUTPUT_DIRECTORY ${QGIS_OUTPUT_DIRECTORY}/${QGIS_LIB_SUBDIR})
|
|
|
|
# write a marker with source directory path into the output's bin directory
|
|
# if run from the build directory QGIS will detect it and alter the paths
|
|
FILE(WRITE ${QGIS_OUTPUT_DIRECTORY}/${QGIS_BIN_SUBDIR}/qgisbuildpath.txt "${CMAKE_SOURCE_DIR}\n${QGIS_OUTPUT_DIRECTORY}")
|
|
|
|
# manual page - makes sense only on unix systems
|
|
IF (UNIX AND NOT APPLE)
|
|
SET (DEFAULT_MANUAL_SUBDIR man)
|
|
SET (QGIS_MANUAL_SUBDIR ${DEFAULT_MANUAL_SUBDIR} CACHE STRING "Subdirectory where manual files will be installed")
|
|
MARK_AS_ADVANCED (QGIS_MANUAL_SUBDIR)
|
|
SET (QGIS_MANUAL_DIR ${CMAKE_INSTALL_PREFIX}/${QGIS_MANUAL_SUBDIR})
|
|
ENDIF (UNIX AND NOT APPLE)
|
|
|
|
SET (DISABLE_DEPRECATED FALSE CACHE BOOL "If set to true, it will disable deprecated functionality to prepare for the next generation of QGIS")
|
|
IF (DISABLE_DEPRECATED)
|
|
ADD_DEFINITIONS(-DQGIS_DISABLE_DEPRECATED)
|
|
ENDIF (DISABLE_DEPRECATED)
|
|
|
|
|
|
#############################################################
|
|
# Python build dependency
|
|
|
|
SET(PYTHON_VER 3 CACHE STRING "Python version")
|
|
|
|
FIND_PACKAGE(PythonInterp ${PYTHON_VER} REQUIRED)
|
|
|
|
#############################################################
|
|
# Python bindings
|
|
|
|
IF (WITH_BINDINGS)
|
|
|
|
FIND_PACKAGE(PythonLibrary REQUIRED)
|
|
|
|
# python support: check for interpreter, sip, pyqt5
|
|
FIND_PACKAGE(PyQt5 REQUIRED)
|
|
SET(PYQT_SIP_FLAGS ${PYQT5_SIP_FLAGS})
|
|
SET(PYQT_SIP_DIR ${PYQT5_SIP_DIR})
|
|
SEPARATE_ARGUMENTS(PYQT_SIP_FLAGS) # convert space separated values to a list
|
|
|
|
FIND_PACKAGE(SIP REQUIRED)
|
|
FIND_PACKAGE(Qsci REQUIRED)
|
|
INCLUDE(PythonMacros)
|
|
INCLUDE(PyQtMacros)
|
|
INCLUDE(SIPMacros)
|
|
|
|
SET(SIP_INCLUDES ${PYQT_SIP_DIR} ${CMAKE_SOURCE_DIR}/python)
|
|
SET(SIP_CONCAT_PARTS 4)
|
|
|
|
IF (NOT BINDINGS_GLOBAL_INSTALL)
|
|
SET(PYTHON_SITE_PACKAGES_DIR ${QGIS_DATA_DIR}/python)
|
|
ENDIF (NOT BINDINGS_GLOBAL_INSTALL)
|
|
|
|
IF (WITH_CUSTOM_WIDGETS)
|
|
SET(PYUIC_WIDGET_PLUGIN_DIRECTORY ${PYQT5_MOD_DIR}/uic/widget-plugins/)
|
|
ENDIF (WITH_CUSTOM_WIDGETS)
|
|
|
|
ENDIF (WITH_BINDINGS)
|
|
|
|
#############################################################
|
|
# create qgsconfig.h
|
|
# installed with app target
|
|
|
|
CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/cmake_templates/qgsconfig.h.in ${CMAKE_BINARY_DIR}/qgsconfig.h)
|
|
INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR})
|
|
|
|
# Added by Jef to prevent python core and gui libs linking to other qgisCore and qgisGui libs
|
|
# that may be in the same install prefix
|
|
LINK_DIRECTORIES(${CMAKE_BINARY_DIR}/src/core ${CMAKE_BINARY_DIR}/src/gui)
|
|
|
|
#############################################################
|
|
# create qgsversion.h
|
|
IF (EXISTS ${CMAKE_SOURCE_DIR}/.git/index)
|
|
FIND_PROGRAM(GITCOMMAND git PATHS c:/cygwin/bin)
|
|
IF(GITCOMMAND)
|
|
IF(WIN32)
|
|
IF(USING_NINJA)
|
|
SET(ARG %a)
|
|
ELSE(USING_NINJA)
|
|
SET(ARG %%a)
|
|
ENDIF(USING_NINJA)
|
|
ADD_CUSTOM_COMMAND(
|
|
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/qgsversion.h ${CMAKE_CURRENT_BINARY_DIR}/qgsversion.inc
|
|
COMMAND for /f \"usebackq tokens=1\" ${ARG} in "(`\"${GITCOMMAND}\" log -n1 --oneline`)" do echo \#define QGSVERSION \"${ARG}\" >${CMAKE_CURRENT_BINARY_DIR}/qgsversion.h.temp
|
|
COMMAND for /f \"usebackq tokens=1\" ${ARG} in "(`\"${GITCOMMAND}\" log -n1 --oneline`)" do echo PROJECT_NUMBER = \"${COMPLETE_VERSION}-${RELEASE_NAME} \(${ARG}\)\" >${CMAKE_CURRENT_BINARY_DIR}/qgsversion.inc
|
|
COMMAND ${CMAKE_COMMAND} -DSRC=${CMAKE_CURRENT_BINARY_DIR}/qgsversion.h.temp -DDST=${CMAKE_CURRENT_BINARY_DIR}/qgsversion.h -P ${CMAKE_SOURCE_DIR}/cmake/CopyIfChanged.cmake
|
|
MAIN_DEPENDENCY ${CMAKE_SOURCE_DIR}/.git/index
|
|
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
|
|
)
|
|
ELSE(WIN32)
|
|
ADD_CUSTOM_COMMAND(
|
|
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/qgsversion.h ${CMAKE_CURRENT_BINARY_DIR}/qgsversion.inc
|
|
COMMAND ${GITCOMMAND} log -n1 --pretty=\#define\\ QGSVERSION\\ \\"%h\\" >${CMAKE_CURRENT_BINARY_DIR}/qgsversion.h.temp
|
|
COMMAND ${GITCOMMAND} log -n1 --pretty='PROJECT_NUMBER = \"${COMPLETE_VERSION}-${RELEASE_NAME} \(%h\)\"' >${CMAKE_CURRENT_BINARY_DIR}/qgsversion.inc
|
|
COMMAND ${GITCOMMAND} config remote.$$\(${GITCOMMAND} config branch.$$\(${GITCOMMAND} name-rev --name-only HEAD\).remote\).url | sed -e 's/^/\#define QGS_GIT_REMOTE_URL \"/' -e 's/$$/\"/' >>${CMAKE_CURRENT_BINARY_DIR}/qgsversion.h.temp
|
|
COMMAND ${CMAKE_COMMAND} -DSRC=${CMAKE_CURRENT_BINARY_DIR}/qgsversion.h.temp -DDST=${CMAKE_CURRENT_BINARY_DIR}/qgsversion.h -P ${CMAKE_SOURCE_DIR}/cmake/CopyIfChanged.cmake
|
|
MAIN_DEPENDENCY ${CMAKE_SOURCE_DIR}/.git/index
|
|
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
|
|
)
|
|
ENDIF(WIN32)
|
|
ELSE(GITCOMMAND)
|
|
MESSAGE(STATUS "git marker, but no git found - version will be unknown")
|
|
IF(NOT SHA)
|
|
SET(SHA "unknown")
|
|
ENDIF(NOT SHA)
|
|
FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/qgsversion.h "#define QGSVERSION \"${SHA}\"\n")
|
|
FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/qgsversion.inc "PROJECT_NUMBER = \"${COMPLETE_VERSION}-${RELEASE_NAME} (${SHA})\"\n")
|
|
ENDIF(GITCOMMAND)
|
|
ELSE (EXISTS ${CMAKE_SOURCE_DIR}/.git/index)
|
|
IF(NOT SHA)
|
|
SET(SHA "exported")
|
|
ENDIF(NOT SHA)
|
|
FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/qgsversion.h "#define QGSVERSION \"${SHA}\"\n")
|
|
FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/qgsversion.inc "PROJECT_NUMBER = \"${COMPLETE_VERSION}-${RELEASE_NAME} (${SHA})\"\n")
|
|
ENDIF (EXISTS ${CMAKE_SOURCE_DIR}/.git/index)
|
|
|
|
ADD_CUSTOM_TARGET(version ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/qgsversion.h)
|
|
|
|
#############################################################
|
|
# process subdirs
|
|
|
|
#create a variable to specify where our test data is
|
|
#so that unit tests can use TEST_DATA_DIR to locate
|
|
#the test data. See CMakeLists in test dirs for more info
|
|
#TEST_DATA_DIR is also used by QgsRenderChecker currently in core
|
|
SET (TEST_DATA_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tests/testdata")
|
|
|
|
ADD_SUBDIRECTORY(src)
|
|
ADD_SUBDIRECTORY(doc)
|
|
ADD_SUBDIRECTORY(images)
|
|
ADD_SUBDIRECTORY(resources)
|
|
ADD_SUBDIRECTORY(i18n)
|
|
|
|
IF (WITH_BINDINGS)
|
|
ADD_SUBDIRECTORY(python)
|
|
ENDIF (WITH_BINDINGS)
|
|
|
|
IF (ENABLE_TESTS)
|
|
ADD_SUBDIRECTORY(tests)
|
|
SET (CTEST_BINARY_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/output/bin" )
|
|
MESSAGE (STATUS "Ctest Binary Directory set to: ${CTEST_BINARY_DIRECTORY}")
|
|
ENDIF (ENABLE_TESTS)
|
|
|
|
IF (APPLE)
|
|
# must be last for install, so install_name_tool can do its work
|
|
ADD_SUBDIRECTORY(mac)
|
|
|
|
# allow QGIS to be run directly from build directory and to run unit tests
|
|
EXECUTE_PROCESS(COMMAND /bin/mkdir -p "${QGIS_OUTPUT_DIRECTORY}/lib")
|
|
EXECUTE_PROCESS(
|
|
COMMAND /bin/ln -fs ../../Plugins/qgis/qgisgrass6.framework lib/
|
|
WORKING_DIRECTORY "${QGIS_OUTPUT_DIRECTORY}"
|
|
)
|
|
EXECUTE_PROCESS(
|
|
COMMAND /bin/ln -fs ../../Plugins/qgis/qgisgrass7.framework lib/
|
|
WORKING_DIRECTORY "${QGIS_OUTPUT_DIRECTORY}"
|
|
)
|
|
ENDIF (APPLE)
|
|
|
|
# manual page - makes sense only on unix systems
|
|
IF (UNIX AND NOT APPLE)
|
|
INSTALL (FILES qgis.1 qbrowser.1 DESTINATION ${QGIS_MANUAL_DIR}/man1)
|
|
ENDIF (UNIX AND NOT APPLE)
|
|
|
|
INSTALL(FILES cmake/FindQGIS.cmake DESTINATION ${QGIS_DATA_DIR})
|
|
|
|
#############################################################
|
|
# Post-install commands
|
|
ADD_SUBDIRECTORY(postinstall)
|
|
|
|
#############################################################
|
|
# Uninstall stuff see: http://www.vtk.org/Wiki/CMake_FAQ
|
|
CONFIGURE_FILE(
|
|
"${CMAKE_CURRENT_SOURCE_DIR}/cmake_templates/cmake_uninstall.cmake.in"
|
|
"${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
|
|
IMMEDIATE @ONLY)
|
|
|
|
ADD_CUSTOM_TARGET(uninstall
|
|
"${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
|
|
|
|
#############################################################
|
|
# Enable packaging
|
|
|
|
# Do not warn about runtime libs when building using VS Express
|
|
IF(NOT DEFINED CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS)
|
|
SET(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS ON)
|
|
ENDIF()
|
|
INCLUDE(InstallRequiredSystemLibraries)
|
|
|
|
SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "QGIS")
|
|
SET(CPACK_PACKAGE_VENDOR "Open Source Geospatial Foundation")
|
|
SET(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README")
|
|
SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/COPYING")
|
|
SET(CPACK_PACKAGE_INSTALL_DIRECTORY "QGIS ${COMPLETE_VERSION}")
|
|
IF(WIN32 AND NOT UNIX)
|
|
# There is a bug in NSI that does not handle full unix paths properly. Make
|
|
# sure there is at least one set of four (4) backslashes.
|
|
SET(CPACK_PACKAGE_ICON "${CMAKE_SOURCE_DIR}/win_build\\\\sidebar.bmp")
|
|
SET(CPACK_NSIS_INSTALLED_ICON_NAME "\\\\qgis.exe")
|
|
SET(CPACK_NSIS_DISPLAY_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY} QGIS")
|
|
SET(CPACK_NSIS_HELP_LINK "http:\\\\\\\\qgis.org")
|
|
SET(CPACK_NSIS_URL_INFO_ABOUT "http:\\\\\\\\qgis.org")
|
|
SET(CPACK_NSIS_CONTACT "tim@linfiniti.com")
|
|
SET(CPACK_NSIS_MODIFY_PATH ON)
|
|
|
|
# SET(CPACK_NSIS_EXTRA_INSTALL_COMMANDS " !include \\\"${CMAKE_SOURCE_DIR}\\\\win_build\\\\extra.nsh\\\"")
|
|
ELSE(WIN32 AND NOT UNIX)
|
|
#SET(CPACK_STRIP_FILES "QGIS")
|
|
#SET(CPACK_SOURCE_STRIP_FILES "")
|
|
ENDIF(WIN32 AND NOT UNIX)
|
|
SET(CPACK_PACKAGE_EXECUTABLES "qgis" "QGIS")
|
|
SET(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_SOURCE_DIR}/README.md")
|
|
INCLUDE(CPack)
|