-kde4 stuff moved to modules/ dir

Alex



svn path=/trunk/KDE/kdesdk/cmake/; revision=501378

5 files changed, 713 insertions, 0 deletions

diff --git a/modules/FindKDE4.cmake b/modules/FindKDE4.cmake
new file mode 100644
index 00000000..8e4c4d4d
--- /dev/null
+++ b/modules/FindKDE4.cmake
@@ -0,0 +1,225 @@
+# - Find the KDE4 include and library dirs, KDE preprocessors and define a some macros
+#
+# KDE4_DEFINITIONS
+# KDE4_INCLUDE_DIR
+# KDE4_INCLUDE_DIRS
+# KDE4_LIB_DIR
+# KDE4_SERVICETYPES_DIR
+# KDE4_DCOPIDL_EXECUTABLE
+# KDE4_DCOPIDL2CPP_EXECUTABLE
+# KDE4_KCFGC_EXECUTABLE
+# KDE4_FOUND
+# it also adds the following macros (from KDE4Macros.cmake)
+# ADD_FILE_DEPENDANCY
+# KDE4_ADD_DCOP_SKELS
+# KDE4_ADD_DCOP_STUBS
+# KDE4_ADD_MOC_FILES
+# KDE4_ADD_UI_FILES
+# KDE4_ADD_KCFG_FILES
+# KDE4_AUTOMOC
+# KDE4_PLACEHOLDER
+# KDE4_CREATE_LIBTOOL_FILE
+# KDE4_CREATE_FINAL_FILE
+# KDE4_ADD_KPART
+# KDE4_ADD_KLM
+# KDE4_ADD_EXECUTABLE
+
+
+CMAKE_MINIMUM_REQUIRED(VERSION 2.2)
+
+IF(UNIX)
+   IF(APPLE)
+      MESSAGE(SEND_ERROR "Mac OSX  not yet supported by FindKDE4.cmake and KDE4Macros.cmake, please edit them as required")
+   ELSE(APPLE)
+      FIND_PACKAGE(X11 REQUIRED)
+   ENDIF(APPLE)
+ELSE(UNIX)
+   MESSAGE(SEND_ERROR "Win32 not yet supported by FindKDE4.cmake and KDE4Macros.cmake, please edit them as required")
+ENDIF(UNIX)
+
+#this line includes FindQt.cmake, which searches the Qt library and headers
+INCLUDE(FindQt4)
+
+#add the definitions found by FindQt to the current definitions
+#ADD_DEFINITIONS(${QT_DEFINITIONS} -DQT_CLEAN_NAMESPACE)
+
+SET(QT_AND_KDECORE_LIBS ${QT_QTCORE_LIBRARY} kdecore)
+
+#add some KDE specific stuff
+# not used in Qt4: QT_NO_COMPAT, QT_CLEAN_NAMESPACE, QT_THREAD_SUPPORT
+SET(KDE4_DEFINITIONS -DQT3_SUPPORT -DQT_NO_STL -DQT_NO_CAST_TO_ASCII -DQT_NO_TRANSLATION -D_REENTRANT )
+
+SET (CMAKE_C_FLAGS     "${CMAKE_C_FLAGS} -Wno-long-long -ansi -Wundef -Wcast-align -Wconversion -Wchar-subscripts -Wall -W -Wpointer-arith -Wwrite-strings -O2 -Wformat-security -Wmissing-format-attribute -fno-common")
+SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wnon-virtual-dtor -Wno-long-long -ansi -Wundef -Wcast-align -Wconversion -Wchar-subscripts -Wall -W -Wpointer-arith -Wwrite-strings -O2 -Wformat-security -Wmissing-format-attribute -fno-exceptions -fno-check-new -fno-common")
+
+#only on linux, but not e.g. on FreeBSD:
+IF(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+  SET(KDE4_DEFINITIONS ${KDE4_DEFINITIONS} -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -D_GNU_SOURCE)
+ENDIF(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+
+IF(${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
+  SET(KDE4_DEFINITIONS ${KDE4_DEFINITIONS} -D_GNU_SOURCE)
+ENDIF(${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
+
+
+#SET(CMAKE_SHARED_LINKER_FLAGS "-avoid-version -module -Wl,--no-undefined -Wl,--allow-shlib-undefined")
+SET(CMAKE_SHARED_LINKER_FLAGS "-Wl,--fatal-warnings -avoid-version -Wl,--no-undefined -lc")
+SET(CMAKE_MODULE_LINKER_FLAGS "-Wl,--fatal-warnings -avoid-version -Wl,--no-undefined -lc")
+
+SET(KDE4_DIR /opt/kde4)
+
+SET(KDE4_APPS_DIR          /share/applnk)
+SET(KDE4_CONFIG_DIR        /share/config)
+SET(KDE4_DATA_DIR          /share/apps)
+SET(KDE4_HTML_DIR          /share/doc/HTML)
+SET(KDE4_ICON_DIR          /share/icons)
+SET(KDE4_KCFG_DIR          /share/config.kcfg)
+SET(KDE4_LIBS_HTML_DIR     /share/doc/HTML)
+SET(KDE4_LOCALE_DIR        /share/locale)
+SET(KDE4_MIME_DIR          /share/mimelnk)
+SET(KDE4_SERVICES_DIR      /share/services)
+SET(KDE4_SERVICETYPES_DIR /share/services)
+SET(KDE4_SOUND_DIR         /share/sounds)
+SET(KDE4_TEMPLATES_DIR     /share/templates)
+SET(KDE4_WALLPAPER_DIR     /share/wallpapers)
+
+SET(XDG_APPS_DIR           /share/applications/kde)
+SET(XDG_DIRECTORY_DIR      /share/desktop-directories)
+
+
+#now try to find some kde stuff
+
+#are we trying to compile kdelibs ?
+#then enter bootstrap mode
+IF(EXISTS ${CMAKE_SOURCE_DIR}/kdecore/kglobal.h)
+
+  MESSAGE(STATUS "Building kdelibs...")
+
+  SET(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin )
+  SET(LIBRARY_OUTPUT_PATH  ${CMAKE_BINARY_DIR}/lib )
+
+  SET(KDE4_INCLUDE_DIR ${CMAKE_SOURCE_DIR})
+  SET(KDE4_LIB_DIR ${LIBRARY_OUTPUT_PATH})
+  SET(KDE4_DCOPIDL_EXECUTABLE ${CMAKE_SOURCE_DIR}/dcop/dcopidlng/dcopidl )
+  SET(KDE4_KALYPTUS_DIR ${CMAKE_SOURCE_DIR}/dcop/dcopidlng/ )
+  SET(KDE4_DCOPIDL2CPP_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/dcopidl2cpp )
+  SET(KDE4_KCFGC_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/kconfig_compiler )
+
+ELSE(EXISTS ${CMAKE_SOURCE_DIR}/kdecore/kglobal.h)
+
+  #at first the KDE include direcory
+  FIND_PATH(KDE4_INCLUDE_DIR kurl.h
+    $ENV{KDEDIR}/include
+    /opt/kde/include
+    /opt/kde4/include
+    /usr/local/include
+    /usr/include/
+    /usr/include/kde
+    /usr/local/include/kde
+  )
+
+  #now the KDE library directory
+  FIND_PATH(KDE4_LIB_DIR libkdecore.so
+    $ENV{KDEDIR}/lib
+    /opt/kde/lib
+    /opt/kde4/lib
+    /usr/lib
+    /usr/local/lib
+  )
+
+#now the KDE service types directory
+#FIND_PATH(KDE4_SERVICETYPES_DIR ktexteditor.desktop
+#  $ENV{KDEDIR}/share/servicetypes/
+#  /opt/kde/share/servicetypes/
+#  /opt/kde4/share/servicetypes/
+#)
+
+
+  #now search for the dcop utilities
+  FIND_PROGRAM(KDE4_DCOPIDL_EXECUTABLE NAME dcopidl PATHS
+    $ENV{KDEDIR}/bin
+    /opt/kde/bin
+    /opt/kde4/bin
+  )
+
+  FIND_PATH(KDE4_KALYPTUS_DIR kalyptus
+    $ENV{KDEDIR}/share/apps/dcopidl
+    /opt/kde/share/apps/dcopidl
+    /opt/kde4/share/apps/dcopidl
+  )
+
+  FIND_PROGRAM(KDE4_DCOPIDL2CPP_EXECUTABLE NAME dcopidl2cpp PATHS
+    $ENV{KDEDIR}/bin
+    /opt/kde/bin
+    /opt/kde4/bin
+  )
+
+  FIND_PROGRAM(KDE4_KCFGC_EXECUTABLE NAME kconfig_compiler PATHS
+    $ENV{KDEDIR}/bin
+    /opt/kde/bin
+    /opt/kde4/bin
+  )
+
+ENDIF(EXISTS ${CMAKE_SOURCE_DIR}/kdecore/kglobal.h)
+
+
+# KDE4Macros.cmake contains all the KDE specific macros
+INCLUDE(KDE4Macros)
+
+#set KDE4_FOUND
+IF (KDE4_INCLUDE_DIR AND KDE4_LIB_DIR AND KDE4_SERVICETYPES_DIR AND KDE4_DCOPIDL_EXECUTABLE AND KDE4_DCOPIDL2CPP_EXECUTABLE AND KDE4_KCFGC_EXECUTABLE)
+   SET(KDE4_FOUND TRUE)
+ELSE (KDE4_INCLUDE_DIR AND KDE4_LIB_DIR AND KDE4_SERVICETYPES_DIR AND KDE4_DCOPIDL_EXECUTABLE AND KDE4_DCOPIDL2CPP_EXECUTABLE AND KDE4_KCFGC_EXECUTABLE)
+   SET(KDE4_FOUND FALSE)
+ENDIF (KDE4_INCLUDE_DIR AND KDE4_LIB_DIR AND KDE4_SERVICETYPES_DIR AND KDE4_DCOPIDL_EXECUTABLE AND KDE4_DCOPIDL2CPP_EXECUTABLE AND KDE4_KCFGC_EXECUTABLE)
+
+
+MACRO (KDE4_PRINT_RESULTS)
+   IF(KDE4_INCLUDE_DIR)
+      MESSAGE(STATUS "Found KDE4 include dir: ${KDE4_INCLUDE_DIR}")
+   ELSE(KDE4_INCLUDE_DIR)
+      MESSAGE(STATUS "Didn't find KDE4 headers")
+   ENDIF(KDE4_INCLUDE_DIR)
+
+   IF(KDE4_LIB_DIR)
+      MESSAGE(STATUS "Found KDE4 library dir: ${KDE4_LIB_DIR}")
+   ELSE(KDE4_LIB_DIR)
+      MESSAGE(STATUS "Didn't find KDE4 core library")
+   ENDIF(KDE4_LIB_DIR)
+
+   IF(KDE4_DCOPIDL_EXECUTABLE)
+      MESSAGE(STATUS "Found KDE4 dcopidl preprocessor: ${KDE4_DCOPIDL_EXECUTABLE}")
+   ELSE(KDE4_DCOPIDL_EXECUTABLE)
+      MESSAGE(STATUS "Didn't find the KDE4 dcopidl preprocessor")
+   ENDIF(KDE4_DCOPIDL_EXECUTABLE)
+
+   IF(KDE4_DCOPIDL2CPP_EXECUTABLE)
+      MESSAGE(STATUS "Found KDE4 dcopidl2cpp preprocessor: ${KDE4_DCOPIDL2CPP_EXECUTABLE}")
+   ELSE(KDE4_DCOPIDL2CPP_EXECUTABLE)
+      MESSAGE(STATUS "Didn't find the KDE4 dcopidl2cpp preprocessor")
+   ENDIF(KDE4_DCOPIDL2CPP_EXECUTABLE)
+
+   IF(KDE4_KCFGC_EXECUTABLE)
+      MESSAGE(STATUS "Found KDE4 kconfig_compiler preprocessor: ${KDE4_KCFGC_EXECUTABLE}")
+   ELSE(KDE4_KCFGC_EXECUTABLE)
+      MESSAGE(STATUS "Didn't find the KDE4 kconfig_compiler preprocessor")
+   ENDIF(KDE4_KCFGC_EXECUTABLE)
+
+ENDMACRO (KDE4_PRINT_RESULTS)
+
+IF (KDE4_FIND_REQUIRED AND NOT KDE4_FOUND)
+   #bail out if something wasn't found
+   KDE4_PRINT_RESULTS()
+   MESSAGE(FATAL_ERROR "Could not find everything required for compiling KDE 4 programs")
+
+ENDIF (KDE4_FIND_REQUIRED AND NOT KDE4_FOUND)
+
+IF (NOT KDE4_FIND_QUIETLY)
+   KDE4_PRINT_RESULTS()
+ENDIF (NOT KDE4_FIND_QUIETLY)
+
+#add the found Qt and KDE include directories to the current include path
+SET(KDE4_INCLUDE_DIRS ${QT_INCLUDES} ${KDE4_INCLUDE_DIR} ${X11_INCLUDE_DIR} )
+#INCLUDE_DIRECTORIES(${QT_INCLUDE_DIR} ${KDE4_INCLUDE_DIR} .)
+#LINK_DIRECTORIES(${KDE4_LIB_DIR})
+
diff --git a/modules/KDE4Macros.cmake b/modules/KDE4Macros.cmake
new file mode 100644
index 00000000..8cbeb6f8
--- /dev/null
+++ b/modules/KDE4Macros.cmake
@@ -0,0 +1,435 @@
+# this file contains the following macros:
+# KDE4_ADD_FILE_DEPENDANCY
+# KDE4_ADD_DCOP_SKELS
+# KDE4_ADD_DCOP_STUBS
+# KDE4_ADD_MOC_FILES
+# KDE4_ADD_UI_FILES
+# KDE4_ADD_KCFG_FILES
+# KDE4_AUTOMOC
+# KDE4_CREATE_LIBTOOL_FILE
+# KDE4_PLACEHOLDER
+# KDE4_CREATE_FINAL_FILE
+# KDE4_ADD_KPART
+# KDE4_ADD_KLM
+# KDE4_ADD_EXECUTABLE
+
+
+#neundorf@kde.org
+
+#this should better be part of cmake:
+#add an additional file to the list of files a source file depends on
+MACRO(KDE4_ADD_FILE_DEPENDANCY file)
+
+   GET_SOURCE_FILE_PROPERTY(_deps ${file} OBJECT_DEPENDS)
+   IF (_deps)
+      SET(_deps ${_deps} ${ARGN})
+   ELSE (_deps)
+      SET(_deps ${ARGN})
+   ENDIF (_deps)
+
+   SET_SOURCE_FILES_PROPERTIES(${file} PROPERTIES OBJECT_DEPENDS "${_deps}")
+
+ENDMACRO(KDE4_ADD_FILE_DEPENDANCY)
+
+
+#create the kidl and skeletion file for dcop stuff
+#usage: KDE_ADD_COP_SKELS(foo_SRCS ${dcop_headers})
+MACRO(KDE4_ADD_DCOP_SKELS _sources)
+   FOREACH (_current_FILE ${ARGN})
+
+      QT4_GET_ABS_PATH(_tmp_FILE ${_current_FILE})
+
+      GET_FILENAME_COMPONENT(_basename ${_tmp_FILE} NAME_WE)
+
+      SET(_skel ${CMAKE_CURRENT_BINARY_DIR}/${_basename}_skel.cpp)
+      SET(_kidl ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.kidl)
+
+      ADD_CUSTOM_COMMAND(OUTPUT ${_kidl}
+         COMMAND ${KDE4_DCOPIDL_EXECUTABLE}
+         ARGS --srcdir ${KDE4_KALYPTUS_DIR} ${_tmp_FILE} > ${_kidl}
+         DEPENDS ${_tmp_FILE}
+      )
+
+      ADD_CUSTOM_COMMAND(OUTPUT ${_skel}
+         COMMAND ${KDE4_DCOPIDL2CPP_EXECUTABLE}
+         ARGS --c++-suffix cpp --no-signals --no-stub ${_kidl}
+         DEPENDS ${_kidl}
+      )
+
+      SET(${_sources} ${${_sources}} ${_skel})
+
+   ENDFOREACH (_current_FILE)
+
+ENDMACRO(KDE4_ADD_DCOP_SKELS)
+
+MACRO(KDE4_ADD_DCOP_STUBS _sources)
+   FOREACH (_current_FILE ${ARGN})
+
+      QT4_GET_ABS_PATH(_tmp_FILE ${_current_FILE})
+
+      GET_FILENAME_COMPONENT(_basename ${_tmp_FILE} NAME_WE)
+
+      SET(_stub_CPP ${CMAKE_CURRENT_BINARY_DIR}/${_basename}_stub.cpp)
+#     SET(_stub_H ${CMAKE_CURRENT_BINARY_DIR}/${_basename}_stub.h)
+      SET(_kidl ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.kidl)
+
+      ADD_CUSTOM_COMMAND(OUTPUT ${_kidl}
+         COMMAND ${KDE4_DCOPIDL_EXECUTABLE}
+         ARGS --srcdir ${KDE4_KALYPTUS_DIR} ${_tmp_FILE} > ${_kidl}
+         DEPENDS ${_tmp_FILE}
+      )
+
+      ADD_CUSTOM_COMMAND(OUTPUT ${_stub_CPP}
+         COMMAND ${KDE4_DCOPIDL2CPP_EXECUTABLE}
+         ARGS --c++-suffix cpp --no-signals --no-skel ${_kidl}
+         DEPENDS ${_kidl}
+      )
+
+      SET(${_sources} ${${_sources}} ${_stub_CPP})
+
+   ENDFOREACH (_current_FILE)
+
+ENDMACRO(KDE4_ADD_DCOP_STUBS)
+
+MACRO(KDE4_ADD_KCFG_FILES _sources)
+   FOREACH (_current_FILE ${ARGN})
+
+      QT4_GET_ABS_PATH(_tmp_FILE ${_current_FILE})
+
+      GET_FILENAME_COMPONENT(_basename ${_tmp_FILE} NAME_WE)
+
+      FILE(READ ${_tmp_FILE} _contents)
+      STRING(REGEX REPLACE "^(.*\n)?File=([^\n]+)\n.*$" "\\2"  _kcfg_FILE "${_contents}")
+
+      SET(_src_FILE    ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp)
+      SET(_header_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)
+
+      ADD_CUSTOM_COMMAND(OUTPUT ${_src_FILE}
+         COMMAND ${KDE4_KCFGC_EXECUTABLE}
+         ARGS ${_kcfg_FILE} ${_tmp_FILE}
+         DEPENDS ${_tmp_FILE} )
+
+      SET(${_sources} ${${_sources}} ${_src_FILE})
+
+   ENDFOREACH (_current_FILE)
+
+ENDMACRO(KDE4_ADD_KCFG_FILES)
+
+
+#create the moc files and add them to the list of sources
+#usage: KDE_ADD_MOC_FILES(foo_SRCS ${moc_headers})
+#MACRO(KDE4_ADD_MOC_FILES _sources)
+#   FOREACH (_current_FILE ${ARGN})
+#      GET_FILENAME_COMPONENT(_basename ${_current_FILE} NAME_WE)
+#      GET_FILENAME_COMPONENT(_path ${_current_FILE} PATH)
+#      SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc.cpp)
+
+#      ADD_CUSTOM_COMMAND(OUTPUT ${_moc}
+#         COMMAND ${QT_MOC_EXECUTABLE}
+#         ARGS ${CMAKE_CURRENT_SOURCE_DIR}/${_current_FILE} -o ${_moc}
+#         DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${_current_FILE}
+#      )
+#      SET(${_sources} ${${_sources}} ${_moc})
+#   ENDFOREACH (_current_FILE)
+#ENDMACRO(KDE4_ADD_MOC_FILES)
+
+
+#create the implementation files from the ui files and add them to the list of sources
+#usage: KDE_ADD_UI_FILES(foo_SRCS ${ui_files})
+MACRO(KDE4_ADD_UI_FILES _sources )
+   FOREACH (_current_FILE ${ARGN})
+
+      QT4_GET_ABS_PATH(_tmp_FILE ${_current_FILE})
+
+      GET_FILENAME_COMPONENT(_basename ${_tmp_FILE} NAME_WE)
+      SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)
+
+      # we need to run uic and replace some things in the generated file
+      # this is done by executing the cmake script kde4uic.cmake
+      ADD_CUSTOM_COMMAND(OUTPUT ${_header}
+         COMMAND ${CMAKE_COMMAND}
+         ARGS
+         -DKDE4_HEADER:BOOL=ON
+         -DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC_EXECUTABLE}
+         -DKDE_UIC_FILE:FILEPATH=${_tmp_FILE}
+         -DKDE_UIC_H_FILE:FILEPATH=${_header}
+         -DKDE_UIC_BASENAME:STRING=${_basename}
+         -P ${CMAKE_ROOT}/Modules/kde4uic.cmake
+         DEPENDS ${_tmp_FILE}
+      )
+   ENDFOREACH (_current_FILE)
+ENDMACRO(KDE4_ADD_UI_FILES)
+
+#create the implementation files from the ui files and add them to the list of sources
+#usage: KDE_ADD_UI_FILES(foo_SRCS ${ui_files})
+MACRO(KDE4_ADD_UI3_FILES _sources )
+
+   QT4_GET_MOC_INC_DIRS(_moc_INCS)
+
+   FOREACH (_current_FILE ${ARGN})
+
+      QT4_GET_ABS_PATH(_tmp_FILE ${_current_FILE})
+
+      GET_FILENAME_COMPONENT(_basename ${_tmp_FILE} NAME_WE)
+      SET(_header ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h)
+      SET(_src ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp)
+      SET(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc.cpp)
+
+#      ADD_CUSTOM_COMMAND(OUTPUT ${_header}
+#         COMMAND ${QT_UIC3_EXECUTABLE}
+#         ARGS  -nounload -o ${_header} ${_tmp_FILE}
+#         DEPENDS ${_tmp_FILE}
+#      )
+
+      ADD_CUSTOM_COMMAND(OUTPUT ${_header}
+         COMMAND ${CMAKE_COMMAND}
+         -DKDE3_HEADER:BOOL=ON
+         -DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC3_EXECUTABLE}
+         -DKDE_UIC_FILE:FILEPATH=${_tmp_FILE}
+         -DKDE_UIC_H_FILE:FILEPATH=${_header}
+         -DKDE_UIC_BASENAME:STRING=${_basename}
+         -DKDE_UIC_PLUGIN_DIR:FILEPATH="."
+         -P ${CMAKE_ROOT}/Modules/kde4uic.cmake
+         DEPENDS ${_tmp_FILE}
+      )
+
+# we need to run uic3 and replace some things in the generated file
+      # this is done by executing the cmake script kde4uic.cmake
+      ADD_CUSTOM_COMMAND(OUTPUT ${_src}
+         COMMAND ${CMAKE_COMMAND}
+         ARGS
+         -DKDE3_IMPL:BOOL=ON
+         -DKDE_UIC_EXECUTABLE:FILEPATH=${QT_UIC3_EXECUTABLE}
+         -DKDE_UIC_FILE:FILEPATH=${_tmp_FILE}
+         -DKDE_UIC_CPP_FILE:FILEPATH=${_src}
+         -DKDE_UIC_H_FILE:FILEPATH=${_header}
+         -DKDE_UIC_BASENAME:STRING=${_basename}
+         -DKDE_UIC_PLUGIN_DIR:FILEPATH="."
+         -P ${CMAKE_ROOT}/Modules/kde4uic.cmake
+         DEPENDS ${_header}
+      )
+
+      ADD_CUSTOM_COMMAND(OUTPUT ${_moc}
+         COMMAND ${QT_MOC_EXECUTABLE}
+         ARGS ${_moc_INCS} ${_header} -o ${_moc}
+         DEPENDS ${_header}
+      )
+      SET(${_sources} ${${_sources}} ${_src} ${_moc} )
+
+   ENDFOREACH (_current_FILE)
+ENDMACRO(KDE4_ADD_UI3_FILES)
+
+
+MACRO(KDE4_AUTOMOC)
+   QT4_GET_MOC_INC_DIRS(_moc_INCS)
+
+   SET(_matching_FILES )
+   FOREACH (_current_FILE ${ARGN})
+
+      QT4_GET_ABS_PATH(_tmp_FILE ${_current_FILE})
+
+      IF (EXISTS ${_tmp_FILE})
+
+         FILE(READ ${_tmp_FILE} _contents)
+
+         GET_FILENAME_COMPONENT(_abs_FILE ${_tmp_FILE} ABSOLUTE)
+         GET_FILENAME_COMPONENT(_abs_PATH ${_abs_FILE} PATH)
+
+         STRING(REGEX MATCHALL "#include +[^ ]+\\.moc[\">]" _match "${_contents}")
+         IF(_match)
+            FOREACH (_current_MOC_INC ${_match})
+               STRING(REGEX MATCH "[^ <\"]+\\.moc" _current_MOC "${_current_MOC_INC}")
+
+               GET_FILENAME_COMPONENT(_basename ${_current_MOC} NAME_WE)
+#               SET(_header ${CMAKE_CURRENT_SOURCE_DIR}/${_basename}.h)
+               SET(_header ${_abs_PATH}/${_basename}.h)
+               SET(_moc    ${CMAKE_CURRENT_BINARY_DIR}/${_current_MOC})
+               ADD_CUSTOM_COMMAND(OUTPUT ${_moc}
+                  COMMAND ${QT_MOC_EXECUTABLE}
+                  ARGS ${_moc_INCS} ${_header} -o ${_moc}
+                  DEPENDS ${_header}
+               )
+
+               KDE4_ADD_FILE_DEPENDANCY(${_tmp_FILE} ${_moc})
+
+            ENDFOREACH (_current_MOC_INC)
+         ENDIF(_match)
+
+      ENDIF (EXISTS ${_tmp_FILE})
+   ENDFOREACH (_current_FILE)
+ENDMACRO(KDE4_AUTOMOC)
+
+MACRO(KDE4_INSTALL_ICONS _theme)
+   ADD_CUSTOM_TARGET(install_icons )
+   SET_TARGET_PROPERTIES(install_icons PROPERTIES POST_INSTALL_SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake )
+   FILE(WRITE install_icons.cmake "# icon installations rules\n")
+   FILE(APPEND install_icons.cmake "SET(CMAKE_BACKWARDS_COMPATIBILITY \"2.2\") \n")
+
+   FILE(GLOB _icons *.png)
+   FOREACH(_current_ICON ${_icons} )
+      STRING(REGEX REPLACE "^.*/[a-zA-Z]+([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\1" _size "${_current_ICON}")
+      STRING(REGEX REPLACE "^.*/[a-zA-Z]+([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\2" _group "${_current_ICON}")
+      STRING(REGEX REPLACE "^.*/[a-zA-Z]+([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\3" _name "${_current_ICON}")
+
+      SET(_icon_GROUP "actions")
+
+      IF(${_group} STREQUAL "mime")
+         SET(_icon_GROUP  "mimetypes")
+      ENDIF(${_group} STREQUAL "mime")
+
+      IF(${_group} STREQUAL "filesys")
+         SET(_icon_GROUP  "filesystems")
+      ENDIF(${_group} STREQUAL "filesys")
+
+      IF(${_group} STREQUAL "device")
+         SET(_icon_GROUP  "devices")
+      ENDIF(${_group} STREQUAL "device")
+
+      IF(${_group} STREQUAL "app")
+         SET(_icon_GROUP  "apps")
+      ENDIF(${_group} STREQUAL "app")
+
+      IF(${_group} STREQUAL "action")
+         SET(_icon_GROUP  "actions")
+      ENDIF(${_group} STREQUAL "action")
+
+#      MESSAGE(STATUS "icon: ${_current_ICON} size: ${_size} group: ${_group} name: ${_name}" )
+      SET(_ICON_INSTALL_NAME ${CMAKE_INSTALL_PREFIX}/share/icons/${_theme}/${_size}x${_size}/${_icon_GROUP}/${_name})
+      FILE(APPEND install_icons.cmake "MESSAGE(STATUS \"Installing ${_ICON_INSTALL_NAME}\") \n")
+      FILE(APPEND install_icons.cmake "CONFIGURE_FILE( ${_current_ICON} ${_ICON_INSTALL_NAME} COPYONLY) \n")
+
+   ENDFOREACH (_current_ICON)
+ENDMACRO(KDE4_INSTALL_ICONS _theme)
+
+# for the case that something should be added to every CMakeLists.txt at the top
+MACRO(KDE4_HEADER)
+ENDMACRO(KDE4_HEADER)
+
+# same as above, but at the end
+MACRO(KDE4_FOOTER)
+ENDMACRO(KDE4_FOOTER)
+
+MACRO(KDE4_CREATE_LIBTOOL_FILE _target)
+   GET_TARGET_PROPERTY(_target_location ${_target} LOCATION)
+
+   GET_FILENAME_COMPONENT(_laname ${_target_location} NAME_WE)
+   GET_FILENAME_COMPONENT(_soname ${_target_location} NAME)
+   SET(_laname ${_laname}.la)
+
+   FILE(WRITE ${_laname} "# ${_laname} - a libtool library file, generated by cmake \n")
+   FILE(APPEND ${_laname} "# The name that we can dlopen(3).\n")
+   FILE(APPEND ${_laname} "dlname='${_soname}'\n")
+   FILE(APPEND ${_laname} "# Names of this library\n")
+   FILE(APPEND ${_laname} "library_names='${_soname} ${_soname} ${_soname}'\n")
+   FILE(APPEND ${_laname} "# The name of the static archive\n")
+   FILE(APPEND ${_laname} "old_library=''\n")
+   FILE(APPEND ${_laname} "# Libraries that this one depends upon.\n")
+   FILE(APPEND ${_laname} "dependency_libs=''\n")
+#   FILE(APPEND ${_laname} "dependency_libs='${${_target}_LIB_DEPENDS}'\n")
+   FILE(APPEND ${_laname} "# Version information.\ncurrent=0\nage=0\nrevision=0\n")
+   FILE(APPEND ${_laname} "# Is this an already installed library?\ninstalled=yes\n")
+   FILE(APPEND ${_laname} "# Should we warn about portability when linking against -modules?\nshouldnotlink=yes\n")
+   FILE(APPEND ${_laname} "# Files to dlopen/dlpreopen\ndlopen=''\ndlpreopen=''\n")
+   FILE(APPEND ${_laname} "# Directory that this library needs to be installed in:\n")
+   FILE(APPEND ${_laname} "libdir='${CMAKE_INSTALL_PREFIX}/lib/kde4'\n")
+
+   INSTALL_FILES(/lib/kde4 FILES ${_laname})
+ENDMACRO(KDE4_CREATE_LIBTOOL_FILE)
+
+
+MACRO(KDE4_CREATE_FINAL_FILE _filename)
+   FILE(WRITE ${_filename} "//autogenerated file\n")
+   FOREACH (_current_FILE ${ARGN})
+      FILE(APPEND ${_filename} "#include \"${_current_FILE}\"\n")
+   ENDFOREACH (_current_FILE)
+
+ENDMACRO(KDE4_CREATE_FINAL_FILE _filename)
+
+
+OPTION(KDE4_ENABLE_FINAL "Enable final all-in-one compilation")
+OPTION(KDE4_BUILD_TESTS  "Build the tests")
+
+MACRO(KDE4_ADD_PLUGIN _target_NAME _with_PREFIX)
+#is the first argument is "WITH_PREFIX" then keep the standard "lib" prefix, otherwise set the prefix empty
+   IF (${_with_PREFIX} STREQUAL "WITH_PREFIX")
+      SET(_first_SRC)
+   ELSE (${_with_PREFIX} STREQUAL "WITH_PREFIX")
+      SET(_first_SRC ${_with_PREFIX})
+   ENDIF (${_with_PREFIX} STREQUAL "WITH_PREFIX")
+
+   IF (KDE4_ENABLE_FINAL)
+      KDE4_CREATE_FINAL_FILE(${_target_NAME}_final.cpp ${_first_SRC} ${ARGN})
+      ADD_LIBRARY(${_target_NAME} MODULE  ${_target_NAME}_final.cpp)
+   ELSE (KDE4_ENABLE_FINAL)
+      ADD_LIBRARY(${_target_NAME} MODULE ${_first_SRC} ${ARGN})
+   ENDIF (KDE4_ENABLE_FINAL)
+
+   IF(_first_SRC)
+      SET_TARGET_PROPERTIES(${_target_NAME} PROPERTIES PREFIX "")
+   ENDIF(_first_SRC)
+
+   KDE4_CREATE_LIBTOOL_FILE(${_target_NAME})
+
+ENDMACRO(KDE4_ADD_PLUGIN _target_NAME _with_PREFIX)
+
+MACRO(KDE4_ADD_KLM _target_NAME )
+
+   IF (KDE4_ENABLE_FINAL)
+      KDE4_CREATE_FINAL_FILE(${_target_NAME}_final.cpp ${ARGN})
+      ADD_LIBRARY(kdeinit_${_target_NAME} SHARED  ${_target_NAME}_final.cpp)
+   ELSE (KDE4_ENABLE_FINAL)
+      ADD_LIBRARY(kdeinit_${_target_NAME} SHARED ${ARGN} )
+#      MESSAGE(STATUS "klm: kdeinit_${_target_NAME}")
+   ENDIF (KDE4_ENABLE_FINAL)
+
+   CONFIGURE_FILE(${CMAKE_ROOT}/Modules/kde4init_dummy.cpp.in ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp)
+
+   ADD_EXECUTABLE( ${_target_NAME} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp )
+   TARGET_LINK_LIBRARIES( ${_target_NAME} kdeinit_${_target_NAME} )
+
+ENDMACRO(KDE4_ADD_KLM _target_NAME)
+
+
+MACRO(KDE4_ADD_EXECUTABLE _target_NAME )
+
+   IF (KDE4_ENABLE_FINAL)
+      KDE4_CREATE_FINAL_FILE(${_target_NAME}_final.cpp ${ARGN})
+      ADD_EXECUTABLE(${_target_NAME} ${_target_NAME}_final.cpp)
+   ELSE (KDE4_ENABLE_FINAL)
+      ADD_EXECUTABLE(${_target_NAME} ${ARGN} )
+   ENDIF (KDE4_ENABLE_FINAL)
+
+ENDMACRO(KDE4_ADD_EXECUTABLE _target_NAME)
+
+MACRO(KDE4_ADD_LIBRARY _target_NAME _lib_TYPE)
+#is the first argument is "WITH_PREFIX" then keep the standard "lib" prefix, otherwise set the prefix empty
+
+   SET(_first_SRC ${_lib_TYPE})
+   SET(_add_lib_param)
+
+   IF (${_lib_TYPE} STREQUAL "STATIC")
+      SET(_first_SRC)
+      SET(_add_lib_param STATIC)
+   ENDIF (${_lib_TYPE} STREQUAL "STATIC")
+   IF (${_lib_TYPE} STREQUAL "SHARED")
+      SET(_first_SRC)
+      SET(_add_lib_param SHARED)
+   ENDIF (${_lib_TYPE} STREQUAL "SHARED")
+   IF (${_lib_TYPE} STREQUAL "MODULE")
+      SET(_first_SRC)
+      SET(_add_lib_param MODULE)
+   ENDIF (${_lib_TYPE} STREQUAL "MODULE")
+
+   IF (KDE4_ENABLE_FINAL)
+      KDE4_CREATE_FINAL_FILE(${_target_NAME}_final.cpp ${_first_SRC} ${ARGN})
+      ADD_LIBRARY(${_target_NAME} ${_add_lib_param}  ${_target_NAME}_final.cpp)
+   ELSE (KDE4_ENABLE_FINAL)
+      ADD_LIBRARY(${_target_NAME} ${_add_lib_param} ${_first_SRC} ${ARGN})
+   ENDIF (KDE4_ENABLE_FINAL)
+
+ENDMACRO(KDE4_ADD_LIBRARY _target_NAME _lib_TYPE)
+
+
+MACRO(KDE4_CREATE_DOXYGEN_DOCS)
+ENDMACRO(KDE4_CREATE_DOXYGEN_DOCS)
+
diff --git a/modules/kde4init_dummy.cpp.in b/modules/kde4init_dummy.cpp.in
new file mode 100644
index 00000000..f0cd3488
--- /dev/null
+++ b/modules/kde4init_dummy.cpp.in
@@ -0,0 +1,3 @@
+extern "C" int kdemain(int argc, char* argv[]);
+extern "C" int kdeinitmain(int argc, char* argv[]) { return kdemain(argc,argv); }
+int main(int argc, char* argv[]) { return kdemain(argc,argv); }
diff --git a/modules/kde4uic.cmake b/modules/kde4uic.cmake
new file mode 100644
index 00000000..42382aac
--- /dev/null
+++ b/modules/kde4uic.cmake
@@ -0,0 +1,47 @@
+
+#using a ui3 file with uic3
+IF(KDE3_IMPL)
+
+  EXEC_PROGRAM(${KDE_UIC_EXECUTABLE} ARGS
+    -nounload -tr tr2i18n
+    -impl ${KDE_UIC_H_FILE}
+    ${KDE_UIC_FILE}
+    OUTPUT_VARIABLE _uic_CONTENTS
+  )
+ENDIF(KDE3_IMPL)
+
+
+IF(KDE3_HEADER)
+
+  EXEC_PROGRAM(${KDE_UIC_EXECUTABLE} ARGS
+    -nounload -tr tr2i18n
+    ${KDE_UIC_FILE}
+    OUTPUT_VARIABLE _uic_CONTENTS
+  )
+   SET(KDE_UIC_CPP_FILE ${KDE_UIC_H_FILE})
+ENDIF(KDE3_HEADER)
+
+# the kde4 branch
+IF (KDE4_HEADER)
+
+  EXEC_PROGRAM(${KDE_UIC_EXECUTABLE} ARGS
+    -tr tr2i18n
+    ${KDE_UIC_FILE}
+    OUTPUT_VARIABLE _uic_CONTENTS
+  )
+
+   SET(KDE_UIC_CPP_FILE ${KDE_UIC_H_FILE})
+ENDIF (KDE4_HEADER)
+
+
+#replace tr218n("") with QString::null to avoid waring from KLocale
+STRING(REGEX REPLACE "tr2i18n\\(\"\"\\)" "QString::null" _uic_CONTENTS "${_uic_CONTENTS}" )
+STRING(REGEX REPLACE "tr2i18n\\(\"\", \"\"\\)" "QString::null" _uic_CONTENTS "${_uic_CONTENTS}" )
+STRING(REGEX REPLACE "\nuic3: [^\n]+" "" _uic_CONTENTS "${_uic_CONTENTS}" )
+STRING(REGEX REPLACE "\n'[^\n]+' [^\n]+" "" _uic_CONTENTS "${_uic_CONTENTS}" )
+
+#replace image15_data with img15_filename to make enable_final work
+STRING(REGEX REPLACE "image([0-9]+)_data" "img\\1_${KDE_UIC_BASENAME}" _uic_CONTENTS "${_uic_CONTENTS}")
+
+FILE(WRITE ${KDE_UIC_CPP_FILE} "#include <kdialog.h>\n#include <klocale.h>\n\n${_uic_CONTENTS}\n")
+
diff --git a/modules/potential_problems b/modules/potential_problems
new file mode 100644
index 00000000..233949c5
--- /dev/null
+++ b/modules/potential_problems
@@ -0,0 +1,3 @@
+/CMakeLists.txt find_package(Perl REQUIRED)
+KDE4_AUTOMOC: -DQ_WS_X11
+test for bzip2