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 <kretz@kde.org>

+

+    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 <QtCore/QCoreApplication>

+#include <QtCore/QDateTime>

+#include <QtCore/QFile>

+#include <QtCore/QFileInfo>

+#include <QtCore/QHash>

+#include <QtCore/QProcess>

+#include <QtCore/QQueue>

+#include <QtCore/QRegExp>

+#include <QtCore/QStringList>

+#include <QtCore/QTextStream>

+#include <QtCore/QtDebug>

+#include <cstdlib>

+

+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<Process> processes;

+        bool failed;

+};

+

+void AutoMoc::usage(const QString &path)

+{

+    cout << "usage: " << path << " <outfile> <srcdir> <builddir> <moc executable>" << 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_<filename>.cpp file is created and included in the _automoc.cpp file.

+    QHash<QString, QString> includedMocs;    // key = moc source filepath, value = moc output filepath

+    QHash<QString, QString> 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<QString, QString>::ConstIterator end = includedMocs.constEnd();

+    QHash<QString, QString>::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 <kevin.krammer@gmx.at>

-#

-# 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 <kevin.krammer@gmx.at>

+#

+# 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, <neundorf@kde.org>

+#

+# Redistribution and use is allowed according to the terms of the BSD license.

+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.

+

+

+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, <neundorf@kde.org>

+# Copyright (c) 2006, 2007, Laurent Montel, <montel@kde.org>

+# Copyright (c) 2007 Matthias Kretz <kretz@kde.org>

+#

+# Redistribution and use is allowed according to the terms of the BSD license.

+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.

+

+macro (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}")