qtbindings 4.6.3.4 → 4.8.3.0

data/ext/generator/cmake/FindQScintilla.cmake

@@ -0,0 +1,57 @@
+# - Try to find the QScintilla2 includes and library
+# which defines
+#
+# QSCINTILLA_FOUND - system has QScintilla2
+# QSCINTILLA_INCLUDE_DIR - where to find qextscintilla.h
+# QSCINTILLA_LIBRARIES - the libraries to link against to use QScintilla
+# QSCINTILLA_LIBRARY - where to find the QScintilla library (not for general use)
+
+# copyright (c) 2007 Thomas Moenicke thomas.moenicke@kdemail.net
+#
+# Redistribution and use is allowed according to the terms of the FreeBSD license.
+
+IF(NOT QT4_FOUND)
+    INCLUDE(FindQt4)
+ENDIF(NOT QT4_FOUND)
+
+SET(QSCINTILLA_FOUND FALSE)
+
+IF(QT4_FOUND)
+    FIND_PATH(QSCINTILLA_INCLUDE_DIR qsciglobal.h
+    "${QT_INCLUDE_DIR}/Qsci" /usr/include /usr/include/Qsci
+    )
+
+    SET(QSCINTILLA_NAMES ${QSCINTILLA_NAMES} qscintilla2 libqscintilla2)
+    FIND_LIBRARY(QSCINTILLA_LIBRARY
+        NAMES ${QSCINTILLA_NAMES}
+        PATHS ${QT_LIBRARY_DIR}
+    )
+
+    IF (QSCINTILLA_LIBRARY AND QSCINTILLA_INCLUDE_DIR)
+
+        SET(QSCINTILLA_LIBRARIES ${QSCINTILLA_LIBRARY})
+        SET(QSCINTILLA_FOUND TRUE)
+
+        IF (CYGWIN)
+            IF(BUILD_SHARED_LIBS)
+            # No need to define QSCINTILLA_USE_DLL here, because it's default for Cygwin.
+            ELSE(BUILD_SHARED_LIBS)
+            SET (QSCINTILLA_DEFINITIONS -DQSCINTILLA_STATIC)
+            ENDIF(BUILD_SHARED_LIBS)
+        ENDIF (CYGWIN)
+
+    ENDIF (QSCINTILLA_LIBRARY AND QSCINTILLA_INCLUDE_DIR)
+ENDIF(QT4_FOUND)
+
+IF (QSCINTILLA_FOUND)
+  IF (NOT QScintilla_FIND_QUIETLY)
+    MESSAGE(STATUS "Found QScintilla2: ${QSCINTILLA_LIBRARY}")
+  ENDIF (NOT QScintilla_FIND_QUIETLY)
+ELSE (QSCINTILLA_FOUND)
+  IF (QScintilla_FIND_REQUIRED)
+    MESSAGE(FATAL_ERROR "Could not find QScintilla library")
+  ENDIF (QScintilla_FIND_REQUIRED)
+ENDIF (QSCINTILLA_FOUND)
+
+MARK_AS_ADVANCED(QSCINTILLA_INCLUDE_DIR QSCINTILLA_LIBRARY)
+

data/ext/generator/cmake/FindQwt5.cmake

@@ -0,0 +1,104 @@
+# Find the Qwt 5.x includes and library, either the version linked to Qt3 or the version linked to Qt4
+#
+# On Windows it makes these assumptions:
+#    - the Qwt DLL is where the other DLLs for Qt are (QT_DIR\bin) or in the path
+#    - the Qwt .h files are in QT_DIR\include\Qwt or in the path
+#    - the Qwt .lib is where the other LIBs for Qt are (QT_DIR\lib) or in the path
+#
+# Qwt5_INCLUDE_DIR - where to find qwt.h if Qwt
+# Qwt5_Qt4_LIBRARY - The Qwt5 library linked against Qt4 (if it exists)
+# Qwt5_Qt3_LIBRARY - The Qwt5 library linked against Qt4 (if it exists)
+# Qwt5_Qt4_FOUND   - Qwt5 was found and uses Qt4
+# Qwt5_Qt3_FOUND   - Qwt5 was found and uses Qt3
+# Qwt5_FOUND - Set to TRUE if Qwt5 was found (linked either to Qt3 or Qt4)
+
+# Copyright (c) 2007, Pau Garcia i Quiles, <pgquiles@elpauer.org>
+#
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+
+# Condition is "(A OR B) AND C", CMake does not support parentheses but it evaluates left to right
+IF(Qwt5_Qt4_LIBRARY OR Qwt5_Qt3_LIBRARY AND Qwt5_INCLUDE_DIR)
+    SET(Qwt5_FIND_QUIETLY TRUE)
+ENDIF(Qwt5_Qt4_LIBRARY OR Qwt5_Qt3_LIBRARY AND Qwt5_INCLUDE_DIR)
+
+IF(NOT QT4_FOUND)
+	FIND_PACKAGE( Qt4 REQUIRED QUIET )
+ENDIF(NOT QT4_FOUND)
+
+IF( QT4_FOUND )
+	# Is Qwt5 installed? Look for header files
+	FIND_PATH( Qwt5_INCLUDE_DIR qwt.h 
+               PATHS ${QT_INCLUDE_DIR} /usr/local/qwt/include /usr/include/qwt
+               PATH_SUFFIXES qwt qwt5 qwt-qt4 qwt5-qt4 qwt-qt3 qwt5-qt3 include qwt/include qwt5/include qwt-qt4/include qwt5-qt4/include qwt-qt3/include qwt5-qt3/include ENV PATH)
+	
+	# Find Qwt version
+	IF( Qwt5_INCLUDE_DIR )
+		FILE( READ ${Qwt5_INCLUDE_DIR}/qwt_global.h QWT_GLOBAL_H )
+		STRING( REGEX MATCH "#define *QWT_VERSION *(0x05*)" QWT_IS_VERSION_5 ${QWT_GLOBAL_H})
+		
+		IF( QWT_IS_VERSION_5 )
+		STRING(REGEX REPLACE ".*#define[\\t\\ ]+QWT_VERSION_STR[\\t\\ ]+\"([0-9]+\\.[0-9]+\\.[0-9]+)\".*" "\\1" Qwt_VERSION "${QWT_GLOBAL_H}")
+
+		# Find Qwt5 library linked to Qt4
+		FIND_LIBRARY( Qwt5_Qt4_TENTATIVE_LIBRARY NAMES qwt5-qt4 qwt-qt4 qwt5 qwt PATHS /usr/local/qwt/lib /usr/local/lib /usr/lib ${QT_LIBRARY_DIR})
+		IF( UNIX AND NOT CYGWIN)
+			IF( Qwt5_Qt4_TENTATIVE_LIBRARY )
+				#MESSAGE("Qwt5_Qt4_TENTATIVE_LIBRARY = ${Qwt5_Qt4_TENTATIVE_LIBRARY}")
+				EXECUTE_PROCESS( COMMAND "ldd" ${Qwt5_Qt4_TENTATIVE_LIBRARY} OUTPUT_VARIABLE Qwt_Qt4_LIBRARIES_LINKED_TO )
+				STRING( REGEX MATCH "QtCore" Qwt5_IS_LINKED_TO_Qt4 ${Qwt_Qt4_LIBRARIES_LINKED_TO})
+				IF( Qwt5_IS_LINKED_TO_Qt4 )
+					SET( Qwt5_Qt4_LIBRARY ${Qwt5_Qt4_TENTATIVE_LIBRARY} )
+					SET( Qwt5_Qt4_FOUND TRUE )
+					IF (NOT Qwt5_FIND_QUIETLY)
+						MESSAGE( STATUS "Found Qwt: ${Qwt5_Qt4_LIBRARY}" )
+					ENDIF (NOT Qwt5_FIND_QUIETLY)
+				ENDIF( Qwt5_IS_LINKED_TO_Qt4 )
+			ENDIF( Qwt5_Qt4_TENTATIVE_LIBRARY )
+		ELSE( UNIX AND NOT CYGWIN)
+		# Assumes qwt.dll is in the Qt dir
+			SET( Qwt5_Qt4_LIBRARY ${Qwt5_Qt4_TENTATIVE_LIBRARY} )
+			SET( Qwt5_Qt4_FOUND TRUE )
+			IF (NOT Qwt5_FIND_QUIETLY)
+				MESSAGE( STATUS "Found Qwt version ${Qwt_VERSION} linked to Qt4" )
+			ENDIF (NOT Qwt5_FIND_QUIETLY)
+		ENDIF( UNIX AND NOT CYGWIN)
+		
+		
+		# Find Qwt5 library linked to Qt3
+		FIND_LIBRARY( Qwt5_Qt3_TENTATIVE_LIBRARY NAMES qwt-qt3 qwt qwt5-qt3 qwt5 )
+		IF( UNIX AND NOT CYGWIN)
+			IF( Qwt5_Qt3_TENTATIVE_LIBRARY )
+				#MESSAGE("Qwt5_Qt3_TENTATIVE_LIBRARY = ${Qwt5_Qt3_TENTATIVE_LIBRARY}")
+				EXECUTE_PROCESS( COMMAND "ldd" ${Qwt5_Qt3_TENTATIVE_LIBRARY} OUTPUT_VARIABLE Qwt-Qt3_LIBRARIES_LINKED_TO )
+				STRING( REGEX MATCH "qt-mt" Qwt5_IS_LINKED_TO_Qt3 ${Qwt-Qt3_LIBRARIES_LINKED_TO})
+				IF( Qwt5_IS_LINKED_TO_Qt3 )
+					SET( Qwt5_Qt3_LIBRARY ${Qwt5_Qt3_TENTATIVE_LIBRARY} )
+					SET( Qwt5_Qt3_FOUND TRUE )
+					IF (NOT Qwt5_FIND_QUIETLY)
+						MESSAGE( STATUS "Found Qwt version ${Qwt_VERSION} linked to Qt3" )
+					ENDIF (NOT Qwt5_FIND_QUIETLY)
+				ENDIF( Qwt5_IS_LINKED_TO_Qt3 )
+			ENDIF( Qwt5_Qt3_TENTATIVE_LIBRARY )
+		ELSE( UNIX AND NOT CYGWIN)
+			SET( Qwt5_Qt3_LIBRARY ${Qwt5_Qt3_TENTATIVE_LIBRARY} )
+			SET( Qwt5_Qt3_FOUND TRUE )
+			IF (NOT Qwt5_FIND_QUIETLY)
+				MESSAGE( STATUS "Found Qwt: ${Qwt5_Qt3_LIBRARY}" )
+			ENDIF (NOT Qwt5_FIND_QUIETLY)
+		ENDIF( UNIX AND NOT CYGWIN)
+		
+		ENDIF( QWT_IS_VERSION_5 )
+		
+		IF( Qwt5_Qt4_FOUND OR Qwt5_Qt3_FOUND )
+			SET( Qwt5_FOUND TRUE )
+		ENDIF( Qwt5_Qt4_FOUND OR Qwt5_Qt3_FOUND )
+		
+		MARK_AS_ADVANCED( Qwt5_INCLUDE_DIR Qwt5_Qt4_LIBRARY Qwt5_Qt3_LIBRARY )
+	ENDIF( Qwt5_INCLUDE_DIR )
+
+   	IF (NOT Qwt5_FOUND AND Qwt5_FIND_REQUIRED)
+      		MESSAGE(FATAL_ERROR "Could not find Qwt 5.x")
+   	ENDIF (NOT Qwt5_FOUND AND Qwt5_FIND_REQUIRED)
+
+ENDIF( QT4_FOUND )

data/ext/generator/cmake/HandleImportedTargetsInCMakeRequiredLibraries.cmake

@@ -0,0 +1,85 @@
+
+# This is a helper function used by CheckCXXSourceRuns.cmake and 
+# CheckCXXSourceCompiles.cmake. Actually it should be used by all macros which 
+# use TRY_COMPILE() or TRY_RUN().
+# It takes the CMAKE_REQUIRED_LIBRARY variable and searches it for imported
+# (library) targets. Since the project created by TRY_COMPILE() (and TRY_RUN())
+# does not know about these imported targets, this macro here replaces these
+# imported targets with the actual library files on disk and it also
+# adds the libraries from the link interface of these imported targets.
+# E.g the imported target KDE4__kdeui is replaced on my system with /opt/kdelibs/lib/libkdeui.so
+# and the link interface libraries, which includes e.g. /opt/kdelibs/lib/libkdecore.so.
+# This way imported targets work also when used with CHECK_CXX_SOURCE_COMPILES/RUNS().
+
+# Copyright (c) 2009, Alexander Neundorf, <neundorf@kde.org>
+#
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+
+FUNCTION(HANDLE_IMPORTED_TARGETS_IN_CMAKE_REQUIRED_LIBRARIES _RESULT)
+# handle imported library targets
+   SET(_CCSR_IMP_TARGETS_MAP)
+   SET(_CCSR_REQ_LIBS ${CMAKE_REQUIRED_LIBRARIES})
+   SET(_CHECK_FOR_IMPORTED_TARGETS TRUE)
+   SET(_CCSR_LOOP_COUNTER 0)
+   WHILE(_CHECK_FOR_IMPORTED_TARGETS)
+      MATH(EXPR _CCSR_LOOP_COUNTER "${_CCSR_LOOP_COUNTER} + 1 ")
+      SET(_CCSR_NEW_REQ_LIBS )
+      SET(_CHECK_FOR_IMPORTED_TARGETS FALSE)
+      FOREACH(_CURRENT_LIB ${_CCSR_REQ_LIBS})
+         GET_TARGET_PROPERTY(_importedConfigs ${_CURRENT_LIB} IMPORTED_CONFIGURATIONS)
+         IF (_importedConfigs)
+            # Ok, so this is an imported target.
+            # First we get the imported configurations.
+            # Then we get the location of the actual library on disk of the first configuration.
+            # then we'll get its link interface libraries property,
+            # iterate through it and replace all imported targets we find there
+            # with there actual location.
+
+            # guard against infinite loop: abort after 100 iterations ( 100 is arbitrary chosen)
+            IF ("${_CCSR_LOOP_COUNTER}" LESS 100)
+               SET(_CHECK_FOR_IMPORTED_TARGETS TRUE)
+#                ELSE ("${_CCSR_LOOP_COUNTER}" LESS 1)
+#                   MESSAGE(STATUS "********* aborting loop, counter : ${_CCSR_LOOP_COUNTER}")
+            ENDIF ("${_CCSR_LOOP_COUNTER}" LESS 100)
+
+            LIST(GET _importedConfigs 0 _firstImportedConfig)
+            GET_TARGET_PROPERTY(_firstImportedLocation ${_CURRENT_LIB} IMPORTED_LOCATION_${_firstImportedConfig})
+            GET_TARGET_PROPERTY(_linkInterfaceLibs ${_CURRENT_LIB} IMPORTED_LINK_INTERFACE_LIBRARIES_${_firstImportedConfig} )
+
+            LIST(APPEND _CCSR_NEW_REQ_LIBS  ${_firstImportedLocation})
+#                MESSAGE(STATUS "Appending lib ${_CURRENT_LIB} as ${_firstImportedLocation}")
+            IF(_linkInterfaceLibs)
+               FOREACH(_currentLinkInterfaceLib ${_linkInterfaceLibs})
+#                   MESSAGE(STATUS "Appending link interface lib ${_currentLinkInterfaceLib}")
+                  IF(_currentLinkInterfaceLib)
+                     LIST(APPEND _CCSR_NEW_REQ_LIBS ${_currentLinkInterfaceLib} )
+                  ENDIF(_currentLinkInterfaceLib) 
+               ENDFOREACH(_currentLinkInterfaceLib ${_linkInterfaceLibs})
+            ENDIF(_linkInterfaceLibs)
+         ELSE(_importedConfigs)
+            # "Normal" libraries are just used as they are.
+            LIST(APPEND _CCSR_NEW_REQ_LIBS ${_CURRENT_LIB} )
+#                MESSAGE(STATUS "Appending lib directly: ${_CURRENT_LIB}")
+         ENDIF(_importedConfigs)
+      ENDFOREACH(_CURRENT_LIB ${_CCSR_REQ_LIBS})
+
+      SET(_CCSR_REQ_LIBS ${_CCSR_NEW_REQ_LIBS} )
+   ENDWHILE(_CHECK_FOR_IMPORTED_TARGETS)
+
+   # Finally we iterate once more over all libraries. This loop only removes
+   # all remaining imported target names (there shouldn't be any left anyway).
+   SET(_CCSR_NEW_REQ_LIBS )
+   FOREACH(_CURRENT_LIB ${_CCSR_REQ_LIBS})
+      GET_TARGET_PROPERTY(_importedConfigs ${_CURRENT_LIB} IMPORTED_CONFIGURATIONS)
+      IF (NOT _importedConfigs)
+         LIST(APPEND _CCSR_NEW_REQ_LIBS ${_CURRENT_LIB} )
+#             MESSAGE(STATUS "final: appending ${_CURRENT_LIB}")
+      ELSE (NOT _importedConfigs)
+#             MESSAGE(STATUS "final: skipping ${_CURRENT_LIB}")
+      ENDIF (NOT _importedConfigs)
+   ENDFOREACH(_CURRENT_LIB ${_CCSR_REQ_LIBS})
+   SET(${_RESULT} ${_CCSR_NEW_REQ_LIBS} PARENT_SCOPE)
+
+ENDFUNCTION(HANDLE_IMPORTED_TARGETS_IN_CMAKE_REQUIRED_LIBRARIES _CCSR_REQ_LIBS)
+

data/ext/generator/cmake/MacroLogFeature.cmake

@@ -0,0 +1,146 @@
+# This file defines the Feature Logging macros.
+#
+# MACRO_LOG_FEATURE(VAR FEATURE DESCRIPTION URL [REQUIRED [MIN_VERSION [COMMENTS]]])
+#   Logs the information so that it can be displayed at the end
+#   of the configure run
+#   VAR : TRUE or FALSE, indicating whether the feature is supported
+#   FEATURE: name of the feature, e.g. "libjpeg"
+#   DESCRIPTION: description what this feature provides
+#   URL: home page
+#   REQUIRED: TRUE or FALSE, indicating whether the featue is required
+#   MIN_VERSION: minimum version number. empty string if unneeded
+#   COMMENTS: More info you may want to provide.  empty string if unnecessary
+#
+# MACRO_DISPLAY_FEATURE_LOG()
+#   Call this to display the collected results.
+#   Exits CMake with a FATAL error message if a required feature is missing
+#
+# Example:
+#
+# INCLUDE(MacroLogFeature)
+#
+# FIND_PACKAGE(JPEG)
+# MACRO_LOG_FEATURE(JPEG_FOUND "libjpeg" "Support JPEG images" "http://www.ijg.org" TRUE "3.2a" "")
+# ...
+# MACRO_DISPLAY_FEATURE_LOG()
+
+# Copyright (c) 2006, Alexander Neundorf, <neundorf@kde.org>
+# Copyright (c) 2006, Allen Winter, <winter@kde.org>
+# Copyright (c) 2009, Sebastian Trueg, <trueg@kde.org>
+#
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+
+IF (NOT _macroLogFeatureAlreadyIncluded)
+   SET(_file ${CMAKE_BINARY_DIR}/MissingRequirements.txt)
+   IF (EXISTS ${_file})
+      FILE(REMOVE ${_file})
+   ENDIF (EXISTS ${_file})
+
+   SET(_file ${CMAKE_BINARY_DIR}/EnabledFeatures.txt)
+   IF (EXISTS ${_file})
+      FILE(REMOVE ${_file})
+   ENDIF (EXISTS ${_file})
+
+   SET(_file ${CMAKE_BINARY_DIR}/DisabledFeatures.txt)
+   IF (EXISTS ${_file})
+      FILE(REMOVE ${_file})
+  ENDIF (EXISTS ${_file})
+
+  SET(_macroLogFeatureAlreadyIncluded TRUE)
+ENDIF (NOT _macroLogFeatureAlreadyIncluded)
+
+
+MACRO(MACRO_LOG_FEATURE _var _package _description _url ) # _required _minvers _comments)
+
+   STRING(TOUPPER "${ARGV4}" _required)
+   SET(_minvers "${ARGV5}")
+   SET(_comments "${ARGV6}")
+   
+   IF (${_var})
+     SET(_LOGFILENAME ${CMAKE_BINARY_DIR}/EnabledFeatures.txt)
+   ELSE (${_var})
+     IF ("${_required}" STREQUAL "TRUE")
+       SET(_LOGFILENAME ${CMAKE_BINARY_DIR}/MissingRequirements.txt)
+     ELSE ("${_required}" STREQUAL "TRUE")
+       SET(_LOGFILENAME ${CMAKE_BINARY_DIR}/DisabledFeatures.txt)
+     ENDIF ("${_required}" STREQUAL "TRUE")
+   ENDIF (${_var})
+
+   SET(_logtext "   * ${_package}")
+
+   IF (NOT ${_var})
+      IF (${_minvers} MATCHES ".*")
+        SET(_logtext "${_logtext} (${_minvers} or higher)")
+      ENDIF (${_minvers} MATCHES ".*")
+      SET(_logtext "${_logtext}  <${_url}>\n     ")
+   ELSE (NOT ${_var})
+     SET(_logtext "${_logtext} - ")
+   ENDIF (NOT ${_var})
+
+   SET(_logtext "${_logtext}${_description}")
+
+   IF (NOT ${_var})
+      IF (${_comments} MATCHES ".*")
+        SET(_logtext "${_logtext}\n     ${_comments}")
+      ENDIF (${_comments} MATCHES ".*")
+#      SET(_logtext "${_logtext}\n") #double-space missing features?
+   ENDIF (NOT ${_var})
+
+   FILE(APPEND "${_LOGFILENAME}" "${_logtext}\n")
+ 
+ENDMACRO(MACRO_LOG_FEATURE)
+
+
+MACRO(MACRO_DISPLAY_FEATURE_LOG)
+
+   SET(_missingFile ${CMAKE_BINARY_DIR}/MissingRequirements.txt)
+   SET(_enabledFile ${CMAKE_BINARY_DIR}/EnabledFeatures.txt)
+   SET(_disabledFile ${CMAKE_BINARY_DIR}/DisabledFeatures.txt)
+
+   IF (EXISTS ${_missingFile} OR EXISTS ${_enabledFile} OR EXISTS ${_disabledFile})
+     SET(_printSummary TRUE)
+   ENDIF (EXISTS ${_missingFile} OR EXISTS ${_enabledFile} OR EXISTS ${_disabledFile})
+
+   IF(_printSummary)
+     SET(_missingDeps 0)
+     IF (EXISTS ${_enabledFile})
+       FILE(READ ${_enabledFile} _enabled)
+       FILE(REMOVE ${_enabledFile})
+       SET(_summary "${_summary}\n-----------------------------------------------------------------------------\n-- The following external packages were located on your system.\n-- This installation will have the extra features provided by these packages.\n-----------------------------------------------------------------------------\n${_enabled}")
+     ENDIF (EXISTS ${_enabledFile})
+
+
+     IF (EXISTS ${_disabledFile})
+       SET(_missingDeps 1)
+       FILE(READ ${_disabledFile} _disabled)
+       FILE(REMOVE ${_disabledFile})
+       SET(_summary "${_summary}\n-----------------------------------------------------------------------------\n-- The following OPTIONAL packages could NOT be located on your system.\n-- Consider installing them to enable more features from this software.\n-----------------------------------------------------------------------------\n${_disabled}")
+     ENDIF (EXISTS ${_disabledFile})
+
+
+     IF (EXISTS ${_missingFile})
+       SET(_missingDeps 1)
+       FILE(READ ${_missingFile} _requirements)
+       SET(_summary "${_summary}\n-----------------------------------------------------------------------------\n-- The following REQUIRED packages could NOT be located on your system.\n-- You must install these packages before continuing.\n-----------------------------------------------------------------------------\n${_requirements}")
+       FILE(REMOVE ${_missingFile})
+       SET(_haveMissingReq 1)
+     ENDIF (EXISTS ${_missingFile})
+
+
+     IF (NOT ${_missingDeps})
+       SET(_summary "${_summary}\n-----------------------------------------------------------------------------\n-- Congratulations! All external packages have been found.")
+     ENDIF (NOT ${_missingDeps})
+
+
+     MESSAGE(${_summary})
+     MESSAGE("-----------------------------------------------------------------------------\n")
+
+
+     IF(_haveMissingReq)
+       MESSAGE(FATAL_ERROR "Exiting: Missing Requirements")
+     ENDIF(_haveMissingReq)
+
+   ENDIF(_printSummary)
+
+ENDMACRO(MACRO_DISPLAY_FEATURE_LOG)

data/ext/generator/cmake/MacroOptionalAddBindings.cmake

@@ -0,0 +1,47 @@
+# Copyright (c) 2010 Maciej Mrozowski <reavertm@gmail.com>
+#
+# Redistribution and use is allowed according to the terms of the GPL license.
+
+# Conditionally enable bindings.
+# Pass -DDISABLE_<component_name>=ON to disable certain binding even if its dependencies are found.
+# CMake project needs to be set before using this macro.
+# Macro sets following variables:
+#     ${CMAKE_PROJECT_NAME}_ENABLED - list of enabled bindings
+#     ${CMAKE_PROJECT_NAME}_DISABLED - list of disabled bindings
+# Usage:
+#     macro_optional_add_bindings(<component_found> <component_name> <subdir1> [<subdir2> ...])
+#
+# Example:
+#     project(SMOKE)
+#     [...]
+#     macro_optional_add_bindings(NEPOMUK_FOUND "Nepomuk" nepomuk nepomukquery)
+#     [...]
+#     macro_display_bindings_log()
+macro(MACRO_OPTIONAL_ADD_BINDINGS _component_found _component_name)
+    get_property(_PREFIX VARIABLE PROPERTY PROJECT_NAME)
+    if(${_component_found} AND NOT DISABLE_${_component_name})
+        foreach(_subdir ${ARGN})
+            add_subdirectory(${_subdir})
+        endforeach(_subdir ${ARGN})
+        list(APPEND ${_PREFIX}_ENABLED ${_component_name})
+    else(${_component_found} AND NOT DISABLE_${_component_name})
+        list(APPEND ${_PREFIX}_DISABLED ${_component_name})
+    endif(${_component_found} AND NOT DISABLE_${_component_name})
+    set(_PREFIX)
+endmacro(MACRO_OPTIONAL_ADD_BINDINGS)
+
+# Show bindings summary
+# Usage:
+#     macro_display_bindings_log()
+macro(MACRO_DISPLAY_BINDINGS_LOG)
+    get_property(_PREFIX VARIABLE PROPERTY PROJECT_NAME)
+    if (${_PREFIX}_ENABLED)
+        list(SORT ${_PREFIX}_ENABLED)
+    endif (${_PREFIX}_ENABLED)
+    if (${_PREFIX}_DISABLED)
+        list(SORT ${_PREFIX}_DISABLED)
+    endif (${_PREFIX}_DISABLED)
+    message(STATUS "Build ${_PREFIX} bindings: ${${_PREFIX}_ENABLED}")
+    message(STATUS "Skip ${_PREFIX} bindings: ${${_PREFIX}_DISABLED}")
+    set(_PREFIX)
+endmacro(MACRO_DISPLAY_BINDINGS_LOG)

data/ext/generator/cmake/MacroOptionalFindPackage.cmake

@@ -0,0 +1,28 @@
+# - MACRO_OPTIONAL_FIND_PACKAGE() combines FIND_PACKAGE() with an OPTION()
+# MACRO_OPTIONAL_FIND_PACKAGE( <name> [QUIT] )
+# This macro is a combination of OPTION() and FIND_PACKAGE(), it
+# works like FIND_PACKAGE(), but additionally it automatically creates
+# an option name WITH_<name>, which can be disabled via the cmake GUI.
+# or via -DWITH_<name>=OFF
+# The standard <name>_FOUND variables can be used in the same way
+# as when using the normal FIND_PACKAGE()
+
+# Copyright (c) 2006, Alexander Neundorf, <neundorf@kde.org>
+#
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+
+
+macro (MACRO_OPTIONAL_FIND_PACKAGE _name )
+   option(WITH_${_name} "Search for ${_name} package" ON)
+   if (WITH_${_name})
+      find_package(${_name} ${ARGN})
+   else (WITH_${_name})
+      set(${_name}_FOUND)
+      set(${_name}_INCLUDE_DIR)
+      set(${_name}_INCLUDES)
+      set(${_name}_LIBRARY)
+      set(${_name}_LIBRARIES)
+   endif (WITH_${_name})
+endmacro (MACRO_OPTIONAL_FIND_PACKAGE)
+