Merge lp:~zeller-benjamin/qtcreator-plugin-ubuntu/qtc41-beta into lp:qtcreator-plugin-ubuntu

[Benjamin Zeller]

- Make QtC-P-U actually compile against Qt 4.1 beta

- Make QtC-P-U actually compile against Qt 4.1 beta

[lp:~zeller-benjamin/qtcreator-plugin-ubuntu/qtc41-beta]

467. By Benjamin Zeller on 2016-08-18

- More fixes
- Upgrading to latest QtC checkout

468. By Benjamin Zeller on 2016-08-18

Merge trunk

469. By Benjamin Zeller on 2016-08-24

Fix the profiler

=== modified file 'UbuntuPlugin.pro'
--- UbuntuPlugin.pro	2016-05-17 16:33:36 +0000
+++ UbuntuPlugin.pro	2016-08-24 15:35:12 +0000
@@ -52,9 +52,9 @@
     src/ubuntu/ubuntuproject.cpp \
     src/ubuntu/ubuntuprojectfile.cpp \
     src/ubuntu/ubuntuprojectnode.cpp \
-    src/ubuntu/ubuntuversion.cpp \
-    src/ubuntu/ubuntufeatureprovider.cpp \
-    src/ubuntu/ubuntuversionmanager.cpp \
+    #src/ubuntu/ubuntuversion.cpp \
+    #src/ubuntu/ubuntufeatureprovider.cpp \
+    #src/ubuntu/ubuntuversionmanager.cpp \
     src/ubuntu/ubuntupackagingmode.cpp \
     src/ubuntu/ubuntubzr.cpp \
     src/ubuntu/ubuntuclickmanifest.cpp \
@@ -121,9 +121,9 @@
     src/ubuntu/ubuntuproject.h \
     src/ubuntu/ubuntuprojectfile.h \
     src/ubuntu/ubuntuprojectnode.h \
-    src/ubuntu/ubuntuversion.h \
-    src/ubuntu/ubuntufeatureprovider.h \
-    src/ubuntu/ubuntuversionmanager.h \
+    #src/ubuntu/ubuntuversion.h \
+    #src/ubuntu/ubuntufeatureprovider.h \
+    #src/ubuntu/ubuntuversionmanager.h \
     src/ubuntu/ubuntupackagingmode.h \
     src/ubuntu/ubuntubzr.h \
     src/ubuntu/ubuntuclickmanifest.h \
 
=== modified file 'src/ubuntu/clicktoolchain.cpp'
--- src/ubuntu/clicktoolchain.cpp	2016-03-18 13:13:22 +0000
+++ src/ubuntu/clicktoolchain.cpp	2016-08-24 15:35:12 +0000
@@ -20,6 +20,7 @@
 #include "ubuntuconstants.h"
 
 #include <utils/fileutils.h>
+#include <utils/algorithm.h>
 #include <projectexplorer/abi.h>
 #include <QDebug>
 #include <QVariant>
@@ -79,11 +80,6 @@
     return Utils::FileName::fromString(QLatin1String("/usr/bin/gdb-multiarch"));
 }
 
-QString ClickToolChain::type() const
-{
-    return QString::fromLatin1(Constants::UBUNTU_CLICK_TOOLCHAIN_ID);
-}
-
 QString ClickToolChain::typeDisplayName() const
 {
     return ClickToolChainFactory::tr("Ubuntu GCC");
@@ -139,6 +135,11 @@
     return clickArchitectures.keys();
 }
 
+QString ClickToolChain::remoteCompilerCommand() const
+{
+    return QString::fromLatin1("/usr/bin/%1").arg(compilerCommand().fileName());
+}
+
 QVariantMap ClickToolChain::toMap() const
 {
     QVariantMap map = GccToolChain::toMap();
@@ -196,7 +197,7 @@
 }
 
 ClickToolChain::ClickToolChain(const UbuntuClickTool::Target &target, Detection d)
-    : GccToolChain(QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID), d)
+    : GccToolChain(Constants::UBUNTU_CLICK_TOOLCHAIN_ID, d)
     , m_clickTarget(target)
 {
     resetToolChain(Utils::FileName::fromString(
@@ -216,24 +217,24 @@
 }
 
 ClickToolChain::ClickToolChain()
-    : GccToolChain(QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID),ManualDetection)
+    : GccToolChain(Constants::UBUNTU_CLICK_TOOLCHAIN_ID,ManualDetection)
 {
 }
 
 ClickToolChainFactory::ClickToolChainFactory()
 {
-    setId(Constants::UBUNTU_CLICK_TOOLCHAIN_ID);
     setDisplayName(tr("Ubuntu GCC"));
 }
 
-QList<ProjectExplorer::ToolChain *> ClickToolChainFactory::autoDetect()
+QList<ProjectExplorer::ToolChain *> ClickToolChainFactory::autoDetect(
+        const QList<ProjectExplorer::ToolChain *> &alreadyKnown)
 {
-    return createToolChainsForClickTargets();
+    return createToolChainsForClickTargets(alreadyKnown);
 }
 
 bool ClickToolChainFactory::canRestore(const QVariantMap &data)
 {
-    return idFromMap(data).startsWith(QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID) + QLatin1Char(':'));
+    return typeIdFromMap(data) == Constants::UBUNTU_CLICK_TOOLCHAIN_ID;
 }
 
 ProjectExplorer::ToolChain *ClickToolChainFactory::restore(const QVariantMap &data)
@@ -259,7 +260,7 @@
     return 0;
 }
 
-QList<ProjectExplorer::ToolChain *> ClickToolChainFactory::createToolChainsForClickTargets()
+QList<ProjectExplorer::ToolChain *> ClickToolChainFactory::createToolChainsForClickTargets(const QList<ProjectExplorer::ToolChain *> &alreadyKnown)
 {
     QList<ProjectExplorer::ToolChain*> toolChains;
 
@@ -270,10 +271,20 @@
         if(!clickArchitectures.contains(target.architecture))
             continue;
 
-        if(UbuntuClickTool::findOrCreateGccWrapper(target).isEmpty())
+        QString comp = UbuntuClickTool::findOrCreateGccWrapper(target);
+        if(comp.isEmpty())
             continue;
 
-        ClickToolChain* tc = new ClickToolChain(target, ProjectExplorer::ToolChain::AutoDetection);
+        auto predicate = [&](ProjectExplorer::ToolChain *tc) {
+            if (tc->typeId() != Constants::UBUNTU_CLICK_TOOLCHAIN_ID)
+                return false;
+            auto clickTc = static_cast<ClickToolChain *>(tc);
+            return clickTc->clickTarget().containerName == target.containerName;
+        };
+
+        ProjectExplorer::ToolChain *tc = Utils::findOrDefault(alreadyKnown, predicate);
+        if (!tc)
+            tc = new ClickToolChain(target, ProjectExplorer::ToolChain::AutoDetection);
         toolChains.append(tc);
     }
 
 
=== modified file 'src/ubuntu/clicktoolchain.h'
--- src/ubuntu/clicktoolchain.h	2015-06-30 13:34:14 +0000
+++ src/ubuntu/clicktoolchain.h	2016-08-24 15:35:12 +0000
@@ -37,7 +37,6 @@
 
     virtual QList<Utils::FileName> suggestedMkspecList() const override;
     virtual Utils::FileName suggestedDebugger() const override;
-    virtual QString type() const override;
     virtual QString typeDisplayName() const override;
     virtual bool isValid() const override;
     virtual void addToEnvironment(Utils::Environment &env) const override;
@@ -53,6 +52,8 @@
     static ProjectExplorer::Abi architectureNameToAbi ( const QString &arch );
     static QList<QString> supportedArchitectures ();
 
+    QString remoteCompilerCommand () const;
+
 protected:
     virtual bool fromMap(const QVariantMap &data) override;
 
@@ -75,11 +76,11 @@
 
     // ToolChainFactory interface
 public:
-    virtual QList<ProjectExplorer::ToolChain *> autoDetect() override;
+    virtual QList<ProjectExplorer::ToolChain *> autoDetect(const QList<ProjectExplorer::ToolChain *> &alreadyKnown) override;
     virtual bool canRestore(const QVariantMap &data) override;
     virtual ProjectExplorer::ToolChain *restore(const QVariantMap &data) override;
 
-    static QList<ProjectExplorer::ToolChain *> createToolChainsForClickTargets();
+    static QList<ProjectExplorer::ToolChain *> createToolChainsForClickTargets(const QList<ProjectExplorer::ToolChain *> &alreadyKnown);
 };
 
 } // namespace Internal
 
=== modified file 'src/ubuntu/device/container/containerdeviceprocess.cpp'
--- src/ubuntu/device/container/containerdeviceprocess.cpp	2016-05-23 07:26:49 +0000
+++ src/ubuntu/device/container/containerdeviceprocess.cpp	2016-08-24 15:35:12 +0000
@@ -3,6 +3,7 @@
 
 #include <utils/qtcassert.h>
 #include <utils/qtcprocess.h>
+#include <projectexplorer/runnables.h>
 
 #include <QProcess>
 #include <QDebug>
@@ -30,13 +31,11 @@
     };
 
     connect(cleaner, &SshDeviceProcess::finished, callback);
-    cleaner->start(QStringLiteral("rm"), QStringList{m_pidFile});
-}
 
-void ContainerDeviceProcess::setWorkingDirectory(const QString &directory)
-{
-    m_workingDir = directory;
-    LinuxDeviceProcess::setWorkingDirectory(directory);
+    ProjectExplorer::StandardRunnable r;
+    r.executable = QStringLiteral("rm");
+    r.commandLineArguments = m_pidFile;
+    cleaner->start(r);
 }
 
 void ContainerDeviceProcess::doSignal(const int sig)
@@ -50,11 +49,14 @@
         }
         signaler->deleteLater();
     });
-    QString cmd = QString::fromLatin1("kill -%2 `cat %1`").arg(m_pidFile).arg(sig);
-    signaler->start(cmd, QStringList());
+
+    ProjectExplorer::StandardRunnable r;
+    r.executable = QStringLiteral("kill");
+    r.commandLineArguments = QString::fromLatin1("-%2 `cat %1`").arg(m_pidFile).arg(sig);
+    signaler->start(r);
 }
 
-QString ContainerDeviceProcess::fullCommandLine() const
+QString ContainerDeviceProcess::fullCommandLine(const ProjectExplorer::StandardRunnable &runnable) const
 {
     QString fullCommandLine;
     QStringList rcFiles {
@@ -63,12 +65,12 @@
     };
     foreach (const QString &filePath, rcFiles)
         fullCommandLine += QString::fromLatin1("test -f %1 && . %1;").arg(filePath);
-    if (!m_workingDir.isEmpty()) {
-        fullCommandLine.append(QLatin1String("cd ")).append(Utils::QtcProcess::quoteArgUnix(m_workingDir))
+    if (runnable.workingDirectory.isEmpty()) {
+        fullCommandLine.append(QLatin1String("cd ")).append(Utils::QtcProcess::quoteArgUnix(runnable.workingDirectory))
                 .append(QLatin1String(" && "));
     }
     QString envString;
-    for (auto it = environment().constBegin(); it != environment().constEnd(); ++it) {
+    for (auto it = runnable.environment.constBegin(); it != runnable.environment.constEnd(); ++it) {
         if (!envString.isEmpty())
             envString += QLatin1Char(' ');
         envString.append(it.key()).append(QLatin1String("='")).append(it.value())
@@ -82,10 +84,10 @@
 
     fullCommandLine.append(Utils::QtcProcess::quoteArgUnix(QStringLiteral("dbus-run-session")));
     fullCommandLine += QString::fromLatin1(" bash -c \"echo \\$\\$ > %1; exec ").arg(m_pidFile);
-    fullCommandLine.append(Utils::QtcProcess::quoteArgUnix(executable()));
-    if (!arguments().isEmpty()) {
+    fullCommandLine.append(Utils::QtcProcess::quoteArgUnix(runnable.executable));
+    if (!runnable.commandLineArguments.isEmpty()) {
         fullCommandLine.append(QLatin1Char(' '));
-        fullCommandLine.append(Utils::QtcProcess::joinArgs(arguments(), Utils::OsTypeLinux));
+        fullCommandLine.append(runnable.commandLineArguments);
     }
     fullCommandLine.append(QStringLiteral("\""));
     return fullCommandLine;
 
=== modified file 'src/ubuntu/device/container/containerdeviceprocess.h'
--- src/ubuntu/device/container/containerdeviceprocess.h	2016-04-08 09:01:23 +0000
+++ src/ubuntu/device/container/containerdeviceprocess.h	2016-08-24 15:35:12 +0000
@@ -17,7 +17,6 @@
 public:
     ContainerDeviceProcess(const QSharedPointer<const ProjectExplorer::IDevice> &device, QObject *parent = 0);
     ~ContainerDeviceProcess();
-    virtual void setWorkingDirectory(const QString &directory) override;
 
     // DeviceProcess interface
     virtual void interrupt() override { doSignal(2); }
@@ -27,8 +26,7 @@
     void doSignal (const int sig);
 private:
     // SshDeviceProcess interface
-    virtual QString fullCommandLine() const override;
-    QString m_workingDir;
+    virtual QString fullCommandLine(const ProjectExplorer::StandardRunnable &) const override;
     QString m_pidFile;
 
 };
 
=== modified file 'src/ubuntu/device/container/ubuntulocaldeployconfiguration.cpp'
--- src/ubuntu/device/container/ubuntulocaldeployconfiguration.cpp	2016-04-06 09:35:59 +0000
+++ src/ubuntu/device/container/ubuntulocaldeployconfiguration.cpp	2016-08-24 15:35:12 +0000
@@ -134,7 +134,7 @@
 
 void UbuntuLocalDeployConfiguration::selectAsDefaultHack()
 {
-    target()->setActiveDeployConfiguration(this);
+    //target()->setActiveDeployConfiguration(this);
 }
 
 } // namespace Internal
 
=== modified file 'src/ubuntu/device/container/ubuntulocalrunconfiguration.cpp'
--- src/ubuntu/device/container/ubuntulocalrunconfiguration.cpp	2016-07-22 10:17:50 +0000
+++ src/ubuntu/device/container/ubuntulocalrunconfiguration.cpp	2016-08-24 15:35:12 +0000
@@ -30,6 +30,7 @@
 #include <qtsupport/qtkitinformation.h>
 #include <projectexplorer/target.h>
 #include <projectexplorer/buildconfiguration.h>
+#include <projectexplorer/runnables.h>
 #include <utils/environment.h>
 #include <utils/qtcprocess.h>
 #include <cmakeprojectmanager/cmakeproject.h>
@@ -60,14 +61,14 @@
 }
 
 UbuntuLocalRunConfiguration::UbuntuLocalRunConfiguration(ProjectExplorer::Target *parent, Core::Id id)
-    : RemoteLinux::AbstractRemoteLinuxRunConfiguration(parent, id)
+    : ProjectExplorer::RunConfiguration(parent, id)
 {
     setDisplayName(appId());
     addExtraAspect(new UbuntuLocalEnvironmentAspect(this));
 }
 
 UbuntuLocalRunConfiguration::UbuntuLocalRunConfiguration(ProjectExplorer::Target *parent, UbuntuLocalRunConfiguration *source)
-    : RemoteLinux::AbstractRemoteLinuxRunConfiguration(parent,source)
+    : ProjectExplorer::RunConfiguration(parent,source)
 {
 }
 
@@ -126,6 +127,23 @@
     return Configured;
 }
 
+ProjectExplorer::Runnable UbuntuLocalRunConfiguration::runnable() const
+{
+    if (m_executable.isEmpty())
+        return ProjectExplorer::Runnable();
+
+    ProjectExplorer::StandardRunnable r;
+    r.executable = remoteExecutableFilePath();
+    r.device = ProjectExplorer::DeviceKitInformation::device(target()->kit());
+    r.commandLineArguments = Utils::QtcProcess::joinArgs(arguments(), Utils::OsTypeLinux);
+
+    // Normalize to work around QTBUG-17529 (QtDeclarative fails with 'File name case mismatch'...)
+    r.workingDirectory = Utils::FileUtils::normalizePathName(m_workingDir.toString());
+    r.environment = environment();
+
+    return r;
+}
+
 bool UbuntuLocalRunConfiguration::aboutToStart(QString *errorMessage)
 {
     if(target()->project()->id() != Constants::UBUNTUPROJECT_ID) {
@@ -628,7 +646,7 @@
     ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit());
     ClickToolChain *uTc = nullptr;
 
-    if (tc && tc->type() == QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID))
+    if (tc && tc->typeId() == Constants::UBUNTU_CLICK_TOOLCHAIN_ID)
         uTc = static_cast<ClickToolChain *>(tc);
 
     if (uTc) {
 
=== modified file 'src/ubuntu/device/container/ubuntulocalrunconfiguration.h'
--- src/ubuntu/device/container/ubuntulocalrunconfiguration.h	2016-07-22 10:17:50 +0000
+++ src/ubuntu/device/container/ubuntulocalrunconfiguration.h	2016-08-24 15:35:12 +0000
@@ -20,7 +20,7 @@
 #define UBUNTURUNCONFIGURATION_H
 
 #include <QObject>
-#include <remotelinux/abstractremotelinuxrunconfiguration.h>
+#include <projectexplorer/runconfiguration.h>
 #include <projectexplorer/deployconfiguration.h>
 #include <projectexplorer/applicationlauncher.h>
 #include <remotelinux/remotelinuxenvironmentaspect.h>
@@ -46,7 +46,7 @@
 
 };
 
-class UbuntuLocalRunConfiguration : public RemoteLinux::AbstractRemoteLinuxRunConfiguration
+class UbuntuLocalRunConfiguration : public ProjectExplorer::RunConfiguration
 {
     Q_OBJECT
 public:
@@ -60,16 +60,16 @@
     QString appId() const;
     void addToBaseEnvironment(Utils::Environment &env) const;
 
-    // AbstractRemoteLinuxRunConfiguration interface
-    virtual QString localExecutableFilePath() const override;
-    virtual QString remoteExecutableFilePath() const override;
-    virtual QStringList arguments() const override;
-    virtual Utils::Environment environment() const override;
-    virtual QString workingDirectory() const override;
+    QString localExecutableFilePath() const;
+    QString remoteExecutableFilePath() const;
+    QStringList arguments() const;
+    Utils::Environment environment() const;
+    QString workingDirectory() const;
 
     // RunConfiguration interface
     virtual bool isConfigured () const override;
     virtual ConfigurationState ensureConfigured(QString *) override;
+    virtual ProjectExplorer::Runnable runnable() const override;
 
     //static helpers
     static QString getDesktopFile (RunConfiguration *config, QString appId, QString *errorMessage = 0);
 
=== modified file 'src/ubuntu/device/container/ubuntulocalrunconfigurationfactory.cpp'
--- src/ubuntu/device/container/ubuntulocalrunconfigurationfactory.cpp	2016-04-06 10:52:54 +0000
+++ src/ubuntu/device/container/ubuntulocalrunconfigurationfactory.cpp	2016-08-24 15:35:12 +0000
@@ -67,7 +67,7 @@
     if (isRemote) {
         //IF we have a remote device we just support a ubuntu toolchain
         ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(parent->kit());
-        if(tc && tc->type() != QLatin1String(Ubuntu::Constants::UBUNTU_CLICK_TOOLCHAIN_ID))
+        if(tc && tc->typeId() != Ubuntu::Constants::UBUNTU_CLICK_TOOLCHAIN_ID)
             return types;
     }
 
 
=== modified file 'src/ubuntu/device/container/ubuntulocalruncontrolfactory.cpp'
--- src/ubuntu/device/container/ubuntulocalruncontrolfactory.cpp	2016-05-23 07:26:49 +0000
+++ src/ubuntu/device/container/ubuntulocalruncontrolfactory.cpp	2016-08-24 15:35:12 +0000
@@ -6,14 +6,16 @@
 
 #include "containerdevice.h"
 
-#include <analyzerbase/analyzerstartparameters.h>
-#include <analyzerbase/analyzerruncontrol.h>
-#include <analyzerbase/analyzermanager.h>
+#include <debugger/analyzer/analyzermanager.h>
+#include <debugger/analyzer/analyzerruncontrol.h>
+#include <debugger/analyzer/analyzerstartparameters.h>
 #include <projectexplorer/kitinformation.h>
 #include <projectexplorer/target.h>
 #include <projectexplorer/abi.h>
 #include <debugger/debuggerruncontrol.h>
 #include <debugger/debuggerstartparameters.h>
+#include <debugger/debuggerrunconfigurationaspect.h>
+#include <qmldebug/qmldebugcommandlinearguments.h>
 #include <utils/fileutils.h>
 #include <utils/portlist.h>
 #include <qmlprofiler/localqmlprofilerrunner.h>
@@ -36,10 +38,7 @@
         if (mode != ProjectExplorer::Constants::NORMAL_RUN_MODE
                 && mode != ProjectExplorer::Constants::DEBUG_RUN_MODE
                 && mode != ProjectExplorer::Constants::DEBUG_RUN_MODE_WITH_BREAK_ON_MAIN
-                && mode != ProjectExplorer::Constants::QML_PROFILER_RUN_MODE
-                && mode != Valgrind::Internal::CALLGRIND_RUN_MODE
-                && mode != Valgrind::MEMCHECK_RUN_MODE
-                && mode != Valgrind::MEMCHECK_WITH_GDB_RUN_MODE) {
+                && mode != ProjectExplorer::Constants::QML_PROFILER_RUN_MODE) {
             return false;
         }
 
@@ -54,7 +53,13 @@
     if (!ubuntuRC)
         return 0;
 
+    if (!ubuntuRC->aboutToStart(errorMessage))
+        return 0;
+
     QTC_ASSERT(canRun(runConfiguration, mode), return 0);
+    const auto rcRunnable = runConfiguration->runnable();
+    QTC_ASSERT(rcRunnable.is<ProjectExplorer::StandardRunnable>(), return 0);
+    const auto stdRunnable = rcRunnable.as<ProjectExplorer::StandardRunnable>();
 
     ProjectExplorer::IDevice::ConstPtr genericDev = ProjectExplorer::DeviceKitInformation::device(runConfiguration->target()->kit());
     if (!genericDev || !genericDev->type().toString().startsWith(QLatin1String(Constants::UBUNTU_CONTAINER_DEVICE_TYPE_ID))) {
@@ -64,7 +69,7 @@
     }
 
     ProjectExplorer::ToolChain *genericToolchain = ProjectExplorer::ToolChainKitInformation::toolChain(runConfiguration->target()->kit());
-    if (!genericToolchain || genericToolchain->type() != QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)) {
+    if (!genericToolchain || genericToolchain->typeId() != Constants::UBUNTU_CLICK_TOOLCHAIN_ID) {
         if(!errorMessage)
             *errorMessage = tr("Wrong toolchain type in runconfiguration.");
         return 0;
@@ -73,9 +78,6 @@
     ContainerDevice::ConstPtr dev = qSharedPointerCast<const ContainerDevice>(genericDev);
     ClickToolChain *tc = static_cast<ClickToolChain *>(genericToolchain);
 
-    if (!ubuntuRC->aboutToStart(errorMessage))
-        return 0;
-
     if (mode == ProjectExplorer::Constants::NORMAL_RUN_MODE) {
         RemoteLinux::RemoteLinuxRunControl *runControl = new RemoteLinux::RemoteLinuxRunControl(ubuntuRC);
         return runControl;
@@ -89,8 +91,8 @@
 
         if (isScope) {
             Debugger::DebuggerStartParameters params;
-            // Normalize to work around QTBUG-17529 (QtDeclarative fails with 'File name case mismatch'...)
-            params.workingDirectory = Utils::FileUtils::normalizePathName(ubuntuRC->workingDirectory());
+
+            params.inferior = stdRunnable;
 
             QString triplet = tc->gnutriplet();
             if (triplet.isEmpty()) {
@@ -101,12 +103,11 @@
 
             QString scoperunnerPth = QString::fromLatin1("/usr/lib/%1/unity-scopes/scoperunner")
                     .arg(triplet);
-            params.executable = QString(UbuntuClickTool::targetBasePath(tc->clickTarget())+scoperunnerPth);
+            params.symbolFile = QString(UbuntuClickTool::targetBasePath(tc->clickTarget())+scoperunnerPth);
             params.continueAfterAttach = true;
             params.startMode = Debugger::AttachToRemoteServer;
             params.remoteSetupNeeded = true;
             params.connParams.host = dev->sshParameters().host;
-            params.environment = ubuntuRC->environment();
             params.solibSearchPath.append(ubuntuRC->soLibSearchPaths());
 
             Debugger::DebuggerRunControl *runControl
@@ -117,28 +118,59 @@
 
             return runControl;
         } else {
-            if (ubuntuRC->portsUsedByDebuggers() > dev->freePorts().count()) {
+            auto aspect = ubuntuRC->extraAspect<Debugger::DebuggerRunConfigurationAspect>();
+            if (aspect->portsUsedByDebugger() > dev->freePorts().count()) {
                 *errorMessage = tr("Cannot debug: Not enough free ports available.");
                 return 0;
             }
 
-            Debugger::DebuggerStartParameters params = RemoteLinux::LinuxDeviceDebugSupport::startParameters(ubuntuRC);
+            /*
+             * Taken from remotelinuxruncontrolfactory.cpp and adapted
+             * to work here.
+             */
+            Debugger::DebuggerStartParameters params;
+            params.startMode = Debugger::AttachToRemoteServer;
+            params.closeMode = Debugger::KillAndExitMonitorAtClose;
+            params.remoteSetupNeeded = true;
+
+            if (aspect->useQmlDebugger()) {
+                params.qmlServer.host = dev->sshParameters().host;
+                params.qmlServer.port = Utils::Port(); // port is selected later on
+            }
+            if (aspect->useCppDebugger()) {
+                aspect->setUseMultiProcess(true);
+                params.inferior.executable = stdRunnable.executable;
+                params.inferior.commandLineArguments = stdRunnable.commandLineArguments;
+                if (aspect->useQmlDebugger()) {
+                    params.inferior.commandLineArguments.prepend(QLatin1Char(' '));
+                    params.inferior.commandLineArguments.prepend(QmlDebug::qmlDebugTcpArguments(QmlDebug::QmlDebuggerServices));
+                }
+                params.remoteChannel = dev->sshParameters().host + QLatin1String(":-1");
+                params.symbolFile = ubuntuRC->localExecutableFilePath();
+            }
+
             params.solibSearchPath.append(ubuntuRC->soLibSearchPaths());
 
             Debugger::DebuggerRunControl * const runControl = Debugger::createDebuggerRunControl(params, ubuntuRC, errorMessage, mode);
             if (!runControl)
                 return 0;
 
-            RemoteLinux::LinuxDeviceDebugSupport * const debugSupport =
-                    new RemoteLinux::LinuxDeviceDebugSupport(ubuntuRC, runControl);
-            connect(runControl, SIGNAL(finished()), debugSupport, SLOT(handleDebuggingFinished()));
+            (void) new RemoteLinux::LinuxDeviceDebugSupport(ubuntuRC, runControl);
             return runControl;
         }
         return 0;
     }
     else if(mode == ProjectExplorer::Constants::QML_PROFILER_RUN_MODE) {
-        Analyzer::AnalyzerStartParameters params = RemoteLinux::RemoteLinuxAnalyzeSupport::startParameters(ubuntuRC, mode);
-        Analyzer::AnalyzerRunControl *runControl = Analyzer::AnalyzerManager::createRunControl(params, ubuntuRC);
+        /*
+         * Taken from remotelinuxruncontrolfactory.cpp and adapted
+         * to work here.
+         */
+        auto runControl = Debugger::createAnalyzerRunControl(ubuntuRC, mode);
+        Debugger::AnalyzerConnection connection;
+        connection.connParams =
+            ProjectExplorer::DeviceKitInformation::device(ubuntuRC->target()->kit())->sshParameters();
+        connection.analyzerHost = connection.connParams.host;
+        runControl->setConnection(connection);
         (void) new RemoteLinux::RemoteLinuxAnalyzeSupport(ubuntuRC, runControl, mode);
         return runControl;
     }
 
=== modified file 'src/ubuntu/device/container/ubuntulocalscopedebugsupport.cpp'
--- src/ubuntu/device/container/ubuntulocalscopedebugsupport.cpp	2016-05-23 07:26:49 +0000
+++ src/ubuntu/device/container/ubuntulocalscopedebugsupport.cpp	2016-08-24 15:35:12 +0000
@@ -38,7 +38,7 @@
 
 void UbuntuLocalScopeDebugSupport::startExecution()
 {
-    QTC_ASSERT(state() == GatheringPorts, return);
+    QTC_ASSERT(state() == GatheringResources, return);
 
     setState(StartingRunner);
     m_gdbserverOutput.clear();
@@ -47,7 +47,8 @@
     // as it will stick even for the next non debug run, and even though
     // we can then start without gdbserver the timouts will be always set
     // high, because the DebugMode=true setting is still there
-    if(!setPort(m_port)) {
+    m_port = findPort();
+    if(!m_port.isValid()) {
         Debugger::RemoteSetupResult res;
         res.success = false;
         res.reason = tr("Could not assign a free port for debugging.");
@@ -118,7 +119,7 @@
     }
 
     args.append(QStringLiteral("--cppdebug"));
-    args.append(QString::number(m_port));
+    args.append(QString::number(m_port.number()));
 
 
     setState(StartingRunner);
@@ -138,9 +139,7 @@
     connect(m_runControl, &Debugger::DebuggerRunControl::stateChanged,
             this, &UbuntuLocalScopeDebugSupport::handleStateChanged);
 
-    runner->setEnvironment(environment());
-    runner->setWorkingDirectory(workingDirectory());
-    runner->start(device(), m_executable, args);
+    runner->start(device(), runnable());
 }
 
 void UbuntuLocalScopeDebugSupport::handleRemoteSetupRequested()
@@ -148,7 +147,7 @@
     QTC_ASSERT(state() == Inactive, return);
 
     showMessage(tr("Checking available ports...") + QLatin1Char('\n'), Debugger::LogStatus);
-    AbstractRemoteLinuxRunSupport::handleRemoteSetupRequested();
+    startPortsGathering();
 }
 
 void UbuntuLocalScopeDebugSupport::handleAppRunnerError(const QString &error)
@@ -171,7 +170,7 @@
 
 void UbuntuLocalScopeDebugSupport::handleRemoteErrorOutput(const QByteArray &output)
 {
-    QTC_ASSERT(state() != GatheringPorts, return);
+    QTC_ASSERT(state() != GatheringResources, return);
 
     if (!m_runControl)
         return;
 
=== modified file 'src/ubuntu/device/container/ubuntulocalscopedebugsupport.h'
--- src/ubuntu/device/container/ubuntulocalscopedebugsupport.h	2016-05-23 07:26:49 +0000
+++ src/ubuntu/device/container/ubuntulocalscopedebugsupport.h	2016-08-24 15:35:12 +0000
@@ -42,7 +42,7 @@
     void showMessage(const QString &msg, int channel);
 
 private:
-    int m_port;
+    Utils::Port m_port;
     QString m_scopeRunnerPath;
     QString m_executable;
     QString m_buildDir;
 
=== modified file 'src/ubuntu/device/remote/abstractremoterunsupport.cpp'
--- src/ubuntu/device/remote/abstractremoterunsupport.cpp	2016-03-29 09:41:07 +0000
+++ src/ubuntu/device/remote/abstractremoterunsupport.cpp	2016-08-24 15:35:12 +0000
@@ -84,14 +84,15 @@
     return &d->runner;
 }
 
-bool AbstractRemoteRunSupport::assignNextFreePort(int *port)
+Utils::Port AbstractRemoteRunSupport::findFreePort( )
 {
-    *port = d->portScanner.getNextFreePort(&d->freePorts);
-    if (*port == -1) {
+    Utils::Port thePort = d->portScanner.getNextFreePort(&d->freePorts);
+    if (!thePort.isValid()){
         handleAdapterSetupFailed(tr("Not enough free ports on device for debugging."));
-        return false;
+        return Utils::Port();
     }
-    return true;
+
+    return thePort;
 }
 
 void AbstractRemoteRunSupport::setFinished()
 
=== modified file 'src/ubuntu/device/remote/abstractremoterunsupport.h'
--- src/ubuntu/device/remote/abstractremoterunsupport.h	2016-03-29 09:41:07 +0000
+++ src/ubuntu/device/remote/abstractremoterunsupport.h	2016-08-24 15:35:12 +0000
@@ -34,7 +34,7 @@
     virtual void handleAdapterSetupFailed(const QString &error);
     virtual void handleAdapterSetupDone();
 
-    bool assignNextFreePort(int *port);
+    Utils::Port findFreePort();
     void setFinished ();
     void reset();
 
 
=== modified file 'src/ubuntu/device/remote/ubuntudeploystepfactory.cpp'
--- src/ubuntu/device/remote/ubuntudeploystepfactory.cpp	2016-03-29 10:39:39 +0000
+++ src/ubuntu/device/remote/ubuntudeploystepfactory.cpp	2016-08-24 15:35:12 +0000
@@ -6,6 +6,7 @@
 #include <ubuntu/ubuntupackagestep.h>
 
 #include <utils/qtcassert.h>
+#include <utils/algorithm.h>
 
 #include <projectexplorer/buildstep.h>
 #include <projectexplorer/buildsteplist.h>
@@ -23,9 +24,9 @@
 namespace Ubuntu {
 namespace Internal {
 
-QList<Core::Id> UbuntuDeployStepFactory::availableCreationIds(ProjectExplorer::BuildStepList *parent) const
+QList<ProjectExplorer::BuildStepInfo> UbuntuDeployStepFactory::availableSteps(ProjectExplorer::BuildStepList *parent) const
 {
-    QList<Core::Id> types;
+    QList<ProjectExplorer::BuildStepInfo> types;
 
     if (parent->id() != ProjectExplorer::Constants::BUILDSTEPS_DEPLOY)
         return types;
@@ -43,34 +44,37 @@
     if (isRemote) {
         //IF we have a remote device we just support a ubuntu toolchain
         ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(parent->target()->kit());
-        if(tc && tc->type() != QLatin1String(Ubuntu::Constants::UBUNTU_CLICK_TOOLCHAIN_ID))
+        if(tc && tc->typeId() != Ubuntu::Constants::UBUNTU_CLICK_TOOLCHAIN_ID)
             return types;
     }
 
-    if(isRemote && ( isHTML || isQML || isCMake || isQMake ) )
-        types << Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID
-              << Constants::UBUNTU_CLICK_PACKAGESTEP_ID;
+    if(isRemote && ( isHTML || isQML || isCMake || isQMake ) ) {
+
+        types << ProjectExplorer::BuildStepInfo (Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID,
+                                                 UbuntuDirectUploadStep::displayName(),
+                                                 ProjectExplorer::BuildStepInfo::UniqueStep)
+              << ProjectExplorer::BuildStepInfo (Constants::UBUNTU_CLICK_PACKAGESTEP_ID,
+                                                 tr("UbuntuSDK create click package", "Display name for UbuntuPackageStep id."),
+                                                 ProjectExplorer::BuildStepInfo::UniqueStep)
+              //backwards compatibility to older projects
+              << ProjectExplorer::BuildStepInfo (Constants::UBUNTU_DEPLOY_MAKESTEP_ID,
+                                                 tr("UbuntuSDK create click package", "Display name for UbuntuPackageStep id."),
+                                                 ProjectExplorer::BuildStepInfo::Flags(ProjectExplorer::BuildStepInfo::UniqueStep
+                                                 | ProjectExplorer::BuildStepInfo::Uncreatable
+                                                 | ProjectExplorer::BuildStepInfo::Unclonable));
+    }
 
     return types;
 }
 
-QString UbuntuDeployStepFactory::displayNameForId(const Core::Id id) const
-{
-    if (id == Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID)
-        return UbuntuDirectUploadStep::displayName();
-    else if (id == Constants::UBUNTU_CLICK_PACKAGESTEP_ID)
-        return tr("UbuntuSDK create click package", "Display name for UbuntuPackageStep id.");
-    return QString();
-}
-
-bool UbuntuDeployStepFactory::canCreate(ProjectExplorer::BuildStepList *parent, const Core::Id id) const
-{
-    return availableCreationIds(parent).contains(id);
+bool UbuntuDeployStepFactory::canHandle(ProjectExplorer::BuildStepList *parent, const Core::Id id) const
+{
+    return Utils::contains(availableSteps(parent), Utils::equal(&ProjectExplorer::BuildStepInfo::id, id));
 }
 
 ProjectExplorer::BuildStep *UbuntuDeployStepFactory::create(ProjectExplorer::BuildStepList *parent, const Core::Id id)
 {
-    if (!canCreate(parent, id))
+    if (!canHandle(parent, id))
         return 0;
 
     if(id == Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID)
@@ -83,24 +87,12 @@
     return 0;
 }
 
-bool UbuntuDeployStepFactory::canRestore(ProjectExplorer::BuildStepList *parent, const QVariantMap &map) const
-{
-    Core::Id toRestore = ProjectExplorer::idFromMap(map);
-
-    //backwards compatibility to older projects
-    if( toRestore == Constants::UBUNTU_DEPLOY_MAKESTEP_ID )
-        return canCreate(parent,Core::Id(Constants::UBUNTU_CLICK_PACKAGESTEP_ID));
-
-    return canCreate(parent,toRestore);
-}
-
 ProjectExplorer::BuildStep *UbuntuDeployStepFactory::restore(ProjectExplorer::BuildStepList *parent, const QVariantMap &map)
 {
     Core::Id id = ProjectExplorer::idFromMap(map);
-    if(!canCreate(parent,id))
+    if(!canHandle(parent,id))
         return 0;
 
-    //backwards compatibility to older projects
     if( id == Constants::UBUNTU_DEPLOY_MAKESTEP_ID ) {
         UbuntuPackageStep *step = new UbuntuPackageStep(parent);
         return step;
@@ -115,14 +107,9 @@
     return step;
 }
 
-bool UbuntuDeployStepFactory::canClone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product) const
-{
-    return canCreate(parent,product->id());
-}
-
 ProjectExplorer::BuildStep *UbuntuDeployStepFactory::clone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product)
 {
-    if (!canClone(parent, product))
+    if (!canHandle(parent, product->id()))
         return 0;
 
     const Core::Id id = product->id();
 
=== modified file 'src/ubuntu/device/remote/ubuntudeploystepfactory.h'
--- src/ubuntu/device/remote/ubuntudeploystepfactory.h	2016-03-29 10:39:39 +0000
+++ src/ubuntu/device/remote/ubuntudeploystepfactory.h	2016-08-24 15:35:12 +0000
@@ -13,14 +13,13 @@
 
 public:
     // IBuildStepFactory interface
-    virtual QList<Core::Id> availableCreationIds(ProjectExplorer::BuildStepList *parent) const override;
-    virtual QString displayNameForId(const Core::Id id) const override;
-    virtual bool canCreate(ProjectExplorer::BuildStepList *parent, const Core::Id id) const override;
+    virtual QList<ProjectExplorer::BuildStepInfo> availableSteps(ProjectExplorer::BuildStepList *parent) const override;
     virtual ProjectExplorer::BuildStep *create(ProjectExplorer::BuildStepList *parent, const Core::Id id) override;
-    virtual bool canRestore(ProjectExplorer::BuildStepList *parent, const QVariantMap &map) const override;
     virtual ProjectExplorer::BuildStep *restore(ProjectExplorer::BuildStepList *parent, const QVariantMap &map) override;
-    virtual bool canClone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product) const override;
     virtual ProjectExplorer::BuildStep *clone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product) override;
+
+private:
+    bool canHandle(ProjectExplorer::BuildStepList *parent, const Core::Id id) const;
 };
 
 } // namespace Internal
 
=== modified file 'src/ubuntu/device/remote/ubuntudevice.cpp'
--- src/ubuntu/device/remote/ubuntudevice.cpp	2016-03-29 09:41:07 +0000
+++ src/ubuntu/device/remote/ubuntudevice.cpp	2016-08-24 15:35:12 +0000
@@ -28,6 +28,7 @@
 #include <ubuntu/settings.h>
 
 #include <projectexplorer/devicesupport/devicemanager.h>
+#include <projectexplorer/runnables.h>
 #include <remotelinux/genericlinuxdeviceconfigurationwidget.h>
 #include <coreplugin/messagemanager.h>
 #include <ssh/sshconnection.h>
@@ -744,14 +745,14 @@
 
     //first port is SSH port
     QSsh::SshConnectionParameters connParms = m_dev->sshParameters();
-    connParms.port = copy.getNext();
+    connParms.port = copy.getNext().number();
     m_dev->setSshParameters(connParms);
 
     m_dev->setFreePorts(copy);
 
     QStringList ports;
     while(copy.hasMore())
-        ports.append(QString::number(copy.getNext()));
+        ports.append(QString::number(copy.getNext().number()));
 
     //@TODO per device settings
     QString deviceSshPort = QString::number(connParms.port);
@@ -1349,17 +1350,12 @@
 {
 }
 
-void UbuntuDeviceProcess::setWorkingDirectory(const QString &directory)
-{
-    m_workingDir = directory;
-}
-
 void UbuntuDeviceProcess::terminate()
 {
     LinuxDeviceProcess::terminate();
 }
 
-QString UbuntuDeviceProcess::fullCommandLine() const
+QString UbuntuDeviceProcess::fullCommandLine(const ProjectExplorer::StandardRunnable &runnable) const
 {
     //return QStringLiteral("%1 %2").arg(quote(executable()),Utils::QtcProcess::joinArgsUnix(arguments()));
 
@@ -1371,15 +1367,15 @@
     QString fullCommandLine;
     foreach (const QString &filePath, rcFiles)
         fullCommandLine += QString::fromLatin1("test -f %1 && . %1;").arg(filePath);
-    if (!m_workingDir.isEmpty()) {
-        fullCommandLine.append(QLatin1String("cd ")).append(quote(m_workingDir))
+    if (!runnable.workingDirectory.isEmpty()) {
+        fullCommandLine.append(QLatin1String("cd ")).append(quote(runnable.workingDirectory))
                 .append(QLatin1String(" && "));
     }
 
-    fullCommandLine.append(quote(executable()));
-    if (!arguments().isEmpty()) {
+    fullCommandLine.append(quote(runnable.executable));
+    if (!runnable.commandLineArguments.isEmpty()) {
         fullCommandLine.append(QLatin1Char(' '));
-        fullCommandLine.append(Utils::QtcProcess::joinArgs(arguments(),Utils::OsTypeLinux));
+        fullCommandLine.append(runnable.commandLineArguments);
     }
 
     if(debug) qDebug()<<fullCommandLine;
 
=== modified file 'src/ubuntu/device/remote/ubuntudevice.h'
--- src/ubuntu/device/remote/ubuntudevice.h	2016-03-29 09:41:07 +0000
+++ src/ubuntu/device/remote/ubuntudevice.h	2016-08-24 15:35:12 +0000
@@ -246,16 +246,13 @@
     explicit UbuntuDeviceProcess(const QSharedPointer<const ProjectExplorer::IDevice> &device,
                                 QObject *parent = 0);
 
-    void setWorkingDirectory(const QString &directory) override;
-
     // DeviceProcess interface
 public:
     virtual void terminate() override;
 
 private:
     // SshDeviceProcess interface
-    virtual QString fullCommandLine() const override;
-    QString m_workingDir;
+    virtual QString fullCommandLine(const ProjectExplorer::StandardRunnable &runnable) const override;
 };
 
 } // namespace Internal
 
=== modified file 'src/ubuntu/device/remote/ubuntudevicesignaloperation.cpp'
--- src/ubuntu/device/remote/ubuntudevicesignaloperation.cpp	2016-03-29 09:41:07 +0000
+++ src/ubuntu/device/remote/ubuntudevicesignaloperation.cpp	2016-08-24 15:35:12 +0000
@@ -10,7 +10,7 @@
 
 }
 
-void UbuntuDeviceSignalOperation::killProcess(int pid)
+void UbuntuDeviceSignalOperation::killProcess(qint64 pid)
 {
     sendSignal(pid,9);
 }
@@ -21,7 +21,7 @@
     emit finished(tr("Sending signals to processes by filePath is not supported on Ubuntu Devices"));
 }
 
-void UbuntuDeviceSignalOperation::interruptProcess(int pid)
+void UbuntuDeviceSignalOperation::interruptProcess(qint64 pid)
 {
     sendSignal(pid,2);
 }
@@ -32,7 +32,7 @@
     emit finished(tr("Sending signals to processes by filePath is not supported on Ubuntu Devices"));
 }
 
-void UbuntuDeviceSignalOperation::sendSignal(int pid, int signal)
+void UbuntuDeviceSignalOperation::sendSignal(qint64 pid, int signal)
 {
     QProcess *proc = new QProcess(this);
 
 
=== modified file 'src/ubuntu/device/remote/ubuntudevicesignaloperation.h'
--- src/ubuntu/device/remote/ubuntudevicesignaloperation.h	2016-07-22 10:17:50 +0000
+++ src/ubuntu/device/remote/ubuntudevicesignaloperation.h	2016-08-24 15:35:12 +0000
@@ -17,13 +17,13 @@
     typedef QSharedPointer<UbuntuDeviceSignalOperation> Ptr;
 
     // DeviceProcessSignalOperation interface
-    virtual void killProcess(int pid) override;
+    virtual void killProcess(qint64 pid) override;
     virtual void killProcess(const QString &filePath) override;
-    virtual void interruptProcess(int pid) override;
+    virtual void interruptProcess(qint64 pid) override;
     virtual void interruptProcess(const QString &filePath) override;
 
 private:
-    void sendSignal (int pid, int signal);
+    void sendSignal (qint64 pid, int signal);
 
 private slots:
     void processFinished (int exitCode, QProcess::ExitStatus exitState);
 
=== modified file 'src/ubuntu/device/remote/ubuntudirectuploadstep.cpp'
--- src/ubuntu/device/remote/ubuntudirectuploadstep.cpp	2016-03-29 10:39:39 +0000
+++ src/ubuntu/device/remote/ubuntudirectuploadstep.cpp	2016-08-24 15:35:12 +0000
@@ -65,12 +65,13 @@
 
 void UbuntuDirectUploadStep::run(QFutureInterface<bool> &fi)
 {
+    m_future = &fi;
+
     m_foundClickPackage = false;
     projectNameChanged();
     if(!m_foundClickPackage) {
-        emit addOutput(tr("Deploy step failed. No click package was created"), ErrorMessageOutput);
-        fi.reportResult(false);
-        emit finished();
+        doFail(tr("Deploy step failed. No click package was created"));
+        m_future = 0;
         return;
     }
 
@@ -80,13 +81,11 @@
 
     UbuntuDevice::ConstPtr dev = deviceFromTarget(target());
     if(!dev) {
-        emit addOutput(tr("Deploy step failed. No valid device configured"), ErrorMessageOutput);
-        fi.reportResult(false);
-        emit finished();
+        doFail(tr("Deploy step failed. No valid device configured"));
+        m_future = 0;
         return;
     }
 
-    m_future = &fi;
     if(dev->deviceState() != ProjectExplorer::IDevice::DeviceReadyToUse) {
         //we are already waiting
         if (m_waitDialog)
@@ -109,10 +108,8 @@
 {
     m_waitDialog->deleteLater();
 
-    emit addOutput(tr("Deploy step failed"), ErrorMessageOutput);
-    m_future->reportResult(false);
+    doFail(tr("Deploy step failed"));
     m_future = 0;
-    emit finished();
 }
 
 void UbuntuDirectUploadStep::handleDeviceReady()
@@ -121,10 +118,8 @@
 
     QString whyNot;
     if(!deployService()->isDeploymentPossible(&whyNot)) {
-        emit addOutput(tr("Deploy step failed. %1").arg(whyNot), ErrorMessageOutput);
-        m_future->reportResult(false);
+        doFail(tr("Deploy step failed. %1").arg(whyNot));
         m_future = 0;
-        emit finished();
         return;
     }
 
@@ -132,6 +127,14 @@
     m_future = 0;
 }
 
+void UbuntuDirectUploadStep::doFail(const QString &err)
+{
+    emit addOutput(err, ErrorMessageOutput);
+    disconnect(deployService(), 0, this, 0);
+    if (m_future)
+        reportRunResult(*m_future, false);
+}
+
 ProjectExplorer::BuildStepConfigWidget *UbuntuDirectUploadStep::createConfigWidget()
 {
     return new ProjectExplorer::SimpleBuildStepConfigWidget(this);
 
=== modified file 'src/ubuntu/device/remote/ubuntudirectuploadstep.h'
--- src/ubuntu/device/remote/ubuntudirectuploadstep.h	2016-07-22 10:17:50 +0000
+++ src/ubuntu/device/remote/ubuntudirectuploadstep.h	2016-08-24 15:35:12 +0000
@@ -39,6 +39,9 @@
     void handleDeviceReady ();
 
 private:
+    void doFail (const QString &err);
+
+private:
     RemoteLinux::GenericDirectUploadService *m_deployService;
     bool m_foundClickPackage;
 
 
=== modified file 'src/ubuntu/device/remote/ubunturemoteanalyzesupport.cpp'
--- src/ubuntu/device/remote/ubunturemoteanalyzesupport.cpp	2016-03-29 09:41:07 +0000
+++ src/ubuntu/device/remote/ubunturemoteanalyzesupport.cpp	2016-08-24 15:35:12 +0000
@@ -4,7 +4,7 @@
 #include <ubuntu/ubuntuconstants.h>
 
 #include <remotelinux/remotelinuxrunconfiguration.h>
-#include <analyzerbase/analyzerruncontrol.h>
+#include <debugger/analyzer/analyzerruncontrol.h>
 
 #include <projectexplorer/buildconfiguration.h>
 #include <projectexplorer/project.h>
@@ -14,6 +14,7 @@
 #include <projectexplorer/kitinformation.h>
 
 #include <utils/qtcassert.h>
+#include <utils/port.h>
 #include <qmldebug/qmloutputparser.h>
 
 #include <QPointer>
@@ -24,30 +25,31 @@
 class UbuntuRemoteAnalyzeSupportPrivate
 {
 public:
-    UbuntuRemoteAnalyzeSupportPrivate(Analyzer::AnalyzerRunControl *rc, Core::Id runMode)
+    UbuntuRemoteAnalyzeSupportPrivate(Debugger::AnalyzerRunControl *rc, Core::Id runMode)
         : runControl(rc),
-          qmlProfiling(runMode == ProjectExplorer::Constants::QML_PROFILER_RUN_MODE),
-          qmlPort(-1)
+          qmlPort(-1),
+          qmlProfiling(runMode == ProjectExplorer::Constants::QML_PROFILER_RUN_MODE)
     {
     }
 
     QString clickPackage;
-    const QPointer<Analyzer::AnalyzerRunControl> runControl;
+
+    const QPointer<Debugger::AnalyzerRunControl> runControl;
+    QmlDebug::QmlOutputParser outputParser;
+
+    Utils::Port qmlPort;
     bool qmlProfiling;
-    int qmlPort;
-
-    QmlDebug::QmlOutputParser outputParser;
 };
 
 UbuntuRemoteAnalyzeSupport::UbuntuRemoteAnalyzeSupport(UbuntuRemoteRunConfiguration *runConfig,
-                                                     Analyzer::AnalyzerRunControl *engine, Core::Id runMode)
+                                                     Debugger::AnalyzerRunControl *engine, Core::Id runMode)
     : AbstractRemoteRunSupport(runConfig, engine),
       d(new UbuntuRemoteAnalyzeSupportPrivate(engine, runMode))
 {
     d->clickPackage = runConfig->clickPackage();
-    connect(d->runControl, SIGNAL(starting(const Analyzer::AnalyzerRunControl*)),
-            SLOT(handleRemoteSetupRequested()));
-    connect(&d->outputParser, SIGNAL(waitingForConnectionOnPort(quint16)),
+    connect(d->runControl, &Debugger::AnalyzerRunControl::starting,
+            this, &UbuntuRemoteAnalyzeSupport::handleRemoteSetupRequested);
+    connect(&d->outputParser, SIGNAL(waitingForConnectionOnPort(Utils::Port)),
             SLOT(remoteIsRunning()));
 }
 
@@ -59,7 +61,7 @@
 void UbuntuRemoteAnalyzeSupport::showMessage(const QString &msg, Utils::OutputFormat format)
 {
     if (state() != Idle && d->runControl)
-        d->runControl->logApplicationMessage(msg, format);
+        d->runControl->appendMessage(msg, format);
     d->outputParser.processOutput(msg);
 }
 
@@ -78,7 +80,8 @@
     // Currently we support only QML profiling
     QTC_ASSERT(d->qmlProfiling, return);
 
-    if (!assignNextFreePort(&d->qmlPort))
+    d->qmlPort = findFreePort();
+    if (!d->qmlPort.isValid())
         return;
 
     setState(Starting);
@@ -91,7 +94,7 @@
     connect(runner, SIGNAL(reportError(QString)), SLOT(handleAppRunnerError(QString)));
 
     runner->setEnv(environment());
-    runner->setQmlDebugPort(d->qmlPort);
+    runner->setQmlDebugPort(d->qmlPort.number());
 
     QTC_ASSERT(device()->type().toString().startsWith(QLatin1String(Constants::UBUNTU_DEVICE_TYPE_ID)),return);
     runner->start(qSharedPointerCast<const UbuntuDevice>(device()),clickPackage(),hook());
 
=== modified file 'src/ubuntu/device/remote/ubunturemoteanalyzesupport.h'
--- src/ubuntu/device/remote/ubunturemoteanalyzesupport.h	2016-03-29 09:41:07 +0000
+++ src/ubuntu/device/remote/ubunturemoteanalyzesupport.h	2016-08-24 15:35:12 +0000
@@ -3,7 +3,7 @@
 
 #include <QObject>
 #include "abstractremoterunsupport.h"
-#include <analyzerbase/analyzerruncontrol.h>
+#include <debugger/analyzer/analyzerruncontrol.h>
 
 namespace Ubuntu {
 namespace Internal {
@@ -16,7 +16,7 @@
     Q_OBJECT
 public:
     UbuntuRemoteAnalyzeSupport(UbuntuRemoteRunConfiguration *runConfig,
-            Analyzer::AnalyzerRunControl *engine, Core::Id runMode);
+            Debugger::AnalyzerRunControl *engine, Core::Id runMode);
     ~UbuntuRemoteAnalyzeSupport() override;
 
 protected:
 
=== modified file 'src/ubuntu/device/remote/ubunturemotedebugsupport.cpp'
--- src/ubuntu/device/remote/ubunturemotedebugsupport.cpp	2016-03-29 09:41:07 +0000
+++ src/ubuntu/device/remote/ubunturemotedebugsupport.cpp	2016-08-24 15:35:12 +0000
@@ -70,8 +70,8 @@
     bool qmlDebugging;
     bool cppDebugging;
     QByteArray gdbserverOutput;
-    int gdbServerPort;
-    int qmlPort;
+    Utils::Port gdbServerPort;
+    Utils::Port qmlPort;
 };
 
 UbuntuRemoteDebugSupport::UbuntuRemoteDebugSupport(UbuntuRemoteRunConfiguration* runConfig,
@@ -80,6 +80,8 @@
       d(new UbuntuRemoteDebugSupportPrivate(runConfig, runControl))
 {
     connect(d->runControl, SIGNAL(requestRemoteSetup()), this, SLOT(handleRemoteSetupRequested()));
+    connect(d->runControl,&Debugger::DebuggerRunControl::finished,
+            this, &UbuntuRemoteDebugSupport::handleDebuggingFinished);
 }
 
 UbuntuRemoteDebugSupport::~UbuntuRemoteDebugSupport()
@@ -105,10 +107,16 @@
 
     setState(Starting);
 
-    if (d->cppDebugging && !assignNextFreePort(&d->gdbServerPort))
-        return;
-    if (d->qmlDebugging && !assignNextFreePort(&d->qmlPort))
-            return;
+    if (d->cppDebugging) {
+        d->gdbServerPort = findFreePort();
+        if (!d->gdbServerPort.isValid())
+            return;
+    }
+    if (d->qmlDebugging) {
+        d->qmlPort = findFreePort();
+        if (!d->qmlPort.isValid())
+            return;
+    }
 
     d->gdbserverOutput.clear();
 
@@ -120,9 +128,9 @@
         connect(launcher, SIGNAL(clickApplicationStarted(quint16)), SLOT(handleRemoteProcessStarted(quint16)));
 
     if(d->cppDebugging)
-        launcher->setCppDebugPort(d->gdbServerPort);
+        launcher->setCppDebugPort(d->gdbServerPort.number());
     if(d->qmlDebugging)
-        launcher->setQmlDebugPort(d->qmlPort);
+        launcher->setQmlDebugPort(d->qmlPort.number());
 
     launcher->setEnv(environment());
 
@@ -222,7 +230,7 @@
 
     Debugger::RemoteSetupResult result;
     result.success = true;
-    result.inferiorPid = d->runControl->startParameters().attachPID;
+    //result.inferiorPid   = d->runControl->startParameters().attachPID;
     result.gdbServerPort = d->gdbServerPort;
     result.qmlServerPort = d->qmlPort;
     d->runControl->notifyEngineRemoteSetupFinished(result);
 
=== modified file 'src/ubuntu/device/remote/ubunturemoterunconfiguration.cpp'
--- src/ubuntu/device/remote/ubunturemoterunconfiguration.cpp	2016-04-06 10:52:54 +0000
+++ src/ubuntu/device/remote/ubunturemoterunconfiguration.cpp	2016-08-24 15:35:12 +0000
@@ -31,6 +31,7 @@
 #include <projectexplorer/target.h>
 #include <projectexplorer/project.h>
 #include <projectexplorer/buildsteplist.h>
+#include <projectexplorer/runnables.h>
 #include <remotelinux/remotelinuxenvironmentaspect.h>
 #include <utils/qtcprocess.h>
 #include <cmakeprojectmanager/cmakeproject.h>
@@ -57,7 +58,7 @@
 const char UNINSTALL_KEY[]="UbuntuRemoteRunConfiguration.Uninstall";
 
 UbuntuRemoteRunConfiguration::UbuntuRemoteRunConfiguration(ProjectExplorer::Target *parent, Core::Id id)
-    : AbstractRemoteLinuxRunConfiguration(parent,id),
+    : RunConfiguration(parent,id),
       m_running(false),
       m_forceInstall(false),
       m_uninstall(true)
@@ -70,7 +71,7 @@
 }
 
 UbuntuRemoteRunConfiguration::UbuntuRemoteRunConfiguration(ProjectExplorer::Target *parent, UbuntuRemoteRunConfiguration *source)
-    : AbstractRemoteLinuxRunConfiguration(parent,source),
+    : RunConfiguration(parent,source),
       m_running(false),
       m_forceInstall(false),
       m_uninstall(true)
@@ -176,6 +177,20 @@
     return ProjectExplorer::RunConfiguration::Configured;
 }
 
+ProjectExplorer::Runnable UbuntuRemoteRunConfiguration::runnable() const
+{
+    if (m_remoteExecutable.isEmpty())
+        return ProjectExplorer::Runnable();
+
+    ProjectExplorer::StandardRunnable r;
+    r.executable = m_remoteExecutable;
+    r.device = ProjectExplorer::DeviceKitInformation::device(target()->kit());
+
+    r.environment = environment();
+
+    return r;
+}
+
 /*!
  * \brief UbuntuRemoteRunConfiguration::aboutToStart
  * Configures the internal parameters and fetched the informations from
@@ -225,7 +240,7 @@
     }
 
     ProjectExplorer::ToolChain* tc = ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit());
-    if(tc->type() != QString::fromLatin1(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)) {
+    if(tc->typeId() != Constants::UBUNTU_CLICK_TOOLCHAIN_ID) {
         if(errorMessage)
             *errorMessage = tr("Wrong toolchain type. Please check your build configuration.");
         return false;
@@ -407,7 +422,7 @@
 {
     if(debug) qDebug()<<Q_FUNC_INFO;
 
-    if(!AbstractRemoteLinuxRunConfiguration::fromMap(map))
+    if(!RunConfiguration::fromMap(map))
         return false;
 
     m_uninstall = map.value(QLatin1String(UNINSTALL_KEY),true).toBool();
@@ -418,7 +433,7 @@
 QVariantMap UbuntuRemoteRunConfiguration::toMap() const
 {
     if(debug) qDebug()<<Q_FUNC_INFO;
-    QVariantMap m = AbstractRemoteLinuxRunConfiguration::toMap();
+    QVariantMap m = RunConfiguration::toMap();
     m.insert(QLatin1String(UNINSTALL_KEY),m_uninstall);
     m.insert(QLatin1String(FORCE_INSTALL_KEY),m_forceInstall);
     return m;
 
=== modified file 'src/ubuntu/device/remote/ubunturemoterunconfiguration.h'
--- src/ubuntu/device/remote/ubunturemoterunconfiguration.h	2016-03-29 09:41:07 +0000
+++ src/ubuntu/device/remote/ubunturemoterunconfiguration.h	2016-08-24 15:35:12 +0000
@@ -18,7 +18,7 @@
 #ifndef UBUNTU_INTERNAL_UBUNTUREMOTERUNCONFIGURATION_H
 #define UBUNTU_INTERNAL_UBUNTUREMOTERUNCONFIGURATION_H
 
-#include <remotelinux/abstractremotelinuxrunconfiguration.h>
+#include <projectexplorer/runconfiguration.h>
 #include <coreplugin/id.h>
 
 namespace Ui {
@@ -28,7 +28,7 @@
 namespace Ubuntu {
 namespace Internal {
 
-class UbuntuRemoteRunConfiguration : public RemoteLinux::AbstractRemoteLinuxRunConfiguration
+class UbuntuRemoteRunConfiguration : public ProjectExplorer::RunConfiguration
 {
     Q_OBJECT
     Q_PROPERTY(bool forceInstall READ forceInstall WRITE setForceInstall NOTIFY forceInstallChanged)
@@ -38,13 +38,12 @@
     UbuntuRemoteRunConfiguration(ProjectExplorer::Target *parent, Core::Id id);
     UbuntuRemoteRunConfiguration(ProjectExplorer::Target *parent, UbuntuRemoteRunConfiguration *source);
 
-    // AbstractRemoteLinuxRunConfiguration interface
 public:
-    virtual QString localExecutableFilePath() const override;
-    virtual QString remoteExecutableFilePath() const override;
-    virtual QStringList arguments() const override;
-    virtual QString workingDirectory() const override;
-    virtual Utils::Environment environment() const override;
+    QString localExecutableFilePath() const;
+    QString remoteExecutableFilePath() const;
+    QStringList arguments() const;
+    QString workingDirectory() const;
+    Utils::Environment environment() const;
 
     virtual QStringList soLibSearchPaths () const;
     bool aboutToStart (QString *errorMessage);
@@ -55,6 +54,7 @@
     virtual QString disabledReason() const override;
     virtual bool isConfigured() const override;
     virtual ConfigurationState ensureConfigured(QString *) override;
+    virtual ProjectExplorer::Runnable runnable ( ) const override;
 
     // ProjectConfiguration interface
     virtual bool fromMap(const QVariantMap &map) override;
 
=== modified file 'src/ubuntu/device/remote/ubunturemoteruncontrol.cpp'
--- src/ubuntu/device/remote/ubunturemoteruncontrol.cpp	2016-03-29 09:41:07 +0000
+++ src/ubuntu/device/remote/ubunturemoteruncontrol.cpp	2016-08-24 15:35:12 +0000
@@ -34,12 +34,12 @@
 #include "ubuntudevice.h"
 #include "ubuntuwaitfordevicedialog.h"
 
-#include <remotelinux/abstractremotelinuxrunconfiguration.h>
 #include <projectexplorer/devicesupport/deviceapplicationrunner.h>
 #include <projectexplorer/kitinformation.h>
 #include <projectexplorer/target.h>
 #include <utils/environment.h>
 #include <coreplugin/icore.h>
+#include <coreplugin/coreicons.h>
 
 #include <QString>
 #include <QIcon>
@@ -73,7 +73,7 @@
     d->environment = d->runConfig->environment();
     d->clickPackage = d->runConfig->clickPackage();
 
-    setIcon(QLatin1String(ProjectExplorer::Constants::ICON_RUN_SMALL));
+    setIcon(Core::Icons::RUN_SMALL);
 }
 
 UbuntuRemoteRunControl::~UbuntuRemoteRunControl()
 
=== modified file 'src/ubuntu/device/remote/ubunturemoteruncontrolfactory.cpp'
--- src/ubuntu/device/remote/ubunturemoteruncontrolfactory.cpp	2016-03-29 09:41:07 +0000
+++ src/ubuntu/device/remote/ubunturemoteruncontrolfactory.cpp	2016-08-24 15:35:12 +0000
@@ -27,13 +27,13 @@
 #include <debugger/debuggerplugin.h>
 #include <debugger/debuggerrunconfigurationaspect.h>
 #include <debugger/debuggerruncontrol.h>
+#include <qmldebug/qmldebugcommandlinearguments.h>
 #include <remotelinux/remotelinuxdebugsupport.h>
 #include <remotelinux/remotelinuxruncontrol.h>
 #include <remotelinux/remotelinuxanalyzesupport.h>
-#include <analyzerbase/analyzerstartparameters.h>
-#include <analyzerbase/analyzermanager.h>
-#include <analyzerbase/analyzerruncontrol.h>
-#include <analyzerbase/ianalyzertool.h>
+#include <debugger/analyzer/analyzerstartparameters.h>
+#include <debugger/analyzer/analyzermanager.h>
+#include <debugger/analyzer/analyzerruncontrol.h>
 #include <utils/portlist.h>
 #include <utils/qtcassert.h>
 
@@ -45,7 +45,6 @@
 
 bool UbuntuRemoteRunControlFactory::canRun(ProjectExplorer::RunConfiguration *runConfiguration,
                                 Core::Id mode) const {
-
     if(qobject_cast<UbuntuRemoteRunConfiguration*>(runConfiguration)) {
         if (mode != ProjectExplorer::Constants::NORMAL_RUN_MODE
                 && mode != ProjectExplorer::Constants::DEBUG_RUN_MODE
@@ -74,7 +73,11 @@
         if (!rc->aboutToStart(errorMessage))
             return 0;
 
-        QTC_ASSERT(rc, return 0);
+        QTC_ASSERT(rc, return 0);        
+        const auto rcRunnable = runConfiguration->runnable();
+        QTC_ASSERT(rcRunnable.is<ProjectExplorer::StandardRunnable>(), return 0);
+        const auto stdRunnable = rcRunnable.as<ProjectExplorer::StandardRunnable>();
+
 
         if (mode == ProjectExplorer::Constants::NORMAL_RUN_MODE) {
             return new UbuntuRemoteRunControl(rc);
@@ -94,34 +97,62 @@
                 return 0;
             }
 
-            if (2 > dev->freePorts().count()) {
+            auto aspect = rc->extraAspect<Debugger::DebuggerRunConfigurationAspect>();
+            if (aspect->portsUsedByDebugger() > dev->freePorts().count()) {
                 *errorMessage = tr("Cannot debug: Not enough free ports available.");
                 return 0;
             }
-            Debugger::DebuggerStartParameters params = RemoteLinux::LinuxDeviceDebugSupport::startParameters(rc);
+
+            /*
+             * Taken from remotelinuxruncontrolfactory.cpp and adapted
+             * to work here.
+             */
+            Debugger::DebuggerStartParameters params;
+            params.startMode = Debugger::AttachToRemoteServer;
+            params.closeMode = Debugger::KillAndExitMonitorAtClose;
+            params.remoteSetupNeeded = true;
+            params.useContinueInsteadOfRun = true;
+
+            if (aspect->useQmlDebugger()) {
+                params.qmlServer.host = dev->sshParameters().host;
+                params.qmlServer.port = Utils::Port(); // port is selected later on
+            }
+            if (aspect->useCppDebugger()) {
+                aspect->setUseMultiProcess(true);
+#if 1
+                params.inferior.executable = stdRunnable.executable;
+                params.inferior.commandLineArguments = stdRunnable.commandLineArguments;
+                if (aspect->useQmlDebugger()) {
+                    params.inferior.commandLineArguments.prepend(QLatin1Char(' '));
+                    params.inferior.commandLineArguments.prepend(QmlDebug::qmlDebugTcpArguments(QmlDebug::QmlDebuggerServices));
+                }
+#endif
+                params.remoteChannel = dev->sshParameters().host + QLatin1String(":-1");
+                params.symbolFile = rc->localExecutableFilePath();
+            }
 
             params.solibSearchPath.append(rc->soLibSearchPaths());
 
-            //Always leave this empty or the debugger backend tries to execute
-            //the binary on the phone instead of attaching and continuing the already
-            //running app
-            params.remoteExecutable = QString();
-            //params.expectedSignals.append("SIGTRAP");
-
-            if(debug) qDebug()<<"Solib search path : "<<params.solibSearchPath;
-
-            Debugger::DebuggerRunControl * const runControl
-                    = Debugger::createDebuggerRunControl(params, rc, errorMessage, mode);
+            Debugger::DebuggerRunControl * const runControl = Debugger::createDebuggerRunControl(params, rc, errorMessage, mode);
             if (!runControl)
                 return 0;
+
             UbuntuRemoteDebugSupport * const debugSupport =
                     new UbuntuRemoteDebugSupport(rc, runControl);
             connect(runControl, SIGNAL(finished()), debugSupport, SLOT(handleDebuggingFinished()));
             return runControl;
 
         } else if ( mode == ProjectExplorer::Constants::QML_PROFILER_RUN_MODE ) {
-            Analyzer::AnalyzerStartParameters params = RemoteLinux::RemoteLinuxAnalyzeSupport::startParameters(rc, mode);
-            Analyzer::AnalyzerRunControl *runControl = Analyzer::AnalyzerManager::createRunControl(params, runConfiguration);
+            /*
+             * Taken from remotelinuxruncontrolfactory.cpp and adapted
+             * to work here.
+             */
+            auto runControl = Debugger::createAnalyzerRunControl(rc, mode);
+            Debugger::AnalyzerConnection connection;
+            connection.connParams =
+                ProjectExplorer::DeviceKitInformation::device(rc->target()->kit())->sshParameters();
+            connection.analyzerHost = connection.connParams.host;
+            runControl->setConnection(connection);
             UbuntuRemoteAnalyzeSupport * const analyzeSupport =
                     new UbuntuRemoteAnalyzeSupport(rc, runControl, mode);
             connect(runControl, SIGNAL(finished()), analyzeSupport, SLOT(handleProfilingFinished()));
 
=== modified file 'src/ubuntu/device/remote/ubunturemoterunner.cpp'
--- src/ubuntu/device/remote/ubunturemoterunner.cpp	2016-03-29 09:41:07 +0000
+++ src/ubuntu/device/remote/ubunturemoterunner.cpp	2016-08-24 15:35:12 +0000
@@ -19,7 +19,7 @@
 const QString SSH_BASE_COMMAND = QStringLiteral("ssh -i %1 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -p%2 %3@%4");
 
 enum {
-    debug = 0
+    debug = 1
 };
 
 class UbuntuRemoteClickApplicationRunnerPrivate
 
=== modified file 'src/ubuntu/localportsmanager.cpp'
--- src/ubuntu/localportsmanager.cpp	2014-11-26 19:45:36 +0000
+++ src/ubuntu/localportsmanager.cpp	2016-08-24 15:35:12 +0000
@@ -100,13 +100,13 @@
         if (serial == device && localPort >= m_instance->m_first && localPort <= m_instance->m_last) {
             if(debug) qDebug()<<"Found port already linked to device: "<<localPort<<":"<<remotePort;
 
-            freePorts.addPort(localPort);
+            freePorts.addPort(Utils::Port(localPort));
 
             if (freePorts.count() == count)
                 break;
         } else {
             if(debug) qDebug()<<"Found port in use: "<<localPort<<":"<<remotePort;
-            usedPorts.addPort(localPort);
+            usedPorts.addPort(Utils::Port(localPort));
         }
     }
 
@@ -116,14 +116,14 @@
         int port = firstPort + i;
 
         //is the port in use?
-        if(usedPorts.contains(port))
+        if(usedPorts.contains(Utils::Port(port)))
             continue;
 
         //is that port already assigned to us?
-        if(freePorts.contains(port))
+        if(freePorts.contains(Utils::Port(port)))
             continue;
 
-        freePorts.addPort(port);
+        freePorts.addPort(Utils::Port(port));
         found++;
         if(debug) qDebug()<<"Found free port: "<<port;
     }
 
=== modified file 'src/ubuntu/ubuntuabstractguieditordocument.cpp'
--- src/ubuntu/ubuntuabstractguieditordocument.cpp	2015-03-06 15:02:08 +0000
+++ src/ubuntu/ubuntuabstractguieditordocument.cpp	2016-08-24 15:35:12 +0000
@@ -59,16 +59,6 @@
     return false;
 }
 
-QString UbuntuAbstractGuiEditorDocument::defaultPath() const
-{
-    return filePath().toFileInfo().absolutePath();
-}
-
-QString UbuntuAbstractGuiEditorDocument::suggestedFileName() const
-{
-    return filePath().toFileInfo().fileName();
-}
-
 bool UbuntuAbstractGuiEditorDocument::isModified() const
 {
     return TextDocument::isModified() ||  m_editorWidget->isModified();
 
=== modified file 'src/ubuntu/ubuntuabstractguieditordocument.h'
--- src/ubuntu/ubuntuabstractguieditordocument.h	2016-07-22 10:17:50 +0000
+++ src/ubuntu/ubuntuabstractguieditordocument.h	2016-08-24 15:35:12 +0000
@@ -33,10 +33,6 @@
 public:
     UbuntuAbstractGuiEditorDocument(const QString &mimeType, UbuntuAbstractGuiEditorWidget *editorWidget);
     bool save(QString *errorString, const QString &fileName = QString(), bool autoSave = false) override;
-
-    QString defaultPath() const override;
-    QString suggestedFileName() const override;
-
     bool isModified() const override;
     bool isSaveAsAllowed() const override;
 private:
 
=== modified file 'src/ubuntu/ubuntuclickdialog.cpp'
--- src/ubuntu/ubuntuclickdialog.cpp	2016-05-17 16:33:36 +0000
+++ src/ubuntu/ubuntuclickdialog.cpp	2016-08-24 15:35:12 +0000
@@ -113,7 +113,7 @@
     int code = runProcessModal(paramList);
     if(mode == UbuntuClickTool::Delete) {
         //redetect documentation
-        QtSupport::QtVersionManager::delayedInitialize();
+        QtSupport::QtVersionManager::triggerDocumentationUpdate();
     }
     return code;
 }
 
=== modified file 'src/ubuntu/ubuntuclicktool.cpp'
--- src/ubuntu/ubuntuclicktool.cpp	2016-07-12 08:47:56 +0000
+++ src/ubuntu/ubuntuclicktool.cpp	2016-08-24 15:35:12 +0000
@@ -105,7 +105,7 @@
                                                                          const QMap<QString, QString> &envMap)
 {
     ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(target);
-    if (!tc || tc->type() != QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)) {
+    if (!tc || tc->typeId() != Constants::UBUNTU_CLICK_TOOLCHAIN_ID) {
         ProjectExplorer::ProcessParameters p;
         p.setArguments(Utils::QtcProcess::joinArgs(args));
         p.setCommand(cmd);
@@ -253,6 +253,10 @@
 
 QString UbuntuClickTool::targetBasePath(const UbuntuClickTool::Target &target)
 {
+    static QMap<QString, QString> basePathCache;
+    if (basePathCache.contains(target.containerName))
+        return basePathCache.value(target.containerName);
+
     QProcess sdkTool;
     sdkTool.setReadChannel(QProcess::StandardOutput);
     sdkTool.setProgram(Constants::UBUNTU_TARGET_TOOL);
@@ -264,7 +268,9 @@
         return QString();
 
     QTextStream in(&sdkTool);
-    return in.readAll().trimmed();
+    QString basePath = in.readAll().trimmed();
+    basePathCache.insert(target.containerName, basePath);
+    return basePath;
 }
 
 bool UbuntuClickTool::parseContainerName(const QString &name, UbuntuClickTool::Target *target, QStringList *allExt)
@@ -292,9 +298,14 @@
  */
 bool UbuntuClickTool::targetExists(const UbuntuClickTool::Target &target)
 {
+    return targetExists(target.containerName);
+}
+
+bool UbuntuClickTool::targetExists(const QString &targetName)
+{
     QProcess proc;
     proc.start(Constants::UBUNTU_TARGET_TOOL,
-               QStringList()<<QStringLiteral("exists")<<target.containerName);
+               QStringList()<<QStringLiteral("exists")<<targetName);
     if(!proc.waitForFinished(3000)) {
         qWarning()<<"usdk-target did not return in time.";
         return false;
@@ -394,7 +405,7 @@
         return nullptr;
 
     ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(t->kit());
-    if(!tc || (tc->type() != QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)))
+    if(!tc || (tc->typeId() != Constants::UBUNTU_CLICK_TOOLCHAIN_ID))
         return nullptr;
 
     Internal::ClickToolChain *clickTc = static_cast<Internal::ClickToolChain*>(tc);
@@ -460,13 +471,13 @@
     return UbuntuClickTool::findOrCreateToolWrapper(QStringLiteral("make"),target);
 }
 
-QString UbuntuClickTool::mapIncludePathsForCMake(ProjectExplorer::Kit *k, const QString &in)
+QString UbuntuClickTool::mapIncludePathsForCMake(const ProjectExplorer::Kit *k, const QString &in)
 {
     if (in.isEmpty())
         return in;
 
     bool canMap = ProjectExplorer::ToolChainKitInformation::toolChain(k)
-            && ProjectExplorer::ToolChainKitInformation::toolChain(k)->type() == QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)
+            && ProjectExplorer::ToolChainKitInformation::toolChain(k)->typeId() == Constants::UBUNTU_CLICK_TOOLCHAIN_ID
             && !ProjectExplorer::SysRootKitInformation::sysRoot(k).isEmpty();
 
     if (!canMap)
 
=== modified file 'src/ubuntu/ubuntuclicktool.h'
--- src/ubuntu/ubuntuclicktool.h	2016-07-12 08:47:56 +0000
+++ src/ubuntu/ubuntuclicktool.h	2016-08-24 15:35:12 +0000
@@ -25,6 +25,7 @@
 #include <QFutureInterface>
 #include <QQueue>
 #include <projectexplorer/processparameters.h>
+#include <cmakeprojectmanager/cmaketool.h>
 #include <utils/qtcprocess.h>
 #include <QDebug>
 
@@ -85,11 +86,12 @@
     static QString findOrCreateToolWrapper(const QString &tool, const UbuntuClickTool::Target &target);
     static QString findOrCreateQMakeWrapper(const UbuntuClickTool::Target &target);
     static QString findOrCreateMakeWrapper(const UbuntuClickTool::Target &target);
-    static QString mapIncludePathsForCMake(ProjectExplorer::Kit *k, const QString &in);
+    static QString mapIncludePathsForCMake(const ProjectExplorer::Kit *k, const QString &in);
     static QString hostArchitecture ();
     static bool    compatibleWithHostArchitecture (const QString &targetArch);
 
     static bool          targetExists (const Target& target);
+    static bool          targetExists (const QString& targetName);
     static QList<Target> listAvailableTargets (const QString &framework=QString());
     static QList<Target> listPossibleDeviceContainers ();
     static const Target *clickTargetFromTarget(ProjectExplorer::Target *t);
 
=== modified file 'src/ubuntu/ubuntucmakecache.cpp'
--- src/ubuntu/ubuntucmakecache.cpp	2014-11-14 11:12:31 +0000
+++ src/ubuntu/ubuntucmakecache.cpp	2016-08-24 15:35:12 +0000
@@ -8,6 +8,7 @@
 
 #include <QRegularExpression>
 #include <QDir>
+#include <QDebug>
 
 namespace Ubuntu{
 namespace Internal {
 
=== modified file 'src/ubuntu/ubuntuconstants.h'
--- src/ubuntu/ubuntuconstants.h	2016-07-06 09:18:16 +0000
+++ src/ubuntu/ubuntuconstants.h	2016-08-24 15:35:12 +0000
@@ -251,6 +251,7 @@
 
 const char  UBUNTU_ICON[] = ":/ubuntu/images/ubuntu-32.png";
 
+/*
 const char  FEATURE_UNITY_SCOPE[] = "Ubuntu.Wizards.FeatureUnityScope";
 const char  FEATURE_UBUNTU_PRECISE[] = "Ubuntu.Wizards.FeatureUbuntuPrecise";
 const char  FEATURE_UBUNTU_QUANTAL[] = "Ubuntu.Wizards.FeatureUbuntuQuantal";
@@ -274,6 +275,7 @@
 
 const char  PLATFORM_DESKTOP[] = "Desktop";
 const char  PLATFORM_DESKTOP_DISPLAYNAME[] = "Ubuntu %0";
+*/
 
 const char  TASK_DEVICE_SCRIPT[] = "Ubuntu.Task.DeviceScript";
 
 
=== modified file 'src/ubuntu/ubuntudevicemode.cpp'
--- src/ubuntu/ubuntudevicemode.cpp	2015-06-19 07:13:13 +0000
+++ src/ubuntu/ubuntudevicemode.cpp	2016-08-24 15:35:12 +0000
@@ -85,7 +85,6 @@
     m_modeView->rootContext()->setContextProperty(QLatin1String("resourceRoot") ,Constants::UBUNTU_DEVICESCREEN_ROOT);
     m_modeView->setSource(QUrl::fromLocalFile(Constants::UBUNTU_DEVICESCREEN_QML));
 
-    connect(Core::ModeManager::instance(), SIGNAL(currentModeChanged(Core::IMode*)), SLOT(modeChanged(Core::IMode*)));
     setWidget(m_modeWidget);
 }
 
@@ -113,11 +112,6 @@
     m_qmlControl->showAddEmulatorDialog();
 }
 
-void UbuntuDeviceMode::modeChanged(Core::IMode *mode)
-{
-    Q_UNUSED(mode);
-}
-
 void UbuntuDeviceMode::initialize() {
 
 }
 
=== modified file 'src/ubuntu/ubuntudevicemode.h'
--- src/ubuntu/ubuntudevicemode.h	2016-03-29 09:41:07 +0000
+++ src/ubuntu/ubuntudevicemode.h	2016-08-24 15:35:12 +0000
@@ -73,9 +73,6 @@
 signals:
     void updateDeviceActions ();
 
-protected slots:
-    void modeChanged(Core::IMode*);
-
 protected:
     static UbuntuDeviceMode *m_instance;
     UbuntuDevicesModel  *m_devicesModel;
 
=== modified file 'src/ubuntu/ubuntudevicesmodel.cpp'
--- src/ubuntu/ubuntudevicesmodel.cpp	2015-11-11 14:50:13 +0000
+++ src/ubuntu/ubuntudevicesmodel.cpp	2016-08-24 15:35:12 +0000
@@ -209,7 +209,7 @@
         case Qt::EditRole:
             return m_knownDevices[index.row()]->device()->displayName();
         case UniqueIdRole:
-            return m_knownDevices[index.row()]->id().uniqueIdentifier();
+            return qVariantFromValue(m_knownDevices[index.row()]->id());
         case DetectionStateRole:
             return m_knownDevices[index.row()]->device()->detectionState();
         case DetectionStateStringRole:
@@ -294,62 +294,62 @@
     return QAbstractListModel::flags(index) | Qt::ItemIsEditable;
 }
 
-void UbuntuDevicesModel::triggerPortForwarding(const int devId)
+void UbuntuDevicesModel::triggerPortForwarding(const QVariant &devId)
 {
-    int row = findDevice(devId);
+    int row = findDevice(devId.value<Core::Id>());
     if(row < 0)
         return;
     m_knownDevices[row]->device()->enablePortForward();
 }
 
-void UbuntuDevicesModel::triggerSSHSetup(const int devId)
+void UbuntuDevicesModel::triggerSSHSetup(const QVariant &devId)
 {
-    int row = findDevice(devId);
+    int row = findDevice(devId.value<Core::Id>());
     if(row < 0)
         return;
     m_knownDevices[row]->device()->deployPublicKey();
 }
 
-void UbuntuDevicesModel::triggerSSHConnection(const int devId)
+void UbuntuDevicesModel::triggerSSHConnection(const QVariant &devId)
 {
-    int row = findDevice(devId);
+    int row = findDevice(devId.value<Core::Id>());
     if(row < 0)
         return;
     m_knownDevices[row]->device()->openTerminal();
 }
 
-void UbuntuDevicesModel::triggerKitAutocreate(const int devId)
+void UbuntuDevicesModel::triggerKitAutocreate(const QVariant &devId)
 {
-    int row = findDevice(devId);
+    int row = findDevice(devId.value<Core::Id>());
     if(row < 0)
         return;
     UbuntuKitManager::autoCreateKit(m_knownDevices[row]->device());
 }
 
-void UbuntuDevicesModel::triggerKitRemove(const int devId, const QVariant &kitid)
+void UbuntuDevicesModel::triggerKitRemove(const QVariant &devId, const QVariant &kitid)
 {
-    int row = findDevice(devId);
+    int row = findDevice(devId.value<Core::Id>());
     if(row < 0)
         return;
 
     ProjectExplorer::Kit* k = ProjectExplorer::KitManager::find(Core::Id::fromSetting(kitid));
-    if(ProjectExplorer::DeviceKitInformation::deviceId(k) == Core::Id::fromUniqueIdentifier(devId)) {
+    if(ProjectExplorer::DeviceKitInformation::deviceId(k) == devId.value<Core::Id>()) {
         //completely delete the kit
         ProjectExplorer::KitManager::deregisterKit(k);
     }
 }
 
-void UbuntuDevicesModel::triggerRedetect(const int devId)
+void UbuntuDevicesModel::triggerRedetect(const QVariant &devId)
 {
-    int row = findDevice(devId);
+    int row = findDevice(devId.value<Core::Id>());
     if(row < 0)
         return;
     m_knownDevices[row]->device()->helper()->refresh();
 }
 
-void UbuntuDevicesModel::deleteDevice(const int devId)
+void UbuntuDevicesModel::deleteDevice(const QVariant &devId)
 {
-    int index = findDevice(devId);
+    int index = findDevice(devId.value<Core::Id>());
     if(index < 0) {
         QMessageBox::critical(Core::ICore::mainWindow(),tr("Could not delete device"),tr("The device ID is unknown, please press the refresh button and try again."));
         return;
@@ -374,18 +374,18 @@
     }
 }
 
-int UbuntuDevicesModel::findDevice(int uniqueIdentifier) const
+int UbuntuDevicesModel::findDevice(const Core::Id &devId) const
 {
     for ( int i = 0; i < m_knownDevices.size(); i++ ) {
-        if(m_knownDevices[i]->id().uniqueIdentifier() == uniqueIdentifier)
+        if(m_knownDevices[i]->id() == devId)
             return i;
     }
     return -1;
 }
 
-bool UbuntuDevicesModel::hasDevice(int uniqueIdentifier) const
+bool UbuntuDevicesModel::hasDevice(const Core::Id &devId) const
 {
-    return findDevice(uniqueIdentifier) >= 0;
+    return findDevice(devId) >= 0;
 }
 
 UbuntuDevice::ConstPtr UbuntuDevicesModel::device(const int index)
@@ -415,7 +415,7 @@
 {
     UbuntuDevicesItem* hlpr = qobject_cast<UbuntuDevicesItem*>(possibleHelper);
     if(!hlpr) return -1;
-    return findDevice(hlpr->id().uniqueIdentifier());
+    return findDevice(hlpr->id());
 }
 
 void UbuntuDevicesModel::deviceChanged(QObject *possibleHelper, const QVector<int> &relatedRoles)
@@ -529,7 +529,7 @@
 
     if(debug) qDebug()<<"Device Manager reports device added: "<<id.toString();
 
-    if (hasDevice(id.uniqueIdentifier()))
+    if (hasDevice(id))
         return;
 
     Ubuntu::Internal::UbuntuDevice::ConstPtr ubuntuDev
@@ -550,7 +550,7 @@
  */
 void UbuntuDevicesModel::deviceRemoved(const Core::Id &id)
 {
-    int index = findDevice(id.uniqueIdentifier());
+    int index = findDevice(id);
     if(index < 0)
         return;
 
@@ -573,7 +573,7 @@
             << Qt::DisplayRole << Qt::EditRole
             << ConnectionStateRole << ConnectionStateStringRole;
 
-    int index = findDevice(id.uniqueIdentifier());
+    int index = findDevice(id);
     if(index >= 0) {
         QModelIndex changed = createIndex(index,0);
         emit dataChanged(changed, changed,relatedRoles);
@@ -582,7 +582,7 @@
 
 void UbuntuDevicesModel::deviceConnected(const QString &id)
 {
-    int idx = findDevice(Core::Id::fromSetting(id).uniqueIdentifier());
+    int idx = findDevice(Core::Id::fromSetting(id));
     if(idx >= 0)
         return;
 
@@ -599,7 +599,7 @@
  */
 void UbuntuDevicesModel::registerNewDevice(const QString &serial, const QString &arch)
 {
-    if(findDevice(Core::Id::fromSetting(serial).uniqueIdentifier()) >= 0)
+    if(findDevice(Core::Id::fromSetting(serial)) >= 0)
         return;
 
     if(!ClickToolChain::supportedArchitectures().contains(arch)) {
@@ -650,30 +650,24 @@
     switch(m_state) {
         case CheckEmulatorInstalled: {
             return tr("Checking if emulator tool is installed");
-            break;
         }
         case InstallEmulator: {
             return tr("Installing emulator tool");
-            break;
         }
         case CreateEmulatorImage: {
             return tr("Creating emulator image");
-            break;
         }
         case ReadFromSettings:{
             return tr("Reading settings");
         }
         case FindImages:{
             return tr("Searching for emulator images");
-            break;
         }
         case AdbList:{
             return tr("Querying ADB");
-            break;
         }
         default:
             return QString();
-            break;
     }
 }
 
@@ -816,7 +810,7 @@
 
 void UbuntuDevicesModel::startEmulator(const QString &name)
 {
-    int idx = findDevice(Core::Id::fromSetting(name).uniqueIdentifier());
+    int idx = findDevice(Core::Id::fromSetting(name));
     if(idx < 0)
         return;
 
@@ -828,7 +822,7 @@
 
 void UbuntuDevicesModel::stopEmulator(const QString &name)
 {
-    int idx = findDevice(Core::Id::fromSetting(name).uniqueIdentifier());
+    int idx = findDevice(Core::Id::fromSetting(name));
     if(idx < 0)
         return;
 
@@ -841,7 +835,7 @@
 
 void UbuntuDevicesModel::deleteEmulator(const QString &name)
 {
-    int index = findDevice(Core::Id::fromSetting(name).uniqueIdentifier());
+    int index = findDevice(Core::Id::fromSetting(name));
     if(index < 0)
         return;
 
@@ -865,7 +859,9 @@
 QVariant UbuntuDevicesModel::validateEmulatorName(const QString &name)
 {
     QString error;
-    bool result = Utils::ProjectIntroPage::validateProjectName(name,&error);
+
+    QRegularExpression exp(QStringLiteral("^[a-zA-Z][a-zA-Z0-9]+"));
+    bool result = exp.match(name).hasMatch();
 
     if(result) {
         foreach (UbuntuDevicesItem *item, m_knownDevices) {
@@ -877,6 +873,8 @@
                 }
             }
         }
+    } else {
+        error = tr("Emulator names can only contain letters and numbers.");
     }
 
     QVariantMap m;
@@ -966,10 +964,10 @@
         case FindImages: {
             QStringList lines = m_reply.trimmed().split(QLatin1String(Constants::LINEFEED));
 
-            QSet<int> notFoundImages;
+            QSet<Core::Id> notFoundImages;
             foreach(UbuntuDevicesItem *item, m_knownDevices) {
                 if(item->device()->machineType() == ProjectExplorer::IDevice::Emulator)
-                    notFoundImages.insert(item->device()->id().uniqueIdentifier());
+                    notFoundImages.insert(item->device()->id());
             }
 
             QMutableStringListIterator iter(lines);
@@ -1021,10 +1019,10 @@
                 bool addToManager = false;
                 Ubuntu::Internal::UbuntuDevice::Ptr dev;
                 Core::Id devId = Core::Id::fromSetting(deviceSerial);
-                int index = findDevice(devId.uniqueIdentifier());
+                int index = findDevice(devId);
 
                 if(index >= 0) {
-                    notFoundImages.remove(devId.uniqueIdentifier());
+                    notFoundImages.remove(devId);
                     dev = m_knownDevices[index]->device();
                 } else {
                     dev = Ubuntu::Internal::UbuntuDevice::create(
@@ -1046,8 +1044,12 @@
             }
 
             //remove all ubuntu emulators that are in the settings but don't exist in the system
-            foreach(int curr,notFoundImages) {
-                ProjectExplorer::DeviceManager::instance()->removeDevice(Core::Id::fromUniqueIdentifier(curr));
+            foreach(const Core::Id &curr,notFoundImages) {
+                int row = findDevice(curr);
+                if (row < 0 || row >= rowCount())
+                    continue;
+
+                ProjectExplorer::DeviceManager::instance()->removeDevice(m_knownDevices.at(row)->id());
             }
 
             queryAdb();
@@ -1069,7 +1071,7 @@
                     continue;
                 }
 
-                QRegularExpression exp(QLatin1String(Constants::UBUNTUDEVICESWIDGET_ONFINISHED_ADB_REGEX));
+                QRegularExpression exp((QLatin1String(Constants::UBUNTUDEVICESWIDGET_ONFINISHED_ADB_REGEX)));
                 QRegularExpressionMatch match = exp.match(line);
 
                 if(match.hasMatch()) {
@@ -1231,4 +1233,3 @@
 
 }
 }
-
 
=== modified file 'src/ubuntu/ubuntudevicesmodel.h'
--- src/ubuntu/ubuntudevicesmodel.h	2016-07-22 10:17:50 +0000
+++ src/ubuntu/ubuntudevicesmodel.h	2016-08-24 15:35:12 +0000
@@ -88,8 +88,8 @@
 
     Q_INVOKABLE bool set(int index, const QString &role, const QVariant &value);
 
-    int findDevice(int uniqueIdentifier) const;
-    bool hasDevice (int uniqueIdentifier) const;
+    int findDevice(const Core::Id &devId) const;
+    bool hasDevice (const Core::Id &devId) const;
     UbuntuDevice::ConstPtr device ( const int index );
 
     // QAbstractItemModel interface
@@ -116,13 +116,13 @@
     void stateChanged(QString arg);
 
 public slots:
-    void triggerPortForwarding  ( const int devId );
-    void triggerSSHSetup        ( const int devId );
-    void triggerSSHConnection   ( const int devId );
-    void triggerKitAutocreate   ( const int devId );
-    void triggerKitRemove       ( const int devId, const QVariant &kitid );
-    void triggerRedetect        ( const int devId );
-    void deleteDevice           ( const int devId );
+    void triggerPortForwarding  ( const QVariant &devId );
+    void triggerSSHSetup        ( const QVariant &devId );
+    void triggerSSHConnection   ( const QVariant &devId );
+    void triggerKitAutocreate   ( const QVariant &devId );
+    void triggerKitRemove       ( const QVariant &devId, const QVariant &kitid );
+    void triggerRedetect        ( const QVariant &devId );
+    void deleteDevice           ( const QVariant &devId );
     void createEmulatorImage    ( const QString &name, const QString &arch, const QString &channel, const QString &passwd );
     void startEmulator          ( const QString &name );
     void stopEmulator           ( const QString &name );
 
=== modified file 'src/ubuntu/ubuntufixmanifeststep.cpp'
--- src/ubuntu/ubuntufixmanifeststep.cpp	2015-02-16 12:27:25 +0000
+++ src/ubuntu/ubuntufixmanifeststep.cpp	2016-08-24 15:35:12 +0000
@@ -42,8 +42,9 @@
     m_packageDir = packageDir;
 }
 
-bool UbuntuFixManifestStep::init()
+bool UbuntuFixManifestStep::init(QList<const BuildStep *> &earlierSteps)
 {
+    Q_UNUSED(earlierSteps);
     return true;
 }
 
 
=== modified file 'src/ubuntu/ubuntufixmanifeststep.h'
--- src/ubuntu/ubuntufixmanifeststep.h	2016-07-22 10:17:50 +0000
+++ src/ubuntu/ubuntufixmanifeststep.h	2016-08-24 15:35:12 +0000
@@ -18,7 +18,7 @@
     void setPackageDir(const QString &packageDir);
 
     // BuildStep interface
-    virtual bool init() override;
+    virtual bool init(QList<const BuildStep *> &earlierSteps) override;
     virtual void run(QFutureInterface<bool> &fi) override;
     virtual ProjectExplorer::BuildStepConfigWidget *createConfigWidget() override;
 
 
=== modified file 'src/ubuntu/ubuntuhtmlbuildconfiguration.cpp'
--- src/ubuntu/ubuntuhtmlbuildconfiguration.cpp	2015-04-28 14:32:58 +0000
+++ src/ubuntu/ubuntuhtmlbuildconfiguration.cpp	2016-08-24 15:35:12 +0000
@@ -162,7 +162,8 @@
     QList<ProjectExplorer::BuildInfo *> builds;
 
     ProjectExplorer::BuildInfo *info = new ProjectExplorer::BuildInfo(this);
-    info->buildDirectory = Utils::FileName::fromString(UbuntuProject::shadowBuildDirectory(projectDir,k,QStringLiteral("default")));
+    QString sBd = UbuntuProject::shadowBuildDirectory(projectDir,k,QStringLiteral("default"), ProjectExplorer::BuildConfiguration::Unknown);
+    info->buildDirectory = Utils::FileName::fromString(sBd);
     info->typeName = tr("Html5");
     info->kitId    = k->id();
     info->displayName = tr("Default");
 
=== modified file 'src/ubuntu/ubuntukitmanager.cpp'
--- src/ubuntu/ubuntukitmanager.cpp	2016-05-17 16:33:36 +0000
+++ src/ubuntu/ubuntukitmanager.cpp	2016-08-24 15:35:12 +0000
@@ -20,7 +20,9 @@
 #include <qtsupport/qtkitinformation.h>
 
 #include <cmakeprojectmanager/cmaketoolmanager.h>
+#include <cmakeprojectmanager/cmaketool.h>
 #include <cmakeprojectmanager/cmakekitinformation.h>
+#include <cmakeprojectmanager/cmakeconfigitem.h>
 #include <qtsupport/qtversionmanager.h>
 
 #include <QMessageBox>
@@ -86,7 +88,7 @@
         if(tc) {
             if (!tc->isAutoDetected())
                 continue;
-            if (tc->type() != QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID))
+            if (tc->typeId() != Constants::UBUNTU_CLICK_TOOLCHAIN_ID)
                 continue;
             toolchains << static_cast<ClickToolChain *>(tc);
         }
@@ -101,7 +103,7 @@
         if (!tc)
             return false;
 
-        if (tc->type() != QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID))
+        if (tc->typeId() != Constants::UBUNTU_CLICK_TOOLCHAIN_ID)
             return false;
 
         ClickToolChain *cTc = static_cast<ClickToolChain *>(tc);
@@ -127,7 +129,7 @@
         }
     }
 
-    UbuntuQtVersion *qtVersion = new UbuntuQtVersion(Utils::FileName::fromString(qmakePath),false);
+    UbuntuQtVersion *qtVersion = new UbuntuQtVersion(tc->clickTarget().containerName, Utils::FileName::fromString(qmakePath),false);
     QtSupport::QtVersionManager::addVersion(qtVersion);
     return qtVersion;
 }
@@ -159,7 +161,8 @@
 {
     QString cmakePathStr = UbuntuClickTool::findOrCreateToolWrapper(QStringLiteral("cmake"), target);
     Utils::FileName cmakePath = Utils::FileName::fromString(cmakePathStr);
-    CMakeProjectManager::CMakeTool *cmake = new CMakeProjectManager::CMakeTool(CMakeProjectManager::CMakeTool::AutoDetection);
+    CMakeProjectManager::CMakeTool *cmake = new CMakeProjectManager::CMakeTool(CMakeProjectManager::CMakeTool::AutoDetection,
+                                                                               CMakeProjectManager::CMakeTool::createId());
 
     cmake->setCMakeExecutable(cmakePath);
     cmake->setDisplayName(tr("Ubuntu SDK cmake (%1-%2-%3)")
@@ -322,7 +325,7 @@
             continue;
 
         ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(k);
-        if (tc && tc->type() != QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID))
+        if (tc && tc->typeId() != Constants::UBUNTU_CLICK_TOOLCHAIN_ID)
             continue;
 
         //@TODO check for ubuntu device information
@@ -364,7 +367,7 @@
     foreach (ProjectExplorer::Kit *k, existingKits) {
         ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(k);
         CMakeProjectManager::CMakeTool* cmake = CMakeProjectManager::CMakeKitInformation::cmakeTool(k);
-        if (tc && tc->type() == QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)
+        if (tc && tc->typeId() == Constants::UBUNTU_CLICK_TOOLCHAIN_ID
                 && cmake
                 && cmake->isValid()) {
             fixKit(k);
@@ -562,13 +565,20 @@
     k->setMutable(ProjectExplorer::SysRootKitInformation::id(),false);
 
     //make sure we use a ubuntu Qt version
-    QtSupport::QtKitInformation::setQtVersion(k, createOrFindQtVersion(tc));
+    UbuntuQtVersion *qtVer = createOrFindQtVersion(tc);
+    QtSupport::QtKitInformation::setQtVersion(k, qtVer);
 
     //make sure we use a ubuntu cmake
     CMakeProjectManager::CMakeTool *cmake = createOrFindCMakeTool(tc);
     if(cmake) {
+        CMakeProjectManager::CMakeConfig  conf{
+            CMakeProjectManager::CMakeConfigItem("QT_QMAKE_EXECUTABLE",  qtVer->remoteQMakeCommand().toUtf8()),
+            CMakeProjectManager::CMakeConfigItem("CMAKE_CXX_COMPILER",  tc->remoteCompilerCommand().toUtf8())
+        };
+
         cmake->setPathMapper(&UbuntuClickTool::mapIncludePathsForCMake);
         CMakeProjectManager::CMakeKitInformation::setCMakeTool(k, cmake->id());
+        CMakeProjectManager::CMakeConfigurationKitInformation::setConfiguration(k , conf);
     }
 
 }
 
=== modified file 'src/ubuntu/ubuntumenu.cpp'
--- src/ubuntu/ubuntumenu.cpp	2016-03-29 09:41:07 +0000
+++ src/ubuntu/ubuntumenu.cpp	2016-08-24 15:35:12 +0000
@@ -116,7 +116,7 @@
         isClickTarget = startupProject->activeTarget()
                 && startupProject->activeTarget()->kit()
                 && ProjectExplorer::ToolChainKitInformation::toolChain(startupProject->activeTarget()->kit())
-                && ProjectExplorer::ToolChainKitInformation::toolChain(startupProject->activeTarget()->kit())->type() == QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID);
+                && ProjectExplorer::ToolChainKitInformation::toolChain(startupProject->activeTarget()->kit())->typeId() == Constants::UBUNTU_CLICK_TOOLCHAIN_ID;
     }
 
     //bool canRun = projectExplorerInstance->canRun(startupProject,ProjectExplorer::NormalRunMode);
 
=== modified file 'src/ubuntu/ubuntupackagestep.cpp'
--- src/ubuntu/ubuntupackagestep.cpp	2015-11-27 10:06:33 +0000
+++ src/ubuntu/ubuntupackagestep.cpp	2016-08-24 15:35:12 +0000
@@ -77,8 +77,9 @@
     cleanup();
 }
 
-bool UbuntuPackageStep::init()
+bool UbuntuPackageStep::init(QList<const BuildStep *> &earlierSteps)
 {
+    Q_UNUSED(earlierSteps);
     //initialization happens in internalInit,
     //because it requires informations that are only available at this
     //time
@@ -277,8 +278,9 @@
         }
         emit addOutput(tr("Configuration is invalid. Aborting build")
                        ,ProjectExplorer::BuildStep::MessageOutput);
-        fi.reportResult(false);
-        emit finished();
+
+        reportRunResult(fi, false);
+        cleanup();
         return;
     }
 
@@ -487,9 +489,9 @@
 
     //the process failed, lets clean up
     if (!success) {
-        m_futureInterface->reportResult(false);
+        if(m_futureInterface)
+            reportRunResult(*m_futureInterface, false);
         cleanup();
-        emit finished();
     }
     return success;
 }
@@ -572,9 +574,9 @@
                            .arg(m_deployDir),
                            BuildStep::ErrorMessageOutput);
 
-            m_futureInterface->reportResult(false);
+            if(m_futureInterface)
+                reportRunResult(*m_futureInterface, false);
             cleanup();
-            emit finished();
             return;
         }
 
@@ -584,9 +586,9 @@
                            .arg(err),
                            BuildStep::ErrorMessageOutput);
 
-            m_futureInterface->reportResult(false);
+            if(m_futureInterface)
+                reportRunResult(*m_futureInterface, false);
             cleanup();
-            emit finished();
             return;
         }
 
@@ -623,7 +625,7 @@
                     continue;
 
                 ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit());
-                if(!tc || tc->type() != QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)) {
+                if(!tc || tc->typeId() != Constants::UBUNTU_CLICK_TOOLCHAIN_ID) {
                     qWarning()<<"Incompatible Toolchain for hook"<<hook.appId;
                     continue;
                 }
@@ -745,9 +747,9 @@
 
             if (m_packageMode == OnlyMakeInstall) {
 
-                m_futureInterface->reportResult(true);
+                if(m_futureInterface)
+                    reportRunResult(*m_futureInterface, true);
                 cleanup();
-                emit finished();
 
                 return;
             }
@@ -772,7 +774,7 @@
             if (!processFinished())
                 return;
 
-            QRegularExpression exp(QLatin1String(Constants::UBUNTU_CLICK_SUCCESS_PACKAGE_REGEX));
+            QRegularExpression exp((QLatin1String(Constants::UBUNTU_CLICK_SUCCESS_PACKAGE_REGEX)));
             QRegularExpressionMatch m = exp.match(m_lastLine);
             if(m.hasMatch()) {
                 m_clickPackageName = m.captured(1);
@@ -794,9 +796,9 @@
             if (!processFinished(IgnoreReturnCode))
                 return;
 
-            m_futureInterface->reportResult(true);
+            if(m_futureInterface)
+                reportRunResult(*m_futureInterface, true);
             cleanup();
-            emit finished();
         }
 
         default:
@@ -824,7 +826,8 @@
 
 void UbuntuPackageStep::onProcessFailedToStart()
 {
-    m_futureInterface->reportResult(false);
+    if(m_futureInterface)
+        reportRunResult(*m_futureInterface, false);
 
     ProjectExplorer::ProcessParameters *params;
     if (m_state == MakeInstall)
@@ -837,7 +840,6 @@
                         params->prettyArguments()),
                    BuildStep::ErrorMessageOutput);
 
-    emit finished();
     cleanup();
 
 }
 
=== modified file 'src/ubuntu/ubuntupackagestep.h'
--- src/ubuntu/ubuntupackagestep.h	2015-07-08 15:38:37 +0000
+++ src/ubuntu/ubuntupackagestep.h	2016-08-24 15:35:12 +0000
@@ -55,7 +55,7 @@
 
 public:
     // BuildStep interface
-    virtual bool init() override;
+    virtual bool init(QList<const ProjectExplorer::BuildStep *> &earlierSteps) override;
     virtual void run(QFutureInterface<bool> &fi) override;
     virtual ProjectExplorer::BuildStepConfigWidget *createConfigWidget() override;
     virtual bool immutable() const override;
 
=== modified file 'src/ubuntu/ubuntupackagingmode.cpp'
--- src/ubuntu/ubuntupackagingmode.cpp	2015-03-03 17:23:52 +0000
+++ src/ubuntu/ubuntupackagingmode.cpp	2016-08-24 15:35:12 +0000
@@ -80,8 +80,6 @@
     m_modeView->rootContext()->setContextProperty(QLatin1String("resourceRoot") ,Constants::UBUNTU_DEVICESCREEN_ROOT);
     m_modeView->setSource(QUrl::fromLocalFile(Constants::UBUNTU_PUBLISHSCREEN_QML));
 
-    connect(Core::ModeManager::instance(), SIGNAL(currentModeChanged(Core::IMode*)), SLOT(modeChanged(Core::IMode*)));
-
     QObject* sessionManager = ProjectExplorer::SessionManager::instance();
     connect(sessionManager,SIGNAL(projectAdded(ProjectExplorer::Project*)),SLOT(on_projectAdded(ProjectExplorer::Project*)));
     connect(sessionManager,SIGNAL(projectRemoved(ProjectExplorer::Project*)),SLOT(on_projectRemoved(ProjectExplorer::Project*)));
@@ -95,10 +93,6 @@
 
 }
 
-void UbuntuPackagingMode::modeChanged(Core::IMode* currentMode) {
-    previousMode = currentMode->id();
-}
-
 void UbuntuPackagingMode::updateModeState() {
     ProjectExplorer::Project* startupProject = ProjectExplorer::SessionManager::startupProject();
 
 
=== modified file 'src/ubuntu/ubuntupackagingmode.h'
--- src/ubuntu/ubuntupackagingmode.h	2015-01-29 07:49:13 +0000
+++ src/ubuntu/ubuntupackagingmode.h	2016-08-24 15:35:12 +0000
@@ -40,15 +40,12 @@
     void initialize();
 
 protected slots:
-    void modeChanged(Core::IMode*);
-
     void on_projectAdded(ProjectExplorer::Project *project);
     void on_projectRemoved(ProjectExplorer::Project *project);
     void updateModeState();
 
 protected:
     QWidget* m_modeWidget;
-    Core::Id previousMode;
 
 private:
     static UbuntuPackagingMode* m_instance;
 
=== modified file 'src/ubuntu/ubuntupackagingmodel.cpp'
--- src/ubuntu/ubuntupackagingmodel.cpp	2016-07-06 09:18:16 +0000
+++ src/ubuntu/ubuntupackagingmodel.cpp	2016-08-24 15:35:12 +0000
@@ -404,7 +404,7 @@
             p->activeTarget() &&
             p->activeTarget()->kit() &&
             ProjectExplorer::ToolChainKitInformation::toolChain(p->activeTarget()->kit()) &&
-            (ProjectExplorer::ToolChainKitInformation::toolChain(p->activeTarget()->kit())->type() == QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)
+            (ProjectExplorer::ToolChainKitInformation::toolChain(p->activeTarget()->kit())->typeId() == Constants::UBUNTU_CLICK_TOOLCHAIN_ID
              ||  p->projectManager()->mimeType() == QLatin1String(QmakeProjectManager::Constants::PROFILE_MIMETYPE));
 
     setCanBuild(buildButtonsEnabled);
@@ -467,7 +467,7 @@
                 m_packageBuildSteps.append(QSharedPointer<ProjectExplorer::BuildStepList> (new ProjectExplorer::BuildStepList(b,ProjectExplorer::Constants::BUILDSTEPS_BUILD)));
 
                 ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(b->target()->kit());
-                if(tc && tc->type() == QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)){
+                if(tc && tc->typeId() == Constants::UBUNTU_CLICK_TOOLCHAIN_ID){
                     ClickToolChain *cTc = static_cast<ClickToolChain *>(tc);
                     usedArchitectures << cTc->clickTarget().architecture;
                 }
 
=== modified file 'src/ubuntu/ubuntuplugin.cpp'
--- src/ubuntu/ubuntuplugin.cpp	2016-07-07 09:11:32 +0000
+++ src/ubuntu/ubuntuplugin.cpp	2016-08-24 15:35:12 +0000
@@ -161,8 +161,8 @@
     addAutoReleasedObject(new UbuntuSettingsProjectDefaultsPage);
     addAutoReleasedObject(new UbuntuSettingsDeviceConnectivityPage);
 
-    addAutoReleasedObject(new UbuntuVersionManager);
-    Core::IWizardFactory::registerFeatureProvider(new UbuntuFeatureProvider);
+    //addAutoReleasedObject(new UbuntuVersionManager);
+    //Core::IWizardFactory::registerFeatureProvider(new UbuntuFeatureProvider);
 
     // welcome page plugin
     addAutoReleasedObject(new UbuntuWelcomePage);
 
=== modified file 'src/ubuntu/ubuntuplugin.h'
--- src/ubuntu/ubuntuplugin.h	2016-05-30 08:28:41 +0000
+++ src/ubuntu/ubuntuplugin.h	2016-08-24 15:35:12 +0000
@@ -24,7 +24,6 @@
 #include "ubuntudevicemode.h"
 #include "ubuntumenu.h"
 #include "ubuntuprojectmanager.h"
-#include "ubuntufeatureprovider.h"
 #include "ubuntuversionmanager.h"
 #include "ubuntupackagingmode.h"
 #include "ubuntusettingsdeviceconnectivitypage.h"
 
=== modified file 'src/ubuntu/ubuntuproject.cpp'
--- src/ubuntu/ubuntuproject.cpp	2016-05-12 06:50:19 +0000
+++ src/ubuntu/ubuntuproject.cpp	2016-08-24 15:35:12 +0000
@@ -36,7 +36,6 @@
 
     setId(Constants::UBUNTUPROJECT_ID);
     setRequiredKitMatcher(UbuntuKitMatcher());
-    setPreferredKitMatcher(QtSupport::QtKitInformation::qtVersionMatcher(Core::FeatureSet(QtSupport::Constants::FEATURE_DESKTOP)));
 
     setProjectContext(Core::Context(Constants::UBUNTUPROJECT_PROJECTCONTEXT));
 
@@ -46,6 +45,7 @@
     m_file = QSharedPointer<UbuntuProjectFile>(new UbuntuProjectFile(this, fileName));
 
     Core::DocumentManager::addDocument(m_file.data(), true);
+    setDocument(m_file.data());
 
     m_rootNode = QSharedPointer<UbuntuProjectNode>(new UbuntuProjectNode(this, m_file.data()));
     m_manager->registerProject(this);
@@ -82,10 +82,6 @@
     return m_projectName;
 }
 
-Core::IDocument *UbuntuProject::document() const {
-    return m_file.data();
-}
-
 ProjectExplorer::IProjectManager *UbuntuProject::projectManager() const {
     return m_manager;
 }
@@ -137,7 +133,10 @@
     return true;
 }
 
-QString UbuntuProject::shadowBuildDirectory(const QString &proFilePath, const ProjectExplorer::Kit *k, const QString &suffix)
+QString UbuntuProject::shadowBuildDirectory(const QString &proFilePath
+                                            , const ProjectExplorer::Kit *k
+                                            , const QString &suffix
+                                            , const ProjectExplorer::BuildConfiguration::BuildType buildType)
 {
     if (proFilePath.isEmpty())
         return QString();
@@ -149,7 +148,7 @@
         return info.absolutePath();
 
     const QString projectName = QFileInfo(proFilePath).completeBaseName();
-    ProjectExplorer::ProjectMacroExpander expander(projectName, k, suffix);
+    ProjectExplorer::ProjectMacroExpander expander(proFilePath, projectName, k, suffix, buildType);
     QDir projectDir = QDir(projectDirectory(Utils::FileName::fromString(proFilePath)).toString());
     QString buildPath = expander.expand(Core::DocumentManager::buildDirectory());
     return QDir::cleanPath(projectDir.absoluteFilePath(buildPath));
@@ -164,7 +163,7 @@
 bool UbuntuKitMatcher::matches(const ProjectExplorer::Kit *k)
 {
     ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(k);
-    if (tc->type() == QLatin1String(Ubuntu::Constants::UBUNTU_CLICK_TOOLCHAIN_ID))
+    if (tc->typeId() == Ubuntu::Constants::UBUNTU_CLICK_TOOLCHAIN_ID)
         return true;
 
     return false;
 
=== modified file 'src/ubuntu/ubuntuproject.h'
--- src/ubuntu/ubuntuproject.h	2015-03-03 17:23:52 +0000
+++ src/ubuntu/ubuntuproject.h	2016-08-24 15:35:12 +0000
@@ -42,6 +42,7 @@
 #include <projectexplorer/session.h>
 #include <projectexplorer/runconfiguration.h>
 #include <projectexplorer/applicationlauncher.h>
+#include <projectexplorer/buildconfiguration.h>
 
 namespace Ubuntu {
 namespace Internal {
@@ -65,7 +66,6 @@
     UbuntuProject(UbuntuProjectManager *manager, const QString &fileName);
 
     QString displayName() const override;
-    Core::IDocument *document() const override;
     ProjectExplorer::IProjectManager *projectManager() const override;
 
     ProjectExplorer::ProjectNode *rootProjectNode() const override;
@@ -88,7 +88,9 @@
     bool needsConfiguration() const override;
     bool requiresTargetPanel() const override;
 
-    static QString shadowBuildDirectory(const QString &proFilePath, const ProjectExplorer::Kit *k, const QString &suffix = QString());
+    static QString shadowBuildDirectory(const QString &proFilePath, const ProjectExplorer::Kit *k,
+                                        const QString &suffix = QString(),
+                                        const ProjectExplorer::BuildConfiguration::BuildType buildType = ProjectExplorer::BuildConfiguration::Unknown);
 private:
     void extractProjectFileData(const QString& filename);
 
 
=== modified file 'src/ubuntu/ubuntuprojectfile.cpp'
--- src/ubuntu/ubuntuprojectfile.cpp	2015-03-03 17:23:52 +0000
+++ src/ubuntu/ubuntuprojectfile.cpp	2016-08-24 15:35:12 +0000
@@ -34,14 +34,6 @@
     return false;
 }
 
-QString UbuntuProjectFile::defaultPath() const {
-    return QString();
-}
-
-QString UbuntuProjectFile::suggestedFileName() const {
-    return QString();
-}
-
 bool UbuntuProjectFile::isModified() const {
     return false;
 }
 
=== modified file 'src/ubuntu/ubuntuprojectfile.h'
--- src/ubuntu/ubuntuprojectfile.h	2015-03-03 17:23:52 +0000
+++ src/ubuntu/ubuntuprojectfile.h	2016-08-24 15:35:12 +0000
@@ -47,10 +47,6 @@
     ~UbuntuProjectFile() {}
 
     bool save(QString *errorString, const QString &fileName, bool autoSave) override;
-
-    QString defaultPath() const override;
-    QString suggestedFileName() const override;
-
     bool isModified() const override;
     bool isSaveAsAllowed() const override;
 
 
=== modified file 'src/ubuntu/ubuntuprojectnode.cpp'
--- src/ubuntu/ubuntuprojectnode.cpp	2015-03-03 17:23:52 +0000
+++ src/ubuntu/ubuntuprojectnode.cpp	2016-08-24 15:35:12 +0000
@@ -87,7 +87,7 @@
     if (! end)
         return 0;
 
-    QString baseDir = path().toFileInfo().path();
+    QString baseDir = filePath().toFileInfo().path();
 
     QString folderName;
     for (int i = 0; i < end; ++i) {
 
=== modified file 'src/ubuntu/ubuntuqmlbuildconfiguration.cpp'
--- src/ubuntu/ubuntuqmlbuildconfiguration.cpp	2015-04-28 14:47:49 +0000
+++ src/ubuntu/ubuntuqmlbuildconfiguration.cpp	2016-08-24 15:35:12 +0000
@@ -11,6 +11,7 @@
 #include <projectexplorer/kitinformation.h>
 #include <projectexplorer/buildsteplist.h>
 #include <utils/fancylineedit.h>
+#include <utils/algorithm.h>
 #include <utils/mimetypes/mimedatabase.h>
 #include <qmlprojectmanager/qmlprojectconstants.h>
 
@@ -184,7 +185,11 @@
     QList<ProjectExplorer::BuildInfo *> builds;
 
     ProjectExplorer::BuildInfo *info = new ProjectExplorer::BuildInfo(this);
-    info->buildDirectory = Utils::FileName::fromString(UbuntuProject::shadowBuildDirectory(projectDir,k,QStringLiteral("default")));
+    info->buildDirectory = Utils::FileName::fromString(UbuntuProject::shadowBuildDirectory(
+                                                           projectDir,
+                                                           k,
+                                                           QStringLiteral("default"),
+                                                           ProjectExplorer::BuildConfiguration::Unknown));
     info->typeName = tr("Qml");
     info->kitId    = k->id();
     info->displayName = tr("Default");
@@ -231,8 +236,9 @@
     : AbstractProcessStep(bsl,bs)
 {}
 
-bool UbuntuQmlUpdateTranslationTemplateStep::init()
+bool UbuntuQmlUpdateTranslationTemplateStep::init(QList<const BuildStep *> &earlierSteps)
 {
+    Q_UNUSED(earlierSteps);
     QString projectDir = target()->project()->projectDirectory().toString();
 
     ProjectExplorer::BuildConfiguration *bc = target()->activeBuildConfiguration();
@@ -269,9 +275,9 @@
     : UbuntuQmlUpdateTranslationTemplateStep(bsl,bs)
 {}
 
-bool UbuntuQmlBuildTranslationStep::init()
+bool UbuntuQmlBuildTranslationStep::init(QList<const BuildStep *> &earlierSteps)
 {
-    if(!UbuntuQmlUpdateTranslationTemplateStep::init())
+    if(!UbuntuQmlUpdateTranslationTemplateStep::init(earlierSteps))
         return false;
 
     ProjectExplorer::BuildConfiguration *bc = target()->activeBuildConfiguration();
@@ -303,36 +309,35 @@
     return UbuntuQmlUpdateTranslationTemplateStep::run(fi);
 }
 
-QList<Core::Id> UbuntuQmlBuildStepFactory::availableCreationIds(ProjectExplorer::BuildStepList *parent) const
-{
+bool UbuntuQmlBuildStepFactory::canHandle(ProjectExplorer::BuildStepList *parent, const Core::Id id) const
+{
+    return Utils::contains(availableSteps(parent), Utils::equal(&ProjectExplorer::BuildStepInfo::id, id));
+}
+
+QList<ProjectExplorer::BuildStepInfo> UbuntuQmlBuildStepFactory::availableSteps(ProjectExplorer::BuildStepList *parent) const
+{
+    QList<ProjectExplorer::BuildStepInfo> res;
+
     if(parent->id() != ProjectExplorer::Constants::BUILDSTEPS_BUILD)
-        return QList<Core::Id>();
+        return res;
 
     UbuntuKitMatcher m;
     if(!m.matches(parent->target()->kit())
             || parent->target()->project()->id() != "QmlProjectManager.QmlProject")
-        return QList<Core::Id>();
-
-    return QList<Core::Id>()<<Constants::UBUNTU_CLICK_QML_BUILD_TRANSL_MAKESTEP<<Constants::UBUNTU_CLICK_QML_UPDATE_TRANSL_MAKESTEP;
-}
-
-QString UbuntuQmlBuildStepFactory::displayNameForId(const Core::Id id) const
-{
-    if(id == Constants::UBUNTU_CLICK_QML_BUILD_TRANSL_MAKESTEP)
-        return tr("Build translations");
-    else if(id == Constants::UBUNTU_CLICK_QML_UPDATE_TRANSL_MAKESTEP)
-        return tr("Update translations template");
-    return QString();
-}
-
-bool UbuntuQmlBuildStepFactory::canCreate(ProjectExplorer::BuildStepList *parent, const Core::Id id) const
-{
-    return availableCreationIds(parent).contains(id);
+        return res;
+
+    res << ProjectExplorer::BuildStepInfo(Constants::UBUNTU_CLICK_QML_BUILD_TRANSL_MAKESTEP,
+                                          tr("Build translations"),
+                                          ProjectExplorer::BuildStepInfo::UniqueStep)
+        << ProjectExplorer::BuildStepInfo(Constants::UBUNTU_CLICK_QML_UPDATE_TRANSL_MAKESTEP,
+                                          tr("Update translations template"),
+                                          ProjectExplorer::BuildStepInfo::UniqueStep);
+    return res;
 }
 
 ProjectExplorer::BuildStep *UbuntuQmlBuildStepFactory::create(ProjectExplorer::BuildStepList *parent, const Core::Id id)
 {
-    QTC_ASSERT(canCreate(parent,id),return 0);
+    QTC_ASSERT(canHandle(parent,id),return 0);
 
     if(id == Constants::UBUNTU_CLICK_QML_BUILD_TRANSL_MAKESTEP)
         return new UbuntuQmlBuildTranslationStep(parent);
@@ -342,18 +347,13 @@
     return nullptr;
 }
 
-bool UbuntuQmlBuildStepFactory::canRestore(ProjectExplorer::BuildStepList *parent, const QVariantMap &map) const
-{
-    return availableCreationIds(parent).contains(ProjectExplorer::idFromMap(map));
-}
-
 ProjectExplorer::BuildStep *UbuntuQmlBuildStepFactory::restore(ProjectExplorer::BuildStepList *parent, const QVariantMap &map)
 {
-    QTC_ASSERT(canRestore(parent,map),return 0);
-
     ProjectExplorer::AbstractProcessStep *step = 0;
     Core::Id id = ProjectExplorer::idFromMap(map);
 
+    QTC_ASSERT(canHandle(parent,id),return 0);
+
     if(id == Constants::UBUNTU_CLICK_QML_BUILD_TRANSL_MAKESTEP)
         step = new UbuntuQmlBuildTranslationStep(parent);
     else if(id == Constants::UBUNTU_CLICK_QML_UPDATE_TRANSL_MAKESTEP)
@@ -369,14 +369,9 @@
     return step;
 }
 
-bool UbuntuQmlBuildStepFactory::canClone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product) const
-{
-    return availableCreationIds(parent).contains(product->id());
-}
-
 ProjectExplorer::BuildStep *UbuntuQmlBuildStepFactory::clone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product)
 {
-    QTC_ASSERT(canClone(parent,product),return 0);
+    QTC_ASSERT(canHandle(parent,product->id()),return 0);
 
     const Core::Id id = product->id();
     if(id == Constants::UBUNTU_CLICK_QML_BUILD_TRANSL_MAKESTEP)
 
=== modified file 'src/ubuntu/ubuntuqmlbuildconfiguration.h'
--- src/ubuntu/ubuntuqmlbuildconfiguration.h	2016-07-22 10:17:50 +0000
+++ src/ubuntu/ubuntuqmlbuildconfiguration.h	2016-08-24 15:35:12 +0000
@@ -57,7 +57,7 @@
     UbuntuQmlUpdateTranslationTemplateStep(ProjectExplorer::BuildStepList *bsl, UbuntuQmlUpdateTranslationTemplateStep *bs);
 
     // BuildStep interface
-    virtual bool init() override;
+    virtual bool init(QList<const BuildStep *> &earlierSteps) override;
     virtual ProjectExplorer::BuildStepConfigWidget *createConfigWidget() override;
 
     QString makeCommand(ProjectExplorer::ToolChain *tc, const Utils::Environment &env) const;
@@ -71,7 +71,7 @@
     UbuntuQmlBuildTranslationStep(ProjectExplorer::BuildStepList *bsl, UbuntuQmlBuildTranslationStep *bs);
 
     // BuildStep interface
-    virtual bool init() override;
+    virtual bool init(QList<const BuildStep *> &earlierSteps) override;
     virtual ProjectExplorer::BuildStepConfigWidget *createConfigWidget() override;
     void run(QFutureInterface<bool> &fi) override;
 
@@ -107,14 +107,14 @@
 
 public:
     // IBuildStepFactory interface
-    virtual QList<Core::Id> availableCreationIds(ProjectExplorer::BuildStepList *parent) const override;
-    virtual QString displayNameForId(const Core::Id id) const override;
-    virtual bool canCreate(ProjectExplorer::BuildStepList *parent, const Core::Id id) const override;
+    virtual QList<ProjectExplorer::BuildStepInfo> availableSteps(ProjectExplorer::BuildStepList *parent) const override;
     virtual ProjectExplorer::BuildStep *create(ProjectExplorer::BuildStepList *parent, const Core::Id id) override;
-    virtual bool canRestore(ProjectExplorer::BuildStepList *parent, const QVariantMap &map) const override;
     virtual ProjectExplorer::BuildStep *restore(ProjectExplorer::BuildStepList *parent, const QVariantMap &map) override;
-    virtual bool canClone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product) const override;
     virtual ProjectExplorer::BuildStep *clone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product) override;
+
+private:
+    bool canHandle(ProjectExplorer::BuildStepList *parent, const Core::Id id) const;
+
 };
 
 } // namespace Internal
 
=== modified file 'src/ubuntu/ubuntuqtversion.cpp'
--- src/ubuntu/ubuntuqtversion.cpp	2016-03-22 13:32:33 +0000
+++ src/ubuntu/ubuntuqtversion.cpp	2016-08-24 15:35:12 +0000
@@ -2,16 +2,20 @@
 #include "ubuntuconstants.h"
 #include "settings.h"
 
+#include <ubuntu/device/container/containerdevice.h>
+#include <ubuntu/ubuntuclicktool.h>
 #include <qtsupport/qtsupportconstants.h>
 
 #include <QCoreApplication>
 #include <QFileInfo>
 #include <QDebug>
+#include <QDir>
 
 namespace Ubuntu {
 namespace Internal {
 
 const char SCRIPT_VERSION_KEY[] = "UbuntuQtVersion.ScriptVersion";
+const char CONTAINER_NAME[] = "UbuntuQtVersion.ContainerName";
 
 /*!
  * \brief MIN_SCRIPT_VERSION
@@ -25,9 +29,10 @@
       m_scriptVersion(MIN_SCRIPT_VERSION)
 { }
 
-UbuntuQtVersion::UbuntuQtVersion(const Utils::FileName &path, bool isAutodetected, const QString &autodetectionSource)
+UbuntuQtVersion::UbuntuQtVersion(const QString &containerName, const Utils::FileName &path, bool isAutodetected, const QString &autodetectionSource)
     : BaseQtVersion(path, isAutodetected, autodetectionSource),
-      m_scriptVersion(MIN_SCRIPT_VERSION)
+      m_scriptVersion(MIN_SCRIPT_VERSION),
+      m_containerName(containerName)
 {
     setUnexpandedDisplayName(defaultUnexpandedDisplayName(path, false));
 }
@@ -39,12 +44,21 @@
 {
     BaseQtVersion::fromMap(map);
     m_scriptVersion = map.value(QLatin1String(SCRIPT_VERSION_KEY),0).toInt();
+    m_containerName = map.value(QLatin1String(CONTAINER_NAME),QString()).toString();
+
+    if (m_containerName.isEmpty()) {
+        //ok, this is a old QtVersion, we need to restore the container name from the
+        //qmake path
+        Utils::FileName command = this->qmakeCommand();
+        m_containerName = command.toFileInfo().dir().dirName();
+    }
 }
 
 QVariantMap UbuntuQtVersion::toMap() const
 {
     QVariantMap map = BaseQtVersion::toMap();
     map.insert(QLatin1String(SCRIPT_VERSION_KEY),m_scriptVersion);
+    map.insert(QLatin1String(CONTAINER_NAME), m_containerName);
     return map;
 }
 
@@ -68,15 +82,23 @@
     return QCoreApplication::translate("QtVersion", "Ubuntu Phone", "Qt Version is used for Ubuntu Phone development");
 }
 
-QString UbuntuQtVersion::platformName() const
-{
-    return QLatin1String(Constants::UBUNTU_PLATFORM_NAME);
-}
-
-QString UbuntuQtVersion::platformDisplayName() const
-{
-    return QLatin1String(Constants::UBUNTU_PLATFORM_NAME_TR);
-}
+QSet<Core::Id> UbuntuQtVersion::targetDeviceTypes() const
+{
+    QSet<Core::Id> set{
+        Constants::UBUNTU_DEVICE_TYPE_ID
+    };
+
+    auto hostAbi = ProjectExplorer::Abi::hostAbi();
+    for (const ProjectExplorer::Abi &abi : qtAbis()) {
+        if (abi.architecture() == hostAbi.architecture() &&
+                abi.os() == hostAbi.os()) {
+            set << ContainerDevice::createIdForContainer(m_containerName);
+        }
+    }
+
+    return set;
+}
+
 int UbuntuQtVersion::scriptVersion() const
 {
     return m_scriptVersion;
@@ -92,6 +114,11 @@
     return MIN_SCRIPT_VERSION;
 }
 
+QString UbuntuQtVersion::remoteQMakeCommand() const
+{
+    return QString::fromLatin1("/usr/bin/%2").arg(qmakeCommand().fileName());
+}
+
 bool UbuntuQtVersion::hasQmlDump() const
 {
     return false;
@@ -132,10 +159,18 @@
 {
     Q_UNUSED(evaluator);
     //we only care about our qmakes
-    if(!qmakePath.toFileInfo().absolutePath().contains(Settings::settingsPath().toString()))
-        return 0;
-
-    return new UbuntuQtVersion(qmakePath,isAutoDetected,autoDetectionSource);
+    QFileInfo qmakeInfo = qmakePath.toFileInfo();
+    if(!qmakeInfo.absolutePath().contains(Settings::settingsPath().toString()))
+        return 0;
+
+    if(!qmakeInfo.isSymLink() || qmakeInfo.symLinkTarget() != Constants::UBUNTU_CLICK_TARGET_WRAPPER)
+        return 0;
+
+    QString containerName = qmakePath.toFileInfo().dir().dirName();
+    if (!UbuntuClickTool::targetExists(containerName))
+        return 0;
+
+    return new UbuntuQtVersion(containerName, qmakePath,isAutoDetected,autoDetectionSource);
 }
 
 } // namespace Internal
 
=== modified file 'src/ubuntu/ubuntuqtversion.h'
--- src/ubuntu/ubuntuqtversion.h	2016-03-22 13:32:33 +0000
+++ src/ubuntu/ubuntuqtversion.h	2016-08-24 15:35:12 +0000
@@ -11,7 +11,7 @@
 {
 public:
     UbuntuQtVersion();
-    UbuntuQtVersion(const Utils::FileName &path, bool isAutodetected = false, const QString &autodetectionSource = QString());
+    UbuntuQtVersion(const QString &containerName, const Utils::FileName &path, bool isAutodetected = false, const QString &autodetectionSource = QString());
     ~UbuntuQtVersion() override;
 
     // BaseQtVersion interface
@@ -26,14 +26,15 @@
 
     QString description() const override;
 
-    QString platformName() const override;
-    QString platformDisplayName() const override;
+    virtual QSet<Core::Id> targetDeviceTypes() const override;
 
     int scriptVersion() const;
     void setScriptVersion(int scriptVersion);
 
     static int minimalScriptVersion ();
 
+    QString remoteQMakeCommand () const;
+
     // BaseQtVersion interface
     virtual bool hasQmlDump() const override;
     virtual bool hasQmlDumpWithRelocatableFlag() const override;
@@ -41,6 +42,7 @@
 
 private:
     int m_scriptVersion;
+    QString m_containerName;
 };
 
 class UbuntuQtVersionFactory : public QtSupport::QtVersionFactory
 
=== modified file 'src/ubuntu/ubuntuwelcomemode.cpp'
--- src/ubuntu/ubuntuwelcomemode.cpp	2016-04-19 12:09:54 +0000
+++ src/ubuntu/ubuntuwelcomemode.cpp	2016-08-24 15:35:12 +0000
@@ -24,6 +24,7 @@
 #include <QQmlContext>
 
 #include <utils/fileutils.h>
+#include <utils/algorithm.h>
 #include <coreplugin/iwizardfactory.h>
 #include <projectexplorer/projectexplorer.h>
 
@@ -69,7 +70,10 @@
 
 void UbuntuWelcomePage::newProject()
 {
-    Core::ICore::showNewItemDialog(tr("New Project"), Core::IWizardFactory::wizardFactoriesOfKind(Core::IWizardFactory::ProjectWizard));
+    Core::ICore::showNewItemDialog(tr("New Project"), Utils::filtered(Core::IWizardFactory::allWizardFactories(),
+                                                                      [](Core::IWizardFactory *f) {
+                                                                          return f->kind() == Core::IWizardFactory::ProjectWizard;
+                                                                      }));
 }
 
 void UbuntuWelcomePage::openProject()
 
=== modified file 'src/ubuntu/wizards/createtargetwizard.cpp'
--- src/ubuntu/wizards/createtargetwizard.cpp	2016-07-12 08:47:56 +0000
+++ src/ubuntu/wizards/createtargetwizard.cpp	2016-08-24 15:35:12 +0000
@@ -364,7 +364,7 @@
         return true;
     });
     ui->lineEditName->setPlaceholderText(tr("Please select a name"));
-    ui->lineEditName->triggerChanged();
+    ui->lineEditName->validate();
 
     setTitle(tr("Please type a name:"));
     setProperty(Utils::SHORT_TITLE_PROPERTY, tr("Name"));
 
=== modified file 'src/ubuntu/wizards/ubuntufatpackagingwizard.cpp'
--- src/ubuntu/wizards/ubuntufatpackagingwizard.cpp	2016-07-06 09:18:16 +0000
+++ src/ubuntu/wizards/ubuntufatpackagingwizard.cpp	2016-08-24 15:35:12 +0000
@@ -231,7 +231,7 @@
     QString fw;
     foreach (ProjectExplorer::BuildConfiguration *conf, selectedSuspects()) {
         ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(conf->target()->kit());
-        if (tc && tc->type() == QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)) {
+        if (tc && tc->typeId() == Constants::UBUNTU_CLICK_TOOLCHAIN_ID) {
             ClickToolChain *cTc = static_cast<ClickToolChain *>(tc);
             if (fw.isEmpty())
                 fw = cTc->clickTarget().framework;
 
=== modified file 'src/ubuntu/wizards/ubuntufirstrunwizard.cpp'
--- src/ubuntu/wizards/ubuntufirstrunwizard.cpp	2016-05-17 16:33:36 +0000
+++ src/ubuntu/wizards/ubuntufirstrunwizard.cpp	2016-08-24 15:35:12 +0000
@@ -135,7 +135,7 @@
         if (!tc || !QtSupport::QtKitInformation::qtVersion(curr))
             continue;
 
-        if (tc->type() == QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)) {
+        if (tc->typeId() == Constants::UBUNTU_CLICK_TOOLCHAIN_ID) {
             found = true;
 
             QTreeWidgetItem* kitItem = new QTreeWidgetItem;
 
=== modified file 'src/ubuntu/wizards/ubuntuprojectapplicationwizard.cpp'
--- src/ubuntu/wizards/ubuntuprojectapplicationwizard.cpp	2016-05-12 06:50:19 +0000
+++ src/ubuntu/wizards/ubuntuprojectapplicationwizard.cpp	2016-08-24 15:35:12 +0000
@@ -33,6 +33,7 @@
 #include <extensionsystem/pluginmanager.h>
 #include <cmakeprojectmanager/cmakekitinformation.h>
 #include <cmakeprojectmanager/cmaketool.h>
+#include <coreplugin/id.h>
 
 #include <projectexplorer/kitinformation.h>
 #include <projectexplorer/toolchain.h>
@@ -141,14 +142,16 @@
 }
 
 
-Core::FeatureSet UbuntuProjectApplicationWizard::requiredFeatures() const
+QSet<Core::Id> UbuntuProjectApplicationWizard::requiredFeatures() const
 {
 #ifdef Q_PROCESSOR_ARM
     return CustomProjectWizard::requiredFeatures();
 #else
-    return CustomProjectWizard::requiredFeatures()
-            | Core::Feature(QtSupport::Constants::FEATURE_QMLPROJECT)
-            | Core::Feature::versionedFeature(QtSupport::Constants::FEATURE_QT_QUICK_PREFIX, 2);
+    QSet<Core::Id> features = CustomProjectWizard::requiredFeatures();
+    features << QtSupport::Constants::FEATURE_QMLPROJECT
+             << Core::Id::versionedId(QtSupport::Constants::FEATURE_QT_QUICK_PREFIX, 2);
+
+    return features;
 #endif
 }
 
@@ -220,7 +223,7 @@
     bool found = false;
     foreach(ProjectExplorer::Kit *curr, allKits) {
         ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(curr);
-        if (tc->type() == QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)) {
+        if (tc->typeId() == Constants::UBUNTU_CLICK_TOOLCHAIN_ID) {
             found = true;
             break;
         }
@@ -279,7 +282,7 @@
 #endif
                 //this is just a fallback for now to remove all ubuntu kits until cross compiling is sorted out
                 //it should not be hit at all but i keep it there just to be safe
-                m_targetSetupPage->setRequiredKitMatcher(QtSupport::QtKitInformation::platformMatcher(QLatin1String(QtSupport::Constants::DESKTOP_PLATFORM)));
+                m_targetSetupPage->setRequiredKitMatcher(QtSupport::QtKitInformation::platformMatcher(ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE));
             break;
         }
         case UbuntuProjectApplicationWizard::QMakeProject:
 
=== modified file 'src/ubuntu/wizards/ubuntuprojectapplicationwizard.h'
--- src/ubuntu/wizards/ubuntuprojectapplicationwizard.h	2015-06-11 14:03:50 +0000
+++ src/ubuntu/wizards/ubuntuprojectapplicationwizard.h	2016-08-24 15:35:12 +0000
@@ -58,7 +58,7 @@
     bool postGenerateFiles(const QWizard *, const Core::GeneratedFiles &l, QString *errorMessage) const override;
 
 private:
-    Core::FeatureSet requiredFeatures() const;
+    QSet<Core::Id> requiredFeatures() const;
     ProjectType m_type;
 };
 
 
=== modified file 'src/ubuntu/wizards/ubuntuprojectmigrationwizard.cpp'
--- src/ubuntu/wizards/ubuntuprojectmigrationwizard.cpp	2015-04-28 14:47:49 +0000
+++ src/ubuntu/wizards/ubuntuprojectmigrationwizard.cpp	2016-08-24 15:35:12 +0000
@@ -135,7 +135,7 @@
 {
     UbuntuProjectMigrationWizard wiz(project,parent);
     if(wiz.exec() == QDialog::Accepted) {
-        bool multiTargetProject = project->rootQmakeProjectNode()->projectType() == QmakeProjectManager::SubDirsTemplate;
+        bool multiTargetProject = project->rootProjectNode()->projectType() == QmakeProjectManager::SubDirsTemplate;
 
 
         QMap<QString,QString> base_replacements;
@@ -168,7 +168,7 @@
             bool canRead = true;
             //setup the file reader correctly
 
-            if (ProFile *pro = reader->parsedProFile(node->path().toString())) {
+            if (ProFile *pro = reader->parsedProFile(node->filePath().toString())) {
                 if(!reader->accept(pro, QMakeEvaluator::LoadAll)) {
                     canRead = false;
                 }
@@ -179,7 +179,7 @@
 
 
             if(!canRead) {
-                printToOutputPane(tr("Can not parse %1, skipping migration.").arg(node->path().toString()));
+                printToOutputPane(tr("Can not parse %1, skipping migration.").arg(node->filePath().toString()));
                 continue;
             }
 
@@ -308,7 +308,7 @@
             //now add required files
             if(projectType == QmakeProjectManager::ApplicationTemplate) {
 
-                QFileInfo proFilePath(node->path().toString());
+                QFileInfo proFilePath(node->filePath().toFileInfo());
 
                 QmakeProjectManager::TargetInformation targetInfo = node->targetInformation();
                 if(hookTargets.contains(targetInfo.target)) {
@@ -441,7 +441,7 @@
             manifestFile.write(doc.toJson());
             manifestFile.close();
 
-            project->rootQmakeProjectNode()->addSubProjects(QStringList()<<QString::fromLatin1("%1/%2").arg(project->projectDirectory().toString()).arg(QStringLiteral("/manifest.pro")));
+            project->rootProjectNode()->addSubProjects(QStringList()<<QString::fromLatin1("%1/%2").arg(project->projectDirectory().toString()).arg(QStringLiteral("/manifest.pro")));
         }
     }
 }