rock-qtbindings 4.8.6.5

data/ext/cmake/modules/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/cmake/modules/FindRuby.cmake

@@ -0,0 +1,279 @@
+# - Find Ruby
+# This module finds if Ruby is installed and determines where the include files
+# and libraries are. Ruby 1.8 and 1.9 are supported. The minimum required version 
+# specified in the find_package() command is honored.
+# It also determines what the name of the library is. This
+# code sets the following variables:
+#
+#  RUBY_EXECUTABLE   = full path to the ruby binary
+#  RUBY_INCLUDE_DIRS = include dirs to be used when using the ruby library
+#  RUBY_LIBRARY      = full path to the ruby library
+#  RUBY_VERSION      = the version of ruby which was found, e.g. "1.8.7"
+#  RUBY_FOUND        = set to true if ruby ws found successfully
+#
+#  RUBY_INCLUDE_PATH = same as RUBY_INCLUDE_DIRS, only provided for compatibility reasons, don't use it
+
+#=============================================================================
+# Copyright 2004-2009 Kitware, Inc.
+# Copyright 2008-2009 Alexander Neundorf <neundorf@kde.org>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distributed this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+#   RUBY_ARCHDIR=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"archdir"@:>@)'`
+#   RUBY_SITEARCHDIR=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"sitearchdir"@:>@)'`
+#   RUBY_SITEDIR=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"sitelibdir"@:>@)'`
+#   RUBY_LIBDIR=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"libdir"@:>@)'`
+#   RUBY_LIBRUBYARG=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"LIBRUBYARG_SHARED"@:>@)'`
+
+# uncomment the following line to get debug output for this file
+SET(_RUBY_DEBUG_OUTPUT TRUE)
+
+# Set this so the .rvm rubies will beat the system ruby on Mac OSX
+SET(CMAKE_FIND_FRAMEWORK LAST)
+
+# Determine the list of possible names of the ruby executable depending
+# on which version of ruby is required
+SET(_RUBY_POSSIBLE_EXECUTABLE_NAMES ruby)
+
+# if 1.9 is required, don't look for ruby18 and ruby1.8, default to version 1.8
+IF(Ruby_FIND_VERSION_MAJOR  AND  Ruby_FIND_VERSION_MINOR)
+   SET(Ruby_FIND_VERSION_SHORT_NODOT "${Ruby_FIND_VERSION_MAJOR}${RUBY_FIND_VERSION_MINOR}")
+ELSE(Ruby_FIND_VERSION_MAJOR  AND  Ruby_FIND_VERSION_MINOR)
+   SET(Ruby_FIND_VERSION_SHORT_NODOT "18")
+ENDIF(Ruby_FIND_VERSION_MAJOR  AND  Ruby_FIND_VERSION_MINOR)
+
+SET(_RUBY_POSSIBLE_EXECUTABLE_NAMES ${_RUBY_POSSIBLE_EXECUTABLE_NAMES} ruby1.9 ruby19 ruby1.9.1 ruby191 ruby1.9.2 ruby192)
+
+# if we want a version below 1.9, also look for ruby 1.8
+IF("${Ruby_FIND_VERSION_SHORT_NODOT}" VERSION_LESS "19")
+   SET(_RUBY_POSSIBLE_EXECUTABLE_NAMES ${_RUBY_POSSIBLE_EXECUTABLE_NAMES} ruby1.8 ruby18)
+ENDIF("${Ruby_FIND_VERSION_SHORT_NODOT}" VERSION_LESS "19")
+
+FIND_PROGRAM(RUBY_EXECUTABLE NAMES ${_RUBY_POSSIBLE_EXECUTABLE_NAMES})
+
+
+IF(RUBY_EXECUTABLE  AND NOT  RUBY_MAJOR_VERSION)
+  # query the ruby version
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['MAJOR']"
+      OUTPUT_VARIABLE RUBY_VERSION_MAJOR)
+
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['MINOR']"
+      OUTPUT_VARIABLE RUBY_VERSION_MINOR)
+
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['TEENY']"
+      OUTPUT_VARIABLE RUBY_VERSION_PATCH)
+
+   # query the different directories
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['archdir']"
+      OUTPUT_VARIABLE RUBY_ARCH_DIR)
+
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['arch']"
+      OUTPUT_VARIABLE RUBY_ARCH)
+
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['rubyhdrdir']"
+      OUTPUT_VARIABLE RUBY_HDR_DIR)
+
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['rubyarchhdrdir']"
+      OUTPUT_VARIABLE RUBY_ARCH_HDR_DIR)
+
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['libdir']"
+      OUTPUT_VARIABLE RUBY_LIB_DIR)
+
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['archlibdir']"
+      OUTPUT_VARIABLE RUBY_ARCH_LIB_DIR)
+
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['rubylibdir']"
+      OUTPUT_VARIABLE RUBY_RUBY_LIB_DIR)
+
+   # site_ruby
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['sitearchdir']"
+      OUTPUT_VARIABLE RUBY_SITEARCH_DIR)
+
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['sitelibdir']"
+      OUTPUT_VARIABLE RUBY_SITELIB_DIR)
+
+   # vendor_ruby available ?
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r vendor-specific -e "print 'true'"
+      OUTPUT_VARIABLE RUBY_HAS_VENDOR_RUBY  ERROR_QUIET)
+
+   IF(RUBY_HAS_VENDOR_RUBY)
+      EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['vendorlibdir']"
+         OUTPUT_VARIABLE RUBY_VENDORLIB_DIR)
+
+      EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['vendorarchdir']"
+         OUTPUT_VARIABLE RUBY_VENDORARCH_DIR)
+   ENDIF(RUBY_HAS_VENDOR_RUBY)
+
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['RUBY_SO_NAME']"
+       OUTPUT_VARIABLE RUBY_SONAME)
+
+   # save the results in the cache so we don't have to run ruby the next time again
+   SET(RUBY_VERSION_MAJOR    ${RUBY_VERSION_MAJOR}    CACHE PATH "The Ruby major version" FORCE)
+   SET(RUBY_VERSION_MINOR    ${RUBY_VERSION_MINOR}    CACHE PATH "The Ruby minor version" FORCE)
+   SET(RUBY_VERSION_PATCH    ${RUBY_VERSION_PATCH}    CACHE PATH "The Ruby patch version" FORCE)
+   SET(RUBY_ARCH_DIR         ${RUBY_ARCH_DIR}         CACHE PATH "The Ruby arch dir" FORCE)
+   SET(RUBY_HDR_DIR          ${RUBY_HDR_DIR}          CACHE PATH "The Ruby header dir (1.9)" FORCE)
+   SET(RUBY_ARCH_HDR_DIR     ${RUBY_ARCH_HDR_DIR}     CACHE PATH "The Ruby header dir for architecture-specific headers" FORCE)
+   SET(RUBY_LIB_DIR          ${RUBY_LIB_DIR}          CACHE PATH "The Ruby base lib dir" FORCE)
+   SET(RUBY_ARCH_LIB_DIR     ${RUBY_ARCH_LIB_DIR}     CACHE PATH "The Ruby architecture-specific lib dir" FORCE)
+   SET(RUBY_RUBY_LIB_DIR     ${RUBY_RUBY_LIB_DIR}     CACHE PATH "The Ruby ruby-lib dir" FORCE)
+   SET(RUBY_SITEARCH_DIR     ${RUBY_SITEARCH_DIR}     CACHE PATH "The Ruby site arch dir" FORCE)
+   SET(RUBY_SITELIB_DIR      ${RUBY_SITELIB_DIR}      CACHE PATH "The Ruby site lib dir" FORCE)
+   SET(RUBY_HAS_VENDOR_RUBY  ${RUBY_HAS_VENDOR_RUBY}  CACHE BOOL "Vendor Ruby is available" FORCE)
+   SET(RUBY_VENDORARCH_DIR   ${RUBY_VENDORARCH_DIR}   CACHE PATH "The Ruby vendor arch dir" FORCE)
+   SET(RUBY_VENDORLIB_DIR    ${RUBY_VENDORLIB_DIR}    CACHE PATH "The Ruby vendor lib dir" FORCE)
+   SET(RUBY_SONAME           ${RUBY_SONAME}           CACHE PATH "The Ruby library's .so name" FORCE)
+
+   MARK_AS_ADVANCED(
+     RUBY_ARCH_DIR
+     RUBY_ARCH
+     RUBY_HDR_DIR
+     RUBY_ARCH_HDR_DIR
+     RUBY_LIB_DIR
+     RUBY_ARCH_LIB_DIR
+     RUBY_RUBY_LIB_DIR
+     RUBY_SITEARCH_DIR
+     RUBY_SITELIB_DIR
+     RUBY_HAS_VENDOR_RUBY
+     RUBY_VENDORARCH_DIR
+     RUBY_VENDORLIB_DIR
+     RUBY_VERSION_MAJOR
+     RUBY_VERSION_MINOR
+     RUBY_VERSION_PATCH
+     RUBY_SONAME
+     )
+ENDIF(RUBY_EXECUTABLE  AND NOT  RUBY_MAJOR_VERSION)
+
+# In case RUBY_EXECUTABLE could not be executed (e.g. cross compiling) 
+# try to detect which version we found. This is not too good.
+IF(NOT RUBY_VERSION_MAJOR)
+   # by default assume 1.8.0
+   SET(RUBY_VERSION_MAJOR 1)
+   SET(RUBY_VERSION_MINOR 8)
+   SET(RUBY_VERSION_PATCH 0)
+   # check whether we found 1.9.x
+   IF(${RUBY_EXECUTABLE} MATCHES "ruby1.?9"  OR  RUBY_HDR_DIR)
+      SET(RUBY_VERSION_MAJOR 1)
+      SET(RUBY_VERSION_MINOR 9)
+   ENDIF(${RUBY_EXECUTABLE} MATCHES "ruby1.?9"  OR  RUBY_HDR_DIR)
+ENDIF(NOT RUBY_VERSION_MAJOR)
+
+
+SET(RUBY_VERSION "${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}.${RUBY_VERSION_PATCH}")
+SET(_RUBY_VERSION_SHORT "${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}")
+SET(_RUBY_VERSION_SHORT_NODOT "${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}")
+SET(_RUBY_VERSION_LONG_NODOT "${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}${RUBY_VERSION_PATCH}")
+
+# Now we know which version we found
+IF(Ruby_FIND_VERSION)
+   IF(${RUBY_VERSION}  VERSION_LESS  ${Ruby_FIND_VERSION})
+      # force running ruby the next time again
+      SET(RUBY_VERSION_MAJOR    ""    CACHE PATH "The Ruby major version" FORCE)
+      IF(Ruby_FIND_REQUIRED)
+         MESSAGE(FATAL_ERROR "Ruby version ${Ruby_FIND_VERSION} required, but only version ${RUBY_VERSION} found.")
+      ELSE(Ruby_FIND_REQUIRED)
+         IF(NOT Ruby_FIND_QUIETLY)
+            MESSAGE(STATUS "Ruby version ${Ruby_FIND_VERSION} required, but only version ${RUBY_VERSION} found.")
+         ENDIF(NOT Ruby_FIND_QUIETLY)
+         RETURN()
+      ENDIF(Ruby_FIND_REQUIRED)
+   ENDIF(${RUBY_VERSION}  VERSION_LESS  ${Ruby_FIND_VERSION})
+ENDIF(Ruby_FIND_VERSION)
+
+FIND_PATH(RUBY_INCLUDE_DIR
+   NAMES ruby.h
+   HINTS
+   ${RUBY_HDR_DIR}
+   ${RUBY_ARCH_DIR}
+   ${RUBY_ARCH_HDR_DIR}
+   /usr/lib/ruby/${_RUBY_VERSION_SHORT}/i586-linux-gnu/ )
+
+SET(RUBY_INCLUDE_DIRS ${RUBY_INCLUDE_DIR} )
+
+# if ruby > 1.8 is required or if ruby > 1.8 was found, search for the config.h dir
+IF( ${Ruby_FIND_VERSION_SHORT_NODOT} GREATER 18  OR  ${_RUBY_VERSION_SHORT_NODOT} GREATER 18  OR  RUBY_HDR_DIR)
+   message(STATUS "looking for config.h")
+   FIND_PATH(RUBY_CONFIG_INCLUDE_DIR
+     NAMES ruby/config.h  config.h
+     HINTS 
+     ${RUBY_ARCH_HDR_DIR}
+     ${RUBY_HDR_DIR}/${RUBY_ARCH}
+     ${RUBY_ARCH_DIR} 
+     )
+
+   SET(RUBY_INCLUDE_DIRS ${RUBY_INCLUDE_DIRS} ${RUBY_CONFIG_INCLUDE_DIR} )
+ENDIF( ${Ruby_FIND_VERSION_SHORT_NODOT} GREATER 18  OR  ${_RUBY_VERSION_SHORT_NODOT} GREATER 18  OR  RUBY_HDR_DIR)
+
+
+# Determine the list of possible names for the ruby library
+SET(_RUBY_POSSIBLE_LIB_NAMES ${RUBY_SONAME} ruby ruby-static ruby${_RUBY_VERSION_SHORT} ruby${_RUBY_VERSION_SHORT_NODOT} ruby-${RUBY_VERSION})
+
+IF(WIN32)
+   SET( _RUBY_MSVC_RUNTIME "" )
+   IF( MSVC60 )
+     SET( _RUBY_MSVC_RUNTIME "60" )
+   ENDIF( MSVC60 )
+   IF( MSVC70 )
+     SET( _RUBY_MSVC_RUNTIME "70" )
+   ENDIF( MSVC70 )
+   IF( MSVC71 )
+     SET( _RUBY_MSVC_RUNTIME "71" )
+   ENDIF( MSVC71 )
+   IF( MSVC80 )
+     SET( _RUBY_MSVC_RUNTIME "80" )
+   ENDIF( MSVC80 )
+   IF( MSVC90 )
+     SET( _RUBY_MSVC_RUNTIME "90" )
+   ENDIF( MSVC90 )
+
+   LIST(APPEND _RUBY_POSSIBLE_LIB_NAMES
+               "msvcr${_RUBY_MSVC_RUNTIME}-ruby${_RUBY_VERSION_SHORT_NODOT}"
+               "msvcr${_RUBY_MSVC_RUNTIME}-ruby${_RUBY_VERSION_SHORT_NODOT}-static" 
+               "msvcrt-ruby${_RUBY_VERSION_SHORT_NODOT}"
+               "msvcrt-ruby${_RUBY_VERSION_SHORT_NODOT}-static"
+               "msvcrt-ruby${_RUBY_VERSION_LONG_NODOT}"
+               "msvcrt-ruby${_RUBY_VERSION_LONG_NODOT}-static" )               
+ENDIF(WIN32)
+
+FIND_LIBRARY(RUBY_LIBRARY NAMES ${_RUBY_POSSIBLE_LIB_NAMES} HINTS ${RUBY_ARCH_LIB_DIR} ${RUBY_LIB_DIR})
+
+INCLUDE(FindPackageHandleStandardArgs)
+SET(_RUBY_REQUIRED_VARS RUBY_EXECUTABLE RUBY_INCLUDE_DIR RUBY_LIBRARY)
+IF(_RUBY_VERSION_SHORT_NODOT GREATER 18)
+   LIST(APPEND _RUBY_REQUIRED_VARS RUBY_CONFIG_INCLUDE_DIR)
+ENDIF(_RUBY_VERSION_SHORT_NODOT GREATER 18)
+
+IF(_RUBY_DEBUG_OUTPUT)
+   MESSAGE(STATUS "--------FindRuby.cmake debug------------")
+   MESSAGE(STATUS "_RUBY_POSSIBLE_EXECUTABLE_NAMES: ${_RUBY_POSSIBLE_EXECUTABLE_NAMES}")
+   MESSAGE(STATUS "_RUBY_POSSIBLE_LIB_NAMES: ${_RUBY_POSSIBLE_LIB_NAMES}")
+   MESSAGE(STATUS "RUBY_ARCH_DIR: ${RUBY_ARCH_DIR}")
+   MESSAGE(STATUS "RUBY_HDR_DIR: ${RUBY_HDR_DIR}")
+   MESSAGE(STATUS "RUBY_POSSIBLE_LIB_DIR: ${RUBY_POSSIBLE_LIB_DIR}")
+   MESSAGE(STATUS "Found RUBY_VERSION: \"${RUBY_VERSION}\" , short: \"${_RUBY_VERSION_SHORT}\", nodot: \"${_RUBY_VERSION_SHORT_NODOT}\"")
+   MESSAGE(STATUS "_RUBY_REQUIRED_VARS: ${_RUBY_REQUIRED_VARS}")
+   MESSAGE(STATUS "--------------------")
+ENDIF(_RUBY_DEBUG_OUTPUT)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Ruby  DEFAULT_MSG  ${_RUBY_REQUIRED_VARS})
+
+MARK_AS_ADVANCED(
+  RUBY_EXECUTABLE
+  RUBY_LIBRARY
+  RUBY_INCLUDE_DIR
+  RUBY_CONFIG_INCLUDE_DIR
+  )
+
+# Set some variables for compatibility with previous version of this file
+SET(RUBY_POSSIBLE_LIB_PATH ${RUBY_POSSIBLE_LIB_DIR})
+SET(RUBY_RUBY_LIB_PATH ${RUBY_RUBY_LIB_DIR})
+SET(RUBY_INCLUDE_PATH ${RUBY_INCLUDE_DIRS})
+

data/ext/cmake/modules/FindSmoke.cmake

@@ -0,0 +1,78 @@
+# Find smoke libraries.
+#
+# Use:
+#
+# find_package(Smoke [REQUIRED] COMPONENTS QtCore QtGui <other components>)
+#
+# Defines:
+#
+# SMOKE_INCLUDE_DIR                 Directory in which smoke.h is located
+# SMOKE_<component>_INCLUDE_DIR     Directory in which to find smoke/<component>_smoke.h
+# SMOKE_<component>_LIBRARY         Library for the smoke lib
+#
+# Copyright (c) 2010, Arno Rehn <arno@arnorehn.de>
+#
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+
+#####################
+# utility functions #
+#####################
+
+function (_print type message)
+    if (NOT Smoke_FIND_QUIETLY)
+        message (${type} "${message}")
+    endif (NOT Smoke_FIND_QUIETLY)
+endfunction (_print type message)
+
+
+##############################
+# find individual smoke libs #
+##############################
+
+macro (find_smoke_component name)
+    string(TOUPPER ${name} uppercase)
+    string(TOLOWER ${name} lowercase)
+
+    if (NOT SMOKE_${uppercase}_FOUND)
+        set (SMOKE_${uppercase}_FOUND FALSE CACHE INTERNAL "")
+
+        find_path(SMOKE_${uppercase}_INCLUDE_DIR smoke/${lowercase}_smoke.h)
+        find_library(SMOKE_${uppercase}_LIBRARY smoke${lowercase})
+
+        if (NOT SMOKE_${uppercase}_INCLUDE_DIR OR NOT SMOKE_${uppercase}_LIBRARY)
+            if (Smoke_FIND_REQUIRED)
+                _print(FATAL_ERROR "Could not find Smoke${name}")
+            else (Smoke_FIND_REQUIRED)
+                _print(STATUS "Could not find Smoke${name}")
+            endif (Smoke_FIND_REQUIRED)
+        else (NOT SMOKE_${uppercase}_INCLUDE_DIR OR NOT SMOKE_${uppercase}_LIBRARY)
+            set (SMOKE_${uppercase}_FOUND TRUE CACHE INTERNAL "")
+            _print(STATUS "Found Smoke${name}: ${SMOKE_${uppercase}_LIBRARY}")
+        endif (NOT SMOKE_${uppercase}_INCLUDE_DIR OR NOT SMOKE_${uppercase}_LIBRARY)
+
+        mark_as_advanced(SMOKE_${uppercase}_INCLUDE_DIR SMOKE_${uppercase}_LIBRARY SMOKE_${uppercase}_FOUND)
+    endif (NOT SMOKE_${uppercase}_FOUND)
+endmacro (find_smoke_component)
+
+################
+# find smoke.h #
+################
+find_path(SMOKE_INCLUDE_DIR smoke.h)
+find_library(SMOKE_BASE_LIBRARY smokebase)
+
+if (NOT SMOKE_INCLUDE_DIR OR NOT SMOKE_BASE_LIBRARY)
+    if (Smoke_FIND_REQUIRED)
+        _print(FATAL_ERROR "Could not find SMOKE")
+    else (Smoke_FIND_REQUIRED)
+        _print(STATUS "Could not find SMOKE")
+    endif (Smoke_FIND_REQUIRED)
+endif (NOT SMOKE_INCLUDE_DIR OR NOT SMOKE_BASE_LIBRARY)
+
+mark_as_advanced(SMOKE_INCLUDE_DIR SMOKE_BASE_LIBRARY)
+
+if (Smoke_FIND_COMPONENTS)
+    foreach (component ${Smoke_FIND_COMPONENTS})
+        find_smoke_component(${component})
+    endforeach(component)
+endif (Smoke_FIND_COMPONENTS)

data/ext/cmake/modules/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)
+