Merge lp:~bzoltan/qtcreator-plugin-cmake/packaging_tunings into lp:qtcreator-plugin-cmake

[Zoltan Balogh]

packaging tunings

Packaging tunings. Feel free to ignore the changelog, but the version scheme should be like this.

=== modified file 'debian/changelog'
--- debian/changelog	2014-02-18 14:30:29 +0000
+++ debian/changelog	2014-02-28 08:31:43 +0000
@@ -0,0 +1,9 @@
+qtcreator-plugin-cmake (3.0.1-0ubuntu1~trusty1~test7) trusty; urgency=medium
+
+  [ Benjamin Zeller ]
+  * Initial release. 
+
+  [ Zoltán Balogh ]
+  * First build
+
+ -- Zoltán Balogh <[e-mail]>  Tue, 25 Feb 2014 09:58:07 +0200

=== modified file 'debian/control'
--- debian/control	2014-02-18 14:36:32 +0000
+++ debian/control	2014-02-28 08:31:43 +0000
@@ -9,7 +9,7 @@
                qt5-qmake (>= 5.2.1~),
                qtcreator-dev (>= 3.0.1),
                qttools5-dev-tools (>= 5.2.1~),
-               qtxmlpatterns5-dev-tools
+               qtxmlpatterns5-dev-tools,
 Standards-Version: 3.9.4
 Homepage: https://launchpad.net/qtcreator-plugin-cmake
 # If you aren't a member of ~ubuntu-sdk-team but need to upload packaging changes,
@@ -18,7 +18,7 @@
 
 Package: qtcreator-plugin-cmake
 Architecture: any
-Depends: qtcreator (>= 3.0.1)
+Depends: qtcreator (>= 3.0.1),
          ${misc:Depends}
 Description: CMake plugin for Qt Creator IDE
  Qt Creator is a new, lightweight, cross-platform integrated development
@@ -27,3 +27,12 @@
  .
  This package contains the CMake plugin for Qt Creator, providing
  support for compiling and running CMake projects.
+
+Package: qtcreator-plugin-cmake-dev
+Architecture: all
+Depends: qtcreator-plugin-cmake (= ${binary:Version}),
+         ${misc:Depends},
+Description: Qt Creator cmake plugin development files
+ This package contains the developer files for Qt
+ Creator cmake plugin evelopment
+

=== renamed file 'debian/qtcreator-plugin-ubuntu.install' => 'debian/qtcreator-plugin-cmake.install'
--- debian/qtcreator-plugin-ubuntu.install	2014-02-18 14:30:29 +0000
+++ debian/qtcreator-plugin-cmake.install	2014-02-28 08:31:43 +0000
@@ -1,2 +1,5 @@
-usr/lib/*/qtcreator/plugins/Canonical/UbuntuCMakeProjectManager.pluginspec
-usr/lib/*/qtcreator/plugins/Canonical/libUbuntuCMakeProjectManager.so
+usr/lib/*/qtcreator/plugins/QtProject/CMakeProjectManager.pluginspec
+usr/lib/*/qtcreator/plugins/QtProject/libCMakeProjectManager.so
+usr/share/qtcreator/templates/wizards/plaincppapp
+usr/share/qtcreator/templates/wizards/plaincapp
+

=== modified file 'debian/rules'
--- debian/rules	2014-02-18 14:30:29 +0000
+++ debian/rules	2014-02-28 08:31:43 +0000
@@ -1,7 +1,7 @@
 #!/usr/bin/make -f
 
 # Uncomment this to turn on verbose mode.
-#export DH_VERBOSE=1
+export DH_VERBOSE=1
 
 export CFLAGS := $(shell dpkg-buildflags --get CFLAGS) $(shell dpkg-buildflags --get CPPFLAGS)
 export CXXFLAGS := $(shell dpkg-buildflags --get CXXFLAGS) $(shell dpkg-buildflags --get CPPFLAGS)
@@ -24,5 +24,5 @@
 	cp -r $(CURDIR)/share $(CURDIR)/debian/tmp/usr
 	dh_auto_install --destdir=debian/tmp/usr
 
-override_dh_shlibdeps:
-	dh_shlibdeps -XlibUbuntu.so
+override_dh_shlibdeps:      
+	dh_shlibdeps -XlibCMakeProjectManager.so

=== added directory 'share'
=== added directory 'share/qtcreator'
=== added directory 'share/qtcreator/templates'
=== added directory 'share/qtcreator/templates/wizards'
=== added directory 'share/qtcreator/templates/wizards/plaincapp'
=== added directory 'share/qtcreator/templates/wizards/plaincapp/cmake'
=== added file 'share/qtcreator/templates/wizards/plaincapp/cmake/CMakeLists.txt'
--- share/qtcreator/templates/wizards/plaincapp/cmake/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/plaincapp/cmake/CMakeLists.txt	2014-02-28 08:31:43 +0000
@@ -0,0 +1,4 @@
+project(%ProjectName%)
+cmake_minimum_required(VERSION 2.8)
+aux_source_directory(. SRC_LIST)
+add_executable(${PROJECT_NAME} ${SRC_LIST})

=== added file 'share/qtcreator/templates/wizards/plaincapp/cmake/console.png'
Binary files share/qtcreator/templates/wizards/plaincapp/cmake/console.png	1970-01-01 00:00:00 +0000 and share/qtcreator/templates/wizards/plaincapp/cmake/console.png	2014-02-28 08:31:43 +0000 differ
=== added file 'share/qtcreator/templates/wizards/plaincapp/cmake/main.c'
--- share/qtcreator/templates/wizards/plaincapp/cmake/main.c	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/plaincapp/cmake/main.c	2014-02-28 08:31:43 +0000
@@ -0,0 +1,7 @@
+#include <stdio.h>
+
+int main(void)
+{
+    printf("Hello World!\n");
+    return 0;
+}

=== added file 'share/qtcreator/templates/wizards/plaincapp/cmake/wizard.xml'
--- share/qtcreator/templates/wizards/plaincapp/cmake/wizard.xml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/plaincapp/cmake/wizard.xml	2014-02-28 08:31:43 +0000
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of Qt Creator.
+**
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+****************************************************************************/
+-->
+<wizard version="1" kind="project" firstpage="10" id="S.Plain C (CMake)" category="I.Projects"
+        platformIndependent="true" featuresRequired="CMake.CMakeSupport"
+        class="cmakeapp-project">
+    <icon>console.png</icon>
+    <description>Creates a plain C project using CMake, not using the Qt library.</description>
+    <displayname>Plain C Project (Ubuntu CMake Build)</displayname>;
+    <displaycategory>Non-Qt Project</displaycategory>
+    <files>
+        <file source="main.c" target="main.c" openeditor="true"/>
+        <file source="CMakeLists.txt" openproject="true"/>
+    </files>
+</wizard>

=== added directory 'share/qtcreator/templates/wizards/plaincppapp'
=== added directory 'share/qtcreator/templates/wizards/plaincppapp/cmake'
=== added file 'share/qtcreator/templates/wizards/plaincppapp/cmake/CMakeLists.txt'
--- share/qtcreator/templates/wizards/plaincppapp/cmake/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/plaincppapp/cmake/CMakeLists.txt	2014-02-28 08:31:43 +0000
@@ -0,0 +1,4 @@
+project(%ProjectName%)
+cmake_minimum_required(VERSION 2.8)
+aux_source_directory(. SRC_LIST)
+add_executable(${PROJECT_NAME} ${SRC_LIST})

=== added file 'share/qtcreator/templates/wizards/plaincppapp/cmake/console.png'
Binary files share/qtcreator/templates/wizards/plaincppapp/cmake/console.png	1970-01-01 00:00:00 +0000 and share/qtcreator/templates/wizards/plaincppapp/cmake/console.png	2014-02-28 08:31:43 +0000 differ
=== added file 'share/qtcreator/templates/wizards/plaincppapp/cmake/main.cpp'
--- share/qtcreator/templates/wizards/plaincppapp/cmake/main.cpp	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/plaincppapp/cmake/main.cpp	2014-02-28 08:31:43 +0000
@@ -0,0 +1,9 @@
+#include <iostream>
+
+using namespace std;
+
+int main()
+{
+    cout << "Hello World!" << endl;
+    return 0;
+}

=== added file 'share/qtcreator/templates/wizards/plaincppapp/cmake/wizard.xml'
--- share/qtcreator/templates/wizards/plaincppapp/cmake/wizard.xml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/plaincppapp/cmake/wizard.xml	2014-02-28 08:31:43 +0000
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of Qt Creator.
+**
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+****************************************************************************/
+-->
+<wizard version="1" kind="project" firstpage="10" id="S.Plain C++ (CMake)2n'" category="I.Projects"
+        platformIndependent="true" featuresRequired="CMake.CMakeSupport"
+        class="cmakeapp-project">
+    <icon>console.png</icon>
+    <description>Creates a plain C++ project using CMake, not using the Qt library.</description>
+    <displayname>Plain C++ Project (Ubuntu CMake Build)</displayname>;
+    <displaycategory>Non-Qt Project</displaycategory>
+    <files>
+        <file source="main.cpp" target="main.cpp" openeditor="true"/>
+        <file source="CMakeLists.txt" openproject="true"/>
+    </files>
+</wizard>

=== added file 'src/cmakeprojectmanager/argumentslineedit.cpp'
--- src/cmakeprojectmanager/argumentslineedit.cpp	1970-01-01 00:00:00 +0000
+++ src/cmakeprojectmanager/argumentslineedit.cpp	2014-02-28 08:31:43 +0000
@@ -0,0 +1,55 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of Qt Creator.
+**
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+****************************************************************************/
+
+#include "argumentslineedit.h"
+#include <utils/qtcprocess.h>
+
+namespace CMakeProjectManager {
+
+ArgumentsLineEdit::ArgumentsLineEdit(QWidget *parent) :
+    Utils::BaseValidatingLineEdit(parent)
+{
+}
+
+bool ArgumentsLineEdit::validate(const QString &value, QString *errorMessage) const
+{
+    Utils::QtcProcess::SplitError err = Utils::QtcProcess::SplitOk;
+    Utils::QtcProcess::splitArgs(value,false,&err);
+
+    if(err != Utils::QtcProcess::SplitOk) {
+        if(err == Utils::QtcProcess::BadQuoting)
+            *errorMessage = tr("Command contains quoting errors");
+        else if(err == Utils::QtcProcess::FoundMeta)
+            *errorMessage = tr("Command contains complex shell constructs");
+        return false;
+    }
+    return true;
+}
+
+} // namespace CMakeProjectManager

=== added file 'src/cmakeprojectmanager/argumentslineedit.h'
--- src/cmakeprojectmanager/argumentslineedit.h	1970-01-01 00:00:00 +0000
+++ src/cmakeprojectmanager/argumentslineedit.h	2014-02-28 08:31:43 +0000
@@ -0,0 +1,50 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of Qt Creator.
+**
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+****************************************************************************/
+
+#ifndef CMAKEPROJECTMANAGER_ARGUMENTSLINEEDIT_H
+#define CMAKEPROJECTMANAGER_ARGUMENTSLINEEDIT_H
+
+#include "cmakeprojectmanager_global.h"
+#include <utils/basevalidatinglineedit.h>
+
+namespace CMakeProjectManager {
+
+class CMAKEPROJECTMANAGER_EXPORT ArgumentsLineEdit : public Utils::BaseValidatingLineEdit
+{
+    Q_OBJECT
+public:
+    explicit ArgumentsLineEdit(QWidget* parent = 0);
+protected:
+    virtual bool validate(const QString &value, QString *errorMessage) const;
+
+};
+
+} // namespace CMakeProjectManager
+
+#endif // CMAKEPROJECTMANAGER_ARGUMENTSLINEEDIT_H

=== added file 'src/cmakeprojectmanager/cmakeappwizard.cpp'
--- src/cmakeprojectmanager/cmakeappwizard.cpp	1970-01-01 00:00:00 +0000
+++ src/cmakeprojectmanager/cmakeappwizard.cpp	2014-02-28 08:31:43 +0000
@@ -0,0 +1,231 @@
+#include "cmakeappwizard.h"
+#include "cmakekitinformation.h"
+#include "cmakeprojectmanager.h"
+#include "cmakeproject.h"
+#include "cmaketoolmanager.h"
+
+#include <utils/qtcassert.h>
+#include <utils/pathchooser.h>
+#include <qtsupport/qtkitinformation.h>
+#include <qtsupport/qtsupportconstants.h>
+#include <projectexplorer/kitmanager.h>
+#include <extensionsystem/pluginmanager.h>
+
+#include <QDir>
+#include <QScrollArea>
+#include <QLabel>
+#include <QVBoxLayout>
+#include <QDebug>
+#include <QLabel>
+#include <QFormLayout>
+
+namespace CMakeProjectManager {
+
+using namespace Internal;
+
+CMakeAppWizard::CMakeAppWizard()
+{
+}
+
+QWizard *CMakeAppWizard::createWizardDialog (QWidget *parent, const Core::WizardDialogParameters &wizardDialogParameters) const
+{
+    QTC_ASSERT(!parameters().isNull(), return 0);
+    CMakeAppWizardDialog *projectDialog = new CMakeAppWizardDialog(parent, wizardDialogParameters);
+
+    int firstPage = 1;
+    if(!CMakeToolManager::defaultCMakeTool()->isValid()) {
+        projectDialog->addChooseCMakePage(firstPage);
+        firstPage++;
+    }
+    projectDialog->addTargetSetupPage(firstPage);
+
+    initProjectWizardDialog(projectDialog,
+                            wizardDialogParameters.defaultPath(),
+                            wizardDialogParameters.extensionPages());
+
+    projectDialog->setIntroDescription(tr("This wizard generates a Application project using CMake."));
+    return projectDialog;
+}
+
+bool CMakeAppWizard::postGenerateFiles(const QWizard *w, const Core::GeneratedFiles &l, QString *errorMessage)
+{
+    const CMakeAppWizardDialog *dialog = qobject_cast<const CMakeAppWizardDialog *>(w);
+
+    // Generate user settings
+    foreach (const Core::GeneratedFile &file, l)
+        if (file.attributes() & Core::GeneratedFile::OpenProjectAttribute) {
+            dialog->writeUserFile(file.path());
+            break;
+        }
+
+    // Post-Generate: Open the projects/editors
+    return ProjectExplorer::CustomProjectWizard::postGenerateOpen(l ,errorMessage);
+}
+
+void CMakeAppWizard::registerSelf()
+{
+    ProjectExplorer::CustomWizard::registerFactory<CMakeAppWizard>(QLatin1String("cmakeapp-project"));
+}
+
+CMakeAppWizardDialog::CMakeAppWizardDialog(QWidget *parent, const Core::WizardDialogParameters &parameters)
+    : ProjectExplorer::BaseProjectWizardDialog(parent,parameters)
+    , m_targetSetupPage(0)
+    , m_cmakePage(0)
+{
+    init();
+}
+
+CMakeAppWizardDialog::~CMakeAppWizardDialog()
+{
+    if (m_targetSetupPage && !m_targetSetupPage->parent())
+        delete m_targetSetupPage;
+
+    if (m_cmakePage && !m_cmakePage->parent())
+        delete m_cmakePage;
+}
+
+bool CMakeAppWizardDialog::writeUserFile(const QString &cmakeFileName) const
+{
+    if (!m_targetSetupPage)
+        return false;
+
+    CMakeManager *manager = ExtensionSystem::PluginManager::getObject<CMakeManager>();
+    Q_ASSERT(manager);
+
+    CMakeProject *pro = new CMakeProject(manager, cmakeFileName);
+    bool success = m_targetSetupPage->setupProject(pro);
+    if (success)
+        pro->saveSettings();
+    delete pro;
+    return success;
+}
+
+
+void CMakeAppWizardDialog::init()
+{
+    connect(this, SIGNAL(projectParametersChanged(QString,QString)),
+            this, SLOT(generateProfileName(QString,QString)));
+}
+
+int CMakeAppWizardDialog::addTargetSetupPage(int id)
+{
+    m_targetSetupPage = new ProjectExplorer::TargetSetupPage;
+    const QString platform = selectedPlatform();
+
+    //prefer Qt Desktop or Platform Kit
+    Core::FeatureSet features = Core::FeatureSet(QtSupport::Constants::FEATURE_DESKTOP);
+    if (platform.isEmpty())
+        m_targetSetupPage->setPreferredKitMatcher(new QtSupport::QtVersionKitMatcher(features));
+    else
+        m_targetSetupPage->setPreferredKitMatcher(new QtSupport::QtPlatformKitMatcher(platform));
+
+    //make sure only CMake compatible Kits are shown
+    m_targetSetupPage->setRequiredKitMatcher(new CMakeKitMatcher());
+
+    resize(900, 450);
+    if (id >= 0)
+        setPage(id, m_targetSetupPage);
+    else
+        id = addPage(m_targetSetupPage);
+
+    wizardProgress()->item(id)->setTitle(tr("Kits"));
+    return id;
+}
+
+int CMakeAppWizardDialog::addChooseCMakePage(int id)
+{
+    m_cmakePage = new ChooseCMakePage;
+
+    if (id >= 0)
+        setPage(id, m_cmakePage);
+    else
+        id = addPage(m_cmakePage);
+
+    wizardProgress()->item(id)->setTitle(tr("CMake"));
+    return id;
+}
+
+QList<Core::Id> CMakeAppWizardDialog::selectedKits() const
+{
+    if(m_targetSetupPage)
+        return m_targetSetupPage->selectedKits();
+
+    return QList<Core::Id>();
+}
+
+void CMakeAppWizardDialog::generateProfileName(const QString &name, const QString &path)
+{
+    if (!m_targetSetupPage)
+        return;
+
+    const QString proFile =
+            QDir::cleanPath(path + QLatin1Char('/') + name + QLatin1Char('/') + QLatin1String("CMakeLists.txt"));
+
+    m_targetSetupPage->setProjectPath(proFile);
+}
+
+ChooseCMakePage::ChooseCMakePage(QWidget *parent)
+    : QWizardPage(parent)
+{
+    QFormLayout *fl = new QFormLayout;
+    fl->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
+    setLayout(fl);
+
+    m_cmakeLabel = new QLabel;
+    m_cmakeLabel->setWordWrap(true);
+    fl->addRow(m_cmakeLabel);
+    // Show a field for the user to enter
+    m_cmakeExecutable = new Utils::PathChooser(this);
+    m_cmakeExecutable->setExpectedKind(Utils::PathChooser::ExistingCommand);
+    fl->addRow(tr("CMake Executable:"), m_cmakeExecutable);
+
+    connect(m_cmakeExecutable, SIGNAL(editingFinished()),
+            this, SLOT(cmakeExecutableChanged()));
+    connect(m_cmakeExecutable, SIGNAL(browsingFinished()),
+            this, SLOT(cmakeExecutableChanged()));
+
+    setTitle(tr("Choose CMake Executable"));
+    updateErrorText();
+}
+
+void ChooseCMakePage::updateErrorText()
+{
+    CMakeTool* cmake = CMakeToolManager::defaultCMakeTool();
+    QString cmakeExecutable = CMakeToolManager::defaultCMakeTool()->cmakeExecutable();
+    if (cmake->isValid()) {
+        m_cmakeLabel->setText(tr("Used CMake: %0.").arg(cmakeExecutable));
+    } else {
+        QString text = tr("Specify the path to the CMake executable. No CMake executable was found in the path.");
+        if (!cmakeExecutable.isEmpty()) {
+            text += QLatin1Char(' ');
+            QFileInfo fi(cmakeExecutable);
+            if (!fi.exists())
+                text += tr("The CMake executable (%1) does not exist.").arg(cmakeExecutable);
+            else if (!fi.isExecutable())
+                text += tr("The path %1 is not an executable.").arg(cmakeExecutable);
+            else
+                text += tr("The path %1 is not a valid CMake executable.").arg(cmakeExecutable);
+        }
+        m_cmakeLabel->setText(text);
+    }
+}
+
+void ChooseCMakePage::cmakeExecutableChanged()
+{
+    CMakeToolManager::setUserCmakePath(m_cmakeExecutable->path());
+    updateErrorText();
+    emit completeChanged();
+}
+
+bool ChooseCMakePage::isComplete() const
+{
+    return CMakeToolManager::defaultCMakeTool()->isValid();
+}
+
+ChooseCMakeWizard::ChooseCMakeWizard()
+{
+    addPage(new ChooseCMakePage(this));
+    setWindowTitle(tr("Choose CMake Wizard"));
+}
+
+} // namespace CMakeProjectManager

=== added file 'src/cmakeprojectmanager/cmakeappwizard.h'
--- src/cmakeprojectmanager/cmakeappwizard.h	1970-01-01 00:00:00 +0000
+++ src/cmakeprojectmanager/cmakeappwizard.h	2014-02-28 08:31:43 +0000
@@ -0,0 +1,82 @@
+#ifndef CMAKEPROJECTMANAGER_CMAKEAPPWIZARD_H
+#define CMAKEPROJECTMANAGER_CMAKEAPPWIZARD_H
+
+#include "cmakeprojectmanager_global.h"
+#include <projectexplorer/baseprojectwizarddialog.h>
+#include <projectexplorer/customwizard/customwizard.h>
+#include <projectexplorer/targetsetuppage.h>
+
+QT_BEGIN_NAMESPACE
+class QLabel;
+QT_END_NAMESPACE
+
+namespace Utils {
+class PathChooser;
+}
+
+namespace CMakeProjectManager {
+
+class ChooseCMakePage;
+
+class CMAKEPROJECTMANAGER_EXPORT CMakeAppWizard : public ProjectExplorer::CustomProjectWizard
+{
+    Q_OBJECT
+
+public:
+    CMakeAppWizard();
+    static void registerSelf();
+
+private:
+    QWizard *createWizardDialog(QWidget *parent,
+                                const Core::WizardDialogParameters &wizardDialogParameters) const;
+    bool postGenerateFiles(const QWizard *, const Core::GeneratedFiles &l, QString *errorMessage);
+
+private:
+    enum { targetPageId = 1 };
+};
+
+class CMAKEPROJECTMANAGER_EXPORT CMakeAppWizardDialog : public ProjectExplorer::BaseProjectWizardDialog
+{
+    Q_OBJECT
+public:
+    explicit CMakeAppWizardDialog(QWidget *parent, const Core::WizardDialogParameters &parameters);
+    virtual ~CMakeAppWizardDialog();
+
+    int addTargetSetupPage(int id = -1);
+    int addChooseCMakePage(int id = -1);
+
+    QList<Core::Id> selectedKits() const;
+    bool writeUserFile(const QString &cmakeFileName) const;
+private slots:
+    void generateProfileName(const QString &name, const QString &path);
+private:
+    ProjectExplorer::TargetSetupPage *m_targetSetupPage;
+    ChooseCMakePage* m_cmakePage;
+    void init();
+};
+
+class CMAKEPROJECTMANAGER_EXPORT ChooseCMakePage : public QWizardPage
+{
+    Q_OBJECT
+public:
+    ChooseCMakePage(QWidget *parent = 0);
+
+    virtual bool isComplete() const;
+public slots:
+    void cmakeExecutableChanged();
+private:
+    void updateErrorText();
+    QLabel *m_cmakeLabel;
+    Utils::PathChooser *m_cmakeExecutable;
+};
+
+class ChooseCMakeWizard : public Utils::Wizard
+{
+    Q_OBJECT
+public:
+    ChooseCMakeWizard();
+};
+
+} // namespace CMakeProjectManager
+
+#endif // CMAKEPROJECTMANAGER_CMAKEAPPWIZARD_H

=== modified file 'src/cmakeprojectmanager/cmakebuildconfiguration.cpp'
--- src/cmakeprojectmanager/cmakebuildconfiguration.cpp	2014-02-18 14:30:29 +0000
+++ src/cmakeprojectmanager/cmakebuildconfiguration.cpp	2014-02-28 08:31:43 +0000
@@ -30,9 +30,10 @@
 #include "cmakebuildconfiguration.h"
 
 #include "cmakebuildinfo.h"
-#include "cmakeopenprojectwizard.h"
 #include "cmakeproject.h"
 #include "cmakeprojectconstants.h"
+#include "cmaketoolmanager.h"
+#include "generatorinfo.h"
 
 #include <coreplugin/icore.h>
 #include <coreplugin/mimedatabase.h>
@@ -40,8 +41,10 @@
 #include <projectexplorer/kit.h>
 #include <projectexplorer/projectexplorerconstants.h>
 #include <projectexplorer/target.h>
+#include <extensionsystem/pluginmanager.h>
 
 #include <utils/qtcassert.h>
+#include <utils/qtcprocess.h>
 
 #include <QInputDialog>
 
@@ -50,15 +53,23 @@
 
 namespace {
 const char USE_NINJA_KEY[] = "CMakeProjectManager.CMakeBuildConfiguration.UseNinja";
+const char USER_ARGS_KEY[] = "CMakeProjectManager.CMakeBuildConfiguration.UserArguments";
 } // namespace
 
 CMakeBuildConfiguration::CMakeBuildConfiguration(ProjectExplorer::Target *parent) :
     BuildConfiguration(parent, Core::Id(Constants::CMAKE_BC_ID)), m_useNinja(false)
 {
     CMakeProject *project = static_cast<CMakeProject *>(parent->project());
+
+
     setBuildDirectory(Utils::FileName::fromString(project->shadowBuildDirectory(project->projectFilePath(),
                                                                                 parent->kit(),
                                                                                 displayName())));
+
+
+    connect(this,SIGNAL(argumentsChanged(QStringList)),this,SLOT(runCMake()));
+    connect(this,SIGNAL(buildDirectoryChanged()),this,SLOT(runCMake()));
+    connect(this,SIGNAL(useNinjaChanged(bool)),this,SLOT(cleanAndRunCMake()));
 }
 
 CMakeBuildConfiguration::CMakeBuildConfiguration(ProjectExplorer::Target *parent,
@@ -69,12 +80,20 @@
 {
     Q_ASSERT(parent);
     cloneSteps(source);
+
+    connect(this,SIGNAL(argumentsChanged(QStringList)),this,SLOT(runCMake()));
+    connect(this,SIGNAL(buildDirectoryChanged()),this,SLOT(runCMake()));
+    connect(this,SIGNAL(useNinjaChanged(bool)),this,SLOT(cleanAndRunCMake()));
 }
 
 QVariantMap CMakeBuildConfiguration::toMap() const
 {
     QVariantMap map(ProjectExplorer::BuildConfiguration::toMap());
     map.insert(QLatin1String(USE_NINJA_KEY), m_useNinja);
+
+    if(m_arguments.size())
+        map.insert(QLatin1String(USER_ARGS_KEY),Utils::QtcProcess::joinArgs(m_arguments));
+
     return map;
 }
 
@@ -83,11 +102,49 @@
     if (!BuildConfiguration::fromMap(map))
         return false;
 
+    CMakeProject* project = static_cast<CMakeProject*>(this->target()->project());
+
     m_useNinja = map.value(QLatin1String(USE_NINJA_KEY), false).toBool();
+    if(map.contains(QLatin1String(USER_ARGS_KEY)))
+        m_arguments = Utils::QtcProcess::splitArgs(map.value(QLatin1String(USER_ARGS_KEY)).toString());
+
+    /*
+     * If this evaluates to true, it means there was a in source build before and
+     * was cleaned out by the user. Instead of querying the user for some build
+     * directory we just use the default one, the user can always change this if
+     * he does not like it
+     */
+    if(this->buildDirectory() == Utils::FileName::fromString(project->projectDirectory()) && !project->hasInSourceBuild()) {
+        this->setBuildDirectory(Utils::FileName::fromString(
+                                    CMakeProject::shadowBuildDirectory(project->projectFilePath()
+                                                                       ,this->target()->kit()
+                                                                       ,this->displayName())));
+    }
 
     return true;
 }
 
+void CMakeBuildConfiguration::setBuildDirectory(const Utils::FileName &directory)
+{
+    if (directory == buildDirectory())
+        return;
+    BuildConfiguration::setBuildDirectory(directory);
+}
+
+void CMakeBuildConfiguration::cleanAndRunCMake()
+{
+    QDir dir(buildDirectory().toString());
+    dir.removeRecursively();
+
+    runCMake();
+}
+
+void CMakeBuildConfiguration::runCMake()
+{
+    ICMakeTool* cmake = CMakeToolManager::cmakeToolForKit(target()->kit());
+    cmake->runCMake(target());
+}
+
 bool CMakeBuildConfiguration::useNinja() const
 {
     return m_useNinja;
@@ -101,6 +158,22 @@
     }
 }
 
+QStringList CMakeBuildConfiguration::arguments() const
+{
+    return m_arguments;
+}
+
+void CMakeBuildConfiguration::setArguments(const QStringList &args)
+{
+    m_arguments = args;
+    emit argumentsChanged(m_arguments);
+}
+
+QByteArray CMakeBuildConfiguration::generator() const
+{
+    return cachedGeneratorFromFile(buildDirectory().toString() + QLatin1String("/CMakeCache.txt"));
+}
+
 CMakeBuildConfiguration::~CMakeBuildConfiguration()
 { }
 
@@ -109,6 +182,29 @@
     return new CMakeBuildSettingsWidget(this);
 }
 
+QByteArray CMakeBuildConfiguration::cachedGeneratorFromFile(const QString &cache)
+{
+    QFile fi(cache);
+    if (fi.exists()) {
+        // Cache exists, then read it...
+        if (fi.open(QIODevice::ReadOnly | QIODevice::Text)) {
+            while (!fi.atEnd()) {
+                QByteArray line = fi.readLine();
+                if (line.startsWith("CMAKE_GENERATOR:INTERNAL=")) {
+                    int splitpos = line.indexOf('=');
+                    if (splitpos != -1) {
+                        QByteArray cachedGenerator = line.mid(splitpos + 1).trimmed();
+                        if (!cachedGenerator.isEmpty())
+                            return cachedGenerator;
+                    }
+                }
+            }
+        }
+    }
+    return QByteArray();
+}
+
+
 /*!
   \class CMakeBuildConfigurationFactory
 */
@@ -133,6 +229,13 @@
 
     CMakeBuildInfo *info = createBuildInfo(parent->kit(),
                                            parent->project()->projectDirectory());
+
+
+    info->buildDirectory =  Utils::FileName::fromString(CMakeProject::shadowBuildDirectory(parent->project()->projectFilePath(),
+                                                                                           parent->kit(),
+                                                                                           info->displayName));
+
+
     result << info;
     return result;
 }
@@ -150,10 +253,13 @@
     CMakeBuildInfo *info = createBuildInfo(k, ProjectExplorer::Project::projectDirectory(projectPath));
     //: The name of the build configuration created by default for a cmake project.
     info->displayName = tr("Default");
+
     info->buildDirectory
-            = Utils::FileName::fromString(CMakeProject::shadowBuildDirectory(projectPath, k,
+            = Utils::FileName::fromString(CMakeProject::shadowBuildDirectory(projectPath,k,
                                                                              info->displayName));
+
     result << info;
+
     return result;
 }
 
@@ -173,10 +279,6 @@
                                                                             parent->kit(),
                                                                             copy.displayName));
 
-    CMakeOpenProjectWizard copw(project->projectManager(), CMakeOpenProjectWizard::ChangeDirectory, &copy);
-    if (copw.exec() != QDialog::Accepted)
-        return 0;
-
     CMakeBuildConfiguration *bc = new CMakeBuildConfiguration(parent);
     bc->setDisplayName(copy.displayName);
     bc->setDefaultDisplayName(copy.displayName);
@@ -192,8 +294,8 @@
     cleanMakeStep->setAdditionalArguments(QLatin1String("clean"));
     cleanMakeStep->setClean(true);
 
-    bc->setBuildDirectory(Utils::FileName::fromString(copw.buildDirectory()));
-    bc->setUseNinja(copw.useNinja());
+    bc->setBuildDirectory(Utils::FileName::fromString(copy.buildDirectory.toString()));
+    bc->setUseNinja(copy.useNinja);
 
     // Default to all
     if (project->hasBuildTarget(QLatin1String("all")))
@@ -246,14 +348,32 @@
 CMakeBuildInfo *CMakeBuildConfigurationFactory::createBuildInfo(const ProjectExplorer::Kit *k,
                                                                 const QString &sourceDir) const
 {
+    //this is safe, because the kit will not be changed and the generator not used outside this function
+    ProjectExplorer::Kit* otherK = const_cast<ProjectExplorer::Kit*>(k);
+
+    CMakeManager *manager = ExtensionSystem::PluginManager::getObject<CMakeManager>();
+    Q_ASSERT(manager);
+
+    ICMakeTool* cmake = CMakeToolManager::cmakeToolForKit(k);
+    if(!cmake)
+        return 0;
+
+    //there should always be a generator when we reach this stage
+    QList<GeneratorInfo> generators = GeneratorInfo::generatorInfosFor(otherK
+                                                                       ,GeneratorInfo::OfferNinja
+                                                                       ,manager->preferNinja()
+                                                                       ,cmake->hasCodeBlocksMsvcGenerator());
+
     CMakeBuildInfo *info = new CMakeBuildInfo(this);
     info->typeName = tr("Build");
     info->kitId = k->id();
     info->environment = Utils::Environment::systemEnvironment();
     k->addToEnvironment(info->environment);
-    info->useNinja = false;
     info->sourceDirectory = sourceDir;
-    info->supportsShadowBuild = true;
+    info->supportsShadowBuild = !CMakeProject::hasInSourceBuild(info->sourceDirectory);
+
+    //if the first generator is ninja, that is the preferred one
+    info->useNinja = (generators.size() > 0) ? generators.first().isNinja() : false;
 
     return info;
 }
@@ -276,7 +396,7 @@
 
     // Cover all common CMake build types
     if (cmakeBuildType.compare(QLatin1String("Release"), Qt::CaseInsensitive) == 0
-        || cmakeBuildType.compare(QLatin1String("MinSizeRel"), Qt::CaseInsensitive) == 0)
+            || cmakeBuildType.compare(QLatin1String("MinSizeRel"), Qt::CaseInsensitive) == 0)
     {
         return Release;
     } else if (cmakeBuildType.compare(QLatin1String("Debug"), Qt::CaseInsensitive) == 0

=== modified file 'src/cmakeprojectmanager/cmakebuildconfiguration.h'
--- src/cmakeprojectmanager/cmakebuildconfiguration.h	2014-02-18 14:30:29 +0000
+++ src/cmakeprojectmanager/cmakebuildconfiguration.h	2014-02-28 08:31:43 +0000
@@ -30,6 +30,7 @@
 #ifndef CMAKEBUILDCONFIGURATION_H
 #define CMAKEBUILDCONFIGURATION_H
 
+#include "cmakeprojectmanager_global.h"
 #include <projectexplorer/buildconfiguration.h>
 #include <projectexplorer/abi.h>
 
@@ -42,10 +43,11 @@
 
 namespace Internal {
 class CMakeProject;
+}
 
 class CMakeBuildConfigurationFactory;
 
-class CMakeBuildConfiguration : public ProjectExplorer::BuildConfiguration
+class CMAKEPROJECTMANAGER_EXPORT CMakeBuildConfiguration : public ProjectExplorer::BuildConfiguration
 {
     Q_OBJECT
     friend class CMakeBuildConfigurationFactory;
@@ -59,25 +61,37 @@
     QVariantMap toMap() const;
 
     BuildType buildType() const;
-
     bool useNinja() const;
     void setUseNinja(bool);
 
+    QStringList arguments() const;
+    void setArguments (const QStringList &args);
+
+    QByteArray generator () const;
+
+    static QByteArray cachedGeneratorFromFile(const QString &cache);
+    void setBuildDirectory(const Utils::FileName &directory);
 signals:
     void useNinjaChanged(bool);
+    void argumentsChanged(const QStringList& list);
 
 protected:
     CMakeBuildConfiguration(ProjectExplorer::Target *parent, CMakeBuildConfiguration *source);
     bool fromMap(const QVariantMap &map);
 
+protected slots:
+    void cleanAndRunCMake();
+    void runCMake();
+
 private:
+    QStringList m_arguments;
     QString m_msvcVersion;
     bool m_useNinja;
 
     friend class CMakeProject;
 };
 
-class CMakeBuildConfigurationFactory : public ProjectExplorer::IBuildConfigurationFactory
+class CMAKEPROJECTMANAGER_EXPORT CMakeBuildConfigurationFactory : public ProjectExplorer::IBuildConfigurationFactory
 {
     Q_OBJECT
 
@@ -103,7 +117,6 @@
     CMakeBuildInfo *createBuildInfo(const ProjectExplorer::Kit *k, const QString &sourceDir) const;
 };
 
-} // namespace Internal
 } // namespace CMakeProjectManager
 
 #endif // CMAKEBUILDCONFIGURATION_H

=== modified file 'src/cmakeprojectmanager/cmakebuildinfo.h'
--- src/cmakeprojectmanager/cmakebuildinfo.h	2014-02-18 14:30:29 +0000
+++ src/cmakeprojectmanager/cmakebuildinfo.h	2014-02-28 08:31:43 +0000
@@ -47,7 +47,7 @@
     CMakeBuildInfo(const ProjectExplorer::IBuildConfigurationFactory *f) :
         ProjectExplorer::BuildInfo(f), useNinja(false) { }
 
-    CMakeBuildInfo(const Internal::CMakeBuildConfiguration *bc) :
+    CMakeBuildInfo(const CMakeBuildConfiguration *bc) :
         ProjectExplorer::BuildInfo(ProjectExplorer::IBuildConfigurationFactory::find(bc->target()))
     {
         displayName = bc->displayName();

=== added file 'src/cmakeprojectmanager/cmakekitinformation.cpp'
--- src/cmakeprojectmanager/cmakekitinformation.cpp	1970-01-01 00:00:00 +0000
+++ src/cmakeprojectmanager/cmakekitinformation.cpp	2014-02-28 08:31:43 +0000
@@ -0,0 +1,161 @@
+#include "cmakekitinformation.h"
+#include "cmaketool.h"
+#include "cmaketoolmanager.h"
+#include "cmakeprojectconstants.h"
+#include "generatorinfo.h"
+
+#include <utils/elidinglabel.h>
+
+using namespace ProjectExplorer;
+using namespace Utils;
+
+namespace CMakeProjectManager {
+
+CMakeKitInformation::CMakeKitInformation()
+{
+    setId(CMakeKitInformation::id());
+}
+
+QVariant CMakeKitInformation::defaultValue(Kit *kit) const
+{
+    Q_UNUSED(kit);
+    return QString::fromLatin1(Constants::CMAKE_TOOL_ID);
+}
+
+QList<Task> CMakeKitInformation::validate(const Kit *) const
+{
+    return QList<Task>();
+}
+
+KitInformation::ItemList CMakeKitInformation::toUserOutput(const Kit *kit) const
+{
+    return KitInformation::ItemList()
+            << qMakePair(tr("CMake Tool"), cmakeTool(kit)->displayName());
+}
+
+KitConfigWidget *CMakeKitInformation::createConfigWidget(Kit *kit) const
+{
+    return new CMakeKitInformationWidget(kit, this);
+}
+
+Core::Id CMakeKitInformation::id()
+{
+    return "CMakeProjectManager.KitInformation";
+}
+
+bool CMakeKitInformation::hasSpecialCMakeTool(const Kit *kit)
+{
+    QString id(kit->value(CMakeKitInformation::id()).toString());
+    if(id.isNull())
+        return false;
+
+    if(id == QString::fromLatin1(Constants::CMAKE_TOOL_ID))
+        return false;
+
+    return true;
+}
+
+ICMakeTool* CMakeKitInformation::cmakeTool(const Kit *kit)
+{
+    Core::Id id = cmakeToolId(kit);
+
+    qDebug()<<"Kit "<<kit->displayName()<<" requests "<<id.toString();
+
+    if(!id.isValid() || id == Constants::CMAKE_TOOL_ID)
+        return CMakeToolManager::defaultCMakeTool();
+
+    ICMakeTool* tool = CMakeToolManager::cmakeTool(id);
+    //the cmake tool id is not known, fall back to default tool
+    //should we also remove the ID from the KIT?
+    if(!tool) {
+        return CMakeToolManager::defaultCMakeTool();
+    }
+    return tool;
+}
+
+Core::Id CMakeKitInformation::cmakeToolId(const Kit *kit)
+{
+    Core::Id test = Core::Id::fromSetting(kit->value(CMakeKitInformation::id()));
+    qDebug()<<"Id for kit: "<<kit->displayName()<<" "<<test.toString()<<" "<<test.uniqueIdentifier();
+    return test;
+}
+
+void CMakeKitInformation::setCMakeTool(Kit *kit, const Core::Id &toolId)
+{
+    kit->setValue(CMakeKitInformation::id(), toolId.toSetting());
+}
+
+///////////////
+// CMakeKitInformationWidget
+///////////////
+
+
+CMakeKitInformationWidget::CMakeKitInformationWidget(Kit *kit, const KitInformation *ki)
+    : KitConfigWidget(kit, ki),
+      m_label(new ElidingLabel)
+{
+    refresh();
+}
+
+CMakeKitInformationWidget::~CMakeKitInformationWidget()
+{
+    delete m_label;
+}
+
+QString CMakeKitInformationWidget::displayName() const
+{
+    return tr("CMake Tool");
+}
+
+QString CMakeKitInformationWidget::toolTip() const
+{
+    return tr("The CMake Tool used for this Kit.");
+}
+
+void CMakeKitInformationWidget::makeReadOnly()
+{
+}
+
+void CMakeKitInformationWidget::refresh()
+{
+    m_label->setText(CMakeKitInformation::cmakeTool(m_kit)->displayName());
+}
+
+bool CMakeKitInformationWidget::visibleInKit()
+{
+    Core::Id toolId = CMakeKitInformation::cmakeToolId(m_kit);
+    if(!toolId.isValid() || toolId == Constants::CMAKE_TOOL_ID)
+        return false;
+    return true;
+}
+
+QWidget *CMakeKitInformationWidget::mainWidget() const
+{
+    return m_label;
+}
+
+QWidget *CMakeKitInformationWidget::buttonWidget() const
+{
+    return 0;
+}
+
+bool CMakeKitMatcher::matches(const ProjectExplorer::Kit *k) const
+{
+    //this is safe, since the returned list is not used for more than checking
+    //if there are any results
+    ProjectExplorer::Kit* otherKit = const_cast<ProjectExplorer::Kit*>(k);
+
+    ICMakeTool* cmake = CMakeToolManager::cmakeToolForKit(k);
+    if(!cmake)
+        return false;
+
+    QList<Internal::GeneratorInfo> infos = Internal::GeneratorInfo::generatorInfosFor(otherKit
+                                                                                      ,Internal::GeneratorInfo::OfferNinja
+                                                                                      ,false //not relevant at this place
+                                                                                      ,cmake->hasCodeBlocksMsvcGenerator());
+
+    qDebug()<<"Found "<<infos.size()<<"Kits for "<<k->displayName();
+    return (infos.size() > 0);
+}
+
+} // namespace CMakeProjectManager

=== added file 'src/cmakeprojectmanager/cmakekitinformation.h'
--- src/cmakeprojectmanager/cmakekitinformation.h	1970-01-01 00:00:00 +0000
+++ src/cmakeprojectmanager/cmakekitinformation.h	2014-02-28 08:31:43 +0000
@@ -0,0 +1,70 @@
+#ifndef CMAKEPROJECTMANAGER_CMAKEKITINFORMATION_H
+#define CMAKEPROJECTMANAGER_CMAKEKITINFORMATION_H
+
+#include "cmakeprojectmanager_global.h"
+#include <projectexplorer/kitmanager.h>
+#include <projectexplorer/kitinformation.h>
+#include <projectexplorer/kitconfigwidget.h>
+
+QT_BEGIN_NAMESPACE
+class QLabel;
+class QPushButton;
+QT_END_NAMESPACE
+
+namespace CMakeProjectManager {
+
+class ICMakeTool;
+
+class CMAKEPROJECTMANAGER_EXPORT CMakeKitInformationWidget : public ProjectExplorer::KitConfigWidget
+{
+    Q_OBJECT
+public:
+    CMakeKitInformationWidget(ProjectExplorer::Kit *kit,
+                        const ProjectExplorer::KitInformation *ki);
+    ~CMakeKitInformationWidget();
+
+    QString displayName() const;
+    QString toolTip() const;
+    void makeReadOnly();
+    void refresh();
+    bool visibleInKit();
+
+    QWidget *mainWidget() const;
+    QWidget *buttonWidget() const;
+
+private:
+    QLabel *m_label;
+    QPushButton *m_button;
+};
+
+class CMAKEPROJECTMANAGER_EXPORT CMakeKitInformation : public ProjectExplorer::KitInformation
+{
+    Q_OBJECT
+public:
+    CMakeKitInformation();
+
+    QVariant defaultValue(ProjectExplorer::Kit *) const;
+
+    QList<ProjectExplorer::Task> validate(const ProjectExplorer::Kit *) const;
+
+    ItemList toUserOutput(const ProjectExplorer::Kit *) const;
+
+    ProjectExplorer::KitConfigWidget *createConfigWidget(ProjectExplorer::Kit *) const;
+
+    static Core::Id id();
+    static bool hasSpecialCMakeTool(const ProjectExplorer::Kit *kit);
+    static ICMakeTool* cmakeTool(const ProjectExplorer::Kit *kit);
+    static Core::Id cmakeToolId(const ProjectExplorer::Kit *kit);
+    static void setCMakeTool(ProjectExplorer::Kit *kit, const Core::Id &toolId);
+};
+
+class CMAKEPROJECTMANAGER_EXPORT CMakeKitMatcher : public ProjectExplorer::KitMatcher
+{
+public:
+    explicit CMakeKitMatcher() { }
+    bool matches(const ProjectExplorer::Kit *k) const;
+};
+
+} // namespace CMakeProjectManager
+
+#endif // CMAKEPROJECTMANAGER_CMAKEKITINFORMATION_H

=== modified file 'src/cmakeprojectmanager/cmakeopenprojectwizard.cpp'
--- src/cmakeprojectmanager/cmakeopenprojectwizard.cpp	2014-02-18 14:30:29 +0000
+++ src/cmakeprojectmanager/cmakeopenprojectwizard.cpp	2014-02-28 08:31:43 +0000
@@ -31,19 +31,16 @@
 #include "cmakeprojectmanager.h"
 #include "cmakebuildconfiguration.h"
 #include "cmakebuildinfo.h"
+#include "generatorinfo.h"
 
 #include <coreplugin/icore.h>
 #include <utils/hostosinfo.h>
 #include <utils/pathchooser.h>
 #include <utils/fancylineedit.h>
 #include <utils/historycompleter.h>
-#include <projectexplorer/kitinformation.h>
 #include <projectexplorer/kitmanager.h>
-#include <projectexplorer/toolchain.h>
-#include <projectexplorer/abi.h>
 #include <projectexplorer/projectexplorerconstants.h>
 #include <texteditor/fontsettings.h>
-#include <remotelinux/remotelinux_constants.h>
 
 #include <QVBoxLayout>
 #include <QFormLayout>
@@ -69,147 +66,6 @@
 //                                   |--> Already existing cbp file (and new enough) --> Page: Ready to load the project
 //                                   |--> Page: Ask for cmd options, run generator
 
-
-namespace CMakeProjectManager {
-namespace Internal {
-    class GeneratorInfo
-    {
-        Q_DECLARE_TR_FUNCTIONS(CMakeProjectManager::Internal::GeneratorInfo)
-    public:
-        enum Ninja { NoNinja, OfferNinja, ForceNinja };
-        static QList<GeneratorInfo> generatorInfosFor(ProjectExplorer::Kit *k, Ninja n, bool preferNinja, bool hasCodeBlocks);
-
-        GeneratorInfo();
-        explicit GeneratorInfo(ProjectExplorer::Kit *kit, bool ninja = false);
-
-        ProjectExplorer::Kit *kit() const;
-        bool isNinja() const;
-
-        QString displayName() const;
-        QByteArray generatorArgument() const;
-        QByteArray generator() const;
-
-    private:
-        ProjectExplorer::Kit *m_kit;
-        bool m_isNinja;
-    };
-}
-}
-
-Q_DECLARE_METATYPE(CMakeProjectManager::Internal::GeneratorInfo);
-
-GeneratorInfo::GeneratorInfo()
-    : m_kit(0), m_isNinja(false)
-{}
-
-GeneratorInfo::GeneratorInfo(ProjectExplorer::Kit *kit, bool ninja)
-    : m_kit(kit), m_isNinja(ninja)
-{}
-
-ProjectExplorer::Kit *GeneratorInfo::kit() const
-{
-    return m_kit;
-}
-
-bool GeneratorInfo::isNinja() const {
-    return m_isNinja;
-}
-
-QByteArray GeneratorInfo::generator() const
-{
-    if (!m_kit)
-        return QByteArray();
-    ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(m_kit);
-    ProjectExplorer::Abi targetAbi = tc->targetAbi();
-    if (m_isNinja) {
-        return "Ninja";
-    } else if (targetAbi.os() == ProjectExplorer::Abi::WindowsOS) {
-        if (targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2005Flavor
-                || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2008Flavor
-                || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2010Flavor
-                || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2012Flavor) {
-            return "NMake Makefiles";
-        } else if (targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMSysFlavor) {
-            if (Utils::HostOsInfo::isWindowsHost())
-                return "MinGW Makefiles";
-            else
-                return "Unix Makefiles";
-        }
-    }
-    return "Unix Makefiles";
-}
-
-QByteArray GeneratorInfo::generatorArgument() const
-{
-    QByteArray tmp = generator();
-    if (tmp.isEmpty())
-        return tmp;
-    return QByteArray("-GCodeBlocks - ") + tmp;
-}
-
-QString GeneratorInfo::displayName() const
-{
-    if (!m_kit)
-        return QString();
-    if (m_isNinja)
-        return tr("Ninja (%1)").arg(m_kit->displayName());
-    ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(m_kit);
-    ProjectExplorer::Abi targetAbi = tc->targetAbi();
-    if (targetAbi.os() == ProjectExplorer::Abi::WindowsOS) {
-        if (targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2005Flavor
-                || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2008Flavor
-                || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2010Flavor
-                || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2012Flavor) {
-            return tr("NMake Generator (%1)").arg(m_kit->displayName());
-        } else if (targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMSysFlavor) {
-            if (Utils::HostOsInfo::isWindowsHost())
-                return tr("MinGW Generator (%1)").arg(m_kit->displayName());
-            else
-                return tr("Unix Generator (%1)").arg(m_kit->displayName());
-        }
-    } else {
-        // Non windows
-        return tr("Unix Generator (%1)").arg(m_kit->displayName());
-    }
-    return QString();
-}
-
-QList<GeneratorInfo> GeneratorInfo::generatorInfosFor(ProjectExplorer::Kit *k, Ninja n, bool preferNinja, bool hasCodeBlocks)
-{
-    QList<GeneratorInfo> results;
-    ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(k);
-    if (!tc)
-        return results;
-    Core::Id deviceType = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(k);
-    if (deviceType !=  ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE
-            && deviceType != RemoteLinux::Constants::GenericLinuxOsType)
-        return results;
-    ProjectExplorer::Abi targetAbi = tc->targetAbi();
-    if (n != ForceNinja) {
-        if (targetAbi.os() == ProjectExplorer::Abi::WindowsOS) {
-            if (targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2005Flavor
-                    || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2008Flavor
-                    || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2010Flavor
-                    || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2012Flavor) {
-                if (hasCodeBlocks)
-                    results << GeneratorInfo(k);
-            } else if (targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMSysFlavor) {
-                results << GeneratorInfo(k);
-            }
-        } else {
-            // Non windows
-            results << GeneratorInfo(k);
-        }
-    }
-    if (n != NoNinja) {
-        if (preferNinja)
-            results.prepend(GeneratorInfo(k, true));
-        else
-            results.append(GeneratorInfo(k, true));
-    }
-    return results;
-}
-
 //////////////
 /// CMakeOpenProjectWizard
 //////////////
@@ -751,7 +607,7 @@
         connect(m_cmakeProcess, SIGNAL(readyReadStandardOutput()), this, SLOT(cmakeReadyReadStandardOutput()));
         connect(m_cmakeProcess, SIGNAL(readyReadStandardError()), this, SLOT(cmakeReadyReadStandardError()));
         connect(m_cmakeProcess, SIGNAL(finished(int)), this, SLOT(cmakeFinished()));
-        cmakeManager->createXmlFile(m_cmakeProcess, m_argumentsLineEdit->text(), m_cmakeWizard->sourceDirectory(),
+        cmakeManager->createXmlFile( m_cmakeProcess, m_argumentsLineEdit->text(), m_cmakeWizard->sourceDirectory(),
                                     m_buildDirectory, env, QString::fromLatin1(generatorInfo.generatorArgument()));
     } else {
         m_runCMake->setEnabled(true);

=== modified file 'src/cmakeprojectmanager/cmakeparser.cpp'
--- src/cmakeprojectmanager/cmakeparser.cpp	2014-02-18 14:30:29 +0000
+++ src/cmakeprojectmanager/cmakeparser.cpp	2014-02-28 08:31:43 +0000
@@ -188,6 +188,7 @@
 
 void CMakeProjectPlugin::testCMakeParser()
 {
+#if 0
     OutputParserTester testbench;
     testbench.appendOutputParser(new CMakeParser);
     QFETCH(QString, input);
@@ -200,6 +201,7 @@
     testbench.testParsing(input, inputChannel,
                           tasks, childStdOutLines, childStdErrLines,
                           outputLines);
+#endif
 }
 
 #endif

=== modified file 'src/cmakeprojectmanager/cmakeproject.cpp'
--- src/cmakeprojectmanager/cmakeproject.cpp	2014-02-18 14:30:29 +0000
+++ src/cmakeprojectmanager/cmakeproject.cpp	2014-02-28 08:31:43 +0000
@@ -33,8 +33,12 @@
 #include "cmakeprojectconstants.h"
 #include "cmakeprojectnodes.h"
 #include "cmakerunconfiguration.h"
+#include "cmakekitinformation.h"
+#include "cmakeappwizard.h"
 #include "makestep.h"
-#include "cmakeopenprojectwizard.h"
+#include "cmaketoolmanager.h"
+#include "argumentslineedit.h"
+#include "generatorinfo.h"
 
 #include <projectexplorer/projectexplorerconstants.h>
 #include <projectexplorer/projectexplorer.h>
@@ -58,16 +62,20 @@
 #include <utils/qtcassert.h>
 #include <utils/stringutils.h>
 #include <utils/hostosinfo.h>
+#include <utils/qtcprocess.h>
+#include <utils/pathchooser.h>
 #include <coreplugin/icore.h>
 #include <coreplugin/infobar.h>
 #include <coreplugin/documentmanager.h>
 #include <coreplugin/editormanager/editormanager.h>
 #include <coreplugin/variablemanager.h>
+#include <coreplugin/modemanager.h>
 
 #include <QDebug>
 #include <QDir>
 #include <QFormLayout>
 #include <QFileSystemWatcher>
+#include <QLabel>
 
 using namespace CMakeProjectManager;
 using namespace CMakeProjectManager::Internal;
@@ -123,32 +131,10 @@
     if (!bc)
         return;
 
-    CMakeBuildConfiguration *cmakebc = static_cast<CMakeBuildConfiguration *>(bc);
-
-    // Pop up a dialog asking the user to rerun cmake
-    QString cbpFile = CMakeManager::findCbpFile(QDir(bc->buildDirectory().toString()));
-    QFileInfo cbpFileFi(cbpFile);
-    CMakeOpenProjectWizard::Mode mode = CMakeOpenProjectWizard::Nothing;
-    if (!cbpFileFi.exists()) {
-        mode = CMakeOpenProjectWizard::NeedToCreate;
-    } else {
-        foreach (const QString &file, m_watchedFiles) {
-            if (QFileInfo(file).lastModified() > cbpFileFi.lastModified()) {
-                mode = CMakeOpenProjectWizard::NeedToUpdate;
-                break;
-            }
-        }
-    }
-
-    if (mode != CMakeOpenProjectWizard::Nothing) {
-        CMakeBuildInfo info(cmakebc);
-        CMakeOpenProjectWizard copw(m_manager, mode, &info);
-        if (copw.exec() == QDialog::Accepted)
-            cmakebc->setUseNinja(copw.useNinja()); // NeedToCreate can change the Ninja setting
-    }
-
-    // reparse
-    parseCMakeLists();
+    //@TODO handle no cmake case
+    ICMakeTool* cmake = CMakeToolManager::cmakeToolForKit(bc->target()->kit());
+    cmake->runCMake(bc->target());
+    connect(cmake,SIGNAL(cmakeFinished(ProjectExplorer::Target*)),this,SLOT(parseCMakeLists(ProjectExplorer::Target*)),Qt::UniqueConnection);
 }
 
 void CMakeProject::activeTargetWasChanged(Target *target)
@@ -184,17 +170,27 @@
     const QString projectName = QFileInfo(info.absolutePath()).fileName();
     ProjectExplorer::ProjectMacroExpander expander(projectFilePath, projectName, k, bcName);
     QDir projectDir = QDir(projectDirectory(projectFilePath));
+
+    if(hasInSourceBuild(projectDir.absolutePath()))
+        return projectDir.absolutePath();
+
     QString buildPath = Utils::expandMacros(Core::DocumentManager::buildDirectory(), &expander);
     return QDir::cleanPath(projectDir.absoluteFilePath(buildPath));
 }
 
-bool CMakeProject::parseCMakeLists()
+bool CMakeProject::parseCMakeLists(Target *t)
 {
+    qDebug()<<"Running parseCMakeLists";
+
     if (!activeTarget() ||
-        !activeTarget()->activeBuildConfiguration()) {
+            !activeTarget()->activeBuildConfiguration()) {
         return false;
     }
 
+    //parse only if active target
+    if(t && t != activeTarget())
+        return false;
+
     CMakeBuildConfiguration *activeBC = static_cast<CMakeBuildConfiguration *>(activeTarget()->activeBuildConfiguration());
     foreach (Core::IDocument *document, Core::EditorManager::documentModel()->openedDocuments())
         if (isProjectFile(document->filePath()))
@@ -255,13 +251,13 @@
 
     //qDebug()<<"Adding Targets";
     m_buildTargets = cbpparser.buildTargets();
-//        qDebug()<<"Printing targets";
-//        foreach (CMakeBuildTarget ct, m_buildTargets) {
-//            qDebug()<<ct.title<<" with executable:"<<ct.executable;
-//            qDebug()<<"WD:"<<ct.workingDirectory;
-//            qDebug()<<ct.makeCommand<<ct.makeCleanCommand;
-//            qDebug()<<"";
-//        }
+    //        qDebug()<<"Printing targets";
+    //        foreach (CMakeBuildTarget ct, m_buildTargets) {
+    //            qDebug()<<ct.title<<" with executable:"<<ct.executable;
+    //            qDebug()<<"WD:"<<ct.workingDirectory;
+    //            qDebug()<<ct.makeCommand<<ct.makeCleanCommand;
+    //            qDebug()<<"";
+    //        }
 
     updateApplicationAndDeploymentTargets();
 
@@ -368,11 +364,49 @@
     return true;
 }
 
+KitMatcher *CMakeProject::createRequiredKitMatcher() const
+{
+    return new CMakeKitMatcher();
+}
+
+bool CMakeProject::supportsKit(Kit *k, QString *errorMessage) const
+{
+    CMakeKitMatcher matcher;
+    if(matcher.matches(k))
+        return true;
+    if(errorMessage)
+        *errorMessage = QLatin1String("Could not find compatible CMake Generators");
+    return false;
+}
+
+bool CMakeProject::supportsNoTargetPanel() const
+{
+    return true;
+}
+
+bool CMakeProject::needsConfiguration() const
+{
+    return targets().isEmpty();
+}
+
 bool CMakeProject::isProjectFile(const QString &fileName)
 {
     return m_watchedFiles.contains(fileName);
 }
 
+bool CMakeProject::hasInSourceBuild() const
+{
+    return hasInSourceBuild(projectDirectory());
+}
+
+bool CMakeProject::hasInSourceBuild(const QString &sourcePath)
+{
+    QFileInfo fi(sourcePath + QLatin1String("/CMakeCache.txt"));
+    if (fi.exists())
+        return true;
+    return false;
+}
+
 QList<CMakeBuildTarget> CMakeProject::buildTargets() const
 {
     return m_buildTargets;
@@ -454,7 +488,7 @@
 
     // add added nodes
     foreach (ProjectExplorer::FileNode *fn, added) {
-//        qDebug()<<"added"<<fn->path();
+        //        qDebug()<<"added"<<fn->path();
         // Get relative path to rootNode
         QString parentDir = QFileInfo(fn->path()).absolutePath();
         ProjectExplorer::FolderNode *folder = findOrCreateFolder(rootNode, parentDir);
@@ -464,7 +498,7 @@
     // remove old file nodes and check whether folder nodes can be removed
     foreach (ProjectExplorer::FileNode *fn, deleted) {
         ProjectExplorer::FolderNode *parent = fn->parentFolderNode();
-//        qDebug()<<"removed"<<fn->path();
+        //        qDebug()<<"removed"<<fn->path();
         rootNode->removeFileNodes(QList<ProjectExplorer::FileNode *>() << fn, parent);
         // Check for empty parent
         while (parent->subFolderNodes().isEmpty() && parent->fileNodes().isEmpty()) {
@@ -544,61 +578,32 @@
     if (!Project::fromMap(map))
         return false;
 
+    //make sure there is always a cmake available
+    if(!CMakeToolManager::defaultCMakeTool()->isValid()) {
+        ChooseCMakeWizard wiz;
+        if(wiz.exec() != QDialog::Accepted)
+            return false;
+
+        if(!CMakeToolManager::defaultCMakeTool()->isValid())
+            return false;
+    }
+
+    //if there is no user file, just leave a empty project
+    //the configure project pane will pup up for the rescue
     bool hasUserFile = activeTarget();
-    if (!hasUserFile) {
-        CMakeOpenProjectWizard copw(m_manager, projectDirectory(), Utils::Environment::systemEnvironment());
-        if (copw.exec() != QDialog::Accepted)
-            return false;
-        Kit *k = copw.kit();
-        Target *t = new Target(this, k);
-        CMakeBuildConfiguration *bc(new CMakeBuildConfiguration(t));
-        bc->setDefaultDisplayName(QLatin1String("all"));
-        bc->setUseNinja(copw.useNinja());
-        bc->setBuildDirectory(Utils::FileName::fromString(copw.buildDirectory()));
-        ProjectExplorer::BuildStepList *buildSteps = bc->stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
-        ProjectExplorer::BuildStepList *cleanSteps = bc->stepList(ProjectExplorer::Constants::BUILDSTEPS_CLEAN);
-
-        // Now create a standard build configuration
-        buildSteps->insertStep(0, new MakeStep(buildSteps));
-
-        MakeStep *cleanMakeStep = new MakeStep(cleanSteps);
-        cleanSteps->insertStep(0, cleanMakeStep);
-        cleanMakeStep->setAdditionalArguments(QLatin1String("clean"));
-        cleanMakeStep->setClean(true);
-
-        t->addBuildConfiguration(bc);
-
-        t->updateDefaultDeployConfigurations();
-
-        addTarget(t);
-    } else {
+    if ( hasUserFile ) {
         // We have a user file, but we could still be missing the cbp file
         // or simply run createXml with the saved settings
-        QFileInfo sourceFileInfo(m_fileName);
         CMakeBuildConfiguration *activeBC = qobject_cast<CMakeBuildConfiguration *>(activeTarget()->activeBuildConfiguration());
         if (!activeBC)
-            return false;
-        QString cbpFile = CMakeManager::findCbpFile(QDir(activeBC->buildDirectory().toString()));
-        QFileInfo cbpFileFi(cbpFile);
-
-        CMakeOpenProjectWizard::Mode mode = CMakeOpenProjectWizard::Nothing;
-        if (!cbpFileFi.exists())
-            mode = CMakeOpenProjectWizard::NeedToCreate;
-        else if (cbpFileFi.lastModified() < sourceFileInfo.lastModified())
-            mode = CMakeOpenProjectWizard::NeedToUpdate;
-
-        if (mode != CMakeOpenProjectWizard::Nothing) {
-            CMakeBuildInfo info(activeBC);
-            CMakeOpenProjectWizard copw(m_manager, mode, &info);
-            if (copw.exec() != QDialog::Accepted)
-                return false;
-            else
-                activeBC->setUseNinja(copw.useNinja());
-        }
+            return true; //give the user a chance to setup a cmake target
+
+        //@TODO handle no cmake case
+        ICMakeTool* cmake = CMakeToolManager::cmakeToolForKit(activeBC->target()->kit());
+        cmake->runCMake(activeBC->target());
+        connect(cmake,SIGNAL(cmakeFinished(ProjectExplorer::Target*)),this,SLOT(parseCMakeLists(ProjectExplorer::Target*)),Qt::UniqueConnection);
     }
 
-    parseCMakeLists();
-
     m_activeTarget = activeTarget();
     if (m_activeTarget)
         connect(m_activeTarget, SIGNAL(activeBuildConfigurationChanged(ProjectExplorer::BuildConfiguration*)),
@@ -832,43 +837,65 @@
     return true;
 }
 
-CMakeBuildSettingsWidget::CMakeBuildSettingsWidget(CMakeBuildConfiguration *bc) : m_buildConfiguration(0)
+CMakeBuildSettingsWidget::CMakeBuildSettingsWidget(CMakeBuildConfiguration *bc) : m_buildConfiguration(bc)
 {
     QFormLayout *fl = new QFormLayout(this);
     fl->setContentsMargins(20, -1, 0, -1);
     fl->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
     setLayout(fl);
 
-    QPushButton *runCmakeButton = new QPushButton(tr("Run cmake"));
-    connect(runCmakeButton, SIGNAL(clicked()),
-            this, SLOT(runCMake()));
-    fl->addRow(tr("Reconfigure project:"), runCmakeButton);
-
-    m_pathLineEdit = new QLineEdit(this);
-    m_pathLineEdit->setReadOnly(true);
-
-    QHBoxLayout *hbox = new QHBoxLayout();
-    hbox->addWidget(m_pathLineEdit);
-
-    m_changeButton = new QPushButton(this);
-    m_changeButton->setText(tr("&Change"));
-    connect(m_changeButton, SIGNAL(clicked()), this, SLOT(openChangeBuildDirectoryDialog()));
-    hbox->addWidget(m_changeButton);
-
-    fl->addRow(tr("Build directory:"), hbox);
-
-    m_buildConfiguration = bc;
-    m_pathLineEdit->setText(m_buildConfiguration->rawBuildDirectory().toString());
-    if (m_buildConfiguration->buildDirectory().toString() == bc->target()->project()->projectDirectory())
-        m_changeButton->setEnabled(false);
-    else
-        m_changeButton->setEnabled(true);
+    bool inSource = CMakeProject::hasInSourceBuild(bc->target()->project()->projectDirectory());
+    if(inSource) {
+        QLabel* inSourceLabel = new QLabel(this);
+        inSourceLabel->setWordWrap(true);
+        inSourceLabel->setText(tr("Qt Creator has detected an <b>in-source-build in %1</b> "
+                                  "which prevents shadow builds. Qt Creator will not allow you to change the build directory. "
+                                  "If you want a shadow build, clean your source directory and re-open the project.")
+                               .arg(bc->target()->project()->projectDirectory()));
+        fl->addRow(inSourceLabel);
+    }
+
+    if(!inSource) {
+        m_pathChooser = new Utils::PathChooser(this);
+        m_pathChooser->setPath(m_buildConfiguration->rawBuildDirectory().toString());
+        fl->addRow(tr("Build directory:"), m_pathChooser);
+
+        connect(m_pathChooser->lineEdit(),SIGNAL(editingFinished()),this,SLOT(onBuilddirChanged()));
+    }
+
+    m_userArguments = new ArgumentsLineEdit(this);
+    fl->addRow(tr("CMake arguments:"),m_userArguments);
+    m_userArguments->setText(Utils::QtcProcess::joinArgs(m_buildConfiguration->arguments()));
+    m_userArguments->setHistoryCompleter(QLatin1String("CMakeArgumentsLineEdit"));
+    connect(m_userArguments,SIGNAL(editingFinished()),this,SLOT(onArgumentsChanged()));
+
+
+    m_generatorBox = new QComboBox(this);
+    ICMakeTool* cmake = CMakeToolManager::cmakeToolForKit(bc->target()->kit());
+    QList<GeneratorInfo> infos = GeneratorInfo::generatorInfosFor(bc->target()->kit(),
+                                                                  cmake->hasCodeBlocksNinjaGenerator() ? GeneratorInfo::OfferNinja : GeneratorInfo::NoNinja,
+                                                                  CMakeManager::preferNinja(),
+                                                                  cmake->hasCodeBlocksMsvcGenerator());
+
+    int idx = -1;
+    QByteArray cachedGenerator = bc->generator();
+    for(int i = 0; i < infos.size(); i++) {
+        const GeneratorInfo &info = infos.at(i);
+        m_generatorBox->addItem(info.displayName(), qVariantFromValue(info));
+        if(info.generator() == cachedGenerator) idx = i;
+    }
+
+    if(idx >= 0)
+        m_generatorBox->setCurrentIndex(idx);
+    connect(m_generatorBox,SIGNAL(currentIndexChanged(int)),this,SLOT(onGeneratorSelected()));
+    fl->addRow(tr("Generator:"),m_generatorBox);
 
     setDisplayName(tr("CMake"));
 }
 
 void CMakeBuildSettingsWidget::openChangeBuildDirectoryDialog()
 {
+#if 0
     CMakeProject *project = static_cast<CMakeProject *>(m_buildConfiguration->target()->project());
     CMakeBuildInfo info(m_buildConfiguration);
     CMakeOpenProjectWizard copw(project->projectManager(), CMakeOpenProjectWizard::ChangeDirectory,
@@ -878,18 +905,32 @@
         m_buildConfiguration->setUseNinja(copw.useNinja());
         m_pathLineEdit->setText(m_buildConfiguration->rawBuildDirectory().toString());
     }
+#endif
 }
 
-void CMakeBuildSettingsWidget::runCMake()
+void CMakeBuildSettingsWidget::onArgumentsChanged()
 {
-    if (!ProjectExplorer::ProjectExplorerPlugin::instance()->saveModifiedFiles())
+    if(!m_userArguments->isValid())
         return;
-    CMakeProject *project = static_cast<CMakeProject *>(m_buildConfiguration->target()->project());
-    CMakeBuildInfo info(m_buildConfiguration);
-    CMakeOpenProjectWizard copw(project->projectManager(),
-                                CMakeOpenProjectWizard::WantToUpdate, &info);
-    if (copw.exec() == QDialog::Accepted)
-        project->parseCMakeLists();
+
+    QStringList args = Utils::QtcProcess::splitArgs(m_userArguments->text());
+
+    if(m_buildConfiguration->arguments() != args)
+        m_buildConfiguration->setArguments(args);
+}
+
+void CMakeBuildSettingsWidget::onBuilddirChanged()
+{
+    qDebug()<<"Changing builddir to: "<<m_pathChooser->fileName().toString();
+    m_buildConfiguration->setBuildDirectory(m_pathChooser->fileName());
+}
+
+void CMakeBuildSettingsWidget::onGeneratorSelected()
+{
+    int curr = m_generatorBox->currentIndex();
+    GeneratorInfo info = m_generatorBox->itemData(curr).value<GeneratorInfo>();
+
+    m_buildConfiguration->setUseNinja(info.isNinja());
 }
 
 /////
@@ -1130,8 +1171,8 @@
                     bool generated = false;
                     QString onlyFileName = QFileInfo(fileName).fileName();
                     if (   (onlyFileName.startsWith(QLatin1String("moc_")) && onlyFileName.endsWith(QLatin1String(".cxx")))
-                        || (onlyFileName.startsWith(QLatin1String("ui_")) && onlyFileName.endsWith(QLatin1String(".h")))
-                        || (onlyFileName.startsWith(QLatin1String("qrc_")) && onlyFileName.endsWith(QLatin1String(".cxx"))))
+                           || (onlyFileName.startsWith(QLatin1String("ui_")) && onlyFileName.endsWith(QLatin1String(".h")))
+                           || (onlyFileName.startsWith(QLatin1String("qrc_")) && onlyFileName.endsWith(QLatin1String(".cxx"))))
                         generated = true;
 
                     if (fileName.endsWith(QLatin1String(".qrc")))

=== modified file 'src/cmakeprojectmanager/cmakeproject.h'
--- src/cmakeprojectmanager/cmakeproject.h	2014-02-18 14:30:29 +0000
+++ src/cmakeprojectmanager/cmakeproject.h	2014-02-28 08:31:43 +0000
@@ -42,10 +42,12 @@
 #include <coreplugin/idocument.h>
 #include <coreplugin/editormanager/editormanager.h>
 #include <coreplugin/editormanager/ieditor.h>
+#include <utils/pathchooser.h>
 
 #include <QXmlStreamReader>
 #include <QPushButton>
 #include <QLineEdit>
+#include <QComboBox>
 
 QT_BEGIN_NAMESPACE
 class QFileSystemWatcher;
@@ -54,6 +56,9 @@
 namespace ProjectExplorer { class Target; }
 
 namespace CMakeProjectManager {
+
+class ArgumentsLineEdit;
+
 namespace Internal {
 
 class CMakeFile;
@@ -97,8 +102,18 @@
                                         const QString &bcName);
 
     bool isProjectFile(const QString &fileName);
-
-    bool parseCMakeLists();
+    bool hasInSourceBuild() const;
+
+    static bool hasInSourceBuild (const QString &sourcePath);
+
+    // Project interface
+    ProjectExplorer::KitMatcher *createRequiredKitMatcher() const;
+    bool supportsKit(ProjectExplorer::Kit *k, QString *errorMessage) const;
+    bool supportsNoTargetPanel() const;
+    bool needsConfiguration() const;
+
+public slots:
+    bool parseCMakeLists(ProjectExplorer::Target* t = 0);
 
 signals:
     /// emitted after parsing
@@ -215,10 +230,13 @@
 
 private slots:
     void openChangeBuildDirectoryDialog();
-    void runCMake();
+    void onArgumentsChanged();
+    void onBuilddirChanged();
+    void onGeneratorSelected();
 private:
-    QLineEdit *m_pathLineEdit;
-    QPushButton *m_changeButton;
+    Utils::PathChooser *m_pathChooser;
+    ArgumentsLineEdit *m_userArguments;
+    QComboBox* m_generatorBox;
     CMakeBuildConfiguration *m_buildConfiguration;
 };
 

=== modified file 'src/cmakeprojectmanager/cmakeprojectconstants.h'
--- src/cmakeprojectmanager/cmakeprojectconstants.h	2014-02-18 14:30:29 +0000
+++ src/cmakeprojectmanager/cmakeprojectconstants.h	2014-02-28 08:31:43 +0000
@@ -51,6 +51,9 @@
 // Menu
 const char M_CONTEXT[] = "CMakeEditor.ContextMenu";
 
+// CMake Tool
+const char CMAKE_TOOL_ID[] = "CMakeProjectManager.DefaultCMakeTool";
+
 } // namespace Constants
 } // namespace CMakeProjectManager
 

=== modified file 'src/cmakeprojectmanager/cmakeprojectmanager.cpp'
--- src/cmakeprojectmanager/cmakeprojectmanager.cpp	2014-02-18 14:30:29 +0000
+++ src/cmakeprojectmanager/cmakeprojectmanager.cpp	2014-02-28 08:31:43 +0000
@@ -28,9 +28,9 @@
 ****************************************************************************/
 
 #include "cmakeprojectmanager.h"
-#include "cmakeopenprojectwizard.h"
 #include "cmakeprojectconstants.h"
 #include "cmakeproject.h"
+#include "cmaketoolmanager.h"
 
 #include <utils/synchronousprocess.h>
 #include <utils/qtcprocess.h>
@@ -43,7 +43,7 @@
 #include <projectexplorer/projectexplorerconstants.h>
 #include <projectexplorer/projectexplorer.h>
 #include <projectexplorer/target.h>
-#include <utils/QtConcurrentTools>
+//#include <utils/QtConcurrentTools>
 #include <QtConcurrentRun>
 #include <QCoreApplication>
 #include <QSettings>
@@ -58,9 +58,12 @@
 
 using namespace CMakeProjectManager::Internal;
 
+CMakeManager* CMakeManager::m_instance = 0;
+
 CMakeManager::CMakeManager(CMakeSettingsPage *cmakeSettingsPage)
     : m_settingsPage(cmakeSettingsPage)
 {
+    m_instance = this;
     ProjectExplorer::ProjectExplorerPlugin *projectExplorer = ProjectExplorer::ProjectExplorerPlugin::instance();
     connect(projectExplorer, SIGNAL(aboutToShowContextMenu(ProjectExplorer::Project*,ProjectExplorer::Node*)),
             this, SLOT(updateContextMenu(ProjectExplorer::Project*,ProjectExplorer::Node*)));
@@ -118,14 +121,9 @@
     if (!ProjectExplorer::ProjectExplorerPlugin::instance()->saveModifiedFiles())
         return;
 
-    CMakeBuildConfiguration *bc
-            = static_cast<CMakeBuildConfiguration *>(cmakeProject->activeTarget()->activeBuildConfiguration());
-
-    CMakeBuildInfo info(bc);
-
-    CMakeOpenProjectWizard copw(this, CMakeOpenProjectWizard::WantToUpdate, &info);
-    if (copw.exec() == QDialog::Accepted)
-        cmakeProject->parseCMakeLists();
+    ICMakeTool* cmake = CMakeToolManager::cmakeToolForKit(cmakeProject->activeTarget()->kit());
+    cmake->runCMake(cmakeProject->activeTarget());
+    connect(cmake,SIGNAL(cmakeFinished(ProjectExplorer::Target*)),cmakeProject,SLOT(parseCMakeLists(ProjectExplorer::Target*)),Qt::UniqueConnection);
 }
 
 ProjectExplorer::Project *CMakeManager::openProject(const QString &fileName, QString *errorString)
@@ -145,63 +143,9 @@
     return QLatin1String(Constants::CMAKEMIMETYPE);
 }
 
-QString CMakeManager::cmakeExecutable() const
-{
-    return m_settingsPage->cmakeExecutable();
-}
-
-bool CMakeManager::isCMakeExecutableValid() const
-{
-    return m_settingsPage->isCMakeExecutableValid();
-}
-
-void CMakeManager::setCMakeExecutable(const QString &executable)
-{
-    m_settingsPage->setCMakeExecutable(executable);
-}
-
-bool CMakeManager::hasCodeBlocksMsvcGenerator() const
-{
-    return m_settingsPage->hasCodeBlocksMsvcGenerator();
-}
-
-bool CMakeManager::hasCodeBlocksNinjaGenerator() const
-{
-    return m_settingsPage->hasCodeBlocksNinjaGenerator();
-}
-
-bool CMakeManager::preferNinja() const
-{
-    return m_settingsPage->preferNinja();
-}
-
-// need to refactor this out
-// we probably want the process instead of this function
-// cmakeproject then could even run the cmake process in the background, adding the files afterwards
-// sounds like a plan
-void CMakeManager::createXmlFile(Utils::QtcProcess *proc, const QString &arguments,
-                                 const QString &sourceDirectory, const QDir &buildDirectory,
-                                 const Utils::Environment &env, const QString &generator)
-{
-    // We create a cbp file, only if we didn't find a cbp file in the base directory
-    // Yet that can still override cbp files in subdirectories
-    // And we are creating tons of files in the source directories
-    // All of that is not really nice.
-    // The mid term plan is to move away from the CodeBlocks Generator and use our own
-    // QtCreator generator, which actually can be very similar to the CodeBlock Generator
-    QString buildDirectoryPath = buildDirectory.absolutePath();
-    buildDirectory.mkpath(buildDirectoryPath);
-    proc->setWorkingDirectory(buildDirectoryPath);
-    proc->setEnvironment(env);
-
-    const QString srcdir = buildDirectory.exists(QLatin1String("CMakeCache.txt")) ?
-                QString(QLatin1Char('.')) : sourceDirectory;
-    QString args;
-    Utils::QtcProcess::addArg(&args, srcdir);
-    Utils::QtcProcess::addArgs(&args, arguments);
-    Utils::QtcProcess::addArg(&args, generator);
-    proc->setCommand(cmakeExecutable(), args);
-    proc->start();
+bool CMakeManager::preferNinja()
+{
+    return m_instance->m_settingsPage->preferNinja();
 }
 
 QString CMakeManager::findCbpFile(const QDir &directory)
@@ -263,27 +207,15 @@
     setDisplayCategory(QCoreApplication::translate("ProjectExplorer",
        ProjectExplorer::Constants::PROJECTEXPLORER_SETTINGS_TR_CATEGORY));
     setCategoryIcon(QLatin1String(ProjectExplorer::Constants::PROJECTEXPLORER_SETTINGS_CATEGORY_ICON));
-
-    QSettings *settings = Core::ICore::settings();
-    settings->beginGroup(QLatin1String("CMakeSettings"));
-    m_cmakeValidatorForUser.setCMakeExecutable(settings->value(QLatin1String("cmakeExecutable")).toString());
-    settings->endGroup();
-
-    m_cmakeValidatorForSystem.setCMakeExecutable(findCmakeExecutable());
 }
 
 bool CMakeSettingsPage::isCMakeExecutableValid() const
 {
-    if (m_cmakeValidatorForUser.isValid())
-        return true;
-
-    return m_cmakeValidatorForSystem.isValid();
+    return CMakeToolManager::defaultCMakeTool()->isValid();
 }
 
 CMakeSettingsPage::~CMakeSettingsPage()
 {
-    m_cmakeValidatorForUser.cancel();
-    m_cmakeValidatorForSystem.cancel();
 }
 
 QString CMakeSettingsPage::findCmakeExecutable() const
@@ -300,7 +232,7 @@
     m_pathchooser->setExpectedKind(Utils::PathChooser::ExistingCommand);
     formLayout->addRow(tr("Executable:"), m_pathchooser);
     formLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Ignored, QSizePolicy::MinimumExpanding));
-    m_pathchooser->setPath(m_cmakeValidatorForUser.cmakeExecutable());
+    m_pathchooser->setPath(CMakeToolManager::userCMakePath());
 
     m_preferNinja = new QCheckBox(tr("Prefer Ninja generator (CMake 2.8.9 or higher required)"));
     m_preferNinja->setChecked(preferNinja());
@@ -313,7 +245,7 @@
 {
     QSettings *settings = Core::ICore::settings();
     settings->beginGroup(QLatin1String("CMakeSettings"));
-    settings->setValue(QLatin1String("cmakeExecutable"), m_cmakeValidatorForUser.cmakeExecutable());
+    settings->setValue(QLatin1String("cmakeExecutable"), CMakeToolManager::userCMakePath());
     settings->setValue(QLatin1String("preferNinja"), m_preferNinja->isChecked());
     settings->endGroup();
 }
@@ -322,8 +254,8 @@
 {
     if (!m_pathchooser) // page was never shown
         return;
-    if (m_cmakeValidatorForUser.cmakeExecutable() != m_pathchooser->path())
-        m_cmakeValidatorForUser.setCMakeExecutable(m_pathchooser->path());
+    if (CMakeToolManager::userCMakePath() != m_pathchooser->path())
+        CMakeToolManager::setUserCmakePath(m_pathchooser->path());
     saveSettings();
 }
 
@@ -332,41 +264,14 @@
 
 }
 
-QString CMakeSettingsPage::cmakeExecutable() const
-{
-    if (!isCMakeExecutableValid())
-        return QString();
-
-    if (m_cmakeValidatorForUser.isValid())
-        return m_cmakeValidatorForUser.cmakeExecutable();
-    if (m_cmakeValidatorForSystem.isValid())
-        return m_cmakeValidatorForSystem.cmakeExecutable();
-    return QString();
-}
-
-void CMakeSettingsPage::setCMakeExecutable(const QString &executable)
-{
-    if (m_cmakeValidatorForUser.cmakeExecutable() == executable)
-        return;
-    m_cmakeValidatorForUser.setCMakeExecutable(executable);
-}
-
 bool CMakeSettingsPage::hasCodeBlocksMsvcGenerator() const
 {
-    if (m_cmakeValidatorForUser.isValid())
-        return m_cmakeValidatorForUser.hasCodeBlocksMsvcGenerator();
-    if (m_cmakeValidatorForSystem.isValid())
-        return m_cmakeValidatorForSystem.hasCodeBlocksMsvcGenerator();
-    return false;
+    return CMakeToolManager::defaultCMakeTool()->hasCodeBlocksMsvcGenerator();
 }
 
 bool CMakeSettingsPage::hasCodeBlocksNinjaGenerator() const
 {
-    if (m_cmakeValidatorForUser.isValid())
-        return m_cmakeValidatorForUser.hasCodeBlocksNinjaGenerator();
-    if (m_cmakeValidatorForSystem.isValid())
-        return m_cmakeValidatorForSystem.hasCodeBlocksNinjaGenerator();
-    return false;
+    return CMakeToolManager::defaultCMakeTool()->hasCodeBlocksNinjaGenerator();
 }
 
 bool CMakeSettingsPage::preferNinja() const
@@ -380,11 +285,9 @@
 
 TextEditor::Keywords CMakeSettingsPage::keywords()
 {
-    if (m_cmakeValidatorForUser.isValid())
-        return m_cmakeValidatorForUser.keywords();
-
-    if (m_cmakeValidatorForSystem.isValid())
-        return m_cmakeValidatorForSystem.keywords();
+    ICMakeTool* defTool = CMakeToolManager::defaultCMakeTool();
+    if(defTool->isValid())
+        return defTool->keywords();
 
     return TextEditor::Keywords(QStringList(), QStringList(), QMap<QString, QStringList>());
 }

=== modified file 'src/cmakeprojectmanager/cmakeprojectmanager.h'
--- src/cmakeprojectmanager/cmakeprojectmanager.h	2014-02-18 14:30:29 +0000
+++ src/cmakeprojectmanager/cmakeprojectmanager.h	2014-02-28 08:31:43 +0000
@@ -69,22 +69,8 @@
     virtual ProjectExplorer::Project *openProject(const QString &fileName, QString *errorString);
     virtual QString mimeType() const;
 
-    QString cmakeExecutable() const;
-    bool isCMakeExecutableValid() const;
-
-    void setCMakeExecutable(const QString &executable);
-
-    void createXmlFile(Utils::QtcProcess *process,
-                       const QString &arguments,
-                       const QString &sourceDirectory,
-                       const QDir &buildDirectory,
-                       const Utils::Environment &env,
-                       const QString &generator);
-    bool hasCodeBlocksMsvcGenerator() const;
-    bool hasCodeBlocksNinjaGenerator() const;
-    bool preferNinja() const;
+    static bool preferNinja();
     static QString findCbpFile(const QDir &);
-
     static QString findDumperLibrary(const Utils::Environment &env);
 private slots:
     void updateContextMenu(ProjectExplorer::Project *project, ProjectExplorer::Node *node);
@@ -98,6 +84,8 @@
     QAction *m_runCMakeAction;
     QAction *m_runCMakeActionContextMenu;
     ProjectExplorer::Project *m_contextProject;
+
+    static CMakeManager* m_instance;
 };
 
 class CMakeSettingsPage : public Core::IOptionsPage
@@ -112,8 +100,6 @@
     void apply();
     void finish();
 
-    QString cmakeExecutable() const;
-    void setCMakeExecutable(const QString &executable);
     bool isCMakeExecutableValid() const;
     bool hasCodeBlocksMsvcGenerator() const;
     bool hasCodeBlocksNinjaGenerator() const;
@@ -127,8 +113,6 @@
 
     Utils::PathChooser *m_pathchooser;
     QCheckBox *m_preferNinja;
-    CMakeValidator m_cmakeValidatorForUser;
-    CMakeValidator m_cmakeValidatorForSystem;
 };
 
 } // namespace Internal

=== modified file 'src/cmakeprojectmanager/cmakeprojectmanager.pro'
--- src/cmakeprojectmanager/cmakeprojectmanager.pro	2014-02-18 14:30:29 +0000
+++ src/cmakeprojectmanager/cmakeprojectmanager.pro	2014-02-28 08:31:43 +0000
@@ -4,11 +4,11 @@
     cmakeproject.h \
     cmakeprojectplugin.h \
     cmakeprojectmanager.h \
+    cmakeprojectmanager_global.h \
     cmakeprojectconstants.h \
     cmakeprojectnodes.h \
     makestep.h \
     cmakerunconfiguration.h \
-    cmakeopenprojectwizard.h \
     cmakebuildconfiguration.h \
     cmakeeditorfactory.h \
     cmakeeditor.h \
@@ -16,8 +16,13 @@
     cmakehighlighterfactory.h \
     cmakelocatorfilter.h \
     cmakefilecompletionassist.h \
-    cmakevalidator.h \
-    cmakeparser.h
+    cmakeparser.h \
+    generatorinfo.h \
+    cmakeappwizard.h \
+    cmakekitinformation.h \
+    cmaketool.h \
+    argumentslineedit.h \
+    cmaketoolmanager.h
 
 SOURCES = cmakeproject.cpp \
     cmakeprojectplugin.cpp \
@@ -25,7 +30,6 @@
     cmakeprojectnodes.cpp \
     makestep.cpp \
     cmakerunconfiguration.cpp \
-    cmakeopenprojectwizard.cpp \
     cmakebuildconfiguration.cpp \
     cmakeeditorfactory.cpp \
     cmakeeditor.cpp \
@@ -33,8 +37,14 @@
     cmakehighlighterfactory.cpp \
     cmakelocatorfilter.cpp \
     cmakefilecompletionassist.cpp \
-    cmakevalidator.cpp \
-    cmakeparser.cpp
+    cmakeparser.cpp \
+    generatorinfo.cpp \
+    cmakeappwizard.cpp \
+    cmakekitinformation.cpp \
+    cmaketool.cpp \
+    argumentslineedit.cpp \
+    cmaketoolmanager.cpp
 
 
 RESOURCES += cmakeproject.qrc
+DEFINES += CMAKEPROJECTMANAGER_LIBRARY

=== added file 'src/cmakeprojectmanager/cmakeprojectmanager_global.h'
--- src/cmakeprojectmanager/cmakeprojectmanager_global.h	1970-01-01 00:00:00 +0000
+++ src/cmakeprojectmanager/cmakeprojectmanager_global.h	2014-02-28 08:31:43 +0000
@@ -0,0 +1,41 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of Qt Creator.
+**
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia. For licensing terms and
+** conditions see http://qt.digia.com/licensing. For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights. These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+****************************************************************************/
+
+#ifndef CMAKEPROJECTMANAGER_GLOBAL_H
+#define CMAKEPROJECTMANAGER_GLOBAL_H
+
+#include <qglobal.h>
+
+#if defined(CMAKEPROJECTMANAGER_LIBRARY)
+# define CMAKEPROJECTMANAGER_EXPORT Q_DECL_EXPORT
+#else
+# define CMAKEPROJECTMANAGER_EXPORT Q_DECL_IMPORT
+#endif
+
+#endif // QMAKEPROJECTMANAGER_GLOBAL_H

=== modified file 'src/cmakeprojectmanager/cmakeprojectplugin.cpp'
--- src/cmakeprojectmanager/cmakeprojectplugin.cpp	2014-02-18 14:30:29 +0000
+++ src/cmakeprojectmanager/cmakeprojectplugin.cpp	2014-02-28 08:31:43 +0000
@@ -37,10 +37,14 @@
 #include "cmakelocatorfilter.h"
 #include "cmakefilecompletionassist.h"
 #include "cmakehighlighterfactory.h"
+#include "cmakeappwizard.h"
+#include "cmaketoolmanager.h"
+#include "cmakekitinformation.h"
 
 #include <coreplugin/featureprovider.h>
 #include <coreplugin/mimedatabase.h>
 #include <texteditor/texteditoractionhandler.h>
+#include <projectexplorer/kitmanager.h>
 
 #include <QtPlugin>
 #include <QDebug>
@@ -70,6 +74,8 @@
 {
     if (!Core::MimeDatabase::addMimeTypes(QLatin1String(":cmakeproject/CMakeProjectManager.mimetypes.xml"), errorMessage))
         return false;
+
+    addAutoReleasedObject(new CMakeToolManager);
     CMakeSettingsPage *cmp = new CMakeSettingsPage();
     addAutoReleasedObject(cmp);
     CMakeManager *manager = new CMakeManager(cmp);
@@ -83,6 +89,10 @@
     addAutoReleasedObject(new CMakeFileCompletionAssistProvider(cmp));
     addAutoReleasedObject(new CMakeFeatureProvider);
     addAutoReleasedObject(new CMakeHighlighterFactory);
+
+    CMakeAppWizard::registerSelf();
+    ProjectExplorer::KitManager::registerKitInformation(new CMakeKitInformation());
+
     return true;
 }
 

=== added file 'src/cmakeprojectmanager/cmaketool.cpp'
--- src/cmakeprojectmanager/cmaketool.cpp	1970-01-01 00:00:00 +0000
+++ src/cmakeprojectmanager/cmaketool.cpp	2014-02-28 08:31:43 +0000
@@ -0,0 +1,441 @@
+#include "cmaketool.h"
+#include "cmakeprojectmanager.h"
+#include "cmakeprojectconstants.h"
+#include "cmakebuildconfiguration.h"
+#include "generatorinfo.h"
+
+#include <QProcess>
+#include <QFileInfo>
+#include <QDir>
+#include <extensionsystem/pluginmanager.h>
+#include <projectexplorer/target.h>
+#include <projectexplorer/kit.h>
+#include <utils/qtcprocess.h>
+#include <coreplugin/messagemanager.h>
+#include <coreplugin/progressmanager/futureprogress.h>
+#include <coreplugin/progressmanager/progressmanager.h>
+
+using namespace CMakeProjectManager;
+using namespace Internal;
+
+/*!
+ * \class ICMakeTool
+ * Generic interface for starting cmake to create the buildfiles
+ * Can be linked to a specific Kit
+ */
+ICMakeTool::ICMakeTool(QObject *parent)
+    : QObject(parent)
+{
+
+}
+
+ICMakeTool::~ICMakeTool()
+{
+
+}
+
+void ICMakeTool::addToEnvironment(Utils::Environment &env) const
+{
+
+}
+
+CMakeTool::CMakeTool(QObject *parent)
+    : ICMakeTool(parent)
+    , m_state(CMakeTool::RunningBasic)
+    , m_process(0)
+    , m_hasCodeBlocksMsvcGenerator(false)
+    , m_hasCodeBlocksNinjaGenerator(false)
+    , m_futureInterface(0)
+{
+    setId(Constants::CMAKE_TOOL_ID);
+}
+
+CMakeTool::~CMakeTool()
+{
+    cancel();
+}
+
+void CMakeTool::cancel()
+{
+    if (m_process) {
+        if(m_futureInterface){
+            m_futureInterface->reportCanceled();
+            m_futureInterface->reportFinished();
+        }
+
+        disconnect(m_process, SIGNAL(finished(int)));
+        m_process->waitForFinished();
+        delete m_process;
+        m_process = 0;
+
+        if(m_state != CMakeTool::RunningDone && m_state != CMakeTool::RunningProject)
+            m_state = CMakeTool::Invalid;
+    }
+
+    m_pendingRuns.clear();
+}
+
+void CMakeTool::setCMakeExecutable(const QString &executable)
+{
+    cancel();
+    createProcessIfNotExists();
+
+    m_executable = executable;
+    QFileInfo fi(m_executable);
+    if (fi.exists() && fi.isExecutable()) {
+        // Run it to find out more
+        m_state = CMakeTool::RunningBasic;
+        if (!startProcess(QStringList(QLatin1String("--help"))))
+            m_state = CMakeTool::Invalid;
+    } else {
+        m_state = CMakeTool::Invalid;
+    }
+}
+
+void CMakeTool::finished(int exitCode)
+{
+    if (exitCode && m_state != CMakeTool::RunningProject) {
+        flushOutput();
+        m_state = CMakeTool::Invalid;
+        return;
+    }
+    if (m_state == CMakeTool::RunningBasic) {
+        QByteArray response = m_process->readAll();
+
+        m_hasCodeBlocksMsvcGenerator = response.contains("CodeBlocks - NMake Makefiles");
+        m_hasCodeBlocksNinjaGenerator = response.contains("CodeBlocks - Ninja");
+
+        if (response.isEmpty()) {
+            m_state = CMakeTool::Invalid;
+        } else {
+            m_state = CMakeTool::RunningFunctionList;
+            if (!startProcess(QStringList(QLatin1String("--help-command-list"))))
+                finished(0); // should never happen, just continue
+        }
+    } else if (m_state == CMakeTool::RunningFunctionList) {
+        parseFunctionOutput(m_process->readAll());
+        m_state = CMakeTool::RunningFunctionDetails;
+        if (!startProcess(QStringList(QLatin1String("--help-commands"))))
+            finished(0); // should never happen, just continue
+    } else if (m_state == CMakeTool::RunningFunctionDetails) {
+        parseFunctionDetailsOutput(m_process->readAll());
+        m_state = CMakeTool::RunningPropertyList;
+        if (!startProcess(QStringList(QLatin1String("--help-property-list"))))
+            finished(0); // should never happen, just continue
+    } else if (m_state == CMakeTool::RunningPropertyList) {
+        parseVariableOutput(m_process->readAll());
+        m_state = CMakeTool::RunningVariableList;
+        if (!startProcess(QStringList(QLatin1String("--help-variable-list"))))
+            finished(0); // should never happen, just continue
+    } else if (m_state == CMakeTool::RunningVariableList) {
+        parseVariableOutput(m_process->readAll());
+        parseDone();
+        m_state = CMakeTool::RunningDone;
+    }else if (m_state == CMakeTool::RunningProject) {
+        //cmake run is finished no matter if we were successful or not
+        m_currentRun.clear();
+        m_state = CMakeTool::RunningDone;
+
+        if(m_futureInterface) {
+            if(exitCode) m_futureInterface->reportCanceled();
+            m_futureInterface->reportFinished();
+        }
+
+        flushOutput();
+        emit cmakeFinished(m_currentRun.data());
+    }
+
+    if(m_state == CMakeTool::RunningDone )
+        startNextRun();
+}
+
+void CMakeTool::onProcessReadyRead()
+{
+    //we only care about cmake project building output
+    if(m_state != CMakeTool::RunningProject)
+        return;
+
+    QString stderr = QString::fromLocal8Bit(m_process->readAllStandardError());
+    QString stdout = QString::fromLocal8Bit(m_process->readAllStandardOutput());
+    if (!stderr.isEmpty()) {
+        Core::MessageManager::write(QString(QLatin1String("%0")).arg(stderr),Core::MessageManager::ModeSwitch);
+    }
+    if (!stdout.isEmpty()) {
+        Core::MessageManager::write(QString(QLatin1String("%0")).arg(stdout),Core::MessageManager::NoModeSwitch);
+    }
+}
+
+void CMakeTool::flushOutput()
+{
+    QString errorMsg = QString::fromLocal8Bit(m_process->readAllStandardError());
+    if (errorMsg.trimmed().length()>0) Core::MessageManager::write(errorMsg,Core::MessageManager::ModeSwitch);
+    QString msg = QString::fromLocal8Bit(m_process->readAllStandardOutput());
+    if (msg.trimmed().length()>0) Core::MessageManager::write(msg,Core::MessageManager::NoModeSwitch);
+}
+
+void CMakeTool::createProcessIfNotExists()
+{
+    if(!m_process) {
+        m_process = new Utils::QtcProcess();
+        connect(m_process, SIGNAL(finished(int)),
+                this, SLOT(finished(int)));
+        connect(m_process,SIGNAL(readyRead()),
+                this,SLOT(onProcessReadyRead()));
+    }
+}
+
+bool CMakeTool::isValid() const
+{
+    if (m_state == CMakeTool::Invalid)
+        return false;
+    if (m_state == CMakeTool::RunningBasic)
+        m_process->waitForFinished();
+    return (m_state != CMakeTool::Invalid);
+}
+
+bool CMakeTool::startProcess(const QStringList &args, Utils::Environment env)
+{
+    QString argsStr = Utils::QtcProcess::joinArgs(args);
+
+    //add custom cmake environment vars
+    addToEnvironment(env);
+
+    qDebug()<<"Starting process: "
+           <<m_executable
+          <<argsStr;
+
+    m_process->setEnvironment(env);
+    m_process->setCommand(m_executable, argsStr);
+    m_process->start();
+    return m_process->waitForStarted(2000);
+}
+
+QString CMakeTool::cmakeExecutable() const
+{
+    return m_executable;
+}
+
+bool CMakeTool::hasCodeBlocksMsvcGenerator() const
+{
+    if (!isValid())
+        return false;
+    return m_hasCodeBlocksMsvcGenerator;
+}
+
+bool CMakeTool::hasCodeBlocksNinjaGenerator() const
+{
+    if (!isValid())
+        return false;
+    return m_hasCodeBlocksNinjaGenerator;
+}
+
+TextEditor::Keywords CMakeTool::keywords()
+{
+    while (m_state != RunningDone && m_state != CMakeTool::Invalid) {
+        m_process->waitForFinished();
+    }
+
+    if (m_state == CMakeTool::Invalid)
+        return TextEditor::Keywords(QStringList(), QStringList(), QMap<QString, QStringList>());
+
+    return TextEditor::Keywords(m_variables, m_functions, m_functionArgs);
+}
+
+void CMakeTool::runCMake( ProjectExplorer::Target* target )
+{
+    if(!isValid())
+        return;
+
+    QPointer<ProjectExplorer::Target> ptrTarget(target);
+
+    if(!m_pendingRuns.contains(ptrTarget))
+        m_pendingRuns.append(ptrTarget);
+
+    if(m_state != CMakeTool::RunningDone)
+        return;
+
+    return startNextRun();
+}
+
+QString CMakeTool::displayName()
+{
+    return QString::fromLatin1("Default");
+}
+
+void CMakeTool::startNextRun()
+{
+    QPointer<ProjectExplorer::Target> ptrMyTarget;
+    while(!m_pendingRuns.isEmpty() && ptrMyTarget.isNull())
+        ptrMyTarget = m_pendingRuns.dequeue();
+
+    if(!ptrMyTarget)
+        return;
+
+    // We create a cbp file, only if we didn't find a cbp file in the base directory
+    // Yet that can still override cbp files in subdirectories
+    // And we are creating tons of files in the source directories
+    // All of that is not really nice.
+    // The mid term plan is to move away from the CodeBlocks Generator and use our own
+    // QtCreator generator, which actually can be very similar to the CodeBlock Generator
+    CMakeBuildConfiguration* config = qobject_cast<CMakeBuildConfiguration*>(ptrMyTarget->activeBuildConfiguration());
+    if(!config)
+        return;
+
+    Utils::Environment env = config->environment();
+    QDir buildDirectory(config->buildDirectory().toString());
+
+    QString buildDirectoryPath = buildDirectory.absolutePath();
+    buildDirectory.mkpath(buildDirectoryPath);
+
+    //user chose the kit on project creation
+    ptrMyTarget->kit()->addToEnvironment(env);
+
+    createProcessIfNotExists();
+    m_state = CMakeTool::RunningProject;
+
+    GeneratorInfo gInfo(ptrMyTarget->kit(),config->useNinja());
+
+    QStringList args;
+    args << ptrMyTarget->project()->projectDirectory()
+         << config->arguments()
+         << QLatin1String(gInfo.generatorArgument());
+
+    m_process->setWorkingDirectory(buildDirectoryPath);
+
+    if(m_futureInterface)
+        delete m_futureInterface;
+
+    m_futureInterface = new QFutureInterface<void>();
+    m_futureInterface->setProgressRange(0,1);
+
+    Core::FutureProgress* futureProgress = Core::ProgressManager::addTask(m_futureInterface->future()
+                                                                          ,tr("Parsing ProjectFile")
+                                                                          ,Core::Id("CMakeProjectManager.CMakeTaskID"));
+    connect(futureProgress,SIGNAL(canceled()),this,SLOT(cancel()));
+
+    m_futureInterface->reportStarted();
+    startProcess(args,env);
+}
+
+static void extractKeywords(const QByteArray &input, QStringList *destination)
+{
+    if (!destination)
+        return;
+
+    QString keyword;
+    int ignoreZone = 0;
+    for (int i = 0; i < input.count(); ++i) {
+        const QChar chr = QLatin1Char(input.at(i));
+        if (chr == QLatin1Char('{'))
+            ++ignoreZone;
+        if (chr == QLatin1Char('}'))
+            --ignoreZone;
+        if (ignoreZone == 0) {
+            if ((chr.isLetterOrNumber() && chr.isUpper())
+                    || chr == QLatin1Char('_')) {
+                keyword += chr;
+            } else {
+                if (!keyword.isEmpty()) {
+                    if (keyword.size() > 1)
+                        *destination << keyword;
+                    keyword.clear();
+                }
+            }
+        }
+    }
+    if (keyword.size() > 1)
+        *destination << keyword;
+}
+
+void CMakeTool::parseFunctionOutput(const QByteArray &output)
+{
+    QList<QByteArray> cmakeFunctionsList = output.split('\n');
+    m_functions.clear();
+    if (!cmakeFunctionsList.isEmpty()) {
+        cmakeFunctionsList.removeFirst(); //remove version string
+        foreach (const QByteArray &function, cmakeFunctionsList)
+            m_functions << QString::fromLocal8Bit(function.trimmed());
+    }
+}
+
+QString CMakeTool::formatFunctionDetails(const QString &command, const QString &args)
+{
+    return QString::fromLatin1("<table><tr><td><b>%1</b></td><td>%2</td></tr>")
+            .arg(Qt::escape(command)).arg(Qt::escape(args));
+}
+
+void CMakeTool::parseFunctionDetailsOutput(const QByteArray &output)
+{
+    QStringList cmakeFunctionsList = m_functions;
+    QList<QByteArray> cmakeCommandsHelp = output.split('\n');
+    for (int i = 0; i < cmakeCommandsHelp.count(); ++i) {
+        QByteArray lineTrimmed = cmakeCommandsHelp.at(i).trimmed();
+        if (cmakeFunctionsList.isEmpty())
+            break;
+        if (cmakeFunctionsList.first().toLatin1() == lineTrimmed) {
+            QStringList commandSyntaxes;
+            QString currentCommandSyntax;
+            QString currentCommand = cmakeFunctionsList.takeFirst();
+            ++i;
+            for (; i < cmakeCommandsHelp.count(); ++i) {
+                lineTrimmed = cmakeCommandsHelp.at(i).trimmed();
+
+                if (!cmakeFunctionsList.isEmpty() && cmakeFunctionsList.first().toLatin1() == lineTrimmed) {
+                    //start of next function in output
+                    if (!currentCommandSyntax.isEmpty())
+                        commandSyntaxes << currentCommandSyntax.append(QLatin1String("</table>"));
+                    --i;
+                    break;
+                }
+                if (lineTrimmed.startsWith(currentCommand.toLatin1() + "(")) {
+                    if (!currentCommandSyntax.isEmpty())
+                        commandSyntaxes << currentCommandSyntax.append(QLatin1String("</table>"));
+
+                    QByteArray argLine = lineTrimmed.mid(currentCommand.length());
+                    extractKeywords(argLine, &m_variables);
+                    currentCommandSyntax = formatFunctionDetails(currentCommand, QString::fromUtf8(argLine));
+                } else {
+                    if (!currentCommandSyntax.isEmpty()) {
+                        if (lineTrimmed.isEmpty()) {
+                            commandSyntaxes << currentCommandSyntax.append(QLatin1String("</table>"));
+                            currentCommandSyntax.clear();
+                        } else {
+                            extractKeywords(lineTrimmed, &m_variables);
+                            currentCommandSyntax += QString::fromLatin1("<tr><td>&nbsp;</td><td>%1</td></tr>")
+                                    .arg(Qt::escape(QString::fromLocal8Bit(lineTrimmed)));
+                        }
+                    }
+                }
+            }
+            m_functionArgs[currentCommand] = commandSyntaxes;
+        }
+    }
+    m_functions = m_functionArgs.keys();
+}
+
+void CMakeTool::parseVariableOutput(const QByteArray &output)
+{
+    QList<QByteArray> variableList = output.split('\n');
+    if (!variableList.isEmpty()) {
+        variableList.removeFirst(); //remove version string
+        foreach (const QByteArray &variable, variableList) {
+            if (variable.contains("_<CONFIG>")) {
+                m_variables << QString::fromLocal8Bit(variable).replace(QLatin1String("_<CONFIG>"), QLatin1String("_DEBUG"));
+                m_variables << QString::fromLocal8Bit(variable).replace(QLatin1String("_<CONFIG>"), QLatin1String("_RELEASE"));
+                m_variables << QString::fromLocal8Bit(variable).replace(QLatin1String("_<CONFIG>"), QLatin1String("_MINSIZEREL"));
+                m_variables << QString::fromLocal8Bit(variable).replace(QLatin1String("_<CONFIG>"), QLatin1String("_RELWITHDEBINFO"));
+            } else if (variable.contains("_<LANG>")) {
+                m_variables << QString::fromLocal8Bit(variable).replace(QLatin1String("_<LANG>"), QLatin1String("_C"));
+                m_variables << QString::fromLocal8Bit(variable).replace(QLatin1String("_<LANG>"), QLatin1String("_CXX"));
+            } else if (!variable.contains("_<") && !variable.contains('[')) {
+                m_variables << QString::fromLocal8Bit(variable);
+            }
+        }
+    }
+}
+
+void CMakeTool::parseDone()
+{
+    m_variables.sort();
+    m_variables.removeDuplicates();
+}

=== added file 'src/cmakeprojectmanager/cmaketool.h'
--- src/cmakeprojectmanager/cmaketool.h	1970-01-01 00:00:00 +0000
+++ src/cmakeprojectmanager/cmaketool.h	2014-02-28 08:31:43 +0000
@@ -0,0 +1,120 @@
+#ifndef CMAKETOOL_H
+#define CMAKETOOL_H
+
+#include "cmakeprojectmanager_global.h"
+
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QQueue>
+#include <QPointer>
+#include <QFutureInterface>
+#include <texteditor/codeassist/keywordscompletionassist.h>
+
+#include <projectexplorer/project.h>
+#include <utils/environment.h>
+
+namespace Utils {
+    QT_FORWARD_DECLARE_CLASS(QtcProcess)
+}
+
+class QProcess;
+
+namespace CMakeProjectManager {
+
+class CMAKEPROJECTMANAGER_EXPORT ICMakeTool: public QObject
+{
+    Q_OBJECT
+public:
+    ICMakeTool(QObject * parent);
+    virtual ~ICMakeTool();
+    virtual void cancel() = 0;
+    virtual QString displayName () = 0;
+    virtual bool isValid() const = 0;
+    virtual bool hasCodeBlocksMsvcGenerator() const = 0;
+    virtual bool hasCodeBlocksNinjaGenerator() const = 0;
+    virtual TextEditor::Keywords keywords() = 0;
+    virtual void runCMake (ProjectExplorer::Target* target) = 0;
+    virtual void addToEnvironment(Utils::Environment &env) const;
+
+    Core::Id id() const { return m_id; }
+
+signals:
+    void cmakeFinished (ProjectExplorer::Target* target);
+
+protected:
+    void setId(Core::Id id) { m_id = id; }
+
+private:
+    Core::Id m_id;
+};
+
+class CMAKEPROJECTMANAGER_EXPORT ICMakeToolFactory : public QObject
+{
+    Q_OBJECT
+public:
+    virtual bool canCreate (const Core::Id& id) const = 0;
+    virtual ICMakeTool* create (const Core::Id& id) = 0;
+};
+
+
+class CMAKEPROJECTMANAGER_EXPORT CMakeTool : public ICMakeTool
+{
+    Q_OBJECT
+public:
+    explicit CMakeTool(QObject *parent = 0);
+    virtual ~CMakeTool();
+
+    enum State { Invalid, RunningBasic, RunningFunctionList, RunningFunctionDetails,
+                 RunningPropertyList, RunningVariableList, RunningDone, RunningProject };
+
+    bool isValid() const;
+
+    void setCMakeExecutable(const QString &executable);
+    QString cmakeExecutable() const;
+    bool hasCodeBlocksMsvcGenerator() const;
+    bool hasCodeBlocksNinjaGenerator() const;
+    TextEditor::Keywords keywords();
+
+    virtual void runCMake (ProjectExplorer::Target *target );
+    virtual QString displayName ();
+
+public slots:
+    void cancel();
+
+protected:
+    void startNextRun ();
+
+private slots:
+    void finished(int exitCode);
+    void onProcessReadyRead();
+
+private:
+    void flushOutput();
+    void finishStep();
+    void createProcessIfNotExists();
+    bool startProcess(const QStringList &args, Utils::Environment env = Utils::Environment::systemEnvironment());
+    void parseFunctionOutput(const QByteArray &output);
+    void parseFunctionDetailsOutput(const QByteArray &output);
+    void parseVariableOutput(const QByteArray &output);
+    void parseDone();
+    QString formatFunctionDetails(const QString &command, const QString &args);
+
+    State m_state;
+    Utils::QtcProcess *m_process;
+    bool m_hasCodeBlocksMsvcGenerator;
+    bool m_hasCodeBlocksNinjaGenerator;
+    QString m_executable;
+
+    QMap<QString, QStringList> m_functionArgs;
+    QStringList m_variables;
+    QStringList m_functions;
+
+    QQueue< QPointer<ProjectExplorer::Target> > m_pendingRuns;
+    QPointer<ProjectExplorer::Target> m_currentRun;
+    QFutureInterface<void> *m_futureInterface;
+};
+
+}
+
+#endif // CMAKETOOL_H

=== added file 'src/cmakeprojectmanager/cmaketoolmanager.cpp'
--- src/cmakeprojectmanager/cmaketoolmanager.cpp	1970-01-01 00:00:00 +0000
+++ src/cmakeprojectmanager/cmaketoolmanager.cpp	2014-02-28 08:31:43 +0000
@@ -0,0 +1,97 @@
+#include "cmaketoolmanager.h"
+#include "cmakeprojectconstants.h"
+#include "cmakekitinformation.h"
+
+#include <coreplugin/icore.h>
+#include <extensionsystem/pluginmanager.h>
+#include <projectexplorer/kit.h>
+#include <utils/environment.h>
+
+namespace CMakeProjectManager {
+
+CMakeToolManager* CMakeToolManager::m_instance = 0;
+CMakeToolManager::CMakeToolManager()
+{
+    m_instance = this;
+    m_cmakeToolForSystem.setCMakeExecutable(findCmakeExecutable());
+
+    QSettings *settings = Core::ICore::settings();
+    settings->beginGroup(QLatin1String("CMakeSettings"));
+    m_cmakeToolForUser.setCMakeExecutable(settings->value(QLatin1String("cmakeExecutable")).toString());
+    settings->endGroup();
+
+}
+
+CMakeToolManager::~CMakeToolManager()
+{
+    m_instance = 0;
+    m_cmakeToolForSystem.cancel();
+    m_cmakeToolForUser.cancel();
+
+    //clean up created cmake tools
+    qDeleteAll(m_cmakeTools.begin(),m_cmakeTools.end());
+}
+
+void CMakeToolManager::setUserCmakePath(const QString &path)
+{
+    m_instance->m_cmakeToolForUser.setCMakeExecutable(path);
+}
+
+QString CMakeToolManager::userCMakePath()
+{
+    return m_instance->m_cmakeToolForUser.cmakeExecutable();
+}
+
+/*!
+ * \brief CMakeToolManager::defaultCMakeTool
+ * Returns a pointer to the internal default cmake tool instance
+ */
+CMakeTool *CMakeToolManager::defaultCMakeTool()
+{
+    if(m_instance->m_cmakeToolForUser.isValid())
+        return &m_instance->m_cmakeToolForUser;
+    return &m_instance->m_cmakeToolForSystem;
+}
+
+bool CMakeToolManager::registerCMakeTool(ICMakeTool *tool)
+{
+    if(m_instance->m_cmakeTools.contains(tool->id().uniqueIdentifier()))
+        return false;
+    m_instance->m_cmakeTools.insert(tool->id().uniqueIdentifier(),tool);
+    return true;
+}
+
+ICMakeTool *CMakeToolManager::cmakeTool(const Core::Id &id)
+{
+    if(id == Constants::CMAKE_TOOL_ID)
+        return defaultCMakeTool();
+
+    if(m_instance->m_cmakeTools.contains(id.uniqueIdentifier()))
+        return m_instance->m_cmakeTools[id.uniqueIdentifier()];
+
+    qDebug()<<"Don't know "<<id.toString()<<" Creating and registering it";
+
+    //try to find a factory that can create the cmake tool
+    QList<ICMakeToolFactory*> factories = ExtensionSystem::PluginManager::getObjects<ICMakeToolFactory>();
+    foreach(ICMakeToolFactory* factory, factories) {
+        if(factory->canCreate(id)) {
+            ICMakeTool* cmake = factory->create(id);
+            m_instance->m_cmakeTools.insert(id.uniqueIdentifier(),cmake);
+
+            return cmake;
+        }
+    }
+    return 0;
+}
+
+ICMakeTool *CMakeToolManager::cmakeToolForKit(const ProjectExplorer::Kit *kit)
+{
+    return CMakeKitInformation::cmakeTool(kit);
+}
+
+QString CMakeToolManager::findCmakeExecutable()
+{
+    return Utils::Environment::systemEnvironment().searchInPath(QLatin1String("cmake"));
+}
+
+} // namespace CMakeProjectManager

=== added file 'src/cmakeprojectmanager/cmaketoolmanager.h'
--- src/cmakeprojectmanager/cmaketoolmanager.h	1970-01-01 00:00:00 +0000
+++ src/cmakeprojectmanager/cmaketoolmanager.h	2014-02-28 08:31:43 +0000
@@ -0,0 +1,35 @@
+#ifndef CMAKEPROJECTMANAGER_CMAKETOOLMANAGER_H
+#define CMAKEPROJECTMANAGER_CMAKETOOLMANAGER_H
+
+#include "cmakeprojectmanager_global.h"
+#include "cmaketool.h"
+
+#include <coreplugin/id.h>
+
+namespace CMakeProjectManager {
+
+class CMAKEPROJECTMANAGER_EXPORT CMakeToolManager : public QObject
+{
+    Q_OBJECT
+public:
+    CMakeToolManager ();
+    ~CMakeToolManager ();
+
+    static void setUserCmakePath (const QString &path);
+    static QString userCMakePath();
+
+    static CMakeTool *defaultCMakeTool ();
+    static bool registerCMakeTool (ICMakeTool* tool);
+    static ICMakeTool *cmakeTool (const Core::Id& id);
+    static ICMakeTool *cmakeToolForKit (const ProjectExplorer::Kit *kit);
+    static QString findCmakeExecutable();
+private:
+    static CMakeToolManager *m_instance;
+    CMakeTool m_cmakeToolForUser;
+    CMakeTool m_cmakeToolForSystem;
+    QMap<uint,ICMakeTool*> m_cmakeTools;
+};
+
+} // namespace CMakeProjectManager
+
+#endif // CMAKEPROJECTMANAGER_CMAKETOOLMANAGER_H

=== added file 'src/cmakeprojectmanager/generatorinfo.cpp'
--- src/cmakeprojectmanager/generatorinfo.cpp	1970-01-01 00:00:00 +0000
+++ src/cmakeprojectmanager/generatorinfo.cpp	2014-02-28 08:31:43 +0000
@@ -0,0 +1,127 @@
+#include "generatorinfo.h"
+
+#include <projectexplorer/projectexplorerconstants.h>
+#include <projectexplorer/kitinformation.h>
+#include <projectexplorer/kitmanager.h>
+#include <projectexplorer/toolchain.h>
+#include <projectexplorer/abi.h>
+#include <remotelinux/remotelinux_constants.h>
+
+namespace CMakeProjectManager {
+namespace Internal {
+
+
+GeneratorInfo::GeneratorInfo()
+    : m_kit(0), m_isNinja(false)
+{}
+
+GeneratorInfo::GeneratorInfo(ProjectExplorer::Kit *kit, bool ninja)
+    : m_kit(kit), m_isNinja(ninja)
+{}
+
+ProjectExplorer::Kit *GeneratorInfo::kit() const
+{
+    return m_kit;
+}
+
+bool GeneratorInfo::isNinja() const {
+    return m_isNinja;
+}
+
+QByteArray GeneratorInfo::generator() const
+{
+    if (!m_kit)
+        return QByteArray();
+    ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(m_kit);
+    ProjectExplorer::Abi targetAbi = tc->targetAbi();
+    if (m_isNinja) {
+        return "Ninja";
+    } else if (targetAbi.os() == ProjectExplorer::Abi::WindowsOS) {
+        if (targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2005Flavor
+                || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2008Flavor
+                || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2010Flavor
+                || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2012Flavor) {
+            return "NMake Makefiles";
+        } else if (targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMSysFlavor) {
+            if (Utils::HostOsInfo::isWindowsHost())
+                return "MinGW Makefiles";
+            else
+                return "Unix Makefiles";
+        }
+    }
+    return "Unix Makefiles";
+}
+
+QByteArray GeneratorInfo::generatorArgument() const
+{
+    QByteArray tmp = generator();
+    if (tmp.isEmpty())
+        return tmp;
+    return QByteArray("-GCodeBlocks - ") + tmp;
+}
+
+QString GeneratorInfo::displayName() const
+{
+    if (!m_kit)
+        return QString();
+    if (m_isNinja)
+        return tr("Ninja (%1)").arg(m_kit->displayName());
+    ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(m_kit);
+    ProjectExplorer::Abi targetAbi = tc->targetAbi();
+    if (targetAbi.os() == ProjectExplorer::Abi::WindowsOS) {
+        if (targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2005Flavor
+                || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2008Flavor
+                || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2010Flavor
+                || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2012Flavor) {
+            return tr("NMake Generator (%1)").arg(m_kit->displayName());
+        } else if (targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMSysFlavor) {
+            if (Utils::HostOsInfo::isWindowsHost())
+                return tr("MinGW Generator (%1)").arg(m_kit->displayName());
+            else
+                return tr("Unix Generator (%1)").arg(m_kit->displayName());
+        }
+    } else {
+        // Non windows
+        return tr("Unix Generator (%1)").arg(m_kit->displayName());
+    }
+    return QString();
+}
+
+QList<GeneratorInfo> GeneratorInfo::generatorInfosFor(ProjectExplorer::Kit *k, Ninja n, bool preferNinja, bool hasCodeBlocks)
+{
+    QList<GeneratorInfo> results;
+    ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(k);
+    if (!tc)
+        return results;
+    Core::Id deviceType = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(k);
+    if (deviceType !=  ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE
+            && deviceType != RemoteLinux::Constants::GenericLinuxOsType)
+        return results;
+    ProjectExplorer::Abi targetAbi = tc->targetAbi();
+    if (n != ForceNinja) {
+        if (targetAbi.os() == ProjectExplorer::Abi::WindowsOS) {
+            if (targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2005Flavor
+                    || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2008Flavor
+                    || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2010Flavor
+                    || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2012Flavor) {
+                if (hasCodeBlocks)
+                    results << GeneratorInfo(k);
+            } else if (targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMSysFlavor) {
+                results << GeneratorInfo(k);
+            }
+        } else {
+            // Non windows
+            results << GeneratorInfo(k);
+        }
+    }
+    if (n != NoNinja) {
+        if (preferNinja)
+            results.prepend(GeneratorInfo(k, true));
+        else
+            results.append(GeneratorInfo(k, true));
+    }
+    return results;
+}
+
+} // namespace Internal
+} // namespace CMake

=== added file 'src/cmakeprojectmanager/generatorinfo.h'
--- src/cmakeprojectmanager/generatorinfo.h	1970-01-01 00:00:00 +0000
+++ src/cmakeprojectmanager/generatorinfo.h	2014-02-28 08:31:43 +0000
@@ -0,0 +1,40 @@
+#ifndef CMAKE_INTERNAL_GENERATORINFO_H
+#define CMAKE_INTERNAL_GENERATORINFO_H
+
+#include <QCoreApplication>
+#include <QMetaType>
+
+#include <projectexplorer/kit.h>
+#include "cmakeprojectmanager.h"
+
+namespace CMakeProjectManager {
+namespace Internal {
+
+class GeneratorInfo
+{
+    Q_DECLARE_TR_FUNCTIONS(CMakeProjectManager::Internal::GeneratorInfo)
+public:
+    enum Ninja { NoNinja, OfferNinja, ForceNinja };
+    static QList<GeneratorInfo> generatorInfosFor(ProjectExplorer::Kit *k, Ninja n, bool preferNinja, bool hasCodeBlocks);
+
+    GeneratorInfo();
+    explicit GeneratorInfo(ProjectExplorer::Kit *kit, bool ninja = false);
+
+    ProjectExplorer::Kit *kit() const;
+    bool isNinja() const;
+
+    QString displayName() const;
+    QByteArray generatorArgument() const;
+    QByteArray generator() const;
+
+private:
+    ProjectExplorer::Kit *m_kit;
+    bool m_isNinja;
+};
+
+} // namespace Internal
+} // namespace CMake
+
+Q_DECLARE_METATYPE(CMakeProjectManager::Internal::GeneratorInfo);
+
+#endif // CMAKE_INTERNAL_GENERATORINFO_H

=== modified file 'src/cmakeprojectmanager/makestep.h'
--- src/cmakeprojectmanager/makestep.h	2014-02-18 14:30:29 +0000
+++ src/cmakeprojectmanager/makestep.h	2014-02-28 08:31:43 +0000
@@ -43,9 +43,9 @@
 }
 
 namespace CMakeProjectManager {
+class CMakeBuildConfiguration;
+
 namespace Internal {
-
-class CMakeBuildConfiguration;
 class MakeStepFactory;
 
 class MakeStep : public ProjectExplorer::AbstractProcessStep
@@ -75,7 +75,7 @@
     QString additionalArguments() const;
     void setAdditionalArguments(const QString &list);
 
-    QString makeCommand(ProjectExplorer::ToolChain *tc, const Utils::Environment &env) const;
+    virtual QString makeCommand(ProjectExplorer::ToolChain *tc, const Utils::Environment &env) const;
 
     void setClean(bool clean);