From b8dd49559136633dff9d2fe718964f8fc09feeea Mon Sep 17 00:00:00 2001 From: Kevin Kofler Date: May 26 2008 15:35:46 +0000 Subject: - restore builtin automoc4 for now --- diff --git a/akonadi-restore-builtin-automoc4.patch b/akonadi-restore-builtin-automoc4.patch new file mode 100644 index 0000000..75bdd5f --- /dev/null +++ b/akonadi-restore-builtin-automoc4.patch @@ -0,0 +1,1976 @@ +Index: cmake/automoc/kde4automoc.cpp +=================================================================== +--- cmake/automoc/kde4automoc.cpp (Revision 0) ++++ cmake/automoc/kde4automoc.cpp (Revision 801202) +@@ -0,0 +1,344 @@ ++/* This file is part of the KDE project ++ Copyright (C) 2007 Matthias Kretz ++ ++ This program is free software; you can redistribute it and/or ++ modify it under the terms of the GNU General Public License as ++ published by the Free Software Foundation; either version 2 of ++ the License, or (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software ++ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA ++ 02110-1301, USA. ++ ++*/ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++class AutoMoc ++{ ++ public: ++ AutoMoc(); ++ bool run(); ++ ++ private: ++ void generateMoc(const QString &sourceFile, const QString &mocFileName); ++ void waitForProcesses(); ++ void usage(const QString &); ++ void echoColor(const QString &msg) ++ { ++ QProcess *cmakeEcho = new QProcess; ++ cmakeEcho->setProcessChannelMode(QProcess::ForwardedChannels); ++ QStringList args(cmakeEchoColorArgs); ++ args << msg; ++ cmakeEcho->start("cmake", args, QIODevice::NotOpen); ++ processes.enqueue(Process(cmakeEcho, QString())); ++ } ++ ++ QString builddir; ++ QString mocExe; ++ QStringList mocIncludes; ++ QStringList cmakeEchoColorArgs; ++ const bool verbose; ++ QTextStream cerr; ++ QTextStream cout; ++ struct Process ++ { ++ Process(QProcess *a, const QString &b) : qproc(a), mocFilePath(b) {} ++ QProcess *qproc; ++ QString mocFilePath; ++ }; ++ QQueue processes; ++ bool failed; ++}; ++ ++void AutoMoc::usage(const QString &path) ++{ ++ cout << "usage: " << path << " " << endl; ++ ::exit(EXIT_FAILURE); ++} ++ ++int main(int argc, char **argv) ++{ ++ QCoreApplication app(argc, argv); ++ if (!AutoMoc().run()) { ++ return EXIT_FAILURE; ++ } ++ return 0; ++} ++ ++AutoMoc::AutoMoc() ++ : verbose(!qgetenv("VERBOSE").isEmpty()), cerr(stderr), cout(stdout), failed(false) ++{ ++ const QByteArray colorEnv = qgetenv("COLOR"); ++ cmakeEchoColorArgs << "-E" << "cmake_echo_color" << QString("--switch=") + colorEnv << "--blue" ++ << "--bold"; ++} ++ ++bool AutoMoc::run() ++{ ++ const QStringList args = QCoreApplication::arguments(); ++ Q_ASSERT(args.size() > 0); ++ if (args.size() < 4) { ++ usage(args[0]); ++ } ++ QFile outfile(args[1]); ++ const QFileInfo outfileInfo(outfile); ++ ++ QString srcdir(args[2]); ++ if (!srcdir.endsWith('/')) { ++ srcdir += '/'; ++ } ++ builddir = args[3]; ++ if (!builddir.endsWith('/')) { ++ builddir += '/'; ++ } ++ mocExe = args[4]; ++ ++ QFile dotFiles(args[1] + ".files"); ++ dotFiles.open(QIODevice::ReadOnly | QIODevice::Text); ++ QByteArray line = dotFiles.readLine(); ++ Q_ASSERT(line == "MOC_INCLUDES:\n"); ++ line = dotFiles.readLine().trimmed(); ++ const QStringList incPaths = QString::fromUtf8(line).split(';'); ++ foreach (const QString &path, incPaths) { ++ if (!path.isEmpty()) { ++ mocIncludes << "-I" + path; ++ } ++ } ++ line = dotFiles.readLine(); ++ Q_ASSERT(line == "SOURCES:\n"); ++ line = dotFiles.readLine().trimmed(); ++ dotFiles.close(); ++ const QStringList sourceFiles = QString::fromUtf8(line).split(';'); ++ ++ // the program goes through all .cpp files to see which moc files are included. It is not really ++ // interesting how the moc file is named, but what file the moc is created from. Once a moc is ++ // included the same moc may not be included in the _automoc.cpp file anymore. OTOH if there's a ++ // header containing Q_OBJECT where no corresponding moc file is included anywhere a ++ // moc_.cpp file is created and included in the _automoc.cpp file. ++ QHash includedMocs; // key = moc source filepath, value = moc output filepath ++ QHash notIncludedMocs; // key = moc source filepath, value = moc output filename ++ ++ QRegExp mocIncludeRegExp("[\n]\\s*#\\s*include\\s+[\"<](moc_[^ \">]+\\.cpp|[^ \">]+\\.moc)[\">]"); ++ QRegExp qObjectRegExp("[\n]\\s*Q_OBJECT\\b"); ++ QStringList headerExtensions; ++ headerExtensions << ".h" << ".hpp" << ".hxx" << ".H"; ++ foreach (const QString &absFilename, sourceFiles) { ++ //qDebug() << absFilename; ++ const QFileInfo sourceFileInfo(absFilename); ++ if (absFilename.endsWith(".cpp") || absFilename.endsWith(".cc") || ++ absFilename.endsWith(".cxx") || absFilename.endsWith(".C")) { ++ //qDebug() << "check .cpp file"; ++ QFile sourceFile(absFilename); ++ sourceFile.open(QIODevice::ReadOnly); ++ const QByteArray contents = sourceFile.readAll(); ++ if (contents.isEmpty()) { ++ cerr << "kde4automoc: empty source file: " << absFilename << endl; ++ continue; ++ } ++ const QString contentsString = QString::fromUtf8(contents); ++ const QString absPath = sourceFileInfo.absolutePath() + '/'; ++ Q_ASSERT(absPath.endsWith('/')); ++ int matchOffset = mocIncludeRegExp.indexIn(contentsString); ++ if (matchOffset < 0) { ++ // no moc #include, look whether we need to create a moc from the .h nevertheless ++ //qDebug() << "no moc #include in the .cpp file"; ++ const QString basename = sourceFileInfo.completeBaseName(); ++ const QString headername = absPath + basename + ".h"; ++ if (QFile::exists(headername) && !includedMocs.contains(headername) && ++ !notIncludedMocs.contains(headername)) { ++ const QString currentMoc = "moc_" + basename + ".cpp"; ++ QFile header(headername); ++ header.open(QIODevice::ReadOnly); ++ const QByteArray contents = header.readAll(); ++ if (qObjectRegExp.indexIn(QString::fromUtf8(contents)) >= 0) { ++ //qDebug() << "header contains Q_OBJECT macro"; ++ notIncludedMocs.insert(headername, currentMoc); ++ } ++ } ++ const QString privateHeaderName = absPath + basename + "_p.h"; ++ if (QFile::exists(privateHeaderName) && !includedMocs.contains(privateHeaderName) && ++ !notIncludedMocs.contains(privateHeaderName)) { ++ const QString currentMoc = "moc_" + basename + "_p.cpp"; ++ QFile header(privateHeaderName); ++ header.open(QIODevice::ReadOnly); ++ const QByteArray contents = header.readAll(); ++ if (qObjectRegExp.indexIn(QString::fromUtf8(contents)) >= 0) { ++ //qDebug() << "header contains Q_OBJECT macro"; ++ notIncludedMocs.insert(privateHeaderName, currentMoc); ++ } ++ } ++ } else { ++ do { // call this for every moc include in the file ++ const QString currentMoc = mocIncludeRegExp.cap(1); ++ //qDebug() << "found moc include: " << currentMoc << " at offset " << matchOffset; ++ QString basename = QFileInfo(currentMoc).completeBaseName(); ++ const bool moc_style = currentMoc.startsWith("moc_"); ++ if (moc_style || qObjectRegExp.indexIn(contentsString) < 0) { ++ if (moc_style) { ++ basename = basename.right(basename.length() - 4); ++ } ++ bool headerFound = false; ++ foreach (const QString &ext, headerExtensions) { ++ QString sourceFilePath = absPath + basename + ext; ++ if (QFile::exists(sourceFilePath)) { ++ headerFound = true; ++ includedMocs.insert(sourceFilePath, currentMoc); ++ notIncludedMocs.remove(sourceFilePath); ++ break; ++ } ++ } ++ if (!headerFound) { ++ cerr << "kde4automoc: The file \"" << absFilename << ++ "\" includes the moc file \"" << currentMoc << "\", but \"" << ++ absPath + basename + "{" + headerExtensions.join(",") + "}" << ++ "\" do not exist." << endl; ++ ::exit(EXIT_FAILURE); ++ } ++ } else { ++ includedMocs.insert(absFilename, currentMoc); ++ notIncludedMocs.remove(absFilename); ++ } ++ ++ matchOffset = mocIncludeRegExp.indexIn(contentsString, ++ matchOffset + currentMoc.length()); ++ } while(matchOffset >= 0); ++ } ++ } else if (absFilename.endsWith(".h") || absFilename.endsWith(".hpp") || ++ absFilename.endsWith(".hxx") || absFilename.endsWith(".H")) { ++ if (!includedMocs.contains(absFilename) && !notIncludedMocs.contains(absFilename)) { ++ // if this header is not getting processed yet and is explicitly mentioned for the ++ // automoc the moc is run unconditionally on the header and the resulting file is ++ // included in the _automoc.cpp file (unless there's a .cpp file later on that ++ // includes the moc from this header) ++ const QString currentMoc = "moc_" + sourceFileInfo.completeBaseName() + ".cpp"; ++ notIncludedMocs.insert(absFilename, currentMoc); ++ } ++ } else { ++ if (verbose) { ++ cout << "kde4automoc: ignoring file '" << absFilename << "' with unknown suffix" << endl; ++ } ++ } ++ } ++ ++ // run moc on all the moc's that are #included in source files ++ QHash::ConstIterator end = includedMocs.constEnd(); ++ QHash::ConstIterator it = includedMocs.constBegin(); ++ for (; it != end; ++it) { ++ generateMoc(it.key(), it.value()); ++ } ++ ++ QByteArray automocSource; ++ QTextStream outStream(&automocSource, QIODevice::WriteOnly); ++ outStream << "/* This file is autogenerated, do not edit */\n"; ++ ++ if (notIncludedMocs.isEmpty()) { ++ outStream << "enum some_compilers { need_more_than_nothing };\n"; ++ } else { ++ // run moc on the remaining headers and include them in the _automoc.cpp file ++ end = notIncludedMocs.constEnd(); ++ it = notIncludedMocs.constBegin(); ++ for (; it != end; ++it) { ++ generateMoc(it.key(), it.value()); ++ outStream << "#include \"" << it.value() << "\"\n"; ++ } ++ } ++ ++ // let all remaining moc processes finish ++ waitForProcesses(); ++ ++ if (failed) { ++ // if any moc process failed we don't want to touch the _automoc.cpp file so that ++ // kde4automoc is rerun until the issue is fixed ++ cerr << "returning failed.."<< endl; ++ return false; ++ } ++ outStream.flush(); ++ ++ // source file that includes all remaining moc files ++ outfile.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate); ++ outfile.write(automocSource); ++ outfile.close(); ++ ++ return true; ++} ++ ++void AutoMoc::waitForProcesses() ++{ ++ while (!processes.isEmpty()) { ++ Process proc = processes.dequeue(); ++ ++ bool result = proc.qproc->waitForFinished(-1); ++ //ignore errors from the cmake echo process ++ if (!proc.mocFilePath.isEmpty()) { ++ if (!result || proc.qproc->exitCode()) { ++ cerr << "kde4automoc: process for " << proc.mocFilePath ++ << " failed: " << proc.qproc->errorString() << endl; ++ cerr << "pid to wait for: " << proc.qproc->pid() << endl; ++ cerr << "processes in queue: " << processes.size() << endl; ++ failed = true; ++ QFile::remove(proc.mocFilePath); ++ } ++ } ++ delete proc.qproc; ++ } ++} ++ ++void AutoMoc::generateMoc(const QString &sourceFile, const QString &mocFileName) ++{ ++ //qDebug() << Q_FUNC_INFO << sourceFile << mocFileName; ++ const QString mocFilePath = builddir + mocFileName; ++ if (QFileInfo(mocFilePath).lastModified() < QFileInfo(sourceFile).lastModified()) { ++ if (verbose) { ++ echoColor("Generating " + mocFilePath + " from " + sourceFile); ++ } else { ++ echoColor("Generating " + mocFileName); ++ } ++ ++ // we don't want too many child processes ++#ifdef Q_OS_FREEBSD ++ static const int max_processes = 0; ++#else ++ static const int max_processes = 10; ++#endif ++ ++ if (processes.size() > max_processes) { ++ waitForProcesses(); ++ } ++ ++ QProcess *mocProc = new QProcess; ++ mocProc->setProcessChannelMode(QProcess::ForwardedChannels); ++ QStringList args(mocIncludes); ++#ifdef Q_OS_WIN ++ args << "-DWIN32"; ++#endif ++ args << "-o" << mocFilePath << sourceFile; ++ //qDebug() << "executing: " << mocExe << args; ++ mocProc->start(mocExe, args, QIODevice::NotOpen); ++ if (mocProc->waitForStarted()) ++ processes.enqueue(Process(mocProc, mocFilePath)); ++ else { ++ cerr << "kde4automoc: process for " << mocFilePath << "failed to start: " ++ << mocProc->errorString() << endl; ++ failed = true; ++ delete mocProc; ++ } ++ } ++} +Index: cmake/automoc/CMakeLists.txt +=================================================================== +--- cmake/automoc/CMakeLists.txt (Revision 0) ++++ cmake/automoc/CMakeLists.txt (Revision 801202) +@@ -0,0 +1,4 @@ ++include_directories(${QT_INCLUDE_DIR}) ++add_executable(kde4automoc kde4automoc.cpp) ++kde4_handle_rpath_for_executable(kde4automoc "RUN_UNINSTALLED") ++target_link_libraries(kde4automoc ${QT_QTCORE_LIBRARY}) +Index: cmake/modules/InstallSettings.cmake +=================================================================== +--- cmake/modules/InstallSettings.cmake (Revision 801314) ++++ cmake/modules/InstallSettings.cmake (Revision 801202) +@@ -1,136 +0,0 @@ +-# Copyright (c) 2008 Kevin Krammer +-# +-# Redistribution and use is allowed according to the terms of the BSD license. +-# For details see the accompanying COPYING-CMAKE-SCRIPTS file. +- +-set(LIB_SUFFIX "" CACHE STRING "Define suffix of directory name (32/64)" ) +- +-if (WIN32) +-# use relative install prefix to avoid hardcoded install paths in cmake_install.cmake files +- +- set(LIB_INSTALL_DIR "lib${LIB_SUFFIX}" ) # The subdirectory relative to the install prefix where libraries will be installed (default is ${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}) +- +- set(EXEC_INSTALL_PREFIX "" ) # Base directory for executables and libraries +- set(SHARE_INSTALL_PREFIX "share" ) # Base directory for files which go to share/ +- set(BIN_INSTALL_DIR "bin" ) # The install dir for executables (default ${EXEC_INSTALL_PREFIX}/bin) +- set(SBIN_INSTALL_DIR "sbin" ) # The install dir for system executables (default ${EXEC_INSTALL_PREFIX}/sbin) +- +- set(LIBEXEC_INSTALL_DIR "${BIN_INSTALL_DIR}" ) # The subdirectory relative to the install prefix where libraries will be installed (default is ${BIN_INSTALL_DIR}) +- set(INCLUDE_INSTALL_DIR "include" ) # The subdirectory to the header prefix +- +- set(PLUGIN_INSTALL_DIR "lib${LIB_SUFFIX}/kde4" ) # "The subdirectory relative to the install prefix where plugins will be installed (default is ${LIB_INSTALL_DIR}/kde4) +- set(CONFIG_INSTALL_DIR "share/config" ) # The config file install dir +- set(DATA_INSTALL_DIR "share/apps" ) # The parent directory where applications can install their data +- set(HTML_INSTALL_DIR "share/doc/HTML" ) # The HTML install dir for documentation +- set(ICON_INSTALL_DIR "share/icons" ) # The icon install dir (default ${SHARE_INSTALL_PREFIX}/share/icons/) +- set(KCFG_INSTALL_DIR "share/config.kcfg" ) # The install dir for kconfig files +- set(LOCALE_INSTALL_DIR "share/locale" ) # The install dir for translations +- set(MIME_INSTALL_DIR "share/mimelnk" ) # The install dir for the mimetype desktop files +- set(SERVICES_INSTALL_DIR "share/kde4/services" ) # The install dir for service (desktop, protocol, ...) files +- set(SERVICETYPES_INSTALL_DIR "share/kde4/servicetypes" ) # The install dir for servicestypes desktop files +- set(SOUND_INSTALL_DIR "share/sounds" ) # The install dir for sound files +- set(TEMPLATES_INSTALL_DIR "share/templates" ) # The install dir for templates (Create new file...) +- set(WALLPAPER_INSTALL_DIR "share/wallpapers" ) # The install dir for wallpapers +- set(DEMO_INSTALL_DIR "share/demos" ) # The install dir for demos +- set(KCONF_UPDATE_INSTALL_DIR "share/apps/kconf_update" ) # The kconf_update install dir +- set(AUTOSTART_INSTALL_DIR "share/autostart" ) # The install dir for autostart files +- +- set(XDG_APPS_INSTALL_DIR "share/applications/kde4" ) # The XDG apps dir +- set(XDG_DIRECTORY_INSTALL_DIR "share/desktop-directories" ) # The XDG directory +- set(XDG_MIME_INSTALL_DIR "share/mime/packages" ) # The install dir for the xdg mimetypes +- +- set(SYSCONF_INSTALL_DIR "etc" ) # The kde sysconfig install dir (default /etc) +- set(MAN_INSTALL_DIR "share/man" ) # The kde man install dir (default ${SHARE_INSTALL_PREFIX}/man/) +- set(INFO_INSTALL_DIR "share/info" ) # The kde info install dir (default ${SHARE_INSTALL_PREFIX}/info)") +- set(DBUS_INTERFACES_INSTALL_DIR "share/dbus-1/interfaces" ) # The kde dbus interfaces install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/interfaces)") +- set(DBUS_SERVICES_INSTALL_DIR "share/dbus-1/services" ) # The kde dbus services install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/services)") +- +-else (WIN32) +- +- # this macro implements some very special logic how to deal with the cache +- # by default the various install locations inherit their value from theit "parent" variable +- # so if you set CMAKE_INSTALL_PREFIX, then EXEC_INSTALL_PREFIX, PLUGIN_INSTALL_DIR will +- # calculate their value by appending subdirs to CMAKE_INSTALL_PREFIX +- # this would work completely without using the cache. +- # but if somebody wants e.g. a different EXEC_INSTALL_PREFIX this value has to go into +- # the cache, otherwise it will be forgotten on the next cmake run. +- # Once a variable is in the cache, it doesn't depend on its "parent" variables +- # anymore and you can only change it by editing it directly. +- # this macro helps in this regard, because as long as you don't set one of the +- # variables explicitely to some location, it will always calculate its value from its +- # parents. So modifying CMAKE_INSTALL_PREFIX later on will have the desired effect. +- # But once you decide to set e.g. EXEC_INSTALL_PREFIX to some special location +- # this will go into the cache and it will no longer depend on CMAKE_INSTALL_PREFIX. +- macro(_SET_FANCY _var _value _comment) +- set(predefinedvalue "${_value}") +- +- if (NOT DEFINED ${_var}) +- set(${_var} ${predefinedvalue}) +- else (NOT DEFINED ${_var}) +- set(${_var} "${${_var}}" CACHE PATH "${_comment}") +- endif (NOT DEFINED ${_var}) +- endmacro(_SET_FANCY) +- +- +- _set_fancy(EXEC_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}" "Base directory for executables and libraries") +- _set_fancy(SHARE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/share" "Base directory for files which go to share/") +- _set_fancy(BIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/bin" "The install dir for executables (default ${EXEC_INSTALL_PREFIX}/bin)") +- _set_fancy(SBIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/sbin" "The install dir for system executables (default ${EXEC_INSTALL_PREFIX}/sbin)") +- _set_fancy(LIB_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}" "The subdirectory relative to the install prefix where libraries will be installed (default is ${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX})") +- _set_fancy(LIBEXEC_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4/libexec" "The subdirectory relative to the install prefix where libraries will be installed (default is ${LIB_INSTALL_DIR}/kde4/libexec)") +- _set_fancy(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" "The subdirectory to the header prefix") +- +- _set_fancy(PLUGIN_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4" "The subdirectory relative to the install prefix where plugins will be installed (default is ${LIB_INSTALL_DIR}/kde4)") +- _set_fancy(CONFIG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config" "The config file install dir") +- _set_fancy(DATA_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/apps" "The parent directory where applications can install their data") +- _set_fancy(HTML_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/doc/HTML" "The HTML install dir for documentation") +- _set_fancy(ICON_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/icons" "The icon install dir (default ${SHARE_INSTALL_PREFIX}/share/icons/)") +- _set_fancy(KCFG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config.kcfg" "The install dir for kconfig files") +- _set_fancy(LOCALE_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/locale" "The install dir for translations") +- _set_fancy(MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mimelnk" "The install dir for the mimetype desktop files") +- _set_fancy(SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/services" "The install dir for service (desktop, protocol, ...) files") +- _set_fancy(SERVICETYPES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/servicetypes" "The install dir for servicestypes desktop files") +- _set_fancy(SOUND_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/sounds" "The install dir for sound files") +- _set_fancy(TEMPLATES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/templates" "The install dir for templates (Create new file...)") +- _set_fancy(WALLPAPER_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/wallpapers" "The install dir for wallpapers") +- _set_fancy(DEMO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/demos" "The install dir for demos") +- _set_fancy(KCONF_UPDATE_INSTALL_DIR "${DATA_INSTALL_DIR}/kconf_update" "The kconf_update install dir") +- _set_fancy(AUTOSTART_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/autostart" "The install dir for autostart files") +- +- _set_fancy(XDG_APPS_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/applications/kde4" "The XDG apps dir") +- _set_fancy(XDG_DIRECTORY_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/desktop-directories" "The XDG directory") +- _set_fancy(XDG_MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mime/packages" "The install dir for the xdg mimetypes") +- +- _set_fancy(SYSCONF_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/etc" "The kde sysconfig install dir (default ${CMAKE_INSTALL_PREFIX}/etc)") +- _set_fancy(MAN_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/man" "The kde man install dir (default ${SHARE_INSTALL_PREFIX}/man/)") +- _set_fancy(INFO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/info" "The kde info install dir (default ${SHARE_INSTALL_PREFIX}/info)") +- _set_fancy(DBUS_INTERFACES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/interfaces" "The kde dbus interfaces install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/interfaces)") +- _set_fancy(DBUS_SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/services" "The kde dbus services install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/services)") +- +-endif (WIN32) +- +-# The INSTALL_TARGETS_DEFAULT_ARGS variable should be used when libraries are installed. +-# The arguments are also ok for regular executables, i.e. executables which don't go +-# into sbin/ or libexec/, but for installing executables the basic syntax +-# INSTALL(TARGETS kate DESTINATION "${BIN_INSTALL_DIR}") +-# is enough, so using this variable there doesn't help a lot. +-# The variable must not be used for installing plugins. +-# Usage is like this: +-# install(TARGETS kdecore kdeui ${INSTALL_TARGETS_DEFAULT_ARGS} ) +-# +-# This will install libraries correctly under UNIX, OSX and Windows (i.e. dll's go +-# into bin/. +-# Later on it will be possible to extend this for installing OSX frameworks +-# The COMPONENT Devel argument has the effect that static libraries belong to the +-# "Devel" install component. If we use this also for all install() commands +-# for header files, it will be possible to install +-# -everything: make install OR cmake -P cmake_install.cmake +-# -only the development files: cmake -DCOMPONENT=Devel -P cmake_install.cmake +-# -everything except the development files: cmake -DCOMPONENT=Unspecified -P cmake_install.cmake +-# This can then also be used for packaging with cpack. +- +-set(INSTALL_TARGETS_DEFAULT_ARGS RUNTIME DESTINATION "${BIN_INSTALL_DIR}" +- LIBRARY DESTINATION "${LIB_INSTALL_DIR}" +- ARCHIVE DESTINATION "${LIB_INSTALL_DIR}" COMPONENT Devel ) +- +- +Index: cmake/modules/AkonadiInternal.cmake +=================================================================== +--- cmake/modules/AkonadiInternal.cmake (Revision 0) ++++ cmake/modules/AkonadiInternal.cmake (Revision 801202) +@@ -0,0 +1,165 @@ ++# Copyright (c) 2008 Kevin Krammer ++# ++# Redistribution and use is allowed according to the terms of the BSD license. ++# For details see the accompanying COPYING-CMAKE-SCRIPTS file. ++ ++include(FindQt4) ++include(KDE4Macros) ++include(MacroAdditionalCleanFiles) ++include(MacroLogFeature) ++ ++set (EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin) ++ ++ if (WIN32) ++ set(LIBRARY_OUTPUT_PATH ${EXECUTABLE_OUTPUT_PATH} ) ++ # CMAKE_CFG_INTDIR is the output subdirectory created e.g. by XCode and MSVC ++ set(KDE4_KCFGC_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/kconfig_compiler ) ++ set(KDE4_AUTOMOC_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/kde4automoc ) ++ set(KDE4_MEINPROC_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/meinproc4 ) ++ set(KDE4_MAKEKDEWIDGETS_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/makekdewidgets ) ++ else (WIN32) ++ set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib ) ++ set(KDE4_KCFGC_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/kconfig_compiler.shell ) ++ set(KDE4_AUTOMOC_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/kde4automoc ) ++ set(KDE4_MEINPROC_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/meinproc4.shell ) ++ set(KDE4_MAKEKDEWIDGETS_EXECUTABLE ${EXECUTABLE_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/makekdewidgets.shell ) ++ endif (WIN32) ++ ++ # when building, make automoc depend on the executable... ++ set( _KDE4_AUTOMOC_EXECUTABLE_DEP kde4automoc) ++ ++if (WIN32) ++# use relative install prefix to avoid hardcoded install paths in cmake_install.cmake files ++ ++ set(LIB_INSTALL_DIR "lib${LIB_SUFFIX}" ) # The subdirectory relative to the install prefix where libraries will be installed (default is ${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}) ++ ++ set(EXEC_INSTALL_PREFIX "" ) # Base directory for executables and libraries ++ set(SHARE_INSTALL_PREFIX "share" ) # Base directory for files which go to share/ ++ set(BIN_INSTALL_DIR "bin" ) # The install dir for executables (default ${EXEC_INSTALL_PREFIX}/bin) ++ set(SBIN_INSTALL_DIR "sbin" ) # The install dir for system executables (default ${EXEC_INSTALL_PREFIX}/sbin) ++ ++ set(LIBEXEC_INSTALL_DIR "${BIN_INSTALL_DIR}" ) # The subdirectory relative to the install prefix where libraries will be installed (default is ${BIN_INSTALL_DIR}) ++ set(INCLUDE_INSTALL_DIR "include" ) # The subdirectory to the header prefix ++ ++ set(PLUGIN_INSTALL_DIR "lib${LIB_SUFFIX}/kde4" ) # "The subdirectory relative to the install prefix where plugins will be installed (default is ${LIB_INSTALL_DIR}/kde4) ++ set(CONFIG_INSTALL_DIR "share/config" ) # The config file install dir ++ set(DATA_INSTALL_DIR "share/apps" ) # The parent directory where applications can install their data ++ set(HTML_INSTALL_DIR "share/doc/HTML" ) # The HTML install dir for documentation ++ set(ICON_INSTALL_DIR "share/icons" ) # The icon install dir (default ${SHARE_INSTALL_PREFIX}/share/icons/) ++ set(KCFG_INSTALL_DIR "share/config.kcfg" ) # The install dir for kconfig files ++ set(LOCALE_INSTALL_DIR "share/locale" ) # The install dir for translations ++ set(MIME_INSTALL_DIR "share/mimelnk" ) # The install dir for the mimetype desktop files ++ set(SERVICES_INSTALL_DIR "share/kde4/services" ) # The install dir for service (desktop, protocol, ...) files ++ set(SERVICETYPES_INSTALL_DIR "share/kde4/servicetypes" ) # The install dir for servicestypes desktop files ++ set(SOUND_INSTALL_DIR "share/sounds" ) # The install dir for sound files ++ set(TEMPLATES_INSTALL_DIR "share/templates" ) # The install dir for templates (Create new file...) ++ set(WALLPAPER_INSTALL_DIR "share/wallpapers" ) # The install dir for wallpapers ++ set(DEMO_INSTALL_DIR "share/demos" ) # The install dir for demos ++ set(KCONF_UPDATE_INSTALL_DIR "share/apps/kconf_update" ) # The kconf_update install dir ++ set(AUTOSTART_INSTALL_DIR "share/autostart" ) # The install dir for autostart files ++ ++ set(XDG_APPS_INSTALL_DIR "share/applications/kde4" ) # The XDG apps dir ++ set(XDG_DIRECTORY_INSTALL_DIR "share/desktop-directories" ) # The XDG directory ++ set(XDG_MIME_INSTALL_DIR "share/mime/packages" ) # The install dir for the xdg mimetypes ++ ++ set(SYSCONF_INSTALL_DIR "etc" ) # The kde sysconfig install dir (default /etc) ++ set(MAN_INSTALL_DIR "share/man" ) # The kde man install dir (default ${SHARE_INSTALL_PREFIX}/man/) ++ set(INFO_INSTALL_DIR "share/info" ) # The kde info install dir (default ${SHARE_INSTALL_PREFIX}/info)") ++ set(DBUS_INTERFACES_INSTALL_DIR "share/dbus-1/interfaces" ) # The kde dbus interfaces install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/interfaces)") ++ set(DBUS_SERVICES_INSTALL_DIR "share/dbus-1/services" ) # The kde dbus services install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/services)") ++ ++else (WIN32) ++ ++ # this macro implements some very special logic how to deal with the cache ++ # by default the various install locations inherit their value from theit "parent" variable ++ # so if you set CMAKE_INSTALL_PREFIX, then EXEC_INSTALL_PREFIX, PLUGIN_INSTALL_DIR will ++ # calculate their value by appending subdirs to CMAKE_INSTALL_PREFIX ++ # this would work completely without using the cache. ++ # but if somebody wants e.g. a different EXEC_INSTALL_PREFIX this value has to go into ++ # the cache, otherwise it will be forgotten on the next cmake run. ++ # Once a variable is in the cache, it doesn't depend on its "parent" variables ++ # anymore and you can only change it by editing it directly. ++ # this macro helps in this regard, because as long as you don't set one of the ++ # variables explicitely to some location, it will always calculate its value from its ++ # parents. So modifying CMAKE_INSTALL_PREFIX later on will have the desired effect. ++ # But once you decide to set e.g. EXEC_INSTALL_PREFIX to some special location ++ # this will go into the cache and it will no longer depend on CMAKE_INSTALL_PREFIX. ++ # ++ # additionally if installing to the same location as kdelibs, the other install ++ # directories are reused from the installed kdelibs ++ macro(_SET_FANCY _var _value _comment) ++ set(predefinedvalue "${_value}") ++ if ("${CMAKE_INSTALL_PREFIX}" STREQUAL "${KDE4_INSTALL_DIR}" AND DEFINED KDE4_${_var}) ++ set(predefinedvalue "${KDE4_${_var}}") ++ endif ("${CMAKE_INSTALL_PREFIX}" STREQUAL "${KDE4_INSTALL_DIR}" AND DEFINED KDE4_${_var}) ++ ++ if (NOT DEFINED ${_var}) ++ set(${_var} ${predefinedvalue}) ++ else (NOT DEFINED ${_var}) ++ set(${_var} "${${_var}}" CACHE PATH "${_comment}") ++ endif (NOT DEFINED ${_var}) ++ endmacro(_SET_FANCY) ++ ++ ++ _set_fancy(EXEC_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}" "Base directory for executables and libraries") ++ _set_fancy(SHARE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/share" "Base directory for files which go to share/") ++ _set_fancy(BIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/bin" "The install dir for executables (default ${EXEC_INSTALL_PREFIX}/bin)") ++ _set_fancy(SBIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/sbin" "The install dir for system executables (default ${EXEC_INSTALL_PREFIX}/sbin)") ++ _set_fancy(LIB_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}" "The subdirectory relative to the install prefix where libraries will be installed (default is ${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX})") ++ _set_fancy(LIBEXEC_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4/libexec" "The subdirectory relative to the install prefix where libraries will be installed (default is ${LIB_INSTALL_DIR}/kde4/libexec)") ++ _set_fancy(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" "The subdirectory to the header prefix") ++ ++ _set_fancy(PLUGIN_INSTALL_DIR "${LIB_INSTALL_DIR}/kde4" "The subdirectory relative to the install prefix where plugins will be installed (default is ${LIB_INSTALL_DIR}/kde4)") ++ _set_fancy(CONFIG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config" "The config file install dir") ++ _set_fancy(DATA_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/apps" "The parent directory where applications can install their data") ++ _set_fancy(HTML_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/doc/HTML" "The HTML install dir for documentation") ++ _set_fancy(ICON_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/icons" "The icon install dir (default ${SHARE_INSTALL_PREFIX}/share/icons/)") ++ _set_fancy(KCFG_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/config.kcfg" "The install dir for kconfig files") ++ _set_fancy(LOCALE_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/locale" "The install dir for translations") ++ _set_fancy(MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mimelnk" "The install dir for the mimetype desktop files") ++ _set_fancy(SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/services" "The install dir for service (desktop, protocol, ...) files") ++ _set_fancy(SERVICETYPES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/kde4/servicetypes" "The install dir for servicestypes desktop files") ++ _set_fancy(SOUND_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/sounds" "The install dir for sound files") ++ _set_fancy(TEMPLATES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/templates" "The install dir for templates (Create new file...)") ++ _set_fancy(WALLPAPER_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/wallpapers" "The install dir for wallpapers") ++ _set_fancy(DEMO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/demos" "The install dir for demos") ++ _set_fancy(KCONF_UPDATE_INSTALL_DIR "${DATA_INSTALL_DIR}/kconf_update" "The kconf_update install dir") ++ _set_fancy(AUTOSTART_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/autostart" "The install dir for autostart files") ++ ++ _set_fancy(XDG_APPS_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/applications/kde4" "The XDG apps dir") ++ _set_fancy(XDG_DIRECTORY_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/desktop-directories" "The XDG directory") ++ _set_fancy(XDG_MIME_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/mime/packages" "The install dir for the xdg mimetypes") ++ ++ _set_fancy(SYSCONF_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/etc" "The kde sysconfig install dir (default ${CMAKE_INSTALL_PREFIX}/etc)") ++ _set_fancy(MAN_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/man" "The kde man install dir (default ${SHARE_INSTALL_PREFIX}/man/)") ++ _set_fancy(INFO_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/info" "The kde info install dir (default ${SHARE_INSTALL_PREFIX}/info)") ++ _set_fancy(DBUS_INTERFACES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/interfaces" "The kde dbus interfaces install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/interfaces)") ++ _set_fancy(DBUS_SERVICES_INSTALL_DIR "${SHARE_INSTALL_PREFIX}/dbus-1/services" "The kde dbus services install dir (default ${SHARE_INSTALL_PREFIX}/dbus-1/services)") ++ ++endif (WIN32) ++ ++# The INSTALL_TARGETS_DEFAULT_ARGS variable should be used when libraries are installed. ++# The arguments are also ok for regular executables, i.e. executables which don't go ++# into sbin/ or libexec/, but for installing executables the basic syntax ++# INSTALL(TARGETS kate DESTINATION "${BIN_INSTALL_DIR}") ++# is enough, so using this variable there doesn't help a lot. ++# The variable must not be used for installing plugins. ++# Usage is like this: ++# install(TARGETS kdecore kdeui ${INSTALL_TARGETS_DEFAULT_ARGS} ) ++# ++# This will install libraries correctly under UNIX, OSX and Windows (i.e. dll's go ++# into bin/. ++# Later on it will be possible to extend this for installing OSX frameworks ++# The COMPONENT Devel argument has the effect that static libraries belong to the ++# "Devel" install component. If we use this also for all install() commands ++# for header files, it will be possible to install ++# -everything: make install OR cmake -P cmake_install.cmake ++# -only the development files: cmake -DCOMPONENT=Devel -P cmake_install.cmake ++# -everything except the development files: cmake -DCOMPONENT=Unspecified -P cmake_install.cmake ++# This can then also be used for packaging with cpack. ++ ++set(INSTALL_TARGETS_DEFAULT_ARGS RUNTIME DESTINATION "${BIN_INSTALL_DIR}" ++ LIBRARY DESTINATION "${LIB_INSTALL_DIR}" ++ ARCHIVE DESTINATION "${LIB_INSTALL_DIR}" COMPONENT Devel ) ++ ++ +Index: cmake/modules/kde4_exec_via_sh.cmake +=================================================================== +--- cmake/modules/kde4_exec_via_sh.cmake (Revision 0) ++++ cmake/modules/kde4_exec_via_sh.cmake (Revision 801202) +@@ -0,0 +1,31 @@ ++ ++# Copyright (c) 2006, Alexander Neundorf, ++# ++# Redistribution and use is allowed according to the terms of the BSD license. ++# For details see the accompanying COPYING-CMAKE-SCRIPTS file. ++ ++ ++if (UNIX) ++ ++file(WRITE "${_filename}" ++"#!/bin/sh ++# created by cmake, don't edit, changes will be lost ++ ++${_library_path_variable}=${_ld_library_path}\${${_library_path_variable}:+:\$${_library_path_variable}} \"${_executable}\" \"$@\" ++") ++ ++# make it executable ++# since this is only executed on UNIX, it is safe to call chmod ++exec_program(chmod ARGS ug+x \"${_filename}\" OUTPUT_VARIABLE _dummy ) ++ ++else (UNIX) ++ ++file(TO_NATIVE_PATH "${_ld_library_path}" win_path) ++ ++file(WRITE "${_filename}" ++" ++set PATH=${win_path};$ENV{PATH} ++\"${_executable}\" %* ++") ++ ++endif (UNIX) +Index: cmake/modules/kde4automoc.files.in +=================================================================== +--- cmake/modules/kde4automoc.files.in (Revision 0) ++++ cmake/modules/kde4automoc.files.in (Revision 801202) +@@ -0,0 +1,4 @@ ++MOC_INCLUDES: ++@_moc_incs@ ++SOURCES: ++@_moc_files@ +Index: cmake/modules/KDE4Macros.cmake +=================================================================== +--- cmake/modules/KDE4Macros.cmake (Revision 0) ++++ cmake/modules/KDE4Macros.cmake (Revision 801202) +@@ -0,0 +1,1131 @@ ++# for documentation look at FindKDE4Internal.cmake ++ ++# this file contains the following macros: ++# KDE4_ADD_UI_FILES ++# KDE4_ADD_UI3_FILES ++# KDE4_ADD_KCFG_FILES ++# KDE4_SET_CUSTOM_TARGET_PROPERTY ++# KDE4_GET_CUSTOM_TARGET_PROPERTY ++# KDE4_MOC_HEADERS ++# KDE4_HANDLE_AUTOMOC ++# KDE4_CREATE_FINAL_FILES ++# KDE4_ADD_PLUGIN ++# KDE4_ADD_KDEINIT_EXECUTABLE ++# KDE4_ADD_UNIT_TEST ++# KDE4_ADD_EXECUTABLE ++# KDE4_ADD_WIDGET_FILES ++# KDE4_UPDATE_ICONCACHE ++# KDE4_INSTALL_ICONS ++# KDE4_REMOVE_OBSOLETE_CMAKE_FILES ++# KDE4_NO_ENABLE_FINAL ++# KDE4_CREATE_HANDBOOK ++# KDE4_ADD_APP_ICON ++# KDE4_CREATE_MANPAGE ++ ++# Copyright (c) 2006, 2007, Alexander Neundorf, ++# Copyright (c) 2006, 2007, Laurent Montel, ++# Copyright (c) 2007 Matthias Kretz ++# ++# Redistribution and use is allowed according to the terms of the BSD license. ++# For details see the accompanying COPYING-CMAKE-SCRIPTS file. ++ ++macro (KDE4_ADD_KCFG_FILES _sources ) ++ if( ${ARGV1} STREQUAL "GENERATE_MOC" ) ++ set(_kcfg_generatemoc TRUE) ++ endif( ${ARGV1} STREQUAL "GENERATE_MOC" ) ++ ++ foreach (_current_FILE ${ARGN}) ++ ++ if(NOT ${_current_FILE} STREQUAL "GENERATE_MOC") ++ get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE) ++ get_filename_component(_abs_PATH ${_tmp_FILE} PATH) ++ get_filename_component(_basename ${_tmp_FILE} NAME_WE) ++ ++ file(READ ${_tmp_FILE} _contents) ++ string(REGEX REPLACE "^(.*\n)?File=([^\n]+kcfg).*\n.*$" "\\2" _kcfg_FILE "${_contents}") ++ set(_src_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.cpp) ++ set(_header_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.h) ++ set(_moc_FILE ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.moc) ++ ++ # the command for creating the source file from the kcfg file ++ add_custom_command(OUTPUT ${_header_FILE} ${_src_FILE} ++ COMMAND ${KDE4_KCFGC_EXECUTABLE} ++ ARGS ${_abs_PATH}/${_kcfg_FILE} ${_tmp_FILE} -d ${CMAKE_CURRENT_BINARY_DIR} ++ MAIN_DEPENDENCY ${_tmp_FILE} ++ DEPENDS ${_abs_PATH}/${_kcfg_FILE} ${_KDE4_KCONFIG_COMPILER_DEP} ) ++ ++ if(_kcfg_generatemoc) ++ qt4_generate_moc(${_header_FILE} ${_moc_FILE} ) ++ set_source_files_properties(${_src_FILE} PROPERTIES SKIP_AUTOMOC TRUE) # don't run automoc on this file ++ list(APPEND ${_sources} ${_moc_FILE}) ++ endif(_kcfg_generatemoc) ++ ++ list(APPEND ${_sources} ${_src_FILE} ${_header_FILE}) ++ endif(NOT ${_current_FILE} STREQUAL "GENERATE_MOC") ++ endforeach (_current_FILE) ++ ++endmacro (KDE4_ADD_KCFG_FILES) ++ ++ ++GET_FILENAME_COMPONENT(KDE4_MODULE_DIR ${CMAKE_CURRENT_LIST_FILE} PATH) ++ ++#create the implementation files from the ui files and add them to the list of sources ++#usage: KDE4_ADD_UI_FILES(foo_SRCS ${ui_files}) ++macro (KDE4_ADD_UI_FILES _sources ) ++ foreach (_current_FILE ${ARGN}) ++ ++ get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE) ++ get_filename_component(_basename ${_tmp_FILE} NAME_WE) ++ set(_header ${CMAKE_CURRENT_BINARY_DIR}/ui_${_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 ${KDE4_MODULE_DIR}/kde4uic.cmake ++ MAIN_DEPENDENCY ${_tmp_FILE} ++ ) ++ list(APPEND ${_sources} ${_header}) ++ 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: KDE4_ADD_UI3_FILES(foo_SRCS ${ui_files}) ++macro (KDE4_ADD_UI3_FILES _sources ) ++ ++ qt4_get_moc_inc_dirs(_moc_INCS) ++ ++ foreach (_current_FILE ${ARGN}) ++ ++ get_filename_component(_tmp_FILE ${_current_FILE} ABSOLUTE) ++ 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 ${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 ${KDE4_MODULE_DIR}/kde4uic.cmake ++ MAIN_DEPENDENCY ${_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 ${KDE4_MODULE_DIR}/kde4uic.cmake ++ MAIN_DEPENDENCY ${_header} ++ ) ++ ++ add_custom_command(OUTPUT ${_moc} ++ COMMAND ${QT_MOC_EXECUTABLE} ++ ARGS ${_moc_INCS} ${_header} -o ${_moc} ++ MAIN_DEPENDENCY ${_header} ++ ) ++ list(APPEND ${_sources} ${_src} ${_moc} ) ++ ++ endforeach (_current_FILE) ++endmacro (KDE4_ADD_UI3_FILES) ++ ++macro (KDE4_SET_CUSTOM_TARGET_PROPERTY _target_name _property_name _property) ++ string(REGEX REPLACE "[/ ]" "_" _dir "${CMAKE_CURRENT_SOURCE_DIR}") ++ set(_kde4_${_dir}_${_target_name}_${_property_name} "${_property}") ++endmacro (KDE4_SET_CUSTOM_TARGET_PROPERTY) ++ ++ ++macro (KDE4_GET_CUSTOM_TARGET_PROPERTY _var _target_name _property_name) ++ string(REGEX REPLACE "[/ ]" "_" _dir "${CMAKE_CURRENT_SOURCE_DIR}") ++ set(${_var} "${_kde4_${_dir}_${_target_name}_${_property_name}}") ++endmacro (KDE4_GET_CUSTOM_TARGET_PROPERTY) ++ ++ ++macro (KDE4_MOC_HEADERS _target_NAME) ++ set (_headers_to_moc) ++ foreach (_current_FILE ${ARGN}) ++ get_filename_component(_suffix "${_current_FILE}" EXT) ++ if (".h" STREQUAL "${_suffix}" OR ".hpp" STREQUAL "${_suffix}" OR ".hxx" STREQUAL "${_suffix}" OR ".H" STREQUAL "${_suffix}") ++ list(APPEND _headers_to_moc ${_current_FILE}) ++ else (".h" STREQUAL "${_suffix}" OR ".hpp" STREQUAL "${_suffix}" OR ".hxx" STREQUAL "${_suffix}" OR ".H" STREQUAL "${_suffix}") ++ message(STATUS "KDE4_MOC_HEADERS: ignoring non-header file ${_current_FILE}") ++ endif (".h" STREQUAL "${_suffix}" OR ".hpp" STREQUAL "${_suffix}" OR ".hxx" STREQUAL "${_suffix}" OR ".H" STREQUAL "${_suffix}") ++ endforeach (_current_FILE) ++ # need to create moc_.cpp file using kde4automoc.cmake ++ # and add it to the target ++ if(_headers_to_moc) ++ kde4_set_custom_target_property(${_target_NAME} AUTOMOC_HEADERS "${_headers_to_moc}") ++ endif(_headers_to_moc) ++endmacro (KDE4_MOC_HEADERS) ++ ++macro(KDE4_HANDLE_AUTOMOC _target_NAME _SRCS) ++ set(_moc_files) ++ set(_moc_headers) ++ ++ # first list all explicitly set headers ++ kde4_get_custom_target_property(_headers_to_moc ${_target_NAME} AUTOMOC_HEADERS) ++ if(NOT _headers_to_moc STREQUAL "NOTFOUND") ++ foreach(_header_to_moc ${_headers_to_moc}) ++ get_filename_component(_abs_header ${_header_to_moc} ABSOLUTE) ++ list(APPEND _moc_files ${_abs_header}) ++ list(APPEND _moc_headers ${_abs_header}) ++ endforeach(_header_to_moc) ++ endif(NOT _headers_to_moc STREQUAL "NOTFOUND") ++ ++ # now add all the sources for the automoc ++ foreach (_current_FILE ${${_SRCS}}) ++ get_filename_component(_abs_current_FILE "${_current_FILE}" ABSOLUTE) ++ get_source_file_property(_skip "${_abs_current_FILE}" SKIP_AUTOMOC) ++ get_source_file_property(_generated "${_abs_current_FILE}" GENERATED) ++ ++ if(NOT _generated AND NOT _skip) ++ get_filename_component(_suffix "${_current_FILE}" EXT) ++ # skip every source file that's not C++ ++ if(_suffix STREQUAL ".cpp" OR _suffix STREQUAL ".cc" OR _suffix STREQUAL ".cxx" OR _suffix STREQUAL ".C") ++ get_filename_component(_basename "${_current_FILE}" NAME_WE) ++ get_filename_component(_abs_path "${_abs_current_FILE}" PATH) ++ set(_header "${_abs_path}/${_basename}.h") ++ if(EXISTS "${_header}") ++ list(APPEND _moc_headers ${_header}) ++ endif(EXISTS "${_header}") ++ set(_pheader "${_abs_path}/${_basename}_p.h") ++ if(EXISTS "${_pheader}") ++ list(APPEND _moc_headers ${_pheader}) ++ endif(EXISTS "${_pheader}") ++ list(APPEND _moc_files ${_abs_current_FILE}) ++ endif(_suffix STREQUAL ".cpp" OR _suffix STREQUAL ".cc" OR _suffix STREQUAL ".cxx" OR _suffix STREQUAL ".C") ++ endif(NOT _generated AND NOT _skip) ++ endforeach (_current_FILE) ++ ++ if(_moc_files) ++ set(_automoc_source "${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_automoc.cpp") ++ get_directory_property(_moc_incs INCLUDE_DIRECTORIES) ++ configure_file(${KDE4_MODULE_DIR}/kde4automoc.files.in ${_automoc_source}.files) ++ add_custom_command(OUTPUT ${_automoc_source} ++ COMMAND ${KDE4_AUTOMOC_EXECUTABLE} ++ ${_automoc_source} ++ ${CMAKE_CURRENT_SOURCE_DIR} ++ ${CMAKE_CURRENT_BINARY_DIR} ++ ${QT_MOC_EXECUTABLE} ++ DEPENDS ${${_SRCS}} ${_moc_headers} ${_automoc_source}.files ${_KDE4_AUTOMOC_EXECUTABLE_DEP} ++ ) ++ # the OBJECT_DEPENDS is only necessary when a new moc file has to be generated that is included in a source file ++ # problem: the whole target is recompiled when the automoc.cpp file is touched ++ # set_source_files_properties(${${_SRCS}} PROPERTIES OBJECT_DEPENDS ${_automoc_source}) ++ set(${_SRCS} ${_automoc_source} ${${_SRCS}}) ++ endif(_moc_files) ++endmacro(KDE4_HANDLE_AUTOMOC) ++ ++macro(KDE4_INSTALL_TS_FILES _lang _sdir) ++ file(GLOB_RECURSE _ts_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${_sdir}/*) ++ foreach(_current_TS_FILES ${_ts_files}) ++ string(REGEX MATCH "\\.svn/" _in_svn ${_current_TS_FILES}) ++ if(NOT _in_svn) ++ get_filename_component(_subpath ${_current_TS_FILES} PATH) ++ install(FILES ${_current_TS_FILES} DESTINATION ${LOCALE_INSTALL_DIR}/${_lang}/LC_SCRIPTS/${_subpath}) ++ endif(NOT _in_svn) ++ endforeach(_current_TS_FILES) ++endmacro(KDE4_INSTALL_TS_FILES) ++ ++macro (KDE4_INSTALL_HANDBOOK _lang) ++ message(STATUS "KDE4_INSTALL_HANDBOOK() is deprecated. Remove it please. Now all is done in KDE4_CREATE_HANDBOOK.") ++endmacro (KDE4_INSTALL_HANDBOOK ) ++ ++ ++macro (KDE4_CREATE_HANDBOOK _docbook) ++ get_filename_component(_input ${_docbook} ABSOLUTE) ++ set(_doc ${CMAKE_CURRENT_BINARY_DIR}/index.cache.bz2) ++ ++ #Bootstrap ++ if (_kdeBootStrapping) ++ set(_ssheet ${CMAKE_SOURCE_DIR}/kdoctools/customization/kde-chunk.xsl) ++ set(_bootstrapOption "--srcdir=${CMAKE_SOURCE_DIR}/kdoctools/") ++ else (_kdeBootStrapping) ++ set(_ssheet ${KDE4_DATA_INSTALL_DIR}/ksgmltools2/customization/kde-chunk.xsl) ++ set(_bootstrapOption) ++ endif (_kdeBootStrapping) ++ ++ file(GLOB _docs *.docbook) ++ add_custom_command(OUTPUT ${_doc} ++ COMMAND ${KDE4_MEINPROC_EXECUTABLE} --check ${_bootstrapOption} --cache ${_doc} ${_input} ++ DEPENDS ${_docs} ${_KDE4_MEINPROC_EXECUTABLE_DEP} ${_ssheet} ++ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} ++ ) ++ get_filename_component(_targ ${CMAKE_CURRENT_SOURCE_DIR} NAME) ++ set(_targ "${_targ}-handbook") ++ add_custom_target(${_targ} ALL DEPENDS ${_doc}) ++ ++ if(KDE4_ENABLE_HTMLHANDBOOK) ++ set(_htmlDoc ${CMAKE_CURRENT_SOURCE_DIR}/index.html) ++ add_custom_command(OUTPUT ${_htmlDoc} ++ COMMAND ${KDE4_MEINPROC_EXECUTABLE} --check ${_bootstrapOption} -o ${_htmlDoc} ${_input} ++ DEPENDS ${_input} ${_KDE4_MEINPROC_EXECUTABLE_DEP} ${_ssheet} ++ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} ++ ) ++ add_custom_target(htmlhandbook DEPENDS ${_htmlDoc}) ++ endif(KDE4_ENABLE_HTMLHANDBOOK) ++ ++ set(_args ${ARGN}) ++ ++ set(_installDest) ++ if(_args) ++ list(GET _args 0 _tmp) ++ if("${_tmp}" STREQUAL "INSTALL_DESTINATION") ++ list(GET _args 1 _installDest ) ++ list(REMOVE_AT _args 0 1) ++ endif("${_tmp}" STREQUAL "INSTALL_DESTINATION") ++ endif(_args) ++ ++ get_filename_component(dirname ${CMAKE_CURRENT_SOURCE_DIR} NAME_WE) ++ if(_args) ++ list(GET _args 0 _tmp) ++ if("${_tmp}" STREQUAL "SUBDIR") ++ list(GET _args 1 dirname ) ++ list(REMOVE_AT _args 0 1) ++ endif("${_tmp}" STREQUAL "SUBDIR") ++ endif(_args) ++ ++ if(_installDest) ++ file(GLOB _images *.png) ++ install(FILES ${_doc} ${_docs} ${_images} DESTINATION ${_installDest}/${dirname}) ++ # TODO symlinks on non-unix platforms ++ if (UNIX) ++ # execute some cmake code on make install which creates the symlink ++ install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink \"${_installDest}/common\" \"\$ENV{DESTDIR}${_installDest}/${dirname}/common\" )" ) ++ endif (UNIX) ++ endif(_installDest) ++ ++endmacro (KDE4_CREATE_HANDBOOK) ++ ++ ++macro (KDE4_CREATE_MANPAGE _docbook _section) ++ get_filename_component(_input ${_docbook} ABSOLUTE) ++ get_filename_component(_base ${_input} NAME_WE) ++ ++ set(_doc ${CMAKE_CURRENT_BINARY_DIR}/${_base}.${_section}) ++ # sometimes we have "man-" prepended ++ string(REGEX REPLACE "/man-" "/" _outdoc ${_doc}) ++ ++ #Bootstrap ++ if (_kdeBootStrapping) ++ set(_ssheet "${CMAKE_SOURCE_DIR}/kdoctools/docbook/xsl/manpages/docbook.xsl") ++ set(_bootstrapOption "--srcdir=${CMAKE_SOURCE_DIR}/kdoctools/") ++ else (_kdeBootStrapping) ++ set(_ssheet "${KDE4_DATA_INSTALL_DIR}/ksgmltools2/docbook/xsl/manpages/docbook.xsl") ++ set(_bootstrapOption) ++ endif (_kdeBootStrapping) ++ ++ add_custom_command(OUTPUT ${_outdoc} ++ COMMAND ${KDE4_MEINPROC_EXECUTABLE} --stylesheet ${_ssheet} --check ${_bootstrapOption} ${_input} ++ DEPENDS ${_input} ${_KDE4_MEINPROC_EXECUTABLE_DEP} ${_ssheet} ++ ) ++ get_filename_component(_targ ${CMAKE_CURRENT_SOURCE_DIR} NAME) ++ set(_targ "${_targ}-manpage") ++ add_custom_target(${_targ} ALL DEPENDS "${_outdoc}") ++ ++ set(_args ${ARGN}) ++ ++ set(_installDest) ++ if(_args) ++ list(GET _args 0 _tmp) ++ if("${_tmp}" STREQUAL "INSTALL_DESTINATION") ++ list(GET _args 1 _installDest ) ++ list(REMOVE_AT _args 0 1) ++ endif("${_tmp}" STREQUAL "INSTALL_DESTINATION") ++ endif(_args) ++ ++ get_filename_component(dirname ${CMAKE_CURRENT_SOURCE_DIR} NAME_WE) ++ if(_args) ++ list(GET _args 0 _tmp) ++ if("${_tmp}" STREQUAL "SUBDIR") ++ list(GET _args 1 dirname ) ++ list(REMOVE_AT _args 0 1) ++ endif("${_tmp}" STREQUAL "SUBDIR") ++ endif(_args) ++ ++ if(_installDest) ++ install(FILES ${_outdoc} DESTINATION ${_installDest}/man${_section}) ++ endif(_installDest) ++endmacro (KDE4_CREATE_MANPAGE) ++ ++ ++macro (KDE4_UPDATE_ICONCACHE) ++ # Update mtime of hicolor icon theme dir. ++ # We don't always have touch command (e.g. on Windows), so instead create ++ # and delete a temporary file in the theme dir. ++ install(CODE " ++ set(DESTDIR_VALUE \"\$ENV{DESTDIR}\") ++ if (NOT DESTDIR_VALUE) ++ file(WRITE \"${ICON_INSTALL_DIR}/hicolor/temp.txt\" \"update\") ++ file(REMOVE \"${ICON_INSTALL_DIR}/hicolor/temp.txt\") ++ endif (NOT DESTDIR_VALUE) ++ ") ++endmacro (KDE4_UPDATE_ICONCACHE) ++ ++# a "map" of short type names to the directories ++# unknown names should give empty results ++# KDE 3 compatibility ++set(_KDE4_ICON_GROUP_mime "mimetypes") ++set(_KDE4_ICON_GROUP_filesys "places") ++set(_KDE4_ICON_GROUP_device "devices") ++set(_KDE4_ICON_GROUP_app "apps") ++set(_KDE4_ICON_GROUP_action "actions") ++# KDE 4 / icon naming specification compatibility ++set(_KDE4_ICON_GROUP_mimetypes "mimetypes") ++set(_KDE4_ICON_GROUP_places "places") ++set(_KDE4_ICON_GROUP_devices "devices") ++set(_KDE4_ICON_GROUP_apps "apps") ++set(_KDE4_ICON_GROUP_actions "actions") ++set(_KDE4_ICON_GROUP_categories "categories") ++set(_KDE4_ICON_GROUP_status "status") ++set(_KDE4_ICON_GROUP_emblems "emblems") ++set(_KDE4_ICON_GROUP_emotes "emotes") ++set(_KDE4_ICON_GROUP_animations "animations") ++set(_KDE4_ICON_GROUP_intl "intl") ++ ++# a "map" of short theme names to the theme directory ++set(_KDE4_ICON_THEME_ox "oxygen") ++set(_KDE4_ICON_THEME_cr "crystalsvg") ++set(_KDE4_ICON_THEME_lo "locolor") ++set(_KDE4_ICON_THEME_hi "hicolor") ++ ++ ++# only used internally by KDE4_INSTALL_ICONS ++macro (_KDE4_ADD_ICON_INSTALL_RULE _install_SCRIPT _install_PATH _group _orig_NAME _install_NAME _l10n_SUBDIR) ++ ++ # if the string doesn't match the pattern, the result is the full string, so all three have the same content ++ if (NOT ${_group} STREQUAL ${_install_NAME} ) ++ set(_icon_GROUP ${_KDE4_ICON_GROUP_${_group}}) ++ if(NOT _icon_GROUP) ++ set(_icon_GROUP "actions") ++ endif(NOT _icon_GROUP) ++# message(STATUS "icon: ${_current_ICON} size: ${_size} group: ${_group} name: ${_name} l10n: ${_l10n_SUBDIR}") ++ install(FILES ${_orig_NAME} DESTINATION ${_install_PATH}/${_icon_GROUP}/${_l10n_SUBDIR}/ RENAME ${_install_NAME} ) ++ endif (NOT ${_group} STREQUAL ${_install_NAME} ) ++ ++endmacro (_KDE4_ADD_ICON_INSTALL_RULE) ++ ++ ++macro (KDE4_INSTALL_ICONS _defaultpath ) ++ ++ # the l10n-subdir if language given as second argument (localized icon) ++ set(_lang ${ARGV1}) ++ if(_lang) ++ set(_l10n_SUBDIR l10n/${_lang}) ++ else(_lang) ++ set(_l10n_SUBDIR ".") ++ endif(_lang) ++ ++ # first the png icons ++ file(GLOB _icons *.png) ++ foreach (_current_ICON ${_icons} ) ++ string(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\1" _type "${_current_ICON}") ++ string(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\2" _size "${_current_ICON}") ++ string(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\3" _group "${_current_ICON}") ++ string(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.png)$" "\\4" _name "${_current_ICON}") ++ ++ set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}}) ++ if( _theme_GROUP) ++ _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake ++ ${_defaultpath}/${_theme_GROUP}/${_size}x${_size} ++ ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR}) ++ endif( _theme_GROUP) ++ endforeach (_current_ICON) ++ ++ # mng icons ++ file(GLOB _icons *.mng) ++ foreach (_current_ICON ${_icons} ) ++ STRING(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" "\\1" _type "${_current_ICON}") ++ STRING(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" "\\2" _size "${_current_ICON}") ++ STRING(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" "\\3" _group "${_current_ICON}") ++ STRING(REGEX REPLACE "^.*/([a-zA-Z]+)([0-9]+)\\-([a-z]+)\\-(.+\\.mng)$" "\\4" _name "${_current_ICON}") ++ ++ set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}}) ++ if( _theme_GROUP) ++ _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake ++ ${_defaultpath}/${_theme_GROUP}/${_size}x${_size} ++ ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR}) ++ endif( _theme_GROUP) ++ endforeach (_current_ICON) ++ ++ # and now the svg icons ++ file(GLOB _icons *.svgz) ++ foreach (_current_ICON ${_icons} ) ++ STRING(REGEX REPLACE "^.*/([a-zA-Z]+)sc\\-([a-z]+)\\-(.+\\.svgz)$" "\\1" _type "${_current_ICON}") ++ STRING(REGEX REPLACE "^.*/([a-zA-Z]+)sc\\-([a-z]+)\\-(.+\\.svgz)$" "\\2" _group "${_current_ICON}") ++ STRING(REGEX REPLACE "^.*/([a-zA-Z]+)sc\\-([a-z]+)\\-(.+\\.svgz)$" "\\3" _name "${_current_ICON}") ++ ++ set(_theme_GROUP ${_KDE4_ICON_THEME_${_type}}) ++ if( _theme_GROUP) ++ _KDE4_ADD_ICON_INSTALL_RULE(${CMAKE_CURRENT_BINARY_DIR}/install_icons.cmake ++ ${_defaultpath}/${_theme_GROUP}/scalable ++ ${_group} ${_current_ICON} ${_name} ${_l10n_SUBDIR}) ++ endif( _theme_GROUP) ++ endforeach (_current_ICON) ++ ++ KDE4_UPDATE_ICONCACHE() ++ ++endmacro (KDE4_INSTALL_ICONS) ++ ++ ++# For all C++ sources a big source file which includes all the files ++# is created. ++# This is not done for the C sources, they are just gathered in a separate list ++# because they are usually not written by KDE and as such not intended to be ++# compiled all-in-one. ++macro (KDE4_CREATE_FINAL_FILES _filenameCPP _filesExcludedFromFinalFile ) ++ set(${_filesExcludedFromFinalFile}) ++ file(WRITE "${_filenameCPP}" "//autogenerated file\n") ++ foreach (_current_FILE ${ARGN}) ++ get_filename_component(_abs_FILE "${_current_FILE}" ABSOLUTE) ++ # don't include any generated files in the final-file ++ # because then cmake will not know the dependencies ++ get_source_file_property(_isGenerated "${_abs_FILE}" GENERATED) ++ if (_isGenerated) ++ list(APPEND ${_filesExcludedFromFinalFile} "${_abs_FILE}") ++ else (_isGenerated) ++ # only put C++ files in the final-file ++ if("${_abs_FILE}" MATCHES ".+\\.(cpp|cc|cxx|C)$") ++ file(APPEND "${_filenameCPP}" "#include \"${_abs_FILE}\"\n") ++ else("${_abs_FILE}" MATCHES ".+\\.(cpp|cc|cxx|C)$") ++ list(APPEND ${_filesExcludedFromFinalFile} "${_abs_FILE}") ++ endif("${_abs_FILE}" MATCHES ".+\\.(cpp|cc|cxx|C)$") ++ endif (_isGenerated) ++ endforeach (_current_FILE) ++ ++endmacro (KDE4_CREATE_FINAL_FILES) ++ ++# This macro sets the RPATH related options for libraries, plugins and kdeinit executables. ++# It overrides the defaults set in FindKDE4Internal.cmake. ++# If RPATH is not explicitly disabled, libraries and plugins are built without RPATH, in ++# the hope that the RPATH which is compiled into the executable is good enough. ++macro (KDE4_HANDLE_RPATH_FOR_LIBRARY _target_NAME) ++ if (NOT CMAKE_SKIP_RPATH) ++ if(KDE4_USE_ALWAYS_FULL_RPATH) ++ set_target_properties(${_target_NAME} PROPERTIES SKIP_BUILD_RPATH FALSE BUILD_WITH_INSTALL_RPATH FALSE) ++ else(KDE4_USE_ALWAYS_FULL_RPATH) ++ set_target_properties(${_target_NAME} PROPERTIES INSTALL_RPATH_USE_LINK_PATH FALSE SKIP_BUILD_RPATH TRUE BUILD_WITH_INSTALL_RPATH TRUE INSTALL_RPATH "") ++ endif(KDE4_USE_ALWAYS_FULL_RPATH) ++ endif (NOT CMAKE_SKIP_RPATH) ++endmacro (KDE4_HANDLE_RPATH_FOR_LIBRARY) ++ ++# This macro sets the RPATH related options for executables ++# and creates wrapper shell scripts for the executables. ++# It overrides the defaults set in FindKDE4Internal.cmake. ++# For every executable a wrapper script is created, which sets the appropriate ++# environment variable for the platform (LD_LIBRARY_PATH on most UNIX systems, ++# DYLD_LIBRARY_PATH on OS X and PATH in Windows) so that it points to the built ++# but not yet installed versions of the libraries. So if RPATH is disabled, the executables ++# can be run via these scripts from the build tree and will find the correct libraries. ++# If RPATH is not disabled, these scripts are also used but only for consistency, because ++# they don't really influence anything then, because the compiled-in RPATH overrides ++# the LD_LIBRARY_PATH env. variable. ++# Executables with the RUN_UNINSTALLED option will be built with the RPATH pointing to the ++# build dir, so that they can be run safely without being installed, e.g. as code generators ++# for other stuff during the build. These executables will be relinked during "make install". ++# All other executables are built with the RPATH with which they will be installed. ++macro (KDE4_HANDLE_RPATH_FOR_EXECUTABLE _target_NAME _type) ++ if (UNIX) ++ ++ # set the RPATH related properties ++ if (NOT CMAKE_SKIP_RPATH) ++ if (${_type} STREQUAL "GUI") ++ set_target_properties(${_target_NAME} PROPERTIES SKIP_BUILD_RPATH TRUE BUILD_WITH_INSTALL_RPATH TRUE) ++ endif (${_type} STREQUAL "GUI") ++ ++ if (${_type} STREQUAL "NOGUI") ++ set_target_properties(${_target_NAME} PROPERTIES SKIP_BUILD_RPATH TRUE BUILD_WITH_INSTALL_RPATH TRUE) ++ endif (${_type} STREQUAL "NOGUI") ++ ++ if (${_type} STREQUAL "RUN_UNINSTALLED") ++ set_target_properties(${_target_NAME} PROPERTIES SKIP_BUILD_RPATH FALSE BUILD_WITH_INSTALL_RPATH FALSE) ++ endif (${_type} STREQUAL "RUN_UNINSTALLED") ++ endif (NOT CMAKE_SKIP_RPATH) ++ ++ if (APPLE) ++ set(_library_path_variable "DYLD_LIBRARY_PATH") ++ else (APPLE) ++ set(_library_path_variable "LD_LIBRARY_PATH") ++ endif (APPLE) ++ ++ if (APPLE) ++ # DYLD_LIBRARY_PATH does not work like LD_LIBRARY_PATH ++ # OSX already has the RPATH in libraries and executables, putting runtime directories in ++ # DYLD_LIBRARY_PATH actually breaks things ++ set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/:${KDE4_LIB_DIR}") ++ else (APPLE) ++ set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}/:${LIB_INSTALL_DIR}:${KDE4_LIB_DIR}:${QT_LIBRARY_DIR}") ++ endif (APPLE) ++ get_target_property(_executable ${_target_NAME} LOCATION ) ++ ++ # use add_custom_target() to have the sh-wrapper generated during build time instead of cmake time ++ add_custom_command(TARGET ${_target_NAME} POST_BUILD ++ COMMAND ${CMAKE_COMMAND} ++ -D_filename=${_executable}.shell -D_library_path_variable=${_library_path_variable} ++ -D_ld_library_path="${_ld_library_path}" -D_executable=${_executable} ++ -P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake ++ ) ++ ++ macro_additional_clean_files(${_executable}.shell) ++ ++ # under UNIX, set the property WRAPPER_SCRIPT to the name of the generated shell script ++ # so it can be queried and used later on easily ++ set_target_properties(${_target_NAME} PROPERTIES WRAPPER_SCRIPT ${_executable}.shell) ++ ++ else (UNIX) ++ # under windows, set the property WRAPPER_SCRIPT just to the name of the executable ++ # maybe later this will change to a generated batch file (for setting the PATH so that the Qt libs are found) ++ get_target_property(_executable ${_target_NAME} LOCATION ) ++ set_target_properties(${_target_NAME} PROPERTIES WRAPPER_SCRIPT ${_executable}) ++ ++ set(_ld_library_path "${LIBRARY_OUTPUT_PATH}/${CMAKE_CFG_INTDIR}\;${LIB_INSTALL_DIR}\;${KDE4_LIB_DIR}\;${QT_LIBRARY_DIR}") ++ get_target_property(_executable ${_target_NAME} LOCATION ) ++ ++ # use add_custom_target() to have the batch-file-wrapper generated during build time instead of cmake time ++ add_custom_command(TARGET ${_target_NAME} POST_BUILD ++ COMMAND ${CMAKE_COMMAND} ++ -D_filename="${_executable}.bat" ++ -D_ld_library_path="${_ld_library_path}" -D_executable="${_executable}" ++ -P ${KDE4_MODULE_DIR}/kde4_exec_via_sh.cmake ++ ) ++ ++ endif (UNIX) ++endmacro (KDE4_HANDLE_RPATH_FOR_EXECUTABLE) ++ ++ ++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") ++ ++ set(_SRCS ${_first_SRC} ${ARGN}) ++ kde4_handle_automoc(${_target_NAME} _SRCS) ++ if (KDE4_ENABLE_FINAL) ++ kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS}) ++ add_library(${_target_NAME} MODULE ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_separate_files}) ++ else (KDE4_ENABLE_FINAL) ++ add_library(${_target_NAME} MODULE ${_SRCS}) ++ endif (KDE4_ENABLE_FINAL) ++ ++ if (_first_SRC) ++ set_target_properties(${_target_NAME} PROPERTIES PREFIX "") ++ endif (_first_SRC) ++ ++ kde4_handle_rpath_for_library(${_target_NAME}) ++ ++ if (WIN32) ++ # for shared libraries/plugins a -DMAKE_target_LIB is required ++ string(TOUPPER ${_target_NAME} _symbol) ++ string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _symbol ${_symbol}) ++ set(_symbol "MAKE_${_symbol}_LIB") ++ set_target_properties(${_target_NAME} PROPERTIES DEFINE_SYMBOL ${_symbol}) ++ endif (WIN32) ++ ++endmacro (KDE4_ADD_PLUGIN _target_NAME _with_PREFIX) ++ ++ ++# this macro is intended to check whether a list of source ++# files has the "NOGUI" or "RUN_UNINSTALLED" keywords at the beginning ++# in _output_LIST the list of source files is returned with the "NOGUI" ++# and "RUN_UNINSTALLED" keywords removed ++# if "NOGUI" is in the list of files, the _nogui argument is set to ++# "NOGUI" (which evaluates to TRUE in cmake), otherwise it is set empty ++# (which evaluates to FALSE in cmake) ++# if "RUN_UNINSTALLED" is in the list of files, the _uninst argument is set to ++# "RUN_UNINSTALLED" (which evaluates to TRUE in cmake), otherwise it is set empty ++# (which evaluates to FALSE in cmake) ++# if "TEST" is in the list of files, the _test argument is set to ++# "TEST" (which evaluates to TRUE in cmake), otherwise it is set empty ++# (which evaluates to FALSE in cmake) ++macro(KDE4_CHECK_EXECUTABLE_PARAMS _output_LIST _nogui _uninst _test) ++ set(${_nogui}) ++ set(${_uninst}) ++ set(${_test}) ++ set(${_output_LIST} ${ARGN}) ++ list(LENGTH ${_output_LIST} count) ++ ++ list(GET ${_output_LIST} 0 first_PARAM) ++ ++ set(second_PARAM "NOTFOUND") ++ if (${count} GREATER 1) ++ list(GET ${_output_LIST} 1 second_PARAM) ++ endif (${count} GREATER 1) ++ ++ set(remove "NOTFOUND") ++ ++ if (${first_PARAM} STREQUAL "NOGUI") ++ set(${_nogui} "NOGUI") ++ set(remove 0) ++ endif (${first_PARAM} STREQUAL "NOGUI") ++ ++ if (${first_PARAM} STREQUAL "RUN_UNINSTALLED") ++ set(${_uninst} "RUN_UNINSTALLED") ++ set(remove 0) ++ endif (${first_PARAM} STREQUAL "RUN_UNINSTALLED") ++ ++ if (${first_PARAM} STREQUAL "TEST") ++ set(${_test} "TEST") ++ set(remove 0) ++ endif (${first_PARAM} STREQUAL "TEST") ++ ++ if (${second_PARAM} STREQUAL "NOGUI") ++ set(${_nogui} "NOGUI") ++ set(remove 0;1) ++ endif (${second_PARAM} STREQUAL "NOGUI") ++ ++ if (${second_PARAM} STREQUAL "RUN_UNINSTALLED") ++ set(${_uninst} "RUN_UNINSTALLED") ++ set(remove 0;1) ++ endif (${second_PARAM} STREQUAL "RUN_UNINSTALLED") ++ ++ if (${second_PARAM} STREQUAL "TEST") ++ set(${_test} "TEST") ++ set(remove 0;1) ++ endif (${second_PARAM} STREQUAL "TEST") ++ ++ ++ ++ if (NOT "${remove}" STREQUAL "NOTFOUND") ++ list(REMOVE_AT ${_output_LIST} ${remove}) ++ endif (NOT "${remove}" STREQUAL "NOTFOUND") ++ ++endmacro(KDE4_CHECK_EXECUTABLE_PARAMS) ++ ++ ++macro (KDE4_ADD_KDEINIT_EXECUTABLE _target_NAME ) ++ ++ kde4_check_executable_params(_SRCS _nogui _uninst _test ${ARGN}) ++ ++# if (WIN32) ++# # under windows, just build a normal executable ++# KDE4_ADD_EXECUTABLE(${_target_NAME} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${ARGN} ) ++# else (WIN32) ++ # under UNIX, create a shared library and a small executable, which links to this library ++ ++ kde4_handle_automoc(kdeinit_${_target_NAME} _SRCS) ++ if (KDE4_ENABLE_FINAL) ++ kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS}) ++ add_library(kdeinit_${_target_NAME} SHARED ${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp ${_separate_files}) ++ ++ else (KDE4_ENABLE_FINAL) ++ add_library(kdeinit_${_target_NAME} SHARED ${_SRCS}) ++ endif (KDE4_ENABLE_FINAL) ++ ++ kde4_handle_rpath_for_library(kdeinit_${_target_NAME}) ++ set_target_properties(kdeinit_${_target_NAME} PROPERTIES OUTPUT_NAME kdeinit4_${_target_NAME}) ++ ++ configure_file(${KDE4_MODULE_DIR}/kde4init_dummy.cpp.in ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp) ++ kde4_add_executable(${_target_NAME} "${_nogui}" "${_uninst}" ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp) ++ target_link_libraries(${_target_NAME} kdeinit_${_target_NAME}) ++# endif (WIN32) ++ ++ if (WIN32) ++ target_link_libraries(${_target_NAME} ${QT_QTMAIN_LIBRARY}) ++ endif (WIN32) ++ ++endmacro (KDE4_ADD_KDEINIT_EXECUTABLE) ++ ++# add a unit test, which is executed when running make test ++# it will be built with RPATH pointing to the build dir ++# The targets are always created, but only built for the "all" ++# target if the option KDE4_BUILD_TESTS is enabled. Otherwise the rules for the target ++# are created but not built by default. You can build them by manually building the target. ++# The name of the target can be specified using TESTNAME , if it is not given ++# the macro will default to the ++macro (KDE4_ADD_UNIT_TEST _test_NAME) ++ set(_srcList ${ARGN}) ++ set(_targetName ${_test_NAME}) ++ if( ${ARGV1} STREQUAL "TESTNAME" ) ++ set(_targetName ${ARGV2}) ++ list(REMOVE_AT _srcList 0 1) ++ endif( ${ARGV1} STREQUAL "TESTNAME" ) ++ ++ set(_nogui) ++ list(GET ${_srcList} 0 first_PARAM) ++ if( ${first_PARAM} STREQUAL "NOGUI" ) ++ set(_nogui "NOGUI") ++ endif( ${first_PARAM} STREQUAL "NOGUI" ) ++ ++ kde4_add_executable( ${_test_NAME} TEST ${_srcList} ) ++ ++ if(NOT KDE4_TEST_OUTPUT) ++ set(KDE4_TEST_OUTPUT plaintext) ++ endif(NOT KDE4_TEST_OUTPUT) ++ set(KDE4_TEST_OUTPUT ${KDE4_TEST_OUTPUT} CACHE STRING "The output to generate when running the QTest unit tests") ++ ++ set(using_qtest "") ++ foreach(_filename ${_srcList}) ++ if(NOT using_qtest) ++ if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_filename}") ++ file(READ ${_filename} file_CONTENT) ++ string(REGEX MATCH "QTEST_(KDE)?MAIN" using_qtest "${file_CONTENT}") ++ endif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_filename}") ++ endif(NOT using_qtest) ++ endforeach(_filename) ++ ++ set(_executable ${EXECUTABLE_OUTPUT_PATH}/${_test_NAME}) ++ if (Q_WS_MAC AND NOT _nogui) ++ set(_executable ${EXECUTABLE_OUTPUT_PATH}/${_test_NAME}.app/Contents/MacOS/${_test_NAME}) ++ else (Q_WS_MAC AND NOT _nogui) ++ # Use .shell wrapper where available, to use uninstalled libs. ++ if (UNIX) ++ set(_executable ${_executable}.shell) ++ endif (UNIX) ++ endif (Q_WS_MAC AND NOT _nogui) ++ ++ if (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml") ++ #MESSAGE(STATUS "${_targetName} : Using QTestLib, can produce XML report.") ++ add_test( ${_targetName} ${_executable} -xml -o ${_targetName}.tml) ++ else (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml") ++ #MESSAGE(STATUS "${_targetName} : NOT using QTestLib, can't produce XML report, please use QTestLib to write your unit tests.") ++ add_test( ${_targetName} ${_executable} ) ++ endif (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml") ++ ++# add_test( ${_targetName} ${EXECUTABLE_OUTPUT_PATH}/${_test_NAME} -xml -o ${_test_NAME}.tml ) ++ ++ if (NOT MSVC_IDE) #not needed for the ide ++ # if the tests are EXCLUDE_FROM_ALL, add a target "buildtests" to build all tests ++ if (NOT KDE4_BUILD_TESTS) ++ get_directory_property(_buildtestsAdded BUILDTESTS_ADDED) ++ if(NOT _buildtestsAdded) ++ add_custom_target(buildtests) ++ set_directory_properties(PROPERTIES BUILDTESTS_ADDED TRUE) ++ endif(NOT _buildtestsAdded) ++ add_dependencies(buildtests ${_test_NAME}) ++ endif (NOT KDE4_BUILD_TESTS) ++ endif (NOT MSVC_IDE) ++ ++endmacro (KDE4_ADD_UNIT_TEST) ++ ++macro (KDE4_ADD_TEST_EXECUTABLE _target_NAME) ++ MESSAGE(SEND_ERROR "KDE4_ADD_TEST_EXECUTABLE is deprecated use KDE4_ADD_EXECUTABLE( TEST ) instead") ++endmacro (KDE4_ADD_TEST_EXECUTABLE) ++ ++ ++macro (KDE4_ADD_EXECUTABLE _target_NAME) ++ ++ kde4_check_executable_params( _SRCS _nogui _uninst _test ${ARGN}) ++ ++ set(_add_executable_param) ++ set(_type "GUI") ++ ++ # determine additional parameters for add_executable() ++ # for GUI apps, create a bundle on OSX ++ if (Q_WS_MAC) ++ set(_add_executable_param MACOSX_BUNDLE) ++ endif (Q_WS_MAC) ++ ++ # for GUI apps, this disables the additional console under Windows ++ if (WIN32) ++ set(_add_executable_param WIN32) ++ endif (WIN32) ++ ++ if (_nogui) ++ set(_type "NOGUI") ++ set(_add_executable_param) ++ endif (_nogui) ++ ++ if (_uninst OR _test) ++ set(_type "RUN_UNINSTALLED ${_type}") ++ endif (_uninst OR _test) ++ ++ if (_test AND NOT KDE4_BUILD_TESTS) ++ set(_add_executable_param ${_add_executable_param} EXCLUDE_FROM_ALL) ++ endif (_test AND NOT KDE4_BUILD_TESTS) ++ ++ kde4_handle_automoc(${_target_NAME} _SRCS) ++ if (KDE4_ENABLE_FINAL) ++ kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS}) ++ add_executable(${_target_NAME} ${_add_executable_param} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_separate_files}) ++ else (KDE4_ENABLE_FINAL) ++ add_executable(${_target_NAME} ${_add_executable_param} ${_SRCS}) ++ endif (KDE4_ENABLE_FINAL) ++ ++ if (_test) ++ set_target_properties(${_target_NAME} PROPERTIES COMPILE_FLAGS -DKDESRCDIR="\\"${CMAKE_CURRENT_SOURCE_DIR}\\"") ++ endif (_test) ++ ++ kde4_handle_rpath_for_executable(${_target_NAME} ${_type}) ++ ++ if (WIN32) ++ target_link_libraries(${_target_NAME} ${QT_QTMAIN_LIBRARY}) ++ endif (WIN32) ++ ++endmacro (KDE4_ADD_EXECUTABLE) ++ ++ ++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") ++ ++ set(_SRCS ${_first_SRC} ${ARGN}) ++ kde4_handle_automoc(${_target_NAME} _SRCS) ++ if (KDE4_ENABLE_FINAL) ++ kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS}) ++ add_library(${_target_NAME} ${_add_lib_param} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp ${_separate_files}) ++ else (KDE4_ENABLE_FINAL) ++ add_library(${_target_NAME} ${_add_lib_param} ${_SRCS}) ++ endif (KDE4_ENABLE_FINAL) ++ ++ kde4_handle_rpath_for_library(${_target_NAME}) ++ ++ # for shared libraries a -DMAKE_target_LIB is required ++ string(TOUPPER ${_target_NAME} _symbol) ++ string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _symbol ${_symbol}) ++ set(_symbol "MAKE_${_symbol}_LIB") ++ set_target_properties(${_target_NAME} PROPERTIES DEFINE_SYMBOL ${_symbol}) ++ ++endmacro (KDE4_ADD_LIBRARY _target_NAME _lib_TYPE) ++ ++ ++macro (KDE4_ADD_WIDGET_FILES _sources) ++ foreach (_current_FILE ${ARGN}) ++ ++ get_filename_component(_input ${_current_FILE} ABSOLUTE) ++ get_filename_component(_basename ${_input} NAME_WE) ++ set(_source ${CMAKE_CURRENT_BINARY_DIR}/${_basename}widgets.cpp) ++ set(_moc ${CMAKE_CURRENT_BINARY_DIR}/${_basename}widgets.moc) ++ ++ # create source file from the .widgets file ++ add_custom_command(OUTPUT ${_source} ++ COMMAND ${KDE4_MAKEKDEWIDGETS_EXECUTABLE} ++ ARGS -o ${_source} ${_input} ++ MAIN_DEPENDENCY ${_input} DEPENDS ${_KDE4_MAKEKDEWIDGETS_DEP}) ++ ++ # create moc file ++ qt4_generate_moc(${_source} ${_moc} ) ++ ++ list(APPEND ${_sources} ${_source} ${_moc}) ++ ++ endforeach (_current_FILE) ++ ++endmacro (KDE4_ADD_WIDGET_FILES) ++ ++ ++MACRO(KDE4_REMOVE_OBSOLETE_CMAKE_FILES) ++# the files listed here will be removed by remove_obsoleted_cmake_files.cmake, Alex ++ install(SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake ) ++ set(module_install_dir ${DATA_INSTALL_DIR}/cmake/modules ) ++ ++ file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "#generated by cmake, dont edit\n\n") ++ foreach ( _current_FILE ${ARGN}) ++ file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "message(STATUS \"Removing ${module_install_dir}/${_current_FILE}\" )\n" ) ++ file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/remove_files.cmake "exec_program( ${CMAKE_COMMAND} ARGS -E remove ${module_install_dir}/${_current_FILE} OUTPUT_VARIABLE _dummy)\n" ) ++ endforeach ( _current_FILE) ++ ++ENDMACRO(KDE4_REMOVE_OBSOLETE_CMAKE_FILES) ++ ++ ++MACRO(KDE4_NO_ENABLE_FINAL _project_name) ++ if(KDE4_ENABLE_FINAL) ++ set(KDE4_ENABLE_FINAL OFF) ++ remove_definitions(-DKDE_USE_FINAL) ++ message(STATUS "You used enable-final argument but \"${_project_name}\" doesn't support it. Try to fix compile it and remove KDE4_NO_ENABLE_FINAL macro. Thanks") ++ ++ endif(KDE4_ENABLE_FINAL) ++ENDMACRO(KDE4_NO_ENABLE_FINAL _project_name) ++ ++ ++macro(KDE4_CREATE_EXPORTS_HEADER _outputFile _libName) ++ string(TOUPPER ${_libName} _libNameUpperCase) ++ string(REGEX REPLACE "[^_A-Za-z0-9]" "_" _libNameUpperCase ${_libNameUpperCase}) ++ # the next line is is required, because in CMake arguments to macros are not real ++ # variables, but handled differently. The next line create a real CMake variable, ++ # so configure_file() will replace it correctly. ++ set(_libName ${_libName}) ++ # compared to write(FILE) configure_file() only really writes the file if the ++ # contents have changed. Otherwise we would have a lot of recompiles. ++ configure_file(${KDE4_MODULE_DIR}/kde4exportsheader.h.in ${_outputFile}) ++endmacro(KDE4_CREATE_EXPORTS_HEADER _outputFile _libName) ++ ++ ++macro (KDE4_CREATE_HTML_HANDBOOK _docbook) ++ message(STATUS "KDE4_CREATE_HTML_HANDBOOK() is deprecated. Enable the option KDE4_ENABLE_HTMLHANDBOOK instead, this will give you targets htmlhandbook for creating the html help.") ++endmacro (KDE4_CREATE_HTML_HANDBOOK) ++ ++ ++# adds application icon to target source list ++# 'appsources' - the sources of the application ++# 'pngfiles' - specifies the list of icon files ++# example: KDE4_ADD_WIN32_APP_ICON(myapp_SRCS "pics/cr16-myapp.png;pics/cr32-myapp.png") ++ ++macro (KDE4_ADD_WIN32_APP_ICON appsources) ++ message(STATUS "KDE4_ADD_WIN32_APP_ICON() is deprecated, use KDE4_ADD_APP_ICON() instead") ++ if (WIN32) ++ find_program(PNG2ICO_EXECUTABLE NAMES png2ico) ++ find_program(WINDRES_EXECUTABLE NAMES windres) ++ if(MSVC) ++ set(WINDRES_EXECUTABLE TRUE) ++ endif(MSVC) ++ STRING(REPLACE _SRCS "" appname ${appsources}) ++ if (PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE) ++ set (_outfilename ${CMAKE_CURRENT_BINARY_DIR}/${appname}) ++ ++ # png2ico is found by the above find_program ++# message("png2ico ${_outfilename}.ico ${ARGN}") ++ exec_program(png2ico ARGS ${_outfilename}.ico ${ARGN}) ++ ++ # now make rc file for adding it to the sources ++ file(WRITE ${_outfilename}.rc "IDI_ICON1 ICON DISCARDABLE \"${_outfilename}.ico\"\n") ++ if (MINGW) ++ exec_program(windres ++ ARGS "-i ${_outfilename}.rc -o ${_outfilename}_res.o --include-dir=${CMAKE_CURRENT_SOURCE_DIR}") ++ list(APPEND ${appsources} ${CMAKE_CURRENT_BINARY_DIR}/${appname}_res.o) ++ else(MINGW) ++ list(APPEND ${appsources} ${CMAKE_CURRENT_BINARY_DIR}/${appname}.rc) ++ endif(MINGW) ++ endif(PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE) ++ endif(WIN32) ++endmacro (KDE4_ADD_WIN32_APP_ICON) ++ ++# adds application icon to target source list ++ ++# this macro adds an application icon to the specified target ++# mac osx notes : the application icon is added to a Mac OS X bundle so that Finder and friends show the right thing. ++# win32 notes: the application icon(s) are compiled into the application ++# parameters: ++# 'appsources' - specifies the list of source files ++# 'pattern' - regular expression for searching application icons ++# example: KDE4_ADD_APP_ICON( myapp_sources "pics/cr*-myapp.png") ++# example: KDE4_ADD_APP_ICON( myapp_sources "icons/oxygen/*/apps/myapp.png") ++ ++macro (KDE4_ADD_APP_ICON appsources pattern) ++ string(REPLACE _SRCS "" target ${appsources}) ++ if (WIN32) ++ find_program(PNG2ICO_EXECUTABLE NAMES png2ico) ++ find_program(WINDRES_EXECUTABLE NAMES windres) ++ if(MSVC) ++ set(WINDRES_EXECUTABLE TRUE) ++ endif(MSVC) ++ if (PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE) ++ string(REPLACE "*" "(.*)" pattern_rx "${pattern}") ++ file(GLOB_RECURSE files "${pattern}") ++ foreach (it ${files}) ++ string(REGEX REPLACE "${pattern_rx}" "\\1" fn "${it}") ++ if (fn MATCHES ".*16.*" ) ++ list (APPEND _icons ${it}) ++ endif (fn MATCHES ".*16.*") ++ if (fn MATCHES ".*32.*" ) ++ list (APPEND _icons ${it}) ++ endif (fn MATCHES ".*32.*") ++ if (fn MATCHES ".*48.*" ) ++ list (APPEND _icons ${it}) ++ endif (fn MATCHES ".*48.*") ++ if (fn MATCHES ".*64.*" ) ++ list (APPEND _icons ${it}) ++ endif (fn MATCHES ".*64.*") ++ if (fn MATCHES ".*128.*" ) ++ list (APPEND _icons ${it}) ++ endif (fn MATCHES ".*128.*") ++ endforeach (it) ++ if (_icons) ++ set (_outfilename ${CMAKE_CURRENT_BINARY_DIR}/${target}) ++ add_custom_command(OUTPUT ${_outfilename}.ico ${_outfilename}.rc ++ COMMAND ${PNG2ICO_EXECUTABLE} ARGS --rcfile ${_outfilename}.rc ${_outfilename}.ico ${_icons} ++ DEPENDS ${PNG2ICO_EXECUTABLE} ${_icons} ++ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ++ ) ++ if (MINGW) ++ add_custom_command(OUTPUT ${_outfilename}_res.o ++ COMMAND ${WINDRES_EXECUTABLE} ARGS -i ${_outfilename}.rc -o ${_outfilename}_res.o --include-dir=${CMAKE_CURRENT_SOURCE_DIR} ++ DEPENDS ${WINDRES_EXECUTABLE} ${_outfilename}.rc ++ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ++ ) ++ list(APPEND ${appsources} ${_outfilename}_res.o) ++ else(MINGW) ++ list(APPEND ${appsources} ${_outfilename}.rc) ++ endif(MINGW) ++ else(_icons) ++ message(STATUS "Unable to find a related icon for target ${target} - application will not have an application icon!") ++ endif(_icons) ++ else(PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE) ++ message(STATUS "Unable to find the png2ico or windres utilities - application will not have an application icon!") ++ endif(PNG2ICO_EXECUTABLE AND WINDRES_EXECUTABLE) ++ endif(WIN32) ++ if (Q_WS_MAC) ++ # first convert image to a tiff using the Mac OS X "sips" utility, ++ # then use tiff2icns to convert to an icon ++ find_program(SIPS_EXECUTABLE NAMES sips) ++ find_program(TIFF2ICNS_EXECUTABLE NAMES tiff2icns) ++ if (SIPS_EXECUTABLE AND TIFF2ICNS_EXECUTABLE) ++ file(GLOB_RECURSE files "${pattern}") ++ # we can only test for the 128-icon like that - we don't use patterns anymore ++ foreach (it ${files}) ++ if (it MATCHES ".*128.*" ) ++ set (_icon ${it}) ++ endif (it MATCHES ".*128.*") ++ endforeach (it) ++ set (_outfilename ${CMAKE_CURRENT_BINARY_DIR}/${target}) ++ ++ if (_icon) ++ ++ # first, get the basename of our app icon ++ add_custom_command(OUTPUT ${_outfilename}.icns ++ COMMAND ${SIPS_EXECUTABLE} -s format tiff ${_icon} --out ${outfilename}.tiff ++ COMMAND ${TIFF2ICNS_EXECUTABLE} ${outfilename}.tiff ${_outfilename}.icns ++ DEPENDS ${_icon} ++ ) ++ ++ macro_additional_clean_files(${outfilename}.tiff ${_outfilename}.icns) ++ ++ # This will register the icon into the bundle ++ set(MACOSX_BUNDLE_ICON_FILE ${target}.icns) ++ ++ # Append the icns file to the sources list so it will be a dependency to the ++ # main target ++ list(APPEND ${appsources} ${_outfilename}.icns) ++ ++ # this doesn't seem to work for me - Use manual "install" instead ++ # SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/${target}.icns PROPERTIES MACOSX_PACKAGE_LOCATION Resources) ++ ++ install(FILES ${_outfilename}.icns DESTINATION ${BIN_INSTALL_DIR}/${target}.app/Contents/Resources/) ++ ++ else(_icon) ++ # TODO - try to scale a non-128 icon...? Try to convert an SVG on the fly? ++ message(STATUS "Unable to find an 128x128 icon for target ${target} - application will not have an application icon!") ++ endif(_icon) ++ ++ else(SIPS_EXECUTABLE AND TIFF2ICNS_EXECUTABLE) ++ message(STATUS "Unable to find the sips and tiff2icns utilities - application will not have an application icon!") ++ endif(SIPS_EXECUTABLE AND TIFF2ICNS_EXECUTABLE) ++ endif(Q_WS_MAC) ++endmacro (KDE4_ADD_APP_ICON) ++ ++ +Index: cmake/CMakeLists.txt +=================================================================== +--- cmake/CMakeLists.txt (Revision 801314) ++++ cmake/CMakeLists.txt (Revision 801202) +@@ -1,3 +1,4 @@ + ++add_subdirectory(automoc) + #add_subdirectory(modules) + +Index: server/control/CMakeLists.txt +=================================================================== +--- server/control/CMakeLists.txt (Revision 801314) ++++ server/control/CMakeLists.txt (Revision 801202) +@@ -25,7 +25,7 @@ + processcontrol.cpp + ) + +-automoc4(akonadi_control control_SRCS) ++qt4_automoc(${control_SRCS}) + + qt4_add_dbus_adaptor( control_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/../../interfaces/org.kde.Akonadi.AgentManager.xml agentmanager.h AgentManager ) + qt4_add_dbus_adaptor( control_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/../interfaces/org.kde.Akonadi.ControlManager.xml controlmanager.h ControlManager ) +Index: server/tests/unittest/CMakeLists.txt +=================================================================== +--- server/tests/unittest/CMakeLists.txt (Revision 801314) ++++ server/tests/unittest/CMakeLists.txt (Revision 801202) +@@ -5,8 +5,6 @@ + + set(handlertest_SRCS handlertest.cpp teststoragebackend.cpp ) + +-automoc4(handlertest handlertest_SRCS) +-add_executable(handlertest ${handlertest_SRCS}) +-add_test(akonadi-handlertest handlertest) ++kde4_add_unit_test(handlertest TESTNAME akonadi-handlertest ${handlertest_SRCS}) + + target_link_libraries(handlertest akonadiprivate ${QT_QTTEST_LIBRARY}) +Index: server/src/tests/CMakeLists.txt +=================================================================== +--- server/src/tests/CMakeLists.txt (Revision 801314) ++++ server/src/tests/CMakeLists.txt (Revision 801202) +@@ -5,17 +5,10 @@ + + set(interpretertest_SRCS interpretertest.cpp ../interpreter.cpp ) + +-automoc4(interpretertest interpretertest_SRCS) +-add_executable(interpretertest ${interpretertest_SRCS}) +-add_test(akonadi-interpretertest interpretertest) ++kde4_add_unit_test(interpretertest TESTNAME akonadi-interpretertest ${interpretertest_SRCS}) + + target_link_libraries(interpretertest ${QT_QTCORE_LIBRARY} ${QT_QTTEST_LIBRARY}) + + +-set(querybuildertest_SRCS querybuildertest.cpp) +- +-automoc4(querybuildertest querybuildertest_SRCS) +-add_executable(querybuildertest ${querybuildertest_SRCS}) +-add_test(akonadi-querybuildertest querybuildertest) +- ++kde4_add_unit_test(querybuildertest TESTNAME akonadi-querybuildertest querybuildertest.cpp) + target_link_libraries(querybuildertest ${QT_QTCORE_LIBRARY} ${QT_QTSQL_LIBRARY} ${QT_QTTEST_LIBRARY}) +Index: server/akonadictl/CMakeLists.txt +=================================================================== +--- server/akonadictl/CMakeLists.txt (Revision 801314) ++++ server/akonadictl/CMakeLists.txt (Revision 801202) +@@ -12,7 +12,7 @@ + main.cpp + ) + +-automoc4(akonadictl akonadictl_SRCS) ++qt4_automoc(${akonadictl_SRCS}) + + qt4_add_dbus_interfaces( akonadictl_SRCS + ${CMAKE_CURRENT_SOURCE_DIR}/../interfaces/org.kde.Akonadi.ControlManager.xml +Index: server/CMakeLists.txt +=================================================================== +--- server/CMakeLists.txt (Revision 801314) ++++ server/CMakeLists.txt (Revision 801202) +@@ -98,7 +103,7 @@ + src/nepomukmanager.cpp + ) + +-automoc4(akonadiprivate libakonadiprivate_SRCS) ++qt4_automoc(${libakonadiprivate_SRCS}) + + qt4_add_dbus_adaptor( libakonadiprivate_SRCS interfaces/org.kde.Akonadi.TracerNotification.xml dbustracer.h Akonadi::DBusTracer ) + qt4_add_dbus_adaptor( libakonadiprivate_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/../interfaces/org.kde.Akonadi.Tracer.xml tracer.h Akonadi::Tracer +@@ -114,7 +119,7 @@ + + set(xesam_xml interfaces/org.freedesktop.xesam.Search.xml) + +-set_source_files_properties(${xesam_xml} PROPERTIES INCLUDE "xesamtypes.h") ++SET_SOURCE_FILES_PROPERTIES(${xesam_xml} PROPERTIES INCLUDE "xesamtypes.h") + + qt4_add_dbus_interface( libakonadiprivate_SRCS ${xesam_xml} xesaminterface ) + +Index: CMakeLists.txt +=================================================================== +--- CMakeLists.txt (Revision 801302) ++++ CMakeLists.txt (Revision 801202) +@@ -2,9 +2,6 @@ + + cmake_minimum_required(VERSION 2.4.5 FATAL_ERROR) + +-# enable unit tests +-enable_testing() +- + # where to look first for cmake modules, before ${CMAKE_ROOT}/Modules/ is checked + set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules") + +@@ -18,8 +15,6 @@ + message(FATAL_ERROR "Akonadi requires Qt4 with QtDBus module in order to built.") + endif(NOT QT_QTDBUS_FOUND) + +-find_package(Automoc4 REQUIRED) +- + set(SHARED_MIME_INFO_MINIMUM_VERSION "0.20") + find_package(SharedMimeInfo REQUIRED) + +@@ -81,7 +76,7 @@ + + ################# build targets ######################## + +-#add_subdirectory(cmake) ++add_subdirectory(cmake) + + include_directories(${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR} ${CMAKE_BINARY_DIR}/akonadi ${QT_INCLUDES}) diff --git a/akonadi.spec b/akonadi.spec index a0414f3..54af331 100644 --- a/akonadi.spec +++ b/akonadi.spec @@ -10,6 +10,8 @@ License: LGPLv2+ URL: http://pim.kde.org/akonadi/ # checked out from svn://anonsvn.kde.org/home/kde/trunk/kdesupport/akonadi/ Source0: akonadi-%{revision}.tar.bz2 +# temporary hack until we have automoc4 packaged separately +Patch0: akonadi-restore-builtin-automoc4.patch BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) Requires(post): /sbin/ldconfig @@ -35,6 +37,7 @@ Requires: qt4-devel %prep %setup -q -n %{name}-%{revision} +%patch0 -p0 -b .restore-automoc4 %build %cmake . -DCONFIG_INSTALL_DIR=%{_sysconfdir} @@ -79,6 +82,7 @@ update-mime-database %{_datadir}/mime &> /dev/null || : %changelog * Mon May 26 2008 Kevin Kofler 0.81.0-0.1.20080526svn812787 - update to revision 812787 from KDE SVN (to match KDE 4.1 Beta 1) +- restore builtin automoc4 for now * Mon May 5 2008 Kevin Kofler 0.80.0-2 - -devel: remove bogus Requires: pkgconfig