rock-qtbindings 4.8.6.5

data/ext/generator/cmake/FindLibraryWithDebug.cmake

@@ -0,0 +1,113 @@
+#
+#  FIND_LIBRARY_WITH_DEBUG
+#  -> enhanced FIND_LIBRARY to allow the search for an
+#     optional debug library with a WIN32_DEBUG_POSTFIX similar
+#     to CMAKE_DEBUG_POSTFIX when creating a shared lib
+#     it has to be the second and third argument
+
+# Copyright (c) 2007, Christian Ehrlicher, <ch.ehrlicher@gmx.de>
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+
+MACRO(FIND_LIBRARY_WITH_DEBUG var_name win32_dbg_postfix_name dgb_postfix libname)
+
+  IF(NOT "${win32_dbg_postfix_name}" STREQUAL "WIN32_DEBUG_POSTFIX")
+
+     # no WIN32_DEBUG_POSTFIX -> simply pass all arguments to FIND_LIBRARY
+     FIND_LIBRARY(${var_name}
+                  ${win32_dbg_postfix_name}
+                  ${dgb_postfix}
+                  ${libname}
+                  ${ARGN}
+     )
+
+  ELSE(NOT "${win32_dbg_postfix_name}" STREQUAL "WIN32_DEBUG_POSTFIX")
+
+    IF(NOT WIN32)
+      # on non-win32 we don't need to take care about WIN32_DEBUG_POSTFIX
+
+      FIND_LIBRARY(${var_name} ${libname} ${ARGN})
+
+    ELSE(NOT WIN32)
+
+      # 1. get all possible libnames
+      SET(args ${ARGN})
+      SET(newargs "")
+      SET(libnames_release "")
+      SET(libnames_debug "")
+
+      LIST(LENGTH args listCount)
+
+      IF("${libname}" STREQUAL "NAMES")
+        SET(append_rest 0)
+        LIST(APPEND args " ")
+
+        FOREACH(i RANGE ${listCount})
+          LIST(GET args ${i} val)
+
+          IF(append_rest)
+            LIST(APPEND newargs ${val})
+          ELSE(append_rest)
+            IF("${val}" STREQUAL "PATHS")
+              LIST(APPEND newargs ${val})
+              SET(append_rest 1)
+            ELSE("${val}" STREQUAL "PATHS")
+              LIST(APPEND libnames_release "${val}")
+              LIST(APPEND libnames_debug   "${val}${dgb_postfix}")
+            ENDIF("${val}" STREQUAL "PATHS")
+          ENDIF(append_rest)
+
+        ENDFOREACH(i)
+
+      ELSE("${libname}" STREQUAL "NAMES")
+
+        # just one name
+        LIST(APPEND libnames_release "${libname}")
+        LIST(APPEND libnames_debug   "${libname}${dgb_postfix}")
+
+        SET(newargs ${args})
+
+      ENDIF("${libname}" STREQUAL "NAMES")
+
+      # search the release lib
+      FIND_LIBRARY(${var_name}_RELEASE
+                   NAMES ${libnames_release}
+                   ${newargs}
+      )
+
+      # search the debug lib
+      FIND_LIBRARY(${var_name}_DEBUG
+                   NAMES ${libnames_debug}
+                   ${newargs}
+      )
+
+      IF(${var_name}_RELEASE AND ${var_name}_DEBUG)
+
+        # both libs found
+        SET(${var_name} optimized ${${var_name}_RELEASE}
+                        debug     ${${var_name}_DEBUG})
+
+      ELSE(${var_name}_RELEASE AND ${var_name}_DEBUG)
+
+        IF(${var_name}_RELEASE)
+
+          # only release found
+          SET(${var_name} ${${var_name}_RELEASE})
+
+        ELSE(${var_name}_RELEASE)
+
+          # only debug (or nothing) found
+          SET(${var_name} ${${var_name}_DEBUG})
+
+        ENDIF(${var_name}_RELEASE)
+       
+      ENDIF(${var_name}_RELEASE AND ${var_name}_DEBUG)
+
+      MARK_AS_ADVANCED(${var_name}_RELEASE)
+      MARK_AS_ADVANCED(${var_name}_DEBUG)
+
+    ENDIF(NOT WIN32)
+
+  ENDIF(NOT "${win32_dbg_postfix_name}" STREQUAL "WIN32_DEBUG_POSTFIX")
+
+ENDMACRO(FIND_LIBRARY_WITH_DEBUG)

data/ext/generator/cmake/FindPhonon.cmake

@@ -0,0 +1,71 @@
+# Find libphonon
+# Once done this will define
+#
+#  PHONON_FOUND    - system has Phonon Library
+#  PHONON_INCLUDES - the Phonon include directory
+#  PHONON_LIBS     - link these to use Phonon
+#  PHONON_VERSION  - the version of the Phonon Library
+
+# Copyright (c) 2008, Matthias Kretz <kretz@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(_phonon_find_version)
+   set(_phonon_namespace_header_file "${PHONON_INCLUDE_DIR}/phonon/phononnamespace.h")
+   if (APPLE AND EXISTS "${PHONON_INCLUDE_DIR}/Headers/phononnamespace.h")
+      set(_phonon_namespace_header_file "${PHONON_INCLUDE_DIR}/Headers/phononnamespace.h")
+   endif (APPLE AND EXISTS "${PHONON_INCLUDE_DIR}/Headers/phononnamespace.h")
+   file(READ ${_phonon_namespace_header_file} _phonon_header LIMIT 5000 OFFSET 1000)
+   string(REGEX MATCH "define PHONON_VERSION_STR \"(4\\.[0-9]+\\.[0-9a-z]+)\"" _phonon_version_match "${_phonon_header}")
+   set(PHONON_VERSION "${CMAKE_MATCH_1}")
+   message(STATUS "Phonon Version: ${PHONON_VERSION}")
+endmacro(_phonon_find_version)
+
+if(PHONON_FOUND)
+   # Already found, nothing more to do except figuring out the version
+   _phonon_find_version()
+else(PHONON_FOUND)
+   if(PHONON_INCLUDE_DIR AND PHONON_LIBRARY)
+      set(PHONON_FIND_QUIETLY TRUE)
+   endif(PHONON_INCLUDE_DIR AND PHONON_LIBRARY)
+
+   # As discussed on kde-buildsystem: first look at CMAKE_PREFIX_PATH, then at the suggested PATHS (kde4 install dir)
+   find_library(PHONON_LIBRARY NAMES phonon PATHS ${KDE4_LIB_INSTALL_DIR} ${QT_LIBRARY_DIR} NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH)
+   # then at the default system locations (CMAKE_SYSTEM_PREFIX_PATH, i.e. /usr etc.)
+   find_library(PHONON_LIBRARY NAMES phonon)
+
+   find_path(PHONON_INCLUDE_DIR NAMES phonon/phonon_export.h PATHS ${KDE4_INCLUDE_INSTALL_DIR} ${QT_INCLUDE_DIR} ${INCLUDE_INSTALL_DIR} ${QT_LIBRARY_DIR} NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH)
+   find_path(PHONON_INCLUDE_DIR NAMES phonon/phonon_export.h)
+
+   if(PHONON_INCLUDE_DIR AND PHONON_LIBRARY)
+      set(PHONON_LIBS ${phonon_LIB_DEPENDS} ${PHONON_LIBRARY})
+      set(PHONON_INCLUDES ${PHONON_INCLUDE_DIR}/KDE ${PHONON_INCLUDE_DIR})
+      set(PHONON_FOUND TRUE)
+      _phonon_find_version()
+   else(PHONON_INCLUDE_DIR AND PHONON_LIBRARY)
+      set(PHONON_FOUND FALSE)
+   endif(PHONON_INCLUDE_DIR AND PHONON_LIBRARY)
+
+   if(PHONON_FOUND)
+      if(NOT PHONON_FIND_QUIETLY)
+         message(STATUS "Found Phonon: ${PHONON_LIBRARY}")
+         message(STATUS "Found Phonon Includes: ${PHONON_INCLUDES}")
+      endif(NOT PHONON_FIND_QUIETLY)
+   else(PHONON_FOUND)
+      if(Phonon_FIND_REQUIRED)
+         if(NOT PHONON_INCLUDE_DIR)
+            message(STATUS "Phonon includes NOT found!")
+         endif(NOT PHONON_INCLUDE_DIR)
+         if(NOT PHONON_LIBRARY)
+            message(STATUS "Phonon library NOT found!")
+         endif(NOT PHONON_LIBRARY)
+         message(FATAL_ERROR "Phonon library or includes NOT found!")
+      else(Phonon_FIND_REQUIRED)
+         message(STATUS "Unable to find Phonon")
+      endif(Phonon_FIND_REQUIRED)
+   endif(PHONON_FOUND)
+
+
+   mark_as_advanced(PHONON_INCLUDE_DIR PHONON_LIBRARY PHONON_INCLUDES)
+endif(PHONON_FOUND)

data/ext/generator/cmake/FindQImageBlitz.cmake

@@ -0,0 +1,51 @@
+# - Try to find the qimageblitz lib
+# Once done this will define
+#
+#  QIMAGEBLITZ_FOUND - system has qimageblitz lib
+#  QIMAGEBLITZ_INCLUDES - the qimageblitz include directory
+#  QIMAGEBLITZ_LIBRARIES - The libraries needed to use qimageblitz
+
+# Copyright (c) 2006, Montel Laurent, <montel@kde.org>
+# Copyright (c) 2007, Allen Winter, <winter@kde.org>
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+
+include(FindLibraryWithDebug)
+
+if (QIMAGEBLITZ_INCLUDES AND QIMAGEBLITZ_LIBRARIES)
+  set(QImageBlitz_FIND_QUIETLY TRUE)
+endif (QIMAGEBLITZ_INCLUDES AND QIMAGEBLITZ_LIBRARIES)
+
+if (NOT WIN32)
+    # use pkg-config to get the directories and then use these values
+    # in the FIND_PATH() and FIND_LIBRARY() calls
+    find_package(PkgConfig)
+    pkg_check_modules(PC_QIMAGEBLITZ QUIET qimageblitz)
+endif (NOT WIN32)
+
+find_path(QIMAGEBLITZ_INCLUDES
+  NAMES
+  qimageblitz.h
+  PATH_SUFFIXES qimageblitz
+  HINTS
+  $ENV{QIMAGEBLITZDIR}/include
+  ${PC_QIMAGEBLITZ_INCLUDEDIR}
+  ${KDE4_INCLUDE_DIR}
+  ${INCLUDE_INSTALL_DIR}
+)
+
+find_library_with_debug(QIMAGEBLITZ_LIBRARIES
+  WIN32_DEBUG_POSTFIX d
+  qimageblitz
+  HINTS
+  $ENV{QIMAGEBLITZDIR}/lib
+  ${PC_QIMAGEBLITZ_LIBDIR}
+  ${KDE4_LIB_DIR}
+  ${LIB_INSTALL_DIR}
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(QImageBlitz DEFAULT_MSG 
+                                  QIMAGEBLITZ_INCLUDES QIMAGEBLITZ_LIBRARIES)
+
+mark_as_advanced(QIMAGEBLITZ_INCLUDES QIMAGEBLITZ_LIBRARIES)

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)