Revert those files back to rev 882880 to get them into a known working state again,

except FindStrigi.cmake, which seems to be working.
Let's start now cleaning them up step by step.

Alex

CCMAIL: helio@kde.org


svn path=/trunk/KDE/kdelibs/; revision=884355

5 files changed, 405 insertions, 137 deletions

diff --git a/modules/FindExiv2.cmake b/modules/FindExiv2.cmake
index c9d8f539..5bef48be 100644
--- a/modules/FindExiv2.cmake
+++ b/modules/FindExiv2.cmake
@@ -2,42 +2,85 @@
 #
 #  EXIV2_MIN_VERSION - You can set this variable to the minimum version you need 
 #                      before doing FIND_PACKAGE(Exiv2). The default is 0.12.
+# 
+# Once done this will define
+#
+#  EXIV2_FOUND - system has libexiv2
+#  EXIV2_INCLUDE_DIR - the libexiv2 include directory
+#  EXIV2_LIBRARIES - Link these to use libexiv2
+#  EXIV2_DEFINITIONS - Compiler switches required for using libexiv2
 #
-# All definitions come with new cmake macro PKG_CHECK_MODULES
 
-if (EXIV2_INCLUDEDIR AND EXIV2_LIBRARIES)
+if (EXIV2_INCLUDE_DIR AND EXIV2_LIBRARIES)
 
   # in cache already
   set(EXIV2_FOUND TRUE)
 
-else (EXIV2_INCLUDEDIR AND EXIV2_LIBRARIES)
-    if (NOT WIN32)
-        find_package(PkgConfig REQUIRED)
-        
-        if(NOT EXIV2_MIN_VERSION)
-            set(EXIV2_MIN_VERSION "0.12")
-        endif(NOT EXIV2_MIN_VERSION)
-
-        if (Exiv2_FIND_REQUIRED)
-            PKG_CHECK_MODULES(EXIV2 REQUIRED exiv2>=${EXIV2_MIN_VERSION})
-        else (Exiv2_FIND_REQUIRED)
-            PKG_CHECK_MODULES(EXIV2 exiv2>=${EXIV2_MIN_VERSION})
-        endif (Exiv2_FIND_REQUIRED)
-
-        if(NOT EXIV2_FOUND)
-            message(STATUS "Cannot find Exiv2 library!")
-        endif(NOT EXIV2_FOUND)
-    else(NOT WIN32)
-        #Better check
-        set(EXIV2_FOUND TRUE)
-    endif (NOT WIN32)
+else (EXIV2_INCLUDE_DIR AND EXIV2_LIBRARIES)
+  if (NOT WIN32)
+  # use pkg-config to get the directories and then use these values
+  # in the FIND_PATH() and FIND_LIBRARY() calls
+  include(UsePkgConfig)
+
+  if(NOT EXIV2_MIN_VERSION)
+    set(EXIV2_MIN_VERSION "0.12")
+  endif(NOT EXIV2_MIN_VERSION)
+  
+  pkgconfig(exiv2 _EXIV2IncDir _EXIV2LinkDir _EXIV2LinkFlags _EXIV2Cflags)
 
-    if(EXIV2_FOUND)
-        set(EXIV2_DEFINITIONS ${EXIV2_CFLAGS})
-        if (NOT Exiv2_FIND_QUIETLY)
-            message(STATUS "Found Exiv2: ${EXIV2_LIBRARIES}")
-        endif (NOT Exiv2_FIND_QUIETLY)
+  if(_EXIV2LinkFlags)
+    # query pkg-config asking for a Exiv2 >= 0.12
+    exec_program(${PKGCONFIG_EXECUTABLE} ARGS --atleast-version=${EXIV2_MIN_VERSION} exiv2 RETURN_VALUE _return_VALUE OUTPUT_VARIABLE _pkgconfigDevNull )
+    if(_return_VALUE STREQUAL "0")
+      message(STATUS "Found Exiv2 release >= ${EXIV2_MIN_VERSION}")
+      set(EXIV2_VERSION_GOOD_FOUND TRUE)
+    else(_return_VALUE STREQUAL "0")
+      message(STATUS "Found Exiv2 release < ${EXIV2_MIN_VERSION}")
+    endif(_return_VALUE STREQUAL "0")
+  else(_EXIV2LinkFlags)
+      set(EXIV2_FOUND FALSE)
+      set(EXIV2_VERSION_GOOD_FOUND FALSE)
+      message(STATUS "Cannot find Exiv2 library!")
+  endif(_EXIV2LinkFlags)
+  
+  else(NOT WIN32)
+     #Better check
+     set(EXIV2_VERSION_GOOD_FOUND TRUE)
+  endif (NOT WIN32)
+
+  if(EXIV2_VERSION_GOOD_FOUND)
+     set(EXIV2_DEFINITIONS ${_EXIV2Cflags})
+ 
+     find_path(EXIV2_INCLUDE_DIR exiv2/exif.hpp
+       ${_EXIV2IncDir}
+     )
+  
+     find_library(EXIV2_LIBRARIES NAMES exiv2 libexiv2
+       PATHS
+       ${_EXIV2LinkDir}
+     )
+  
+     if (EXIV2_INCLUDE_DIR AND EXIV2_LIBRARIES)
+        set(EXIV2_FOUND TRUE)
+        # TODO version check is missing
+     endif (EXIV2_INCLUDE_DIR AND EXIV2_LIBRARIES)
+   endif(EXIV2_VERSION_GOOD_FOUND)
+   if (EXIV2_FOUND)
+      if (NOT Exiv2_FIND_QUIETLY)
+       message(STATUS "Found Exiv2: ${EXIV2_LIBRARIES}")
+      endif (NOT Exiv2_FIND_QUIETLY)
+   else (EXIV2_FOUND)
+     if (Exiv2_FIND_REQUIRED)
+       if (NOT EXIV2_INCLUDE_DIR)
+         message(FATAL_ERROR "Could NOT find Exiv2 header files")
+       endif (NOT EXIV2_INCLUDE_DIR)
+       if (NOT EXIV2_LIBRARIES)
+           message(FATAL_ERROR "Could NOT find Exiv2 library")
+       endif (NOT EXIV2_LIBRARIES)
+     endif (Exiv2_FIND_REQUIRED)
    endif (EXIV2_FOUND)
 
-endif (EXIV2_INCLUDEDIR AND EXIV2_LIBRARIES)
+  mark_as_advanced(EXIV2_INCLUDE_DIR EXIV2_LIBRARIES)
+  
+endif (EXIV2_INCLUDE_DIR AND EXIV2_LIBRARIES)
 
diff --git a/modules/FindKdcraw.cmake b/modules/FindKdcraw.cmake
index 5527a5f4..f3b33bf8 100644
--- a/modules/FindKdcraw.cmake
+++ b/modules/FindKdcraw.cmake
@@ -1,41 +1,104 @@
-# - Try to find the Kdcraw library using cmake pkg_check_modulesi otherwise fallback to standard search
-# Once done this will define:
+# - Try to find the Kdcraw library
+# Once done this will define
 #
 #  KDCRAW_FOUND - system has libkdcraw
-#  KDCRAW_INCLUDEDIR - the libkdcraw include directory
+#  KDCRAW_INCLUDE_DIR - the libkdcraw include directory
 #  KDCRAW_LIBRARIES - Link these to use libkdcraw
 #  KDCRAW_DEFINITIONS - Compiler switches required for using libkdcraw
+#
+
+if (KDCRAW_INCLUDE_DIR AND KDCRAW_LIBRARIES)
+
+  message(STATUS "Found Kdcraw library in cache: ${KDCRAW_LIBRARIES}")
+
+  # in cache already
+  SET(KDCRAW_FOUND TRUE)
+
+else (KDCRAW_INCLUDE_DIR AND KDCRAW_LIBRARIES)
+
+  message(STATUS "Check Kdcraw library in local sub-folder...")
+
+  # Check if library is not in local sub-folder
+ 
+  FIND_FILE(KDCRAW_LOCAL_FOUND libkdcraw/version.h ${CMAKE_BINARY_DIR}/libkdcraw ${CMAKE_BINARY_DIR}/libs/libkdcraw NO_DEFAULT_PATH)
+
+  if (KDCRAW_LOCAL_FOUND)
 
+    # Was it found in libkdcraw/ or in libs/libkdcraw?
+    FIND_FILE(KDCRAW_LOCAL_FOUND_IN_LIBS libkdcraw/version.h ${CMAKE_BINARY_DIR}/libs/libkdcraw NO_DEFAULT_PATH)
+    if (KDCRAW_LOCAL_FOUND_IN_LIBS)
+      set(KDCRAW_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/libs/libkdcraw)
+    else (KDCRAW_LOCAL_FOUND_IN_LIBS)
+      set(KDCRAW_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/libkdcraw)
+    endif (KDCRAW_LOCAL_FOUND_IN_LIBS)
+    set(KDCRAW_DEFINITIONS "-I${KDCRAW_INCLUDE_DIR}")
+    set(KDCRAW_LIBRARIES kdcraw)
+    message(STATUS "Found Kdcraw library in local sub-folder: ${KDCRAW_INCLUDE_DIR}")
+    set(KDCRAW_FOUND TRUE)
+    MARK_AS_ADVANCED(KDCRAW_INCLUDE_DIR KDCRAW_LIBRARIES)
 
-if (KDCRAW_INCLUDEDIR AND KDCRAW_LIBRARIES)
-    # in cache already
-    SET(KDCRAW_FOUND TRUE)
-else (KDCRAW_INCLUDEDIR AND KDCRAW_LIBRARIES)
+  else(KDCRAW_LOCAL_FOUND)
+
+    message(STATUS "Check Kdcraw library using pkg-config...")
     if(NOT WIN32)
-        find_package(PkgConfig)
-        if(PKG_CONFIG_EXECUTABLE)
-            pkg_check_modules(KDCRAW libkdcraw>=0.2.0)
-        endif(PKG_CONFIG_EXECUTABLE)
-    endif(NOT WIN32)
-
-    if(NOT KDCRAW_FOUND)
-        find_path(KDCRAW_INCLUDEDIR libkdcraw/version.h)
-        find_library(KDCRAW_LIBRARIES NAMES kdcraw)
-        if (KDCRAW_INCLUDEDIR AND KDCRAW_LIBRARIES)
+      # use pkg-config to get the directories and then use these values
+      # in the FIND_PATH() and FIND_LIBRARY() calls
+      INCLUDE(UsePkgConfig)
+    
+      PKGCONFIG(libkdcraw _KDCRAWIncDir _KDCRAWLinkDir _KDCRAWLinkFlags _KDCRAWCflags)
+    
+      if(_KDCRAWLinkFlags)
+        # query pkg-config asking for a libkdcraw >= 0.2.0
+        EXEC_PROGRAM(${PKGCONFIG_EXECUTABLE} ARGS --atleast-version=0.2.0 libkdcraw RETURN_VALUE _return_VALUE OUTPUT_VARIABLE _pkgconfigDevNull )
+        if(_return_VALUE STREQUAL "0")
+            message(STATUS "Found libkdcraw release >= 0.2.0")
+            set(KDCRAW_VERSION_GOOD_FOUND TRUE)
+        else(_return_VALUE STREQUAL "0")
+            message(STATUS "Found libkdcaw release < 0.2.0, too old")
+            set(KDCRAW_VERSION_GOOD_FOUND FALSE)
+            set(KDCRAW_FOUND FALSE)
+        endif(_return_VALUE STREQUAL "0")
+      else(_KDCRAWLinkFlags)
+        set(KDCRAW_VERSION_GOOD_FOUND FALSE)
+        set(KDCRAW_FOUND FALSE)
+      endif(_KDCRAWLinkFlags)
+    ELSE(NOT WIN32)
+      set(KDCRAW_VERSION_GOOD_FOUND TRUE)
+    ENDif(NOT WIN32)
+
+    if(KDCRAW_VERSION_GOOD_FOUND)
+        set(KDCRAW_DEFINITIONS "${_KDCRAWCflags}")
+    
+        FIND_PATH(KDCRAW_INCLUDE_DIR libkdcraw/version.h
+        ${_KDCRAWIncDir}
+        )
+    
+        FIND_LIBRARY(KDCRAW_LIBRARIES NAMES kdcraw
+        PATHS
+        ${_KDCRAWLinkDir}
+        )
+    
+        if (KDCRAW_INCLUDE_DIR AND KDCRAW_LIBRARIES)
             set(KDCRAW_FOUND TRUE)
-        endif (KDCRAW_INCLUDEDIR AND KDCRAW_LIBRARIES)
-    endif(NOT KDCRAW_FOUND)
+        endif (KDCRAW_INCLUDE_DIR AND KDCRAW_LIBRARIES)
+     endif(KDCRAW_VERSION_GOOD_FOUND) 
+     if (KDCRAW_FOUND)
+         if (NOT Kdcraw_FIND_QUIETLY)
+             message(STATUS "Found libkdcraw: ${KDCRAW_LIBRARIES}")
+         endif (NOT Kdcraw_FIND_QUIETLY)
+     else (KDCRAW_FOUND)
+         if (Kdcraw_FIND_REQUIRED)
+             if (NOT KDCRAW_INCLUDE_DIR)
+                 message(FATAL_ERROR "Could NOT find libkdcraw header files")
+             endif (NOT KDCRAW_INCLUDE_DIR)
+             if (NOT KDCRAW_LIBRARIES)
+                 message(FATAL_ERROR "Could NOT find libkdcraw library")
+             endif (NOT KDCRAW_LIBRARIES)
+         endif (Kdcraw_FIND_REQUIRED)
+     endif (KDCRAW_FOUND)
     
-    if(KDCRAW_FOUND)
-        set(KDCRAW_DEFINITIONS ${KDCRAW_CFLAGS})
-        if (NOT Kdcraw_FIND_QUIETLY)
-            message(STATUS "Found libkdcraw: ${KDCRAW_LIBRARIES}")
-        endif (NOT Kdcraw_FIND_QUIETLY)
-        set(KDCRAW_INCLUDE_DIR ${KDCRAW_INCLUDEDIR})
-        mark_as_advanced( KDCRAW_INCLUDE_DIR )
-    else(KDCRAW_FOUND)
-        if (Kdcraw_FIND_REQUIRED)
-            message(FATAL_ERROR "Not found required libkdcraw")
-        endif (Kdcraw_FIND_REQUIRED)
-    endif (KDCRAW_FOUND)
-endif (KDCRAW_INCLUDEDIR AND KDCRAW_LIBRARIES)
+    MARK_AS_ADVANCED(KDCRAW_INCLUDE_DIR KDCRAW_LIBRARIES)
+
+  endif(KDCRAW_LOCAL_FOUND)
+  
+endif (KDCRAW_INCLUDE_DIR AND KDCRAW_LIBRARIES)
diff --git a/modules/FindKexiv2.cmake b/modules/FindKexiv2.cmake
index 739f187d..c57ed1c2 100644
--- a/modules/FindKexiv2.cmake
+++ b/modules/FindKexiv2.cmake
@@ -1,41 +1,103 @@
-# - Try to find the Kexiv2 library using cmake pkg_check_modulesi otherwise fallback to standard search
-# Once done this will define:
+# - Try to find the KExiv2 library
+# Once done this will define
 #
 #  KEXIV2_FOUND - system has libkexiv2
-#  KEXIV2_INCLUDEDIR - the libkexiv2 include directory
+#  KEXIV2_INCLUDE_DIR - the libkexiv2 include directory
 #  KEXIV2_LIBRARIES - Link these to use libkexiv2
 #  KEXIV2_DEFINITIONS - Compiler switches required for using libkexiv2
+#
+
+if (KEXIV2_INCLUDE_DIR AND KEXIV2_LIBRARIES)
+
+  message(STATUS "Found Kexiv2 library in cache: ${KEXIV2_LIBRARIES}")
+
+  # in cache already
+  SET(KEXIV2_FOUND TRUE)
+
+else (KEXIV2_INCLUDE_DIR AND KEXIV2_LIBRARIES)
+
+  message(STATUS "Check Kexiv2 library in local sub-folder...")
+
+  # Check if library is not in local sub-folder
+
+  FIND_FILE(KEXIV2_LOCAL_FOUND libkexiv2/version.h.cmake ${CMAKE_SOURCE_DIR}/libkexiv2 ${CMAKE_SOURCE_DIR}/libs/libkexiv2 NO_DEFAULT_PATH)
 
+  if (KEXIV2_LOCAL_FOUND)
 
-if (KEXIV2_INCLUDEDIR AND KEXIV2_LIBRARIES)
-    # in cache already
-    SET(KEXIV2_FOUND TRUE)
-else (KEXIV2_INCLUDEDIR AND KEXIV2_LIBRARIES)
-    if(NOT WIN32)
-        find_package(PkgConfig)
-        if(PKG_CONFIG_EXECUTABLE)
-            pkg_check_modules(KEXIV2 libkexiv2>=0.2.0)
-        endif(PKG_CONFIG_EXECUTABLE)
+    FIND_FILE(KEXIV2_LOCAL_FOUND_IN_LIBS libkexiv2/version.h.cmake ${CMAKE_SOURCE_DIR}/libs/libkexiv2 NO_DEFAULT_PATH)
+    if (KEXIV2_LOCAL_FOUND_IN_LIBS)
+      set(KEXIV2_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/libs/libkexiv2)
+    else (KEXIV2_LOCAL_FOUND_IN_LIBS)
+      set(KEXIV2_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/libkexiv2)
+    endif (KEXIV2_LOCAL_FOUND_IN_LIBS)
+    set(KEXIV2_DEFINITIONS "-I${KEXIV2_INCLUDE_DIR}")
+    set(KEXIV2_LIBRARIES kexiv2)
+    message(STATUS "Found Kexiv2 library in local sub-folder: ${KEXIV2_INCLUDE_DIR}")
+    set(KEXIV2_FOUND TRUE)
+    MARK_AS_ADVANCED(KEXIV2_INCLUDE_DIR KEXIV2_LIBRARIES)
+
+  else(KEXIV2_LOCAL_FOUND)
+    if(NOT WIN32) 
+      message(STATUS "Check Kexiv2 library using pkg-config...")
+
+      # use pkg-config to get the directories and then use these values
+      # in the FIND_PATH() and FIND_LIBRARY() calls
+      INCLUDE(UsePkgConfig)
+    
+      PKGCONFIG(libkexiv2 _KEXIV2IncDir _KEXIV2LinkDir _KEXIV2LinkFlags _KEXIV2Cflags)
+    
+      if(_KEXIV2LinkFlags)
+        # query pkg-config asking for a libkexiv2 >= 0.2.0
+        EXEC_PROGRAM(${PKGCONFIG_EXECUTABLE} ARGS --atleast-version=0.2.0 libkexiv2 RETURN_VALUE _return_VALUE OUTPUT_VARIABLE _pkgconfigDevNull )
+        if(_return_VALUE STREQUAL "0")
+            message(STATUS "Found libkexiv2 release >= 0.2.0")
+            set(KEXIV2_VERSION_GOOD_FOUND TRUE)
+        else(_return_VALUE STREQUAL "0")
+            message(STATUS "Found libkexiv2 release < 0.2.0, too old")
+            set(KEXIV2_VERSION_GOOD_FOUND FALSE)
+            set(KEXIV2_FOUND FALSE)
+        endif(_return_VALUE STREQUAL "0")
+      else(_KEXIV2LinkFlags)
+        set(KEXIV2_VERSION_GOOD_FOUND FALSE)
+        set(KEXIV2_FOUND FALSE)
+      endif(_KEXIV2LinkFlags)
+    else(NOT WIN32)
+      set(KEXIV2_VERSION_GOOD_FOUND TRUE)
     endif(NOT WIN32)
 
-    if(NOT KEXIV2_FOUND)
-        find_path(KEXIV2_INCLUDEDIR libkexiv2/version.h)
-        find_library(KEXIV2_LIBRARIES NAMES kexiv2)
-        if (KEXIV2_INCLUDEDIR AND KEXIV2_LIBRARIES)
+    if(KEXIV2_VERSION_GOOD_FOUND)
+        set(KEXIV2_DEFINITIONS "${_KEXIV2Cflags}")
+    
+        FIND_PATH(KEXIV2_INCLUDE_DIR libkexiv2/version.h
+        ${_KEXIV2IncDir}
+        )
+    
+        FIND_LIBRARY(KEXIV2_LIBRARIES NAMES kexiv2
+        PATHS
+        ${_KEXIV2LinkDir}
+        )
+    
+        if (KEXIV2_INCLUDE_DIR AND KEXIV2_LIBRARIES)
             set(KEXIV2_FOUND TRUE)
-        endif (KEXIV2_INCLUDEDIR AND KEXIV2_LIBRARIES)
-    endif(NOT KEXIV2_FOUND)
+        endif (KEXIV2_INCLUDE_DIR AND KEXIV2_LIBRARIES)
+      endif(KEXIV2_VERSION_GOOD_FOUND) 
+      if (KEXIV2_FOUND)
+          if (NOT Kexiv2_FIND_QUIETLY)
+              message(STATUS "Found libkexiv2: ${KEXIV2_LIBRARIES}")
+          endif (NOT Kexiv2_FIND_QUIETLY)
+      else (KEXIV2_FOUND)
+          if (Kexiv2_FIND_REQUIRED)
+              if (NOT KEXIV2_INCLUDE_DIR)
+                  message(FATAL_ERROR "Could NOT find libkexiv2 header files")
+              endif (NOT KEXIV2_INCLUDE_DIR)
+              if (NOT KEXIV2_LIBRARIES)
+                  message(FATAL_ERROR "Could NOT find libkexiv2 library")
+              endif (NOT KEXIV2_LIBRARIES)
+          endif (Kexiv2_FIND_REQUIRED)
+      endif (KEXIV2_FOUND)
     
-    if(KEXIV2_FOUND)
-        set(KEXIV2_DEFINITIONS ${KEXIV2_CFLAGS})
-        if (NOT Kexiv2_FIND_QUIETLY)
-            message(STATUS "Found libkexiv2: ${KEXIV2_LIBRARIES}")
-        endif (NOT Kexiv2_FIND_QUIETLY)
-        set(KEXIV2_INCLUDE_DIR ${KEXIV2_INCLUDEDIR})
-        mark_as_advanced( KEXIV2_INCLUDE_DIR )
-    else(KEXIV2_FOUND)
-        if (Kexiv2_FIND_REQUIRED)
-            message(FATAL_ERROR "Not found required libkexiv2")
-        endif (Kexiv2_FIND_REQUIRED)
-    endif (KEXIV2_FOUND)
-endif (KEXIV2_INCLUDEDIR AND KEXIV2_LIBRARIES)
+    MARK_AS_ADVANCED(KEXIV2_INCLUDE_DIR KEXIV2_LIBRARIES)
+
+  endif(KEXIV2_LOCAL_FOUND)
+  
+endif (KEXIV2_INCLUDE_DIR AND KEXIV2_LIBRARIES)
diff --git a/modules/FindKipi.cmake b/modules/FindKipi.cmake
index 0c6c33d7..de0d046b 100644
--- a/modules/FindKipi.cmake
+++ b/modules/FindKipi.cmake
@@ -1,41 +1,97 @@
-# - Try to find the Kipi library using cmake pkg_check_modulesi otherwise fallback to standard search
-# Once done this will define:
+# - Try to find the Kipi library
+# Once done this will define
 #
 #  KIPI_FOUND - system has libkipi
-#  KIPI_INCLUDEDIR - the libkipi include directory
+#  KIPI_INCLUDE_DIR - the libkipi include directory
 #  KIPI_LIBRARIES - Link these to use libkipi
 #  KIPI_DEFINITIONS - Compiler switches required for using libkipi
+#
+
+if (KIPI_INCLUDE_DIR AND KIPI_LIBRARIES)
+
+  message(STATUS "Found Kipi library in cache: ${KIPI_LIBRARIES}")
+
+  # in cache already
+  SET(KIPI_FOUND TRUE)
+
+else (KIPI_INCLUDE_DIR AND KIPI_LIBRARIES)
+
+  message(STATUS "Check Kipi library in local sub-folder...")
+
+  # Check if library is not in local sub-folder
+
+  find_file (KIPI_LOCAL_FOUND libkipi/version.h.cmake ${CMAKE_SOURCE_DIR}/libkipi ${CMAKE_SOURCE_DIR}/libs/libkipi NO_DEFAULT_PATH)
 
+  if (KIPI_LOCAL_FOUND)
+
+    find_file (KIPI_LOCAL_FOUND_IN_LIBS libkipi/version.h.cmake ${CMAKE_SOURCE_DIR}/libs/libkipi NO_DEFAULT_PATH)
+    if (KIPI_LOCAL_FOUND_IN_LIBS)
+      set(KIPI_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/libs/libkipi)
+    else (KIPI_LOCAL_FOUND_IN_LIBS)
+      set(KIPI_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/libkipi)
+    endif (KIPI_LOCAL_FOUND_IN_LIBS)
+    set(KIPI_DEFINITIONS -I${KIPI_INCLUDE_DIR})
+    set(KIPI_LIBRARIES kipi)
+    message(STATUS "Found Kipi library in local sub-folder: ${KIPI_INCLUDE_DIR}")
+    set(KIPI_FOUND TRUE)
+    mark_as_advanced(KIPI_INCLUDE_DIR KIPI_LIBRARIES)
+
+  else(KIPI_LOCAL_FOUND)
 
-if (KIPI_INCLUDEDIR AND KIPI_LIBRARIES)
-    # in cache already
-    SET(KIPI_FOUND TRUE)
-else (KIPI_INCLUDEDIR AND KIPI_LIBRARIES)
     if(NOT WIN32)
-        find_package(PkgConfig)
-        if(PKG_CONFIG_EXECUTABLE)
-            pkg_check_modules(KIPI libkipi>=0.2.0)
-        endif(PKG_CONFIG_EXECUTABLE)
+      message(STATUS "Check Kipi library using pkg-config...")
+
+      # use pkg-config to get the directories and then use these values
+      # in the FIND_PATH() and FIND_LIBRARY() calls
+      INCLUDE(UsePkgConfig)
+
+      PKGCONFIG(libkipi _KIPIIncDir _KIPILinkDir _KIPILinkFlags _KIPICflags)
+
+      if(_KIPILinkFlags)
+        # query pkg-config asking for a libkipi >= 0.2.0
+        exec_program(${PKGCONFIG_EXECUTABLE} ARGS --atleast-version=0.2.0 libkipi RETURN_VALUE _return_VALUE OUTPUT_VARIABLE _pkgconfigDevNull )
+        if(_return_VALUE STREQUAL "0")
+            message(STATUS "Found libkipi release >= 0.2.0")
+            set(KIPI_VERSION_GOOD_FOUND TRUE)
+        else(_return_VALUE STREQUAL "0")
+            message(STATUS "Found libkipi release < 0.2.0, too old")
+            set(KIPI_VERSION_GOOD_FOUND FALSE)
+            set(KIPI_FOUND FALSE)
+        endif(_return_VALUE STREQUAL "0")
+      else(_KIPILinkFlags)
+        set(KIPI_VERSION_GOOD_FOUND FALSE)
+        set(KIPI_FOUND FALSE)
+      endif(_KIPILinkFlags)
+    else(NOT WIN32)
+      set(KIPI_VERSION_GOOD_FOUND TRUE)
     endif(NOT WIN32)
+    if(KIPI_VERSION_GOOD_FOUND)
+        set(KIPI_DEFINITIONS ${_KIPICflags})
+
+        find_path(KIPI_INCLUDE_DIR NAMES libkipi/version.h PATHS ${KDE4_INCLUDE_DIR} ${_KIPIIncDir})
+        find_library(KIPI_LIBRARIES NAMES kipi PATHS ${KDE4_LIB_DIR} ${_KIPILinkDir})
 
-    if(NOT KIPI_FOUND)
-        find_path(KIPI_INCLUDEDIR libkipi/version.h)
-        find_library(KIPI_LIBRARIES NAMES kipi)
-        if (KIPI_INCLUDEDIR AND KIPI_LIBRARIES)
+        if (KIPI_INCLUDE_DIR AND KIPI_LIBRARIES)
             set(KIPI_FOUND TRUE)
-        endif (KIPI_INCLUDEDIR AND KIPI_LIBRARIES)
-    endif(NOT KIPI_FOUND)
+        endif (KIPI_INCLUDE_DIR AND KIPI_LIBRARIES)
+      endif(KIPI_VERSION_GOOD_FOUND)
+      if (KIPI_FOUND)
+          if (NOT Kipi_FIND_QUIETLY)
+              message(STATUS "Found libkipi: ${KIPI_LIBRARIES}")
+          endif (NOT Kipi_FIND_QUIETLY)
+      else (KIPI_FOUND)
+          if (Kipi_FIND_REQUIRED)
+              if (NOT KIPI_INCLUDE_DIR)
+                  message(FATAL_ERROR "Could NOT find libkipi header files")
+              endif (NOT KIPI_INCLUDE_DIR)
+              if (NOT KIPI_LIBRARIES)
+                  message(FATAL_ERROR "Could NOT find libkipi library")
+              endif (NOT KIPI_LIBRARIES)
+          endif (Kipi_FIND_REQUIRED)
+      endif (KIPI_FOUND)
     
-    if(KIPI_FOUND)
-        set(KIPI_DEFINITIONS ${KIPI_CFLAGS})
-        if (NOT Kipi_FIND_QUIETLY)
-            message(STATUS "Found libkipi: ${KIPI_LIBRARIES}")
-        endif (NOT Kipi_FIND_QUIETLY)
-        set(KIPI_INCLUDE_DIR ${KIPI_INCLUDEDIR})
-        mark_as_advanced( KIPI_INCLUDE_DIR )
-    else(KIPI_FOUND)
-        if (Kipi_FIND_REQUIRED)
-            message(FATAL_ERROR "Not found required libkipi")
-        endif (Kipi_FIND_REQUIRED)
-    endif (KIPI_FOUND)
-endif (KIPI_INCLUDEDIR AND KIPI_LIBRARIES)
+    MARK_AS_ADVANCED(KIPI_INCLUDE_DIR KIPI_LIBRARIES)
+
+  endif(KIPI_LOCAL_FOUND)
+  
+endif (KIPI_INCLUDE_DIR AND KIPI_LIBRARIES)
diff --git a/modules/FindXine.cmake b/modules/FindXine.cmake
index c7dce744..534613a6 100644
--- a/modules/FindXine.cmake
+++ b/modules/FindXine.cmake
@@ -1,28 +1,72 @@
-# - Try to find the XINE  library using standard cmake tool PKG_CHECK_MODULES
+# - Try to find the XINE  library
+# Once done this will define
+#
+#  XINE_FOUND - system has the XINE library
+#  XINE_VERSION - XINE version
+#  XINE_BUGFIX_VERSION - the XINE bugfix version
+#  XINE_INCLUDE_DIR - the XINE include directory
+#  XINE_LIBRARY - The libraries needed to use XINE
+#  XINE_XCB_FOUND - libxine can use XCB for video output
 
-# Copyright (c) 2008 Helio Chissini de Castro, <helio@kde.org>
 # Copyright (c) 2006,2007 Laurent Montel, <montel@kde.org>
 # Copyright (c) 2006, 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.
 
-if (XINE_INCLUDEDIR AND XINE_LIBRARIES)
-    # Already in cache, be silent
-    set(Xine_FIND_QUIETLY TRUE)
-endif (XINE_INCLUDEDIR AND XINE_LIBRARIES)
+if (XINE_INCLUDE_DIR AND XINE_LIBRARY)
+  # Already in cache, be silent
+  set(Xine_FIND_QUIETLY TRUE)
+endif (XINE_INCLUDE_DIR AND XINE_LIBRARY)
+  IF (NOT WIN32)
+	INCLUDE(UsePkgConfig)
+	PKGCONFIG(libxine _LibXineIncDir _LibXineLinkDir _LibXineLinkFlags _LibXineCflags)
+	EXEC_PROGRAM(${PKGCONFIG_EXECUTABLE} ARGS "--variable=prefix libxine" OUTPUT_VARIABLE _LibXinePrefix)
+  ENDIF (NOT WIN32)
+FIND_PATH(XINE_INCLUDE_DIR NAMES xine.h 
+    PATHS 
+    ${_LibXineIncDir} 
+    NO_DEFAULT_PATH)
+
+FIND_LIBRARY(XINE_LIBRARY NAMES xine
+ PATHS
+  ${_LibXineLinkDir}
+ NO_DEFAULT_PATH
+)
+
+FIND_PROGRAM(XINECONFIG_EXECUTABLE NAMES xine-config PATHS
+   ${_LibXinePrefix}/bin
+)
+
+if (XINE_INCLUDE_DIR AND XINE_LIBRARY AND XINECONFIG_EXECUTABLE)
+   EXEC_PROGRAM(${XINECONFIG_EXECUTABLE} ARGS --version RETURN_VALUE _return_VALUE OUTPUT_VARIABLE XINE_VERSION)
+   macro_ensure_version(1.1.1 ${XINE_VERSION} XINE_VERSION_OK)
+   if (XINE_VERSION_OK)
+      set(XINE_FOUND TRUE)
+      string(REGEX REPLACE "[0-9].[0-9]." "" XINE_BUGFIX_VERSION ${XINE_VERSION})
+   endif (XINE_VERSION_OK)
+endif (XINE_INCLUDE_DIR AND XINE_LIBRARY AND XINECONFIG_EXECUTABLE)
 
-IF (NOT WIN32)
-    find_package(PkgConfig REQUIRED)
-    pkg_check_modules(XINE libxine>=1.1.9)
-ENDIF (NOT WIN32)
 
 if( XINE_FOUND )
-    SET(CMAKE_REQUIRED_INCLUDES ${XINE_INCLUDEDIR})
-    SET(CMAKE_REQUIRED_LIBRARIES ${XINE_LIBRARIES})
-    if (NOT Xine_FIND_QUIETLY)
-        message(STATUS "Found XINE: ${XINE_LIBRARIES}")
-    endif (NOT Xine_FIND_QUIETLY)
+  INCLUDE(CheckCSourceCompiles)
+  SET(CMAKE_REQUIRED_INCLUDES ${XINE_INCLUDE_DIR})
+  SET(CMAKE_REQUIRED_LIBRARIES ${XINE_LIBRARY})
+  CHECK_C_SOURCE_COMPILES("#include <xine.h>\nint main()\n{\n  xine_open_video_driver(xine_new(), \"auto\", XINE_VISUAL_TYPE_XCB, NULL);\n  return 0;\n}\n" XINE_XCB_FOUND)
 endif(XINE_FOUND)
 
+if (XINE_FOUND)
+   if (NOT Xine_FIND_QUIETLY)
+      message(STATUS "Found XINE: ${XINE_LIBRARY}")
+   endif (NOT Xine_FIND_QUIETLY)
+   #   if(XINECONFIG_EXECUTABLE)
+   #      EXEC_PROGRAM(${XINECONFIG_EXECUTABLE} ARGS --plugindir RETURN_VALUE _return_VALUE OUTPUT_VARIABLE XINEPLUGINSDIR)
+   #      MESSAGE(STATUS "XINEPLUGINSDIR :<${XINEPLUGINSDIR}>")
+   #   endif(XINECONFIG_EXECUTABLE)
+else (XINE_FOUND)
+   if (Xine_FIND_REQUIRED)
+      message(FATAL_ERROR "Could NOT find XINE 1.1.1 or greater")
+   endif (Xine_FIND_REQUIRED)
+endif (XINE_FOUND)
 
+MARK_AS_ADVANCED(XINE_INCLUDE_DIR XINE_LIBRARY)