QGIS » QGIS Application

# Macros for SIP

# ~~~~~~~~~~~~~~

# Copyright (c) 2007, Simon Edwards <[email protected]>

# Redistribution and use is allowed according to the terms of the BSD license.

# For details see the accompanying COPYING-CMAKE-SCRIPTS file.

#

# SIP website: http://www.riverbankcomputing.co.uk/sip/index.php

#

# This file defines the following macros:

#

# ADD_SIP_PYTHON_MODULE (MODULE_NAME MODULE_SIP [library1, libaray2, ...])

#     Specifies a SIP file to be built into a Python module and installed.

#     MODULE_NAME is the name of Python module including any path name. (e.g.

#     os.sys, Foo.bar etc). MODULE_SIP the path and filename of the .sip file

#     to process and compile. libraryN are libraries that the Python module,

#     which is typically a shared library, should be linked to. The built

#     module will also be install into Python's site-packages directory.

#

# The behaviour of the ADD_SIP_PYTHON_MODULE macro can be controlled by a

# number of variables:

#

# SIP_INCLUDES - List of directories which SIP will scan through when looking

#     for included .sip files. (Corresponds to the -I option for SIP.)

#

# SIP_TAGS - List of tags to define when running SIP. (Corresponds to the -t

#     option for SIP.)

#

# SIP_CONCAT_PARTS - An integer which defines the number of parts the C++ code

#     of each module should be split into. Defaults to 8. (Corresponds to the

#     -j option for SIP.)

#

# SIP_DISABLE_FEATURES - List of feature names which should be disabled

#     running SIP. (Corresponds to the -x option for SIP.)

#

# SIP_EXTRA_OPTIONS - Extra command line options which should be passed on to

#     SIP.

SET(SIP_INCLUDES)

SET(SIP_TAGS)

SET(SIP_CONCAT_PARTS 8)

SET(SIP_DISABLE_FEATURES)

SET(SIP_EXTRA_OPTIONS)

MACRO(ADD_SIP_PYTHON_MODULE MODULE_NAME MODULE_SIP)

    SET(EXTRA_LINK_LIBRARIES ${ARGN})

    STRING(REPLACE "." "/" _x ${MODULE_NAME})

    GET_FILENAME_COMPONENT(_parent_module_path ${_x}  PATH)

    GET_FILENAME_COMPONENT(_child_module_name ${_x} NAME)

    GET_FILENAME_COMPONENT(_module_path ${MODULE_SIP} PATH)

    GET_FILENAME_COMPONENT(_abs_module_sip ${MODULE_SIP} ABSOLUTE)

    # We give this target a long logical target name.

    # (This is to avoid having the library name clash with any already

    # install library names. If that happens then cmake dependancy

    # tracking get confused.)

    STRING(REPLACE "." "_" _logical_name ${MODULE_NAME})

    SET(_logical_name "python_module_${_logical_name}")

    FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${_module_path})    # Output goes in this dir.

    SET(_sip_includes)

    FOREACH (_inc ${SIP_INCLUDES})

        GET_FILENAME_COMPONENT(_abs_inc ${_inc} ABSOLUTE)

        LIST(APPEND _sip_includes -I ${_abs_inc})

    ENDFOREACH (_inc )

    SET(_sip_tags)

    FOREACH (_tag ${SIP_TAGS})

        LIST(APPEND _sip_tags -t ${_tag})

    ENDFOREACH (_tag)

    SET(_sip_x)

    FOREACH (_x ${SIP_DISABLE_FEATURES})

        LIST(APPEND _sip_x -x ${_x})

    ENDFOREACH (_x ${SIP_DISABLE_FEATURES})

    SET(_message "-DMESSAGE=Generating CPP code for module ${MODULE_NAME}")

    SET(_sip_output_files)

    FOREACH(CONCAT_NUM RANGE 0 ${SIP_CONCAT_PARTS} )

        IF( ${CONCAT_NUM} LESS ${SIP_CONCAT_PARTS} )

            SET(_sip_output_files ${_sip_output_files} ${CMAKE_CURRENT_BINARY_DIR}/${_module_path}/sip${_child_module_name}part${CONCAT_NUM}.cpp )

        ENDIF( ${CONCAT_NUM} LESS ${SIP_CONCAT_PARTS} )

    ENDFOREACH(CONCAT_NUM RANGE 0 ${SIP_CONCAT_PARTS} )

    IF(NOT WIN32)

        SET(TOUCH_COMMAND touch)

    ELSE(NOT WIN32)

        SET(TOUCH_COMMAND echo)

        # instead of a touch command, give out the name and append to the files

        # this is basically what the touch command does.

        FOREACH(filename ${_sip_output_files})

            FILE(APPEND filename "")

        ENDFOREACH(filename ${_sip_output_files})

    ENDIF(NOT WIN32)

    ADD_CUSTOM_COMMAND(

        OUTPUT ${_sip_output_files} 

        COMMAND ${CMAKE_COMMAND} -E echo ${message}

        COMMAND ${TOUCH_COMMAND} ${_sip_output_files} 

        COMMAND ${SIP_EXECUTABLE} ${_sip_tags} ${_sip_x} ${SIP_EXTRA_OPTIONS} -j ${SIP_CONCAT_PARTS} -c ${CMAKE_CURRENT_BINARY_DIR}/${_module_path} ${_sip_includes} ${_abs_module_sip}

        DEPENDS ${_abs_module_sip} ${SIP_EXTRA_FILES_DEPEND}

    )

    # not sure if type MODULE could be uses anywhere, limit to cygwin for now

    IF (CYGWIN)

        ADD_LIBRARY(${_logical_name} MODULE ${_sip_output_files} )

    ELSE (CYGWIN)

        ADD_LIBRARY(${_logical_name} SHARED ${_sip_output_files} )

    ENDIF (CYGWIN)

    TARGET_LINK_LIBRARIES(${_logical_name} ${PYTHON_LIBRARY})

    TARGET_LINK_LIBRARIES(${_logical_name} ${EXTRA_LINK_LIBRARIES})

    SET_TARGET_PROPERTIES(${_logical_name} PROPERTIES PREFIX "" OUTPUT_NAME ${_child_module_name})

    IF (WIN32)

      SET_TARGET_PROPERTIES(${_logical_name} PROPERTIES SUFFIX ".pyd")

    ENDIF (WIN32)

    INSTALL(TARGETS ${_logical_name} DESTINATION "${PYTHON_SITE_PACKAGES_DIR}/${_parent_module_path}")

ENDMACRO(ADD_SIP_PYTHON_MODULE)

# By Simon Edwards <[email protected]>

# This file is in the public domain.

import py_compile

py_compile.main()

# FindSIP.py

#

# Copyright (c) 2007, Simon Edwards <[email protected]>

# Redistribution and use is allowed according to the terms of the BSD license.

# For details see the accompanying COPYING-CMAKE-SCRIPTS file.

import sys

import sipconfig

sipcfg = sipconfig.Configuration()

print("sip_version:%06.0x" % sipcfg.sip_version)

print("sip_version_str:%s" % sipcfg.sip_version_str)

print("sip_bin:%s" % sipcfg.sip_bin)

print("default_sip_dir:%s" % sipcfg.default_sip_dir)

print("sip_inc_dir:%s" % sipcfg.sip_inc_dir)

# Copyright (c) 2007, Simon Edwards <[email protected]>

# Redistribution and use is allowed according to the terms of the BSD license.

# For details see the accompanying COPYING-CMAKE-SCRIPTS file.

import PyQt4.pyqtconfig

pyqtcfg = PyQt4.pyqtconfig.Configuration()

print("pyqt_version:%06.0x" % pyqtcfg.pyqt_version)

print("pyqt_version_str:%s" % pyqtcfg.pyqt_version_str)

pyqt_version_tag = ""

in_t = False

for item in pyqtcfg.pyqt_sip_flags.split(' '):

    if item=="-t":

        in_t = True

    elif in_t:

        if item.startswith("Qt_4"):

            pyqt_version_tag = item

    else:

        in_t = False

print("pyqt_version_tag:%s" % pyqt_version_tag)

print("pyqt_sip_dir:%s" % pyqtcfg.pyqt_sip_dir)

print("pyqt_sip_flags:%s" % pyqtcfg.pyqt_sip_flags)

# Find Python

# ~~~~~~~~~~~

# Find the Python interpreter and related Python directories.

#

# This file defines the following variables:

#

# PYTHON_EXECUTABLE - The path and filename of the Python interpreter.

#

# PYTHON_SHORT_VERSION - The version of the Python interpreter found,

#     excluding the patch version number. (e.g. 2.5 and not 2.5.1))

#

# PYTHON_LONG_VERSION - The version of the Python interpreter found as a human

#     readable string.

#

# PYTHON_SITE_PACKAGES_DIR - Location of the Python site-packages directory.

#

# PYTHON_INCLUDE_PATH - Directory holding the python.h include file.

#

# PYTHON_LIBRARY, PYTHON_LIBRARIES- Location of the Python library.

# Copyright (c) 2007, Simon Edwards <[email protected]>

# Redistribution and use is allowed according to the terms of the BSD license.

# For details see the accompanying COPYING-CMAKE-SCRIPTS file.

INCLUDE(CMakeFindFrameworks)

if(EXISTS PYTHON_LIBRARY)

  # Already in cache, be silent

  set(PYTHONLIBRARY_FOUND TRUE)

else(EXISTS PYTHON_LIBRARY)

  FIND_PACKAGE(PythonInterp)

  if(PYTHONINTERP_FOUND)

    FIND_FILE(_find_lib_python_py FindLibPython.py PATHS ${CMAKE_MODULE_PATH})

    EXECUTE_PROCESS(COMMAND ${PYTHON_EXECUTABLE}  ${_find_lib_python_py} OUTPUT_VARIABLE python_config)

    if(python_config)

      STRING(REGEX REPLACE ".*exec_prefix:([^\n]+).*$" "\\1" PYTHON_PREFIX ${python_config})

      STRING(REGEX REPLACE ".*\nshort_version:([^\n]+).*$" "\\1" PYTHON_SHORT_VERSION ${python_config})

      STRING(REGEX REPLACE ".*\nlong_version:([^\n]+).*$" "\\1" PYTHON_LONG_VERSION ${python_config})

      STRING(REGEX REPLACE ".*\npy_inc_dir:([^\n]+).*$" "\\1" PYTHON_INCLUDE_PATH ${python_config})

      if(NOT PYTHON_SITE_PACKAGES_DIR)

        if(NOT PYTHON_LIBS_WITH_KDE_LIBS)

          STRING(REGEX REPLACE ".*\nsite_packages_dir:([^\n]+).*$" "\\1" PYTHON_SITE_PACKAGES_DIR ${python_config})

        else(NOT PYTHON_LIBS_WITH_KDE_LIBS)

          set(PYTHON_SITE_PACKAGES_DIR ${KDE4_LIB_INSTALL_DIR}/python${PYTHON_SHORT_VERSION}/site-packages)

        endif(NOT PYTHON_LIBS_WITH_KDE_LIBS)

      endif(NOT PYTHON_SITE_PACKAGES_DIR)

      STRING(REGEX REPLACE "([0-9]+).([0-9]+)" "\\1\\2" PYTHON_SHORT_VERSION_NO_DOT ${PYTHON_SHORT_VERSION})

      set(PYTHON_LIBRARY_NAMES python${PYTHON_SHORT_VERSION} python${PYTHON_SHORT_VERSION_NO_DOT})

      if(WIN32)

          STRING(REPLACE "\\" "/" PYTHON_SITE_PACKAGES_DIR ${PYTHON_SITE_PACKAGES_DIR})

      endif(WIN32)

      FIND_LIBRARY(PYTHON_LIBRARY NAMES ${PYTHON_LIBRARY_NAMES} PATHS ${PYTHON_PREFIX}/lib ${PYTHON_PREFIX}/libs NO_DEFAULT_PATH)

      set(PYTHONLIBRARY_FOUND TRUE)

    endif(python_config)

    # adapted from cmake's builtin FindPythonLibs

    if(APPLE)

      CMAKE_FIND_FRAMEWORKS(Python)

      set(PYTHON_FRAMEWORK_INCLUDES)

      if(Python_FRAMEWORKS)

        # If a framework has been selected for the include path,

        # make sure "-framework" is used to link it.

        if("${PYTHON_INCLUDE_PATH}" MATCHES "Python\\.framework")

          set(PYTHON_LIBRARY "")

          set(PYTHON_DEBUG_LIBRARY "")

        endif("${PYTHON_INCLUDE_PATH}" MATCHES "Python\\.framework")

        if(NOT PYTHON_LIBRARY)

          set (PYTHON_LIBRARY "-framework Python" CACHE FILEPATH "Python Framework" FORCE)

        endif(NOT PYTHON_LIBRARY)

        set(PYTHONLIBRARY_FOUND TRUE)

      endif(Python_FRAMEWORKS)

    endif(APPLE)

  endif(PYTHONINTERP_FOUND)

  if(PYTHONLIBRARY_FOUND)

    set(PYTHON_LIBRARIES ${PYTHON_LIBRARY})

    if(NOT PYTHONLIBRARY_FIND_QUIETLY)

      message(STATUS "Found Python executable: ${PYTHON_EXECUTABLE}")

      message(STATUS "Found Python version: ${PYTHON_LONG_VERSION}")

      message(STATUS "Found Python library: ${PYTHON_LIBRARY}")

    endif(NOT PYTHONLIBRARY_FIND_QUIETLY)

  else(PYTHONLIBRARY_FOUND)

    if(PYTHONLIBRARY_FIND_REQUIRED)

      message(FATAL_ERROR "Could not find Python")

    endif(PYTHONLIBRARY_FIND_REQUIRED)

  endif(PYTHONLIBRARY_FOUND)

endif (EXISTS PYTHON_LIBRARY)

# Copyright (c) 2007, Simon Edwards <[email protected]>

# Redistribution and use is allowed according to the terms of the BSD license.

# For details see the accompanying COPYING-CMAKE-SCRIPTS file.

import sys

import distutils.sysconfig

print("exec_prefix:%s" % sys.exec_prefix)

print("short_version:%s" % sys.version[:3])

print("long_version:%s" % sys.version.split()[0])

print("py_inc_dir:%s" % distutils.sysconfig.get_python_inc())

print("site_packages_dir:%s" % distutils.sysconfig.get_python_lib(plat_specific=1))

# Find PyQt4

# ~~~~~~~~~~

# Copyright (c) 2007-2008, Simon Edwards <[email protected]>

# Redistribution and use is allowed according to the terms of the BSD license.

# For details see the accompanying COPYING-CMAKE-SCRIPTS file.

#

# PyQt4 website: http://www.riverbankcomputing.co.uk/pyqt/index.php

#

# Find the installed version of PyQt4. FindPyQt4 should only be called after

# Python has been found.

#

# This file defines the following variables:

#

# PYQT4_VERSION - The version of PyQt4 found expressed as a 6 digit hex number

#     suitable for comparision as a string

#

# PYQT4_VERSION_STR - The version of PyQt4 as a human readable string.

#

# PYQT4_VERSION_TAG - The PyQt version tag using by PyQt's sip files.

#

# PYQT4_SIP_DIR - The directory holding the PyQt4 .sip files.

#

# PYQT4_SIP_FLAGS - The SIP flags used to build PyQt.

IF(EXISTS PYQT4_VERSION)

  # Already in cache, be silent

  SET(PYQT4_FOUND TRUE)

ELSE(EXISTS PYQT4_VERSION)

  FIND_FILE(_find_pyqt_py FindPyQt.py PATHS ${CMAKE_MODULE_PATH})

  EXECUTE_PROCESS(COMMAND ${PYTHON_EXECUTABLE} ${_find_pyqt_py} OUTPUT_VARIABLE pyqt_config)

  IF(pyqt_config)

    STRING(REGEX REPLACE "^pyqt_version:([^\n]+).*$" "\\1" PYQT4_VERSION ${pyqt_config})

    STRING(REGEX REPLACE ".*\npyqt_version_str:([^\n]+).*$" "\\1" PYQT4_VERSION_STR ${pyqt_config})

    STRING(REGEX REPLACE ".*\npyqt_version_tag:([^\n]+).*$" "\\1" PYQT4_VERSION_TAG ${pyqt_config})

    STRING(REGEX REPLACE ".*\npyqt_sip_dir:([^\n]+).*$" "\\1" PYQT4_SIP_DIR ${pyqt_config})

    STRING(REGEX REPLACE ".*\npyqt_sip_flags:([^\n]+).*$" "\\1" PYQT4_SIP_FLAGS ${pyqt_config})

    SET(PYQT4_FOUND TRUE)

  ENDIF(pyqt_config)

  IF(PYQT4_FOUND)

    IF(NOT PYQT4_FIND_QUIETLY)

      MESSAGE(STATUS "Found PyQt4 version: ${PYQT4_VERSION_STR}")

    ENDIF(NOT PYQT4_FIND_QUIETLY)

  ELSE(PYQT4_FOUND)

    IF(PYQT4_FIND_REQUIRED)

      MESSAGE(FATAL_ERROR "Could not find Python")

    ENDIF(PYQT4_FIND_REQUIRED)

  ENDIF(PYQT4_FOUND)

ENDIF(EXISTS PYQT4_VERSION)

# Python macros

# ~~~~~~~~~~~~~

# Copyright (c) 2007, Simon Edwards <[email protected]>

#

# Redistribution and use is allowed according to the terms of the BSD license.

# For details see the accompanying COPYING-CMAKE-SCRIPTS file.

#

# This file defines the following macros:

#

# PYTHON_INSTALL (SOURCE_FILE DESINATION_DIR)

#     Install the SOURCE_FILE, which is a Python .py file, into the

#     destination directory during install. The file will be byte compiled

#     and both the .py file and .pyc file will be installed.

GET_FILENAME_COMPONENT(PYTHON_MACROS_MODULE_PATH ${CMAKE_CURRENT_LIST_FILE}  PATH)

MACRO(PYTHON_INSTALL SOURCE_FILE DESINATION_DIR)

  FIND_FILE(_python_compile_py PythonCompile.py PATHS ${CMAKE_MODULE_PATH})

  # Install the source file.

  INSTALL(FILES ${SOURCE_FILE} DESTINATION ${DESINATION_DIR})

  # Byte compile and install the .pyc file.        

  GET_FILENAME_COMPONENT(_absfilename ${SOURCE_FILE} ABSOLUTE)

  GET_FILENAME_COMPONENT(_filename ${SOURCE_FILE} NAME)

  GET_FILENAME_COMPONENT(_filenamebase ${SOURCE_FILE} NAME_WE)

  GET_FILENAME_COMPONENT(_basepath ${SOURCE_FILE} PATH)

  if(WIN32)

    string(REGEX REPLACE ".:/" "/" _basepath "${_basepath}")

  endif(WIN32)

  SET(_bin_py ${CMAKE_CURRENT_BINARY_DIR}/${_basepath}/${_filename})

  SET(_bin_pyc ${CMAKE_CURRENT_BINARY_DIR}/${_basepath}/${_filenamebase}.pyc)

  FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${_basepath})

  SET(_message "-DMESSAGE=Byte-compiling ${_bin_py}")

  GET_FILENAME_COMPONENT(_abs_bin_py ${_bin_py} ABSOLUTE)

  IF(_abs_bin_py STREQUAL ${_absfilename})    # Don't copy the file onto itself.

    ADD_CUSTOM_COMMAND(

      TARGET compile_python_files

      COMMAND ${CMAKE_COMMAND} -E echo ${message}

      COMMAND ${PYTHON_EXECUTABLE} ${_python_compile_py} ${_bin_py}

      DEPENDS ${_absfilename}

    )

  ELSE(_abs_bin_py STREQUAL ${_absfilename})

    ADD_CUSTOM_COMMAND(

      TARGET compile_python_files

      COMMAND ${CMAKE_COMMAND} -E echo ${message} 

      COMMAND ${CMAKE_COMMAND} -E copy ${_absfilename} ${_bin_py}

      COMMAND ${PYTHON_EXECUTABLE} ${_python_compile_py} ${_bin_py}

      DEPENDS ${_absfilename}

    )

  ENDIF(_abs_bin_py STREQUAL ${_absfilename})

  INSTALL(FILES ${_bin_pyc} DESTINATION ${DESINATION_DIR})

ENDMACRO(PYTHON_INSTALL)

IF(NOT PYUIC4_PROGRAM)

  IF (MSVC)

    FIND_PROGRAM(PYUIC4_PROGRAM

      NAMES pyuic4.bat

      PATHS $ENV{LIB_DIR}/bin

    )

  ELSE(MSVC)

    FIND_PROGRAM(PYUIC4_PROGRAM pyuic4)

  ENDIF (MSVC)

  IF (NOT PYUIC4_PROGRAM)

    MESSAGE(FATAL_ERROR "pyuic4 not found - aborting")

  ENDIF (NOT PYUIC4_PROGRAM)

ENDIF(NOT PYUIC4_PROGRAM)

# Adapted from QT4_WRAP_UI

MACRO(PYQT4_WRAP_UI outfiles )

  FOREACH(it ${ARGN})

    GET_FILENAME_COMPONENT(outfile ${it} NAME_WE)

    GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE)

    SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/ui_${outfile}.py)

    ADD_CUSTOM_COMMAND(OUTPUT ${outfile}

      COMMAND ${PYUIC4_PROGRAM} ${infile} -o ${outfile}

      MAIN_DEPENDENCY ${infile}                       

    )

    SET(${outfiles} ${${outfiles}} ${outfile})

  ENDFOREACH(it)

ENDMACRO(PYQT4_WRAP_UI)

IF(NOT PYRCC4_PROGRAM)

  IF (MSVC)

    FIND_PROGRAM(PYRCC4_PROGRAM

      NAMES pyrcc4.exe

      PATHS $ENV{LIB_DIR}/bin

    )

  ELSE(MSVC)

    FIND_PROGRAM(PYRCC4_PROGRAM pyrcc4)

  ENDIF (MSVC)

  IF (NOT PYRCC4_PROGRAM)

    MESSAGE(FATAL_ERROR "pyrcc4 not found - aborting")

  ENDIF (NOT PYRCC4_PROGRAM)

ENDIF(NOT PYRCC4_PROGRAM)

# Adapted from QT4_ADD_RESOURCES

MACRO (PYQT4_ADD_RESOURCES outfiles )

  FOREACH (it ${ARGN})

    GET_FILENAME_COMPONENT(outfile ${it} NAME_WE)

    GET_FILENAME_COMPONENT(infile ${it} ABSOLUTE)

    GET_FILENAME_COMPONENT(rc_path ${infile} PATH)

    SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/${outfile}_rc.py)

    #  parse file for dependencies 

    #  all files are absolute paths or relative to the location of the qrc file

    FILE(READ "${infile}" _RC_FILE_CONTENTS)

    STRING(REGEX MATCHALL "<file[^<]+" _RC_FILES "${_RC_FILE_CONTENTS}")

    SET(_RC_DEPENDS)

    FOREACH(_RC_FILE ${_RC_FILES})

      STRING(REGEX REPLACE "^<file[^>]*>" "" _RC_FILE "${_RC_FILE}")

      STRING(REGEX MATCH "^/|([A-Za-z]:/)" _ABS_PATH_INDICATOR "${_RC_FILE}")

      IF(NOT _ABS_PATH_INDICATOR)

        SET(_RC_FILE "${rc_path}/${_RC_FILE}")

      ENDIF(NOT _ABS_PATH_INDICATOR)

      SET(_RC_DEPENDS ${_RC_DEPENDS} "${_RC_FILE}")

    ENDFOREACH(_RC_FILE)

    ADD_CUSTOM_COMMAND(OUTPUT ${outfile}

      COMMAND ${PYRCC4_PROGRAM} -name ${outfile} -o ${outfile} ${infile}

      MAIN_DEPENDENCY ${infile}

      DEPENDS ${_RC_DEPENDS})

    SET(${outfiles} ${${outfiles}} ${outfile})

  ENDFOREACH (it)

ENDMACRO (PYQT4_ADD_RESOURCES)

# Find SIP

# ~~~~~~~~

#

# SIP website: http://www.riverbankcomputing.co.uk/sip/index.php

#

# Find the installed version of SIP. FindSIP should be called after Python

# has been found.

#

# This file defines the following variables:

#

# SIP_VERSION - The version of SIP found expressed as a 6 digit hex number

#     suitable for comparision as a string.

#

# SIP_VERSION_STR - The version of SIP found as a human readable string.

#

# SIP_EXECUTABLE - Path and filename of the SIP command line executable.

#

# SIP_INCLUDE_DIR - Directory holding the SIP C++ header file.

#

# SIP_DEFAULT_SIP_DIR - Default directory where .sip files should be installed

#     into.

# Copyright (c) 2007, Simon Edwards <[email protected]>

# Redistribution and use is allowed according to the terms of the BSD license.

# For details see the accompanying COPYING-CMAKE-SCRIPTS file.

IF(SIP_VERSION)

  # Already in cache, be silent

  SET(SIP_FOUND TRUE)

ELSE(SIP_VERSION)

  FIND_FILE(_find_sip_py FindSIP.py PATHS ${CMAKE_MODULE_PATH})

  EXECUTE_PROCESS(COMMAND ${PYTHON_EXECUTABLE} ${_find_sip_py} OUTPUT_VARIABLE sip_config)

  IF(sip_config)

    STRING(REGEX REPLACE "^sip_version:([^\n]+).*$" "\\1" SIP_VERSION ${sip_config})

    STRING(REGEX REPLACE ".*\nsip_version_str:([^\n]+).*$" "\\1" SIP_VERSION_STR ${sip_config})

    STRING(REGEX REPLACE ".*\nsip_bin:([^\n]+).*$" "\\1" SIP_EXECUTABLE ${sip_config})

    STRING(REGEX REPLACE ".*\ndefault_sip_dir:([^\n]+).*$" "\\1" SIP_DEFAULT_SIP_DIR ${sip_config})

    STRING(REGEX REPLACE ".*\nsip_inc_dir:([^\n]+).*$" "\\1" SIP_INCLUDE_DIR ${sip_config})

    SET(SIP_FOUND TRUE)

  ENDIF(sip_config)

  IF(SIP_FOUND)

    IF(NOT SIP_FIND_QUIETLY)

      MESSAGE(STATUS "Found SIP version: ${SIP_VERSION_STR}")

    ENDIF(NOT SIP_FIND_QUIETLY)

  ELSE(SIP_FOUND)

    IF(SIP_FIND_REQUIRED)

      MESSAGE(FATAL_ERROR "Could not find SIP")

    ENDIF(SIP_FIND_REQUIRED)

  ENDIF(SIP_FOUND)

ENDIF(SIP_VERSION)

SET (QT_INCLUDES

  ${QT_QTCORE_INCLUDE_DIR}

  ${QT_QTGUI_INCLUDE_DIR}

  ${QT_QTNETWORK_INCLUDE_DIR}

  ${QT_QTSVG_INCLUDE_DIR}

  ${QT_QTXML_INCLUDE_DIR}

)

SET (QT_LIBS

  ${QT_QTCORE_LIBRARY}

  ${QT_QTGUI_LIBRARY}

  ${QT_QTNETWORK_LIBRARY}

  ${QT_QTSVG_LIBRARY}

  ${QT_QTXML_LIBRARY}

)

INCLUDE_DIRECTORIES(

    ${PYTHON_INCLUDE_PATH}

    ${SIP_INCLUDE_DIR}

    ${QT_INCLUDES}

    ${GDAL_INCLUDE_DIR}

    ${GEOS_INCLUDE_DIR}

    ../src/core

    ../src/core/composer

    ../src/core/raster

    ../src/core/renderer

    ../src/core/spatialindex

    ../src/core/symbology

    ../src/core/symbology-ng

    ${CMAKE_BINARY_DIR}  # qgsconfig.h, qgssvnversion.h

)

# core module

FILE(GLOB sip_files_core core/*.sip)

set(SIP_EXTRA_FILES_DEPEND ${sip_files_core})

ADD_SIP_PYTHON_MODULE(qgis.core core/core.sip qgis_core ${QT_LIBS})

# additional gui includes

INCLUDE_DIRECTORIES(

    ../src/gui

    ../src/gui/symbology-ng

    ../src/plugins

    ${CMAKE_BINARY_DIR}/src/gui

    ${CMAKE_BINARY_DIR}/src/ui

)

# gui module

FILE(GLOB sip_files_gui gui/*.sip)

set(SIP_EXTRA_FILES_DEPEND ${sip_files_gui})

ADD_SIP_PYTHON_MODULE(qgis.gui gui/gui.sip qgis_core qgis_gui ${QT_LIBS})

# additional analysis includes

INCLUDE_DIRECTORIES(

    ../src/analysis/vector

    ${CMAKE_BINARY_DIR}/src/analysis/vector

)

# analysis module

FILE(GLOB sip_files_analysis analysis/*.sip)

set(SIP_EXTRA_FILES_DEPEND ${sip_files_analysis})

ADD_SIP_PYTHON_MODULE(qgis.analysis analysis/analysis.sip qgis_core qgis_analysis ${QT_LIBS})

SET (QGIS_PYTHON_DIR ${PYTHON_SITE_PACKAGES_DIR}/qgis)

ADD_CUSTOM_TARGET(compile_python_files ALL)

PYTHON_INSTALL(__init__.py ${QGIS_PYTHON_DIR})

PYTHON_INSTALL(utils.py    ${QGIS_PYTHON_DIR})

PYTHON_INSTALL(console.py  ${QGIS_PYTHON_DIR})

# Python bindings

IF (WITH_BINDINGS)

  # python support: check for interpreter, sip, pyqt4

  FIND_PACKAGE(PythonInterp REQUIRED)

  FIND_PACKAGE(PythonLibrary REQUIRED)

  FIND_PACKAGE(SIP REQUIRED)

  FIND_PACKAGE(PyQt4 REQUIRED)

  INCLUDE(PythonMacros)

  INCLUDE(SIPMacros)

  INCLUDE(PyQt4Macros)

  # setup SIP variables

  separate_arguments(PYQT4_SIP_FLAGS) # convert space separated values to a list

  set(SIP_INCLUDES ${PYQT4_SIP_DIR} ${CMAKE_SOURCE_DIR}/python)

  set(SIP_CONCAT_PARTS 4)

  set(SIP_EXTRA_OPTIONS ${PYQT4_SIP_FLAGS})

  IF (NOT BINDINGS_GLOBAL_INSTALL)

    set(PYTHON_SITE_PACKAGES_DIR ${QGIS_DATA_DIR}/python)

  ENDIF (NOT BINDINGS_GLOBAL_INSTALL)

ENDIF (WITH_BINDINGS)

#############################################################

IF (WITH_BINDINGS)

ENDIF (WITH_BINDINGS)