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

[Benjamin Zeller]

- Adding run support for HTML and webcontainer projects
- Refactored some code to make the project easier to maintain
- Remove MenuItems for HTML projects
- Fix packaging widget to work correctly for the new HTML configurations
- Adding UbuntuHtmlBuildConfiguration
- Add TargetSetupPage to the new htmlproject wizard
- Make sure trusty users get a list of available frameworks based on the
Toolchain they use
- Hardcode list of frameworks for now since click chroots are broken

- Adding run support for HTML and webcontainer projects
- Refactored some code to make the project easier to maintain
- Remove MenuItems for HTML projects
- Fix packaging widget to work correctly for the new HTML configurations
- Adding UbuntuHtmlBuildConfiguration
- Add TargetSetupPage to the new htmlproject wizard

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:214
http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-ci/339/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-utopic-amd64-ci/107
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-utopic-armhf-ci/107

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtcreator-plugin-ubuntu-ci/339/rebuild

review: Approve (continuous-integration)

[Zoltan Balogh (bzoltan)]

OK

review: Approve

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

215. By Benjamin Zeller on 2014-07-21

Merge branch: https://code.launchpad.net/~zeller-benjamin/qtcreator-plugin-ubuntu/fixfwlist/+merge/227518

216. By Benjamin Zeller on 2014-07-23

Make sure the correct value is selected when the target is switched

=== modified file 'debian/control'
--- debian/control	2014-07-04 14:22:41 +0000
+++ debian/control	2014-07-23 14:19:54 +0000
@@ -43,6 +43,7 @@
          qtcreator-plugin-cmake (>= 3.1.1~),
          qtcreator-plugin-remotelinux (>= 3.1.1~),
          qtdeclarative5-controls-plugin,
+         webapp-container,
 # Only for unity8-supported archs
          unity-scope-tool [i386 amd64 armhf],
          ${shlibs:Depends},
 
=== modified file 'share/qtcreator/templates/wizards/ubuntu/html5-simple/wizard.xml'
--- share/qtcreator/templates/wizards/ubuntu/html5-simple/wizard.xml	2014-07-10 13:20:17 +0000
+++ share/qtcreator/templates/wizards/ubuntu/html5-simple/wizard.xml	2014-07-23 14:19:54 +0000
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <wizard version="1" kind="project" firstpage="10" id="UbuntuAppSimpleHtml5'" category="A.UbuntuProject"
         platformIndependent="true" 
-        class="ubuntu-project-plain"
+        class="ubuntu-project-plain-html"
 				featuresRequired=""
         >
     <icon>../share/ubuntu.png</icon>
 
=== modified file 'share/qtcreator/templates/wizards/ubuntu/simple/wizard.xml'
--- share/qtcreator/templates/wizards/ubuntu/simple/wizard.xml	2014-07-11 10:10:16 +0000
+++ share/qtcreator/templates/wizards/ubuntu/simple/wizard.xml	2014-07-23 14:19:54 +0000
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <wizard version="1" kind="project" firstpage="10" id="UbuntuAppSimple'" category="A.UbuntuProject"
         platformIndependent="true" 
-        class="ubuntu-project-plain"
+        class="ubuntu-project-plain-qml"
 				featuresRequired=""
         >
     <icon>../share/ubuntu.png</icon>
 
=== modified file 'share/qtcreator/templates/wizards/ubuntu/tabs/wizard.xml'
--- share/qtcreator/templates/wizards/ubuntu/tabs/wizard.xml	2014-07-10 13:20:17 +0000
+++ share/qtcreator/templates/wizards/ubuntu/tabs/wizard.xml	2014-07-23 14:19:54 +0000
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <wizard version="1" kind="project" firstpage="10" id="UbuntuAppTabs'" category="A.UbuntuProject"
         platformIndependent="true" 
-        class="ubuntu-project-plain"
+        class="ubuntu-project-plain-qml"
 				featuresRequired=""
         >
     <icon>../share/ubuntu.png</icon>
 
=== modified file 'share/qtcreator/templates/wizards/ubuntu/webapp/wizard.xml'
--- share/qtcreator/templates/wizards/ubuntu/webapp/wizard.xml	2014-07-11 09:55:15 +0000
+++ share/qtcreator/templates/wizards/ubuntu/webapp/wizard.xml	2014-07-23 14:19:54 +0000
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<wizard version="1" kind="project" firstpage="10" id="UbuntuWebApp" category="A.UbuntuProject" platformIndependent="true" class="ubuntu-project-plain" featuresRequired="">
+<wizard version="1" kind="project" firstpage="10" id="UbuntuWebApp" category="A.UbuntuProject" platformIndependent="true" class="ubuntu-project-plain-html" featuresRequired="">
     <icon>../share/ubuntu.png</icon>
     <description>Web App template, for converting a web site into a standalone application. Web Apps are restricted to using available W3C APIs only, unlike HTML5 Apps which have full platform access.</description>
     <displayname>Web App</displayname>
 
=== modified file 'share/qtcreator/ubuntu/menu.json'
--- share/qtcreator/ubuntu/menu.json	2014-05-21 15:37:37 +0000
+++ share/qtcreator/ubuntu/menu.json	2014-07-23 14:19:54 +0000
@@ -74,20 +74,6 @@
                 ]
             },
             {
-                "name": "Run Application on Device",
-                "id": "Ubuntu.Build.RunHtml5",
-                "workingDirectory": "%0/..",
-                "projectRequired": true,
-                "keysequence": "Ctrl+F12",
-                "deviceRequired": true,
-                "ubuntuHtmlProjectRequired": true,
-                "saveRequired": true,
-                "context" : ["UbuntuProject.ProjectContext"],
-                "actions": [
-                    "%SCRIPTDIRECTORY%/qtc_device_run_app_click %SERIALNUMBER% %FOLDERNAME% %USERNAME%@%IP% %PORT% /home/%USERNAME%/dev_tmp"
-                ]
-            },
-            {
                 "name": "Close Application on Device",
                 "id": "Ubuntu.Build.CancelRun",
                 "keysequence": "Ctrl+Shift+F12",
@@ -116,7 +102,7 @@
                 "workingDirectory": "%0/..",
                 "projectRequired": true,
                 "deviceRequired": true,
-                "context": ["QmlProject.ProjectContext","UbuntuProject.ProjectContext"],
+                "context": ["QmlProject.ProjectContext"],
                 "saveRequired": true,
                 "actions": [
                     "%SCRIPTDIRECTORY%/qtc_project_click_createanddeploy %SERIALNUMBER% %FOLDERNAME% %USERNAME%@%IP% %PORT% /home/%USERNAME%/dev_tmp %USERNAME%"
@@ -124,6 +110,24 @@
             },
             {
                 "name": "Install Application on Device",
+                "id": "Ubuntu.Build.PackageInstall.Html",
+                "workingDirectory": "%0/..",
+                "projectRequired": true,
+                "deviceRequired": true,
+                "context": ["UbuntuProject.ProjectContext"],
+                "saveRequired": true,
+                "actions": [
+                    {
+                        "metacall": {
+                             "method":"requestBuildAndInstallProject",
+                             "args":[]
+                        }
+                    }
+                ]
+            },
+
+            {
+                "name": "Install Application on Device",
                 "id": "Ubuntu.Build.PackageInstall.CMake",
                 "workingDirectory": "%0/..",
                 "projectRequired": true,
@@ -138,8 +142,8 @@
                         }
                     }
                 ]
-            },
-						{
+            },				
+            {
                 "name": "Install Application on Device",
                 "id": "Ubuntu.Build.PackageInstall.Go",
                 "workingDirectory": "%0/..",
 
=== modified file 'src/plugin.pri'
--- src/plugin.pri	2014-07-01 10:09:49 +0000
+++ src/plugin.pri	2014-07-23 14:19:54 +0000
@@ -17,6 +17,7 @@
     DEFINES += UBUNTU_RESOURCE_PATH_LOCAL=\"$${PATHSTR}\" UBUNTU_BUILD_LOCAL
 
     #create a link so we get our wizards in the new project wizard
+    system("rm '$$(HOME)/.config/QtProject/qtcreator/templates'")
     system("ln -s '$${PWD}/../share/qtcreator/templates' '$$(HOME)/.config/QtProject/qtcreator/templates'")
 }
 
 
=== modified file 'src/ubuntu/ubuntu.pro'
--- src/ubuntu/ubuntu.pro	2014-07-07 06:33:37 +0000
+++ src/ubuntu/ubuntu.pro	2014-07-23 14:19:54 +0000
@@ -116,7 +116,10 @@
     ubunturemoterunner.cpp \
     abstractremoterunsupport.cpp\
     ubuntushared.cpp \
-    ubuntupackagestep.cpp
+    ubuntupackagestep.cpp \
+    ubuntudeploystepfactory.cpp \
+    ubuntudirectuploadstep.cpp \
+    ubuntuhtmlbuildconfiguration.cpp
 
 HEADERS += \
     ubuntuplugin.h \
@@ -182,5 +185,8 @@
     ubuntudevicesignaloperation.h \
     ubunturemoterunner.h \
     abstractremoterunsupport.h \
-    ubuntupackagestep.h
+    ubuntupackagestep.h \
+    ubuntudeploystepfactory.h \
+    ubuntudirectuploadstep.h \
+    ubuntuhtmlbuildconfiguration.h
 
 
=== modified file 'src/ubuntu/ubuntuclickmanifest.cpp'
--- src/ubuntu/ubuntuclickmanifest.cpp	2014-06-17 10:21:20 +0000
+++ src/ubuntu/ubuntuclickmanifest.cpp	2014-07-23 14:19:54 +0000
@@ -34,6 +34,7 @@
 #include <projectexplorer/session.h>
 #include <projectexplorer/project.h>
 #include <projectexplorer/iprojectmanager.h>
+#include <projectexplorer/target.h>
 
 using namespace Ubuntu::Internal;
 
@@ -287,20 +288,22 @@
 
     if (fileName == QLatin1String(":/ubuntu/manifest.json.template")) {
 
-        QString mimeType = ProjectExplorer::SessionManager::startupProject()->projectManager()->mimeType();
-        QString proName  = ProjectExplorer::SessionManager::startupProject()->projectFilePath();
+
+        ProjectExplorer::Project *proj = ProjectExplorer::SessionManager::startupProject();
+        QString mimeType = proj->projectManager()->mimeType();
+        QString proName  = proj->projectFilePath();
 
         bool isUbuntuProject = (mimeType == QLatin1String(Constants::UBUNTUPROJECT_MIMETYPE));
         bool isUbuntuHtmlProject = proName.endsWith(QLatin1String(Constants::UBUNTUHTMLPROJECT_SUFFIX));
 
         QString defFramework;
         if(isUbuntuProject && isUbuntuHtmlProject) {
-            defFramework = UbuntuClickTool::getMostRecentFramework(QLatin1String("html"));
+            defFramework = UbuntuClickTool::getMostRecentFramework(QLatin1String("html"),UbuntuClickTool::clickTargetFromTarget(proj->activeTarget()));
 
             if(defFramework.isEmpty())
                 defFramework = QLatin1String(Constants::UBUNTU_DEFAULT_HTML_FRAMEWORK);
         } else {
-            defFramework = UbuntuClickTool::getMostRecentFramework(QLatin1String("qml"));
+            defFramework = UbuntuClickTool::getMostRecentFramework(QLatin1String("qml"),UbuntuClickTool::clickTargetFromTarget(proj->activeTarget()));
 
             if(defFramework.isEmpty())
                 defFramework = QLatin1String(Constants::UBUNTU_DEFAULT_QML_FRAMEWORK);
 
=== modified file 'src/ubuntu/ubuntuclicktool.cpp'
--- src/ubuntu/ubuntuclicktool.cpp	2014-07-07 06:56:31 +0000
+++ src/ubuntu/ubuntuclicktool.cpp	2014-07-23 14:19:54 +0000
@@ -20,6 +20,7 @@
 #include "ubuntuclickmanifest.h"
 #include "ubuntuconstants.h"
 #include "ubuntushared.h"
+#include "clicktoolchain.h"
 
 #include <QRegularExpression>
 #include <QDir>
@@ -44,6 +45,7 @@
 #include <projectexplorer/target.h>
 #include <projectexplorer/project.h>
 #include <projectexplorer/buildconfiguration.h>
+#include <projectexplorer/kitinformation.h>
 #include <utils/qtcprocess.h>
 #include <utils/environment.h>
 #include <utils/consoleprocess.h>
@@ -96,21 +98,21 @@
 {
     QString arguments;
     switch (mode) {
-    case Upgrade:
-        params->setCommand(QLatin1String(Constants::UBUNTU_CLICK_BINARY));
-        arguments = QString::fromLatin1(Constants::UBUNTU_CLICK_CHROOT_UPGRADE_ARGS)
-                .arg(target.architecture)
-                .arg(target.framework)
-                .arg(target.series);
-        break;
-    case Delete:
-        params->setCommand(QLatin1String(Constants::UBUNTU_SUDO_BINARY));
-        arguments = QString::fromLatin1(Constants::UBUNTU_CLICK_CHROOT_DESTROY_ARGS)
-                .arg(Constants::UBUNTU_SCRIPTPATH)
-                .arg(target.architecture)
-                .arg(target.framework)
-                .arg(target.series);
-        break;
+        case Upgrade:
+            params->setCommand(QLatin1String(Constants::UBUNTU_CLICK_BINARY));
+            arguments = QString::fromLatin1(Constants::UBUNTU_CLICK_CHROOT_UPGRADE_ARGS)
+                    .arg(target.architecture)
+                    .arg(target.framework)
+                    .arg(target.series);
+            break;
+        case Delete:
+            params->setCommand(QLatin1String(Constants::UBUNTU_SUDO_BINARY));
+            arguments = QString::fromLatin1(Constants::UBUNTU_CLICK_CHROOT_DESTROY_ARGS)
+                    .arg(Constants::UBUNTU_SCRIPTPATH)
+                    .arg(target.architecture)
+                    .arg(target.framework)
+                    .arg(target.series);
+            break;
     }
 
 
@@ -190,27 +192,101 @@
  * \brief UbuntuClickTool::getSupportedFrameworks
  * returns all available frameworks on the host system
  */
-QStringList UbuntuClickTool::getSupportedFrameworks()
+QStringList UbuntuClickTool::getSupportedFrameworks(const UbuntuClickTool::Target *target)
 {
-    QStringList items;
-    QDir frameworksDir(QLatin1String(Constants::UBUNTU_CLICK_FRAMEWORKS_BASEPATH));
-
-    if(!frameworksDir.exists())
-        return items;
-
-    QStringList availableFrameworkFiles = frameworksDir.entryList(QStringList()<<QLatin1String("*.framework"),
-                                                           QDir::Files | QDir::NoDotAndDotDot,
-                                                           QDir::Name | QDir::Reversed);
-
-    QStringList availableFrameworks;
-    foreach(QString fw, availableFrameworkFiles) {
-        fw.replace(QLatin1String(".framework"),QString());
-        availableFrameworks.append(fw);
-    }
-
-    if(debug) qDebug()<<"Available Frameworks on the host"<<availableFrameworks;
-    return availableFrameworks;
-
+#if 0
+    QProcess proc;
+    proc.setProgram(QStringLiteral("click"));
+
+    QStringList args;
+    if (target) {
+        args << QStringLiteral("chroot")
+             << QStringLiteral("-a")
+             << target->architecture
+             << QStringLiteral("-f")
+             << target->framework
+             << QStringLiteral("run")
+             << QStringLiteral("click");
+    }
+    args << QStringLiteral("framework")
+         << QStringLiteral("list");
+
+    if(debug) qDebug()<<"click"<<Utils::QtcProcess::joinArgs(args);
+    proc.setArguments(args);
+    proc.start();
+    if (!proc.waitForFinished()) {
+        proc.kill();
+        return QStringList();
+    }
+
+    if(proc.exitCode() != 0 || proc.exitStatus() != QProcess::NormalExit)
+        return QStringList();
+
+    QStringList allFws = QString::fromLocal8Bit(proc.readAllStandardOutput()).split(QStringLiteral("\n"),QString::SkipEmptyParts);
+
+    //reverse the list
+    QStringList result;
+    result.reserve( allFws.size() );
+    std::reverse_copy( allFws.begin(), allFws.end(), std::back_inserter( result ) );
+
+    return result;
+#endif
+
+    if (!target) {
+        QStringList items;
+        QDir frameworksDir(QLatin1String(Constants::UBUNTU_CLICK_FRAMEWORKS_BASEPATH));
+
+        if(!frameworksDir.exists())
+            return items;
+
+        QStringList availableFrameworkFiles = frameworksDir.entryList(QStringList()<<QLatin1String("*.framework"),
+                                                                      QDir::Files | QDir::NoDotAndDotDot,
+                                                                      QDir::Name | QDir::Reversed);
+
+        QStringList availableFrameworks;
+        foreach(QString fw, availableFrameworkFiles) {
+            fw.replace(QLatin1String(".framework"),QString());
+            availableFrameworks.append(fw);
+        }
+
+        if(debug) qDebug()<<"Available Frameworks on the host"<<availableFrameworks;
+        return availableFrameworks;
+    } else {
+        //hardcode for now, click chroots are broken, click is not installed and even if its installed
+        //it does not show any valid informations
+        if(target->majorVersion == 14 && target->minorVersion == 10) {
+            return QStringList() << QStringLiteral("ubuntu-sdk-14.10-qml-dev3")
+                                 << QStringLiteral("ubuntu-sdk-14.10-qml-dev2")
+                                 << QStringLiteral("ubuntu-sdk-14.10-qml-dev1")
+                                 << QStringLiteral("ubuntu-sdk-14.10-papi-dev2")
+                                 << QStringLiteral("ubuntu-sdk-14.10-papi-dev1")
+                                 << QStringLiteral("ubuntu-sdk-14.10-html-dev2")
+                                 << QStringLiteral("ubuntu-sdk-14.10-html-dev1")
+                                 << QStringLiteral("ubuntu-sdk-14.10-dev2")
+                                 << QStringLiteral("ubuntu-sdk-14.10-dev1")
+                                 << QStringLiteral("ubuntu-sdk-14.04")
+                                 << QStringLiteral("ubuntu-sdk-14.04-qml")
+                                 << QStringLiteral("ubuntu-sdk-14.04-qml-dev1")
+                                 << QStringLiteral("ubuntu-sdk-14.04-papi")
+                                 << QStringLiteral("ubuntu-sdk-14.04-papi-dev1")
+                                 << QStringLiteral("ubuntu-sdk-14.04-html")
+                                 << QStringLiteral("ubuntu-sdk-14.04-html-dev1")
+                                 << QStringLiteral("ubuntu-sdk-14.04-dev1")
+                                 << QStringLiteral("ubuntu-sdk-13.10");
+        } else if (target->majorVersion == 14 && target->minorVersion == 4){
+            return QStringList() << QStringLiteral("ubuntu-sdk-14.04")
+                                 << QStringLiteral("ubuntu-sdk-14.04-qml")
+                                 << QStringLiteral("ubuntu-sdk-14.04-qml-dev1")
+                                 << QStringLiteral("ubuntu-sdk-14.04-papi")
+                                 << QStringLiteral("ubuntu-sdk-14.04-papi-dev1")
+                                 << QStringLiteral("ubuntu-sdk-14.04-html")
+                                 << QStringLiteral("ubuntu-sdk-14.04-html-dev1")
+                                 << QStringLiteral("ubuntu-sdk-14.04-dev1")
+                                 << QStringLiteral("ubuntu-sdk-13.10");
+        } else {
+            return QStringList() << QStringLiteral("ubuntu-sdk-13.10");
+        }
+    }
 }
 
 /*!
@@ -231,10 +307,10 @@
  * returns the framework with the highest number supporting the subFramework
  * or a empty string of no framework with the given \a subFramework was found
  */
-QString UbuntuClickTool::getMostRecentFramework(const QString &subFramework)
+QString UbuntuClickTool::getMostRecentFramework(const QString &subFramework, const Target *target)
 {
     //returned list is ordered from newest -> oldest framework
-    QStringList allFws = getSupportedFrameworks();
+    QStringList allFws = getSupportedFrameworks(target);
 
     QString currFw;
     foreach(const QString &framework, allFws) {
@@ -421,6 +497,32 @@
     return true;
 }
 
+/*!
+ * \brief UbuntuClickTool::clickTargetFromTarget
+ * Tries to get the Click target from a projectconfiguration,
+ * \returns 0 if nothing was found
+ */
+const UbuntuClickTool::Target *UbuntuClickTool::clickTargetFromTarget(ProjectExplorer::Target *t)
+{
+#ifndef IN_TEST_PROJECT
+    if(!t)
+        return 0;
+
+    ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(t->kit());
+    if(!tc || (tc->type() != QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)))
+        return 0;
+
+    ClickToolChain *clickTc = static_cast<ClickToolChain*>(tc);
+    if(!clickTc)
+        return 0;
+
+    return  &clickTc->clickTarget();
+#else
+    Q_UNUSED(t);
+    return 0;
+#endif
+}
+
 QDebug operator<<(QDebug dbg, const UbuntuClickTool::Target& t)
 {
     dbg.nospace() << "("<<"series: "<<t.series<<" "
 
=== modified file 'src/ubuntu/ubuntuclicktool.h'
--- src/ubuntu/ubuntuclicktool.h	2014-06-02 09:15:55 +0000
+++ src/ubuntu/ubuntuclicktool.h	2014-07-23 14:19:54 +0000
@@ -71,13 +71,14 @@
 
     static QString targetBasePath (const Target& target);
     static bool getTargetFromUser (Target* target, const QString &framework=QString());
-    static QStringList getSupportedFrameworks ();
-    static QString getMostRecentFramework ( const QString &subFramework );
+    static QStringList getSupportedFrameworks (const Target *target);
+    static QString getMostRecentFramework ( const QString &subFramework, const Target *target );
 
     static bool          targetExists (const Target& target);
     static QList<Target> listAvailableTargets (const QString &framework=QString());
     static QPair<int,int> targetVersion (const Target& target);
     static bool        targetFromPath(const QString& targetPath, Target* tg);
+    static const Target *clickTargetFromTarget(ProjectExplorer::Target *t);
 };
 
 QDebug operator<<(QDebug dbg, const UbuntuClickTool::Target& t);
 
=== modified file 'src/ubuntu/ubuntucmakemakestep.cpp'
--- src/ubuntu/ubuntucmakemakestep.cpp	2014-06-17 09:25:03 +0000
+++ src/ubuntu/ubuntucmakemakestep.cpp	2014-07-23 14:19:54 +0000
@@ -50,11 +50,6 @@
     if(!canHandle(parent->target()))
         return QList<Core::Id>();
 
-    if (parent->id() == ProjectExplorer::Constants::BUILDSTEPS_DEPLOY) {
-        return QList<Core::Id>()
-                << Core::Id(Constants::UBUNTU_CLICK_PACKAGESTEP_ID);
-    }
-
     return QList<Core::Id>() << Core::Id(Constants::UBUNTU_CLICK_CMAKE_MAKESTEP_ID);
 }
 
@@ -83,8 +78,6 @@
 {
     if (id == Constants::UBUNTU_CLICK_CMAKE_MAKESTEP_ID)
         return tr("UbuntuSDK-Make", "Display name for UbuntuCMakeMakeStep id.");
-    if (id == Constants::UBUNTU_CLICK_PACKAGESTEP_ID)
-        return tr("UbuntuSDK create click package", "Display name for UbuntuPackageStep id.");
     return QString();
 }
 
@@ -100,11 +93,6 @@
     if (!canCreate(parent, id))
         return 0;
 
-    if (id == Constants::UBUNTU_CLICK_PACKAGESTEP_ID) {
-        UbuntuPackageStep *step = new UbuntuPackageStep(parent);
-        return step;
-    }
-
     UbuntuCMakeMakeStep *step = new UbuntuCMakeMakeStep(parent);
     if (parent->id() == ProjectExplorer::Constants::BUILDSTEPS_CLEAN) {
         step->setUseNinja(false);
@@ -117,11 +105,6 @@
 bool UbuntuCMakeMakeStepFactory::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 canHandle(parent->target());
-
     return canCreate(parent, toRestore);
 }
 
@@ -131,18 +114,11 @@
         return 0;
 
     Core::Id toRestore = ProjectExplorer::idFromMap(map);
-
-    //backwards compatibility to older projects
-    if( toRestore == Constants::UBUNTU_DEPLOY_MAKESTEP_ID ) {
-        UbuntuPackageStep *step = new UbuntuPackageStep(parent);
+    ProjectExplorer::BuildStep* step = create(parent,toRestore);
+    if(step->fromMap(map))
         return step;
-    } else {
-        ProjectExplorer::BuildStep* step = create(parent,toRestore);
-        if(step->fromMap(map))
-            return step;
 
-        delete step;
-    }
+    delete step;
     return 0;
 }
 
@@ -158,8 +134,6 @@
 
     if(product->id() == Core::Id(Constants::UBUNTU_CLICK_CMAKE_MAKESTEP_ID))
         return new UbuntuCMakeMakeStep(parent, static_cast<UbuntuCMakeMakeStep *>(product));
-    else if(product->id() == Core::Id(Constants::UBUNTU_CLICK_PACKAGESTEP_ID))
-        return new UbuntuPackageStep(parent, static_cast<UbuntuPackageStep *>(product));
 
     QTC_ASSERT(false,return 0);
 }
 
=== modified file 'src/ubuntu/ubuntuconstants.h'
--- src/ubuntu/ubuntuconstants.h	2014-06-11 13:50:09 +0000
+++ src/ubuntu/ubuntuconstants.h	2014-07-23 14:19:54 +0000
@@ -151,6 +151,7 @@
 const char UBUNTUPROJECT_RUNCONTROL_ID[] = "UbuntuProjectManager.UbuntuRunConfiguration";
 
 const char UBUNTUHTML_PROJECT_LAUNCHER_EXE[] = "ubuntu-html5-app-launcher";
+const char UBUNTUWEBAPP_PROJECT_LAUNCHER_EXE[] = "webapp-container";
 const char UBUNTUSCOPES_PROJECT_LAUNCHER_EXE[] = "unity-scope-tool";
 
 const char UBUNTU_PROJECT_WIZARD_CATEGORY_DISPLAY[] = QT_TRANSLATE_NOOP("ProjectExplorer", "Ubuntu");
@@ -508,7 +509,7 @@
 const char UBUNTU_CLICK_CMAKE_WRAPPER[]  = "%0/qtc_chroot_cmake2";
 const char UBUNTU_CLICK_MAKE_WRAPPER[]   = "%0/qtc_chroot_make2";
 const char UBUNTU_CLICK_GCC_WRAPPER[]    = "%0/qtc_chroot_gcc";
-
+const char UBUNTU_CLICK_HTML_BC_ID[]     = "UbuntuProjectManager.UbuntuHTML5.BuildConfiguration";
 //Devicesupport
 const char UBUNTU_DEVICE_TYPE_ID[] = "UbuntuProjectManager.DeviceTypeId";
 const char UBUNTU_DEVICE_SSHIDENTITY[] = "%0/.config/ubuntu-sdk/ubuntudevice_id_rsa";
 
=== added file 'src/ubuntu/ubuntudeploystepfactory.cpp'
--- src/ubuntu/ubuntudeploystepfactory.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntudeploystepfactory.cpp	2014-07-23 14:19:54 +0000
@@ -0,0 +1,138 @@
+#include "ubuntudeploystepfactory.h"
+#include "ubuntuprojectguesser.h"
+#include "ubuntuconstants.h"
+#include "ubuntudirectuploadstep.h"
+#include "ubuntupackagestep.h"
+
+#include <utils/qtcassert.h>
+
+#include <projectexplorer/buildstep.h>
+#include <projectexplorer/buildsteplist.h>
+#include <projectexplorer/kitinformation.h>
+#include <projectexplorer/target.h>
+#include <projectexplorer/project.h>
+#include <projectexplorer/toolchain.h>
+#include <projectexplorer/projectexplorerconstants.h>
+
+#include <qmlprojectmanager/qmlprojectconstants.h>
+
+#include <cmakeprojectmanager/cmakeprojectconstants.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+QList<Core::Id> UbuntuDeployStepFactory::availableCreationIds(ProjectExplorer::BuildStepList *parent) const
+{
+    QList<Core::Id> types;
+
+    if (parent->id() != ProjectExplorer::Constants::BUILDSTEPS_DEPLOY)
+        return types;
+
+    Core::Id targetDevice = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(parent->target()->kit());
+    if(targetDevice != ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE && targetDevice != Ubuntu::Constants::UBUNTU_DEVICE_TYPE_ID)
+        return types;
+
+    bool isRemote = targetDevice == Ubuntu::Constants::UBUNTU_DEVICE_TYPE_ID;
+    bool isCMake  = parent->target()->project()->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID;
+    bool isHTML   = parent->target()->project()->id() == Ubuntu::Constants::UBUNTUPROJECT_ID;
+    //bool isQML    = parent->target()->project()->id() == "QmlProjectManager.QmlProject";
+
+    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))
+            return types;
+    }
+
+    if(isRemote && isCMake && !UbuntuProjectGuesser::isScopesProject(parent->target()->project()))
+        types << Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID
+              << Constants::UBUNTU_CLICK_PACKAGESTEP_ID;
+    else if(isRemote && isHTML)
+        types << Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID
+              << Constants::UBUNTU_CLICK_PACKAGESTEP_ID;
+
+    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);
+}
+
+ProjectExplorer::BuildStep *UbuntuDeployStepFactory::create(ProjectExplorer::BuildStepList *parent, const Core::Id id)
+{
+    if (!canCreate(parent, id))
+        return 0;
+
+    if(id == Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID)
+        return new UbuntuDirectUploadStep(parent);
+    else if (id == Constants::UBUNTU_CLICK_PACKAGESTEP_ID) {
+        UbuntuPackageStep *step = new UbuntuPackageStep(parent);
+        return step;
+    }
+
+    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))
+        return 0;
+
+    //backwards compatibility to older projects
+    if( id == Constants::UBUNTU_DEPLOY_MAKESTEP_ID ) {
+        UbuntuPackageStep *step = new UbuntuPackageStep(parent);
+        return step;
+    }
+
+    ProjectExplorer::BuildStep* step = create(parent,id);
+    if (!step->fromMap(map)) {
+        delete step;
+        return 0;
+    }
+
+    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))
+        return 0;
+
+    const Core::Id id = product->id();
+    if(id == Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID)
+        return new UbuntuDirectUploadStep(parent, static_cast<UbuntuDirectUploadStep *>(product));
+    else if(id == Core::Id(Constants::UBUNTU_CLICK_PACKAGESTEP_ID))
+        return new UbuntuPackageStep(parent, static_cast<UbuntuPackageStep *>(product));
+
+    return 0;
+}
+
+} // namespace Internal
+} // namespace Ubuntu
 
=== added file 'src/ubuntu/ubuntudeploystepfactory.h'
--- src/ubuntu/ubuntudeploystepfactory.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntudeploystepfactory.h	2014-07-23 14:19:54 +0000
@@ -0,0 +1,29 @@
+#ifndef UBUNTU_INTERNAL_UBUNTUDEPLOYSTEPFACTORY_H
+#define UBUNTU_INTERNAL_UBUNTUDEPLOYSTEPFACTORY_H
+
+#include <projectexplorer/buildstep.h>
+#include <projectexplorer/abstractprocessstep.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+class UbuntuDeployStepFactory : public ProjectExplorer::IBuildStepFactory
+{
+    Q_OBJECT
+
+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 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;
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_UBUNTUDEPLOYSTEPFACTORY_H
 
=== added file 'src/ubuntu/ubuntudirectuploadstep.cpp'
--- src/ubuntu/ubuntudirectuploadstep.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntudirectuploadstep.cpp	2014-07-23 14:19:54 +0000
@@ -0,0 +1,134 @@
+#include "ubuntudirectuploadstep.h"
+#include "ubuntupackagestep.h"
+#include "ubuntuconstants.h"
+
+#include <utils/qtcassert.h>
+#include <projectexplorer/deployablefile.h>
+#include <projectexplorer/target.h>
+#include <projectexplorer/project.h>
+
+#include <remotelinux/genericdirectuploadservice.h>
+#include <remotelinux/remotelinuxdeployconfiguration.h>
+
+#include <QFileInfo>
+
+namespace Ubuntu {
+namespace Internal {
+
+enum {
+    debug = 0
+};
+
+UbuntuDirectUploadStep::UbuntuDirectUploadStep(ProjectExplorer::BuildStepList *bsl)
+    : AbstractRemoteLinuxDeployStep(bsl, UbuntuDirectUploadStep::stepId())
+    , m_deployService(new RemoteLinux::GenericDirectUploadService(this))
+{
+    setDefaultDisplayName(displayName());
+}
+
+UbuntuDirectUploadStep::UbuntuDirectUploadStep(ProjectExplorer::BuildStepList *bsl, UbuntuDirectUploadStep *other)
+    : AbstractRemoteLinuxDeployStep(bsl, other)
+    , m_deployService(new RemoteLinux::GenericDirectUploadService(this))
+{
+    setDefaultDisplayName(displayName());
+
+    connect(target()->project(),SIGNAL(displayNameChanged()),this,SLOT(projectNameChanged()));
+    connect(target(),SIGNAL(applicationTargetsChanged()),this,SLOT(projectNameChanged()));
+}
+
+UbuntuDirectUploadStep::~UbuntuDirectUploadStep()
+{
+}
+
+void UbuntuDirectUploadStep::run(QFutureInterface<bool> &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();
+        return;
+    }
+
+
+    m_deployService->setIncrementalDeployment(false);
+    m_deployService->setIgnoreMissingFiles(false);
+
+    QString whyNot;
+    if(!deployService()->isDeploymentPossible(&whyNot)) {
+        emit addOutput(tr("Deploy step failed. %1").arg(whyNot), ErrorMessageOutput);
+        fi.reportResult(false);
+        emit finished();
+        return;
+    }
+
+    AbstractRemoteLinuxDeployStep::run(fi);
+}
+
+ProjectExplorer::BuildStepConfigWidget *UbuntuDirectUploadStep::createConfigWidget()
+{
+    return new ProjectExplorer::SimpleBuildStepConfigWidget(this);
+}
+
+bool UbuntuDirectUploadStep::initInternal(QString *error)
+{
+    Q_UNUSED(error)
+    return true;
+}
+
+RemoteLinux::AbstractRemoteLinuxDeployService *UbuntuDirectUploadStep::deployService() const
+{
+    return m_deployService;
+}
+
+bool UbuntuDirectUploadStep::fromMap(const QVariantMap &map)
+{
+    if (!AbstractRemoteLinuxDeployStep::fromMap(map))
+        return false;
+    return true;
+}
+
+QVariantMap UbuntuDirectUploadStep::toMap() const
+{
+    return AbstractRemoteLinuxDeployStep::toMap();
+}
+
+
+Core::Id UbuntuDirectUploadStep::stepId()
+{
+    return Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID;
+}
+
+QString UbuntuDirectUploadStep::displayName()
+{
+    return tr("Upload files to Ubuntu Device");
+}
+
+void UbuntuDirectUploadStep::projectNameChanged()
+{
+    if(debug) qDebug()<<"------------------------ Updating DEPLOYLIST ---------------------------";
+
+    ProjectExplorer::BuildStepList *bsList = deployConfiguration()->stepList();
+
+    QList<ProjectExplorer::DeployableFile> list;
+    foreach(ProjectExplorer::BuildStep *currStep ,bsList->steps()) {
+        UbuntuPackageStep *pckStep = qobject_cast<UbuntuPackageStep*>(currStep);
+        if(!pckStep)
+            continue;
+
+        QFileInfo info(pckStep->packagePath());
+        if(info.exists()) {
+            list.append(ProjectExplorer::DeployableFile(info.filePath(),
+                                                        QStringLiteral("/tmp")));
+
+            list.append(ProjectExplorer::DeployableFile(QStringLiteral("%1/qtc_device_applaunch.py").arg(Constants::UBUNTU_SCRIPTPATH),
+                                                        QStringLiteral("/tmp")));
+            m_deployService->setDeployableFiles(list);
+            m_foundClickPackage = true;
+            break;
+        }
+    }
+}
+} // namespace Internal
+} // namespace Ubuntu
 
=== added file 'src/ubuntu/ubuntudirectuploadstep.h'
--- src/ubuntu/ubuntudirectuploadstep.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntudirectuploadstep.h	2014-07-23 14:19:54 +0000
@@ -0,0 +1,46 @@
+#ifndef UBUNTU_INTERNAL_UBUNTUDIRECTUPLOADSTEP_H
+#define UBUNTU_INTERNAL_UBUNTUDIRECTUPLOADSTEP_H
+
+#include <remotelinux/abstractremotelinuxdeploystep.h>
+
+namespace RemoteLinux {
+class GenericDirectUploadService;
+}
+
+namespace Ubuntu {
+namespace Internal {
+
+class UbuntuDirectUploadStep : public RemoteLinux::AbstractRemoteLinuxDeployStep
+{
+    Q_OBJECT
+
+public:
+    UbuntuDirectUploadStep(ProjectExplorer::BuildStepList *bsl);
+    UbuntuDirectUploadStep(ProjectExplorer::BuildStepList *bsl, UbuntuDirectUploadStep *other);
+    ~UbuntuDirectUploadStep();
+
+    // BuildStep interface
+    virtual void run(QFutureInterface<bool> &fi) override;
+
+    ProjectExplorer::BuildStepConfigWidget *createConfigWidget();
+    bool initInternal(QString *error = 0) override;
+
+    RemoteLinux::AbstractRemoteLinuxDeployService *deployService() const override;
+    bool fromMap(const QVariantMap &map) override;
+    QVariantMap toMap() const override;
+
+    static Core::Id stepId();
+    static QString displayName();
+
+private slots:
+    void projectNameChanged();
+
+private:
+    RemoteLinux::GenericDirectUploadService *m_deployService;
+    bool m_foundClickPackage;
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_UBUNTUDIRECTUPLOADSTEP_H
 
=== added file 'src/ubuntu/ubuntuhtmlbuildconfiguration.cpp'
--- src/ubuntu/ubuntuhtmlbuildconfiguration.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntuhtmlbuildconfiguration.cpp	2014-07-23 14:19:54 +0000
@@ -0,0 +1,202 @@
+#include "ubuntuhtmlbuildconfiguration.h"
+#include "ubuntuconstants.h"
+#include "ubuntuproject.h"
+
+#include <coreplugin/mimedatabase.h>
+
+#include <projectexplorer/target.h>
+#include <projectexplorer/project.h>
+#include <projectexplorer/buildinfo.h>
+#include <projectexplorer/kit.h>
+#include <utils/fancylineedit.h>
+
+#include <QFormLayout>
+
+namespace Ubuntu {
+namespace Internal {
+
+/*!
+ * \class UbuntuHtmlBuildConfiguration
+ *
+ * Even though HTML projects don't need to be built, we need
+ * that BuildConfiguration to store the Builddirectory (where the click
+ * package goes) and to enable the Target page to show us some actual
+ * targets
+ */
+
+UbuntuHtmlBuildConfiguration::UbuntuHtmlBuildConfiguration(ProjectExplorer::Target *target)
+    : BuildConfiguration(target,Constants::UBUNTU_CLICK_HTML_BC_ID)
+{
+}
+
+UbuntuHtmlBuildConfiguration::UbuntuHtmlBuildConfiguration(ProjectExplorer::Target *target, UbuntuHtmlBuildConfiguration *source)
+    : BuildConfiguration(target,source)
+{
+
+}
+
+bool UbuntuHtmlBuildConfiguration::fromMap(const QVariantMap &map)
+{
+    return BuildConfiguration::fromMap(map);
+}
+
+QVariantMap UbuntuHtmlBuildConfiguration::toMap() const
+{
+    return BuildConfiguration::toMap();
+}
+
+ProjectExplorer::NamedWidget *UbuntuHtmlBuildConfiguration::createConfigWidget()
+{
+    return new UbuntuHtmlBuildSettingsWidget(this);
+}
+
+ProjectExplorer::BuildConfiguration::BuildType UbuntuHtmlBuildConfiguration::buildType() const
+{
+    return Release;
+}
+
+UbuntuHtmlBuildConfigurationFactory::UbuntuHtmlBuildConfigurationFactory(QObject *parent)
+    : IBuildConfigurationFactory(parent)
+{
+
+}
+
+UbuntuHtmlBuildConfigurationFactory::~UbuntuHtmlBuildConfigurationFactory()
+{
+
+}
+
+int UbuntuHtmlBuildConfigurationFactory::priority(const ProjectExplorer::Target *parent) const
+{
+    if (canHandle(parent))
+        return 100;
+    return -1;
+}
+
+QList<ProjectExplorer::BuildInfo *> UbuntuHtmlBuildConfigurationFactory::availableBuilds(const ProjectExplorer::Target *parent) const
+{
+    if(!canHandle(parent))
+        return QList<ProjectExplorer::BuildInfo *>();
+    return createBuildInfos(parent->kit(),parent->project()->projectFilePath());
+}
+
+int UbuntuHtmlBuildConfigurationFactory::priority(const ProjectExplorer::Kit *k, const QString &projectPath) const
+{
+    return (k && Core::MimeDatabase::findByFile(QFileInfo(projectPath))
+            .matchesType(QLatin1String(Constants::UBUNTUPROJECT_MIMETYPE))) ? 100 : -1;
+}
+
+QList<ProjectExplorer::BuildInfo *> UbuntuHtmlBuildConfigurationFactory::availableSetups(const ProjectExplorer::Kit *k, const QString &projectPath) const
+{
+    UbuntuKitMatcher m;
+    if(priority(k,projectPath) < 0 || !m.matches(k))
+        return QList<ProjectExplorer::BuildInfo *>();
+
+    return createBuildInfos(k,projectPath);
+}
+
+UbuntuHtmlBuildConfiguration *UbuntuHtmlBuildConfigurationFactory::create(ProjectExplorer::Target *parent, const ProjectExplorer::BuildInfo *info) const
+{
+    QTC_ASSERT(info->factory() == this, return 0);
+    QTC_ASSERT(info->kitId == parent->kit()->id(), return 0);
+    QTC_ASSERT(!info->displayName.isEmpty(), return 0);
+
+    UbuntuHtmlBuildConfiguration *conf = new UbuntuHtmlBuildConfiguration(parent);
+    conf->setBuildDirectory(info->buildDirectory);
+    conf->setDefaultDisplayName(info->displayName);
+    conf->setDisplayName(info->displayName);
+
+    return conf;
+}
+
+bool UbuntuHtmlBuildConfigurationFactory::canRestore(const ProjectExplorer::Target *parent, const QVariantMap &map) const
+{
+    if (!canHandle(parent))
+        return false;
+    return ProjectExplorer::idFromMap(map) == Constants::UBUNTU_CLICK_HTML_BC_ID;
+}
+
+UbuntuHtmlBuildConfiguration *UbuntuHtmlBuildConfigurationFactory::restore(ProjectExplorer::Target *parent, const QVariantMap &map)
+{
+    if (!canRestore(parent,map) )
+        return 0;
+
+    UbuntuHtmlBuildConfiguration *conf = new UbuntuHtmlBuildConfiguration(parent);
+    if (conf->fromMap(map))
+        return conf;
+
+    delete conf;
+    return 0;
+}
+
+bool UbuntuHtmlBuildConfigurationFactory::canClone(const ProjectExplorer::Target *parent, ProjectExplorer::BuildConfiguration *product) const
+{
+    if (!canHandle(parent))
+        return false;
+    if (product->id() != Constants::UBUNTU_CLICK_HTML_BC_ID )
+        return false;
+
+    return true;
+}
+
+UbuntuHtmlBuildConfiguration *UbuntuHtmlBuildConfigurationFactory::clone(ProjectExplorer::Target *parent, ProjectExplorer::BuildConfiguration *product)
+{
+    if (!canClone(parent,product))
+        return 0;
+    return new UbuntuHtmlBuildConfiguration(parent,static_cast<UbuntuHtmlBuildConfiguration*>(product));
+}
+
+bool UbuntuHtmlBuildConfigurationFactory::canHandle(const ProjectExplorer::Target *t) const
+{
+    UbuntuKitMatcher m;
+    if(!m.matches(t->kit()))
+        return false;
+
+    if (t->project()->projectManager()->mimeType() != QLatin1String(Constants::UBUNTUPROJECT_MIMETYPE))
+        return false;
+
+    return true;
+}
+
+QList<ProjectExplorer::BuildInfo *> UbuntuHtmlBuildConfigurationFactory::createBuildInfos(const ProjectExplorer::Kit *k, const QString &projectDir) const
+{
+    QList<ProjectExplorer::BuildInfo *> builds;
+
+    ProjectExplorer::BuildInfo *info = new ProjectExplorer::BuildInfo(this);
+    info->buildDirectory = Utils::FileName::fromString(UbuntuProject::shadowBuildDirectory(projectDir,k,QStringLiteral("default")));
+    info->typeName = tr("Html5");
+    info->kitId    = k->id();
+    info->supportsShadowBuild = true;
+    info->displayName = tr("Default");
+
+    builds << info;
+    return builds;
+}
+
+UbuntuHtmlBuildSettingsWidget::UbuntuHtmlBuildSettingsWidget(UbuntuHtmlBuildConfiguration *conf, QWidget *parent)
+    : NamedWidget(parent) ,
+      m_buildConfiguration(conf)
+{
+    QFormLayout *fl = new QFormLayout(this);
+    fl->setContentsMargins(20, -1, 0, -1);
+    fl->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
+    setLayout(fl);
+
+    m_pathChooser = new Utils::PathChooser(this);
+    m_pathChooser->setPath(m_buildConfiguration->rawBuildDirectory().toString());
+    fl->addRow(tr("Build directory:"), m_pathChooser);
+
+    connect(m_pathChooser->lineEdit(),SIGNAL(editingFinished()),this,SLOT(onBuilddirChanged()));
+    connect(m_buildConfiguration,SIGNAL(buildDirectoryChanged()),this,SLOT(updateBuildDirectory()));
+}
+
+void UbuntuHtmlBuildSettingsWidget::updateBuildDirectory() const
+{
+    m_pathChooser->blockSignals(true);
+    m_pathChooser->setPath(m_buildConfiguration->rawBuildDirectory().toString());
+    m_pathChooser->blockSignals(false);
+}
+
+
+} // namespace Internal
+} // namespace Ubuntu
 
=== added file 'src/ubuntu/ubuntuhtmlbuildconfiguration.h'
--- src/ubuntu/ubuntuhtmlbuildconfiguration.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntuhtmlbuildconfiguration.h	2014-07-23 14:19:54 +0000
@@ -0,0 +1,71 @@
+#ifndef UBUNTU_INTERNAL_UBUNTUHTMLBUILDCONFIGURATION_H
+#define UBUNTU_INTERNAL_UBUNTUHTMLBUILDCONFIGURATION_H
+
+#include <projectexplorer/buildconfiguration.h>
+#include <utils/pathchooser.h>
+#include <projectexplorer/namedwidget.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+class UbuntuHtmlBuildConfiguration : public ProjectExplorer::BuildConfiguration
+{
+    Q_OBJECT
+
+public:
+    UbuntuHtmlBuildConfiguration(ProjectExplorer::Target *target);
+    UbuntuHtmlBuildConfiguration(ProjectExplorer::Target *target, UbuntuHtmlBuildConfiguration *source);
+
+    // ProjectConfiguration interface
+    virtual bool fromMap(const QVariantMap &map) override;
+    virtual QVariantMap toMap() const override;
+
+    // BuildConfiguration interface
+    virtual ProjectExplorer::NamedWidget *createConfigWidget() override;
+    virtual BuildType buildType() const override;
+
+private:
+    friend class UbuntuHtmlBuildConfigurationFactory;
+};
+
+class UbuntuHtmlBuildSettingsWidget : public ProjectExplorer::NamedWidget
+{
+    Q_OBJECT
+
+public:
+    explicit UbuntuHtmlBuildSettingsWidget(UbuntuHtmlBuildConfiguration *conf, QWidget *parent = 0);
+
+private slots:
+    void updateBuildDirectory () const;
+
+private:
+    Utils::PathChooser *m_pathChooser;
+    UbuntuHtmlBuildConfiguration *m_buildConfiguration;
+};
+
+class UbuntuHtmlBuildConfigurationFactory : public ProjectExplorer::IBuildConfigurationFactory
+{
+    Q_OBJECT
+public:
+    UbuntuHtmlBuildConfigurationFactory(QObject *parent = 0);
+    ~UbuntuHtmlBuildConfigurationFactory();
+
+    // IBuildConfigurationFactory interface
+    virtual int priority(const ProjectExplorer::Target *parent) const override;
+    virtual QList<ProjectExplorer::BuildInfo *> availableBuilds(const ProjectExplorer::Target *parent) const override;
+    virtual int priority(const ProjectExplorer::Kit *k, const QString &projectPath) const override;
+    virtual QList<ProjectExplorer::BuildInfo *> availableSetups(const ProjectExplorer::Kit *k, const QString &projectPath) const override;
+    virtual UbuntuHtmlBuildConfiguration *create(ProjectExplorer::Target *parent, const ProjectExplorer::BuildInfo *info) const override;
+    virtual bool canRestore(const ProjectExplorer::Target *parent, const QVariantMap &map) const override;
+    virtual UbuntuHtmlBuildConfiguration *restore(ProjectExplorer::Target *parent, const QVariantMap &map) override;
+    virtual bool canClone(const ProjectExplorer::Target *parent, ProjectExplorer::BuildConfiguration *product) const override;
+    virtual UbuntuHtmlBuildConfiguration*clone(ProjectExplorer::Target *parent, ProjectExplorer::BuildConfiguration *product) override;
+private:
+    bool canHandle(const ProjectExplorer::Target *t) const;
+    QList<ProjectExplorer::BuildInfo *> createBuildInfos (const ProjectExplorer::Kit *k, const QString &projectDir) const;
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_UBUNTUHTMLBUILDCONFIGURATION_H
 
=== modified file 'src/ubuntu/ubuntulocalrunconfiguration.cpp'
--- src/ubuntu/ubuntulocalrunconfiguration.cpp	2014-07-08 09:35:23 +0000
+++ src/ubuntu/ubuntulocalrunconfiguration.cpp	2014-07-23 14:19:54 +0000
@@ -20,6 +20,7 @@
 #include "ubuntuproject.h"
 #include "ubuntuprojectguesser.h"
 #include "ubuntuclickmanifest.h"
+#include "ubunturemoterunconfiguration.h"
 
 #include <qtsupport/baseqtversion.h>
 #include <qtsupport/qtkitinformation.h>
@@ -177,7 +178,15 @@
         return desk;
     }
 
-    QDir package_dir(config->target()->activeBuildConfiguration()->buildDirectory().toString()+QDir::separator()+QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR));
+
+     UbuntuRemoteRunConfiguration *remConf = qobject_cast<UbuntuRemoteRunConfiguration*>(config);
+    if (!remConf) {
+        if(errorMessage)
+            *errorMessage = tr("Invalid configuration type");
+        return QString();
+    }
+
+    QDir package_dir(remConf->packageDir());
     if(!package_dir.exists()) {
         if(errorMessage)
             *errorMessage = tr("No packaging directory available, please check if the deploy configuration is correct.");
@@ -376,6 +385,13 @@
             m_executable = env.searchInPath(QString::fromLatin1(Ubuntu::Constants::UBUNTUHTML_PROJECT_LAUNCHER_EXE));
             m_args = QStringList()<<QString::fromLatin1("--www=%0/www").arg(ubuntuProject->projectDirectory())
                                  <<QString::fromLatin1("--inspector");
+        } else if (ubuntuProject->mainFile().endsWith(QStringLiteral(".desktop"), Qt::CaseInsensitive)) {
+            Utils::Environment env = Utils::Environment::systemEnvironment();
+
+            if(!readDesktopFile(ubuntuProject->projectDirectory()+QDir::separator()+ubuntuProject->mainFile(),&m_executable,&m_args,errorMessage))
+                return false;
+
+            m_executable = env.searchInPath(QString::fromLatin1(Ubuntu::Constants::UBUNTUWEBAPP_PROJECT_LAUNCHER_EXE));
         } else {
             m_executable = QtSupport::QtKitInformation::qtVersion(target()->kit())->qmlsceneCommand();
             m_args = QStringList()<<QString(QLatin1String("%0.qml")).arg(ubuntuProject->displayName());
 
=== modified file 'src/ubuntu/ubuntulocalrunconfigurationfactory.cpp'
--- src/ubuntu/ubuntulocalrunconfigurationfactory.cpp	2014-06-18 07:29:05 +0000
+++ src/ubuntu/ubuntulocalrunconfigurationfactory.cpp	2014-07-23 14:19:54 +0000
@@ -33,50 +33,59 @@
 using namespace Ubuntu;
 using namespace Ubuntu::Internal;
 
-QList<Core::Id> UbuntuLocalRunConfigurationFactory::availableCreationIds(ProjectExplorer::Target *parent) const {
-    if (!canHandle(parent))
-        return QList<Core::Id>();
-
-    QList<Core::Id> list;
+enum {
+    debug = 1
+};
+
+QList<Core::Id> UbuntuLocalRunConfigurationFactory::availableCreationIds(ProjectExplorer::Target *parent) const
+{
+    QList<Core::Id> types;
+
+    Core::Id targetDevice = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(parent->kit());
+    if(targetDevice != ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE && targetDevice != Ubuntu::Constants::UBUNTU_DEVICE_TYPE_ID) {
+        if(debug) qDebug()<<"Rejecting device type: "<<targetDevice.toString();
+        return types;
+    }
+
+    bool isRemote = targetDevice == Ubuntu::Constants::UBUNTU_DEVICE_TYPE_ID;
+    bool isCMake  = parent->project()->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID;
+    bool isHTML   = parent->project()->id() == Ubuntu::Constants::UBUNTUPROJECT_ID;
+    bool isApp    = UbuntuProjectGuesser::isClickAppProject(parent->project());
+    //bool isQML    = parent->target()->project()->id() == "QmlProjectManager.QmlProject";
+
+    if (!isCMake && !isHTML)
+        return types;
+
+    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))
+            return types;
+    }
 
     QString manifestPath = QStringLiteral("%1/manifest.json").arg(parent->project()->projectDirectory());
     UbuntuClickManifest manifest;
 
     //if we have no manifest, we can not query the app id's
-    if(!manifest.load(manifestPath,parent->project()->displayName()))
-        return list;
+    if(!manifest.load(manifestPath,parent->displayName()))
+        return types;
 
     QList<UbuntuClickManifest::Hook> hooks = manifest.hooks();
-
-
-    bool isDesktopDevice = ProjectExplorer::DeviceKitInformation::deviceId(parent->kit()) == ProjectExplorer::Constants::DESKTOP_DEVICE_ID;
-
-    ProjectExplorer::IDevice::ConstPtr devPtr = ProjectExplorer::DeviceKitInformation::device(parent->kit());
-    bool isUbuntuDevice  = (devPtr.isNull() == false) && (devPtr->type() == Constants::UBUNTU_DEVICE_TYPE_ID);
-
-    if(parent->project()->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID) {
-
-        bool isScopes = UbuntuProjectGuesser::isScopesProject(parent->project());
-        bool isApp    = UbuntuProjectGuesser::isClickAppProject(parent->project());
-
-        //the scopes project has no run on device yet, thats why finding a
-        //scopes project will block creating any runconfigurations for the device
-        if ( isScopes && !isDesktopDevice)
-                return list;
-
+    if (!isRemote) {
         foreach (const UbuntuClickManifest::Hook &hook, hooks) {
-            if (isUbuntuDevice && isApp) {
-                list << UbuntuRemoteRunConfiguration::typeId().withSuffix(hook.appId);
-            } else {
-                list << Core::Id(Constants::UBUNTUPROJECT_RUNCONTROL_ID).withSuffix(hook.appId);
+            types << Core::Id(Constants::UBUNTUPROJECT_RUNCONTROL_ID).withSuffix(hook.appId);
+        }
+    }
+    else if (isRemote) {
+        //when CMake we only support App projects, scopes have no way to be controlled on the device atm
+        if ((isCMake && isApp) || isHTML) {
+            foreach (const UbuntuClickManifest::Hook &hook, hooks) {
+                types << UbuntuRemoteRunConfiguration::typeId().withSuffix(hook.appId);
             }
         }
-    } else {
-        foreach (const UbuntuClickManifest::Hook &hook, hooks) {
-            list << Core::Id(Constants::UBUNTUPROJECT_RUNCONTROL_ID).withSuffix(hook.appId);
-        }
     }
-    return list;
+
+    return types;
 }
 
 QString UbuntuLocalRunConfigurationFactory::displayNameForId(const Core::Id id) const
@@ -88,40 +97,9 @@
     return QString();
 }
 
-bool UbuntuLocalRunConfigurationFactory::canHandle(ProjectExplorer::Target *parent) const {
-
-    if(qobject_cast<CMakeProjectManager::CMakeProject*>(parent->project())) {
-        if (!parent->project()->supportsKit(parent->kit()))
-            return false;
-
-        ProjectExplorer::ToolChain *tc
-                = ProjectExplorer::ToolChainKitInformation::toolChain(parent->kit());
-        if (!tc || tc->targetAbi().os() != ProjectExplorer::Abi::LinuxOS)
-            return false;
-
-        if(tc->type() == QString::fromLatin1(Constants::UBUNTU_CLICK_TOOLCHAIN_ID))
-            return true;
-
-        bool isDesktopDevice = ProjectExplorer::DeviceKitInformation::deviceId(parent->kit()) == ProjectExplorer::Constants::DESKTOP_DEVICE_ID;
-        if(UbuntuProjectGuesser::isScopesProject(parent->project())
-                && isDesktopDevice)
-            return true;
-        else if(isDesktopDevice && UbuntuProjectGuesser::isClickAppProject(parent->project()))
-            return true;
-
-        return false;
-    }
-
-    if (!qobject_cast<UbuntuProject *>(parent->project()))
-        return false;
-    return true;
-}
-
 bool UbuntuLocalRunConfigurationFactory::canCreate(ProjectExplorer::Target *parent,
-                                         const Core::Id id) const {
-    if (!canHandle(parent))
-        return false;
-
+                                                   const Core::Id id) const
+{
     return availableCreationIds(parent).contains(id);
 }
 
@@ -160,7 +138,7 @@
 }
 
 ProjectExplorer::RunConfiguration *UbuntuLocalRunConfigurationFactory::clone(ProjectExplorer::Target *parent,
-                                                                   ProjectExplorer::RunConfiguration *source) {
+                                                                             ProjectExplorer::RunConfiguration *source) {
     if (!canClone(parent, source))
         return NULL;
 
 
=== modified file 'src/ubuntu/ubuntupackagestep.cpp'
--- src/ubuntu/ubuntupackagestep.cpp	2014-06-17 11:48:05 +0000
+++ src/ubuntu/ubuntupackagestep.cpp	2014-07-23 14:19:54 +0000
@@ -13,6 +13,7 @@
 #include <projectexplorer/deployconfiguration.h>
 #include <projectexplorer/ioutputparser.h>
 #include <utils/qtcprocess.h>
+#include <cmakeprojectmanager/cmakeprojectconstants.h>
 
 #include <QDir>
 #include <QTimer>
@@ -67,42 +68,117 @@
 {
     m_tasks.clear();
 
-    ProjectExplorer::BuildConfiguration *bc = target()->activeBuildConfiguration();
-    if (!bc){
-        ProjectExplorer::Task t(ProjectExplorer::Task::Error
-                                ,tr("No valid BuildConfiguration set for step: %1").arg(displayName())
-                                ,Utils::FileName(),-1
-                                ,ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM);
-        m_tasks.append(t);
-
-        //UbuntuClickPackageStep::run will stop if tasks exist
-        return true;
-
+    QString projectDir = target()->project()->projectDirectory();
+    QString deployDir;
+    Utils::Environment env = Utils::Environment::systemEnvironment();
+    Utils::AbstractMacroExpander *mExp = 0;
+
+    {
+        ProjectExplorer::BuildConfiguration *bc = target()->activeBuildConfiguration();
+        if(bc) {
+            m_buildDir  = bc->buildDirectory().toString();
+            deployDir = bc->buildDirectory().toString()
+                    + QDir::separator()
+                    + QString::fromLatin1(Constants::UBUNTU_DEPLOY_DESTDIR);
+            env = bc->environment();
+            mExp = bc->macroExpander();
+        } else {
+            //cmake projects NEED a buildconfiguration
+            if (target()->project()->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID) {
+                ProjectExplorer::Task t(ProjectExplorer::Task::Error
+                                        ,tr("No valid BuildConfiguration set for step: %1").arg(displayName())
+                                        ,Utils::FileName(),-1
+                                        ,ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM);
+                m_tasks.append(t);
+
+                //UbuntuClickPackageStep::run will stop if tasks exist
+                return true;
+            } else {
+                //backward compatibility, old HTML5 projects did not have a Buildconfiguration
+                //this would crash otherwise
+
+                //ubuntu + qml project types
+                QDir pDir(projectDir);
+                m_buildDir = QDir::cleanPath(target()->project()->projectDirectory()
+                                           +QDir::separator()+QStringLiteral("..")
+                                           +QDir::separator()+pDir.dirName()+QStringLiteral("_build"));
+                deployDir = m_buildDir+QDir::separator()+QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR);
+
+                //clean up the old "build"
+                QDir bd(m_buildDir);
+                if(!bd.exists(m_buildDir))
+                    bd.mkdir(m_buildDir);
+            }
+        }
     }
 
     //build the make process arguments
     {
-        QStringList arguments;
-        arguments << QStringLiteral("DESTDIR=%1").arg(QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR))
-                  << QStringLiteral("install");
-
-        ProjectExplorer::ProcessParameters* params = &m_MakeParam;
-        params->setMacroExpander(bc->macroExpander());
-
-        //setup process parameters
-        params->setWorkingDirectory(bc->buildDirectory().toString());
-        params->setCommand(
-                    makeCommand(ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit()),
-                                bc->environment()));
-        params->setArguments(Utils::QtcProcess::joinArgs(arguments));
-
-        Utils::Environment env = bc->environment();
-        // Force output to english for the parsers. Do this here and not in the toolchain's
-        // addToEnvironment() to not screw up the users run environment.
-        env.set(QLatin1String("LC_ALL"), QLatin1String("C"));
-        params->setEnvironment(env);
-
-        params->resolveAll();
+        if (target()->project()->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID) {
+            QStringList arguments;
+            arguments << QStringLiteral("DESTDIR=%1").arg(QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR))
+                      << QStringLiteral("install");
+
+            ProjectExplorer::ProcessParameters* params = &m_MakeParam;
+            params->setMacroExpander(mExp);
+
+            //setup process parameters
+            params->setWorkingDirectory(m_buildDir);
+            params->setCommand(
+                        makeCommand(ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit()),
+                                    env));
+            params->setArguments(Utils::QtcProcess::joinArgs(arguments));
+
+            Utils::Environment tmpenv = env;
+            // Force output to english for the parsers. Do this here and not in the toolchain's
+            // addToEnvironment() to not screw up the users run environment.
+            tmpenv.set(QLatin1String("LC_ALL"), QLatin1String("C"));
+            params->setEnvironment(tmpenv);
+
+            params->resolveAll();
+        } else {
+            //QML and HTML projects are just rsynced for now
+            QStringList arguments;
+            arguments << QStringLiteral("-avh")
+                      << QStringLiteral("--delete")
+                      << QStringLiteral("--exclude")<<QStringLiteral(".bzr")
+                      << QStringLiteral("--exclude")<<QStringLiteral(".git")
+                      << QStringLiteral("--exclude")<<QStringLiteral(".hg")
+                      << QStringLiteral("--exclude")<<QStringLiteral(".svn")
+                      << QStringLiteral("--exclude")<<QStringLiteral("*.qmlproject")
+                      << QStringLiteral("--exclude")<<QStringLiteral("*.user")
+                      << QStringLiteral("--exclude")<<QStringLiteral("tests")
+                      << QStringLiteral("--exclude")<<QStringLiteral("Makefile")
+                      << QStringLiteral("--exclude")<<QStringLiteral(".excludes")
+                      << QStringLiteral("--exclude")<<QStringLiteral("*.ubuntuhtmlproject");
+
+            QFile excludes (projectDir+QDir::separator()+QStringLiteral(".excludes"));
+            if (excludes.open(QIODevice::ReadOnly)) {
+                while (excludes.canReadLine()) {
+                    arguments << QStringLiteral("--exclude") << QString::fromUtf8(excludes.readLine());
+                }
+                excludes.close();
+            }
+
+            arguments << projectDir+QDir::separator()
+                      << deployDir;
+
+            ProjectExplorer::ProcessParameters* params = &m_MakeParam;
+            params->setMacroExpander(mExp);
+
+            //setup process parameters
+            params->setWorkingDirectory(m_buildDir);
+            params->setCommand(QStringLiteral("rsync"));
+            params->setArguments(Utils::QtcProcess::joinArgs(arguments));
+
+            Utils::Environment tmpenv = env;
+            // Force output to english for the parsers. Do this here and not in the toolchain's
+            // addToEnvironment() to not screw up the users run environment.
+            tmpenv.set(QLatin1String("LC_ALL"), QLatin1String("C"));
+            params->setEnvironment(tmpenv);
+
+            params->resolveAll();
+        }
     }
 
 
@@ -110,23 +186,21 @@
     {
         QStringList arguments;
         arguments << QLatin1String("build")
-                  << bc->buildDirectory().toString()
-                     + QDir::separator()
-                     + QString::fromLatin1(Constants::UBUNTU_DEPLOY_DESTDIR);
+                  << deployDir;
 
         ProjectExplorer::ProcessParameters* params = &m_ClickParam;
-        params->setMacroExpander(bc->macroExpander());
+        params->setMacroExpander(mExp);
 
         //setup process parameters
-        params->setWorkingDirectory(bc->buildDirectory().toString());
+        params->setWorkingDirectory(m_buildDir);
         params->setCommand(QLatin1String("click"));
         params->setArguments(Utils::QtcProcess::joinArgs(arguments));
 
-        Utils::Environment env = bc->environment();
+        Utils::Environment tmpEnv = env;
         // Force output to english for the parsers. Do this here and not in the toolchain's
         // addToEnvironment() to not screw up the users run environment.
-        env.set(QLatin1String("LC_ALL"), QLatin1String("C"));
-        params->setEnvironment(env);
+        tmpEnv.set(QLatin1String("LC_ALL"), QLatin1String("C"));
+        params->setEnvironment(tmpEnv);
 
         params->resolveAll();
     }
@@ -198,7 +272,7 @@
 {
     if(m_clickPackageName.isEmpty())
         return QString();
-    return target()->activeBuildConfiguration()->buildDirectory().toString()
+    return m_buildDir
             + QDir::separator()
             + m_clickPackageName;
 }
@@ -376,6 +450,11 @@
 {
     ProjectExplorer::BuildConfiguration *bc = target()->activeBuildConfiguration();
 
+    if(!bc) {
+        QTimer::singleShot(0,this,SLOT(doNextStep()));
+        return;
+    }
+
     bool ubuntuDevice = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(bc->target()->kit()) == Constants::UBUNTU_DEVICE_TYPE_ID;
     bool injectDebugScript = (m_packageMode == EnableDebugScript) ||
             (m_packageMode == AutoEnableDebugScript && bc->buildType() == ProjectExplorer::BuildConfiguration::Debug);
@@ -400,10 +479,10 @@
 
         UbuntuClickManifest manifest;
         if(!manifest.load(bc->buildDirectory()
-                      .appendPath(QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR))
-                      .appendPath(QStringLiteral("manifest.json"))
-                      .toString(),
-                      projectName)) {
+                          .appendPath(QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR))
+                          .appendPath(QStringLiteral("manifest.json"))
+                          .toString(),
+                          projectName)) {
 
             emit addOutput(tr("Could not find the manifest.json file in %1.\nPlease check if it is added to the install targets in your project file")
                            .arg(bc->buildDirectory()
@@ -514,7 +593,7 @@
 
             //return to MainLoop to update the progressBar
             QTimer::singleShot(0,this,SLOT(injectDebugHelperStep()));
-                    break;
+            break;
         }
         case PreparePackage: {
             m_futureInterface->setProgressValueAndText(2,tr("Building click package"));
@@ -533,7 +612,7 @@
             QRegularExpressionMatch m = exp.match(m_lastLine);
             if(m.hasMatch()) {
                 m_clickPackageName = m.captured(1);
-                emit addOutput(tr("The click package has been created in %1").arg(target()->activeBuildConfiguration()->buildDirectory().toString()) ,
+                emit addOutput(tr("The click package has been created in %1").arg(m_buildDir) ,
                                ProjectExplorer::BuildStep::MessageOutput);
             }
 
 
=== modified file 'src/ubuntu/ubuntupackagestep.h'
--- src/ubuntu/ubuntupackagestep.h	2014-06-17 09:25:03 +0000
+++ src/ubuntu/ubuntupackagestep.h	2014-07-23 14:19:54 +0000
@@ -81,6 +81,7 @@
     State m_state;
     QString m_lastLine;
     QString m_clickPackageName;
+    QString m_buildDir;
     QList<ProjectExplorer::Task> m_tasks;
     QFutureInterface<bool> *m_futureInterface;
 
 
=== modified file 'src/ubuntu/ubuntupackagingwidget.cpp'
--- src/ubuntu/ubuntupackagingwidget.cpp	2014-07-10 13:20:17 +0000
+++ src/ubuntu/ubuntupackagingwidget.cpp	2014-07-23 14:19:54 +0000
@@ -26,6 +26,7 @@
 #include "ubuntuvalidationresultmodel.h"
 #include "ubuntudevice.h"
 #include "ubuntupackagestep.h"
+#include "ubuntushared.h"
 
 #include <projectexplorer/projectexplorer.h>
 #include <projectexplorer/project.h>
@@ -98,10 +99,9 @@
     connect(m_validationModel,SIGNAL(rowsInserted(QModelIndex,int,int)),this,SLOT(onNewValidationData()));
 
     connect(UbuntuMenu::instance(),SIGNAL(requestBuildAndInstallProject()),this,SLOT(buildAndInstallPackageRequested()));
+    connect(ProjectExplorer::SessionManager::instance(),SIGNAL(startupProjectChanged(ProjectExplorer::Project*)),this,SLOT(onStartupProjectChanged()));
 
-    ui->comboBoxFramework->blockSignals(true);
-    ui->comboBoxFramework->addItems(UbuntuClickTool::getSupportedFrameworks());
-    ui->comboBoxFramework->blockSignals(false);
+    updateFrameworkList();
 
     m_reviewToolsInstalled = false;
     checkClickReviewerTool();
@@ -112,7 +112,7 @@
     autoSave();
     delete ui;
 
-    clearAdditionalBuildSteps();
+    clearPackageBuildList();
 }
 
 QString UbuntuPackagingWidget::createPackageName(const QString &userName, const QString &projectName)
@@ -185,7 +185,9 @@
     }
 }
 
-void UbuntuPackagingWidget::onMessage(QString msg) {
+void UbuntuPackagingWidget::onMessage(QString msg)
+{
+    if(debug) printToOutputPane(msg);
     m_reply.append(msg);
     m_inputParser->addRecievedData(msg);
 }
@@ -280,6 +282,26 @@
     m_ubuntuProcess.start(QString(QLatin1String(Constants::UBUNTUPACKAGINGWIDGET_CLICK_REVIEWER_TOOLS_AGAINST_PACKAGE)).arg(clickPackage));
 }
 
+void UbuntuPackagingWidget::onStartupProjectChanged()
+{
+    ProjectExplorer::Project *currProject = ProjectExplorer::SessionManager::startupProject();
+    if (currProject == m_currentProject.data())
+        return;
+
+    if(m_currentProject)
+        m_currentProject->disconnect(this);
+
+    m_currentProject = currProject;
+    connect(currProject,SIGNAL(activeTargetChanged(ProjectExplorer::Target*)),this,SLOT(onActiveTargetChanged()));
+    onActiveTargetChanged();
+}
+
+void UbuntuPackagingWidget::onActiveTargetChanged()
+{
+    if(this->isVisible())
+        reload();
+}
+
 void UbuntuPackagingWidget::autoSave() {
     save((ui->tabWidget->currentWidget() == ui->tabSimple));
 }
@@ -289,6 +311,8 @@
     ProjectExplorer::Project* startupProject = ProjectExplorer::SessionManager::startupProject();
 
     if (startupProject) {
+        updateFrameworkList();
+
         m_projectName = startupProject->displayName();
         m_projectDir  = startupProject->projectDirectory();
 
@@ -511,7 +535,12 @@
 
                 if(debug) qDebug()<<"Setting to "<<bzr->whoami();
             } else if (i.key() == QStringLiteral("framework")) {
-                targetObject.insert(i.key(),UbuntuClickTool::getMostRecentFramework( QString() ));
+                const UbuntuClickTool::Target *t = 0;
+                ProjectExplorer::Project *p = ProjectExplorer::SessionManager::startupProject();
+                if (p)
+                    t = UbuntuClickTool::clickTargetFromTarget(p->activeTarget());
+
+                targetObject.insert(i.key(),UbuntuClickTool::getMostRecentFramework( QString(), t));
             } else {
                 targetObject.insert(i.key(),i.value());
 
@@ -597,6 +626,7 @@
     ui->lineEdit_version->setText(m_manifest.version());
     ui->lineEdit_description->setText(m_manifest.description());
 
+    updateFrameworkList();
     int idx = ui->comboBoxFramework->findText(m_manifest.frameworkName());
 
     //disable the currentIndexChanged signal, reloading the files
@@ -668,7 +698,9 @@
     if(!project)
         return;
 
-    if(project->projectManager()->mimeType() == QLatin1String(CMakeProjectManager::Constants::CMAKEMIMETYPE)) {
+    QString mimeType = project->projectManager()->mimeType();
+    if(mimeType == QLatin1String(CMakeProjectManager::Constants::CMAKEMIMETYPE)
+       || mimeType == QLatin1String(Ubuntu::Constants::UBUNTUPROJECT_MIMETYPE) ) {
         if(m_reviewToolsInstalled)
             m_postPackageTask = Verify;
         else
@@ -699,13 +731,13 @@
 {
     disconnect(m_buildManagerConnection);
     if (success) {
-        UbuntuPackageStep *pckStep = qobject_cast<UbuntuPackageStep*>(m_additionalPackagingBuildSteps.last());
+        UbuntuPackageStep *pckStep = qobject_cast<UbuntuPackageStep*>(m_packageBuildSteps->steps().last());
         if (pckStep && !pckStep->packagePath().isEmpty()) {
             m_ubuntuProcess.stop();
 
             QString sClickPackagePath = pckStep->packagePath();
             if (sClickPackagePath.isEmpty()) {
-                clearAdditionalBuildSteps();
+                clearPackageBuildList();
                 return;
             }
 
@@ -744,7 +776,7 @@
             }
         }
     }
-    clearAdditionalBuildSteps();
+    clearPackageBuildList();
 }
 
 void UbuntuPackagingWidget::buildAndInstallPackageRequested()
@@ -769,7 +801,11 @@
     if(!project)
         return;
 
-    if(project->projectManager()->mimeType() == QLatin1String(CMakeProjectManager::Constants::CMAKEMIMETYPE)) {
+    QString mimeType = project->projectManager()->mimeType();
+    bool isCMake = mimeType == QLatin1String(CMakeProjectManager::Constants::CMAKEMIMETYPE);
+    bool isHtml  = mimeType == QLatin1String(Ubuntu::Constants::UBUNTUPROJECT_MIMETYPE);
+
+    if(isCMake || isHtml) {
         ProjectExplorer::Target* target = project->activeTarget();
         if(!target)
             return;
@@ -783,9 +819,16 @@
             return;
         }
 
+        if(ProjectExplorer::BuildManager::isBuilding()) {
+            QMessageBox::information(this,tr("Build running"),tr("There is currently a build running, please wait for it to be finished"));
+            return;
+        }
+
         ProjectExplorer::BuildConfiguration* bc = target->activeBuildConfiguration();
-        if(!bc)
+        if(!bc) {
+            QMessageBox::information(this,tr("Error"),tr("Please add a valid buildconfiguration to your project"));
             return;
+        }
 
         if(!bc->isEnabled()) {
             QString disabledReason = bc->disabledReason();
@@ -793,27 +836,22 @@
             return;
         }
 
-        if(ProjectExplorer::BuildManager::isBuilding()) {
-            QMessageBox::information(this,tr("Build running"),tr("There is currently a build running, please wait for it to be finished"));
-            return;
+        clearPackageBuildList();
+
+        m_packageBuildSteps = QSharedPointer<ProjectExplorer::BuildStepList> (new ProjectExplorer::BuildStepList(bc,ProjectExplorer::Constants::BUILDSTEPS_BUILD));
+        if (isCMake) {
+            //add the normal buildsteps
+            m_packageBuildSteps->cloneSteps(bc->stepList(Core::Id(ProjectExplorer::Constants::BUILDSTEPS_BUILD)));
         }
 
-        clearAdditionalBuildSteps();
-
-        ProjectExplorer::BuildStepList* steps = bc->stepList(Core::Id(ProjectExplorer::Constants::BUILDSTEPS_BUILD));
-        if(!steps || steps->isEmpty())
-            return;
-
-        UbuntuPackageStep* package = new UbuntuPackageStep(steps);
+        //append the click packaging step
+        UbuntuPackageStep* package = new UbuntuPackageStep(m_packageBuildSteps.data());
         package->setPackageMode(UbuntuPackageStep::DisableDebugScript);
-
-        m_additionalPackagingBuildSteps.append(package);
+        m_packageBuildSteps->appendStep(package);
 
         m_buildManagerConnection = connect(ProjectExplorer::BuildManager::instance(),SIGNAL(buildQueueFinished(bool)),this,SLOT(buildFinished(bool)));
 
-        ProjectExplorer::BuildManager::buildList(steps,tr("Build Project"));
-        ProjectExplorer::BuildManager::appendStep(package ,tr("Creating Click package"));
-
+        ProjectExplorer::BuildManager::buildList(m_packageBuildSteps.data(),tr("Build Project"));
     }
 }
 
@@ -823,14 +861,27 @@
  * \note This will cancel a current build if its building the ProjectConfiguration
  *       the BuildSteps belong to!
  */
-void UbuntuPackagingWidget::clearAdditionalBuildSteps()
-{
-    foreach(QPointer<ProjectExplorer::BuildStep> step,m_additionalPackagingBuildSteps) {
-        if(step) {
-            if(ProjectExplorer::BuildManager::isBuilding(step->projectConfiguration()))
-                ProjectExplorer::BuildManager::cancel();
-            delete step.data();
-        }
-    }
-    m_additionalPackagingBuildSteps.clear();
+void UbuntuPackagingWidget::clearPackageBuildList()
+{
+    if (!m_packageBuildSteps)
+        return;
+
+    if(ProjectExplorer::BuildManager::isBuilding( static_cast<ProjectExplorer::ProjectConfiguration *>(m_packageBuildSteps->parent())))
+        ProjectExplorer::BuildManager::cancel();
+
+    m_packageBuildSteps->deleteLater();
+    m_packageBuildSteps.clear();
+}
+
+void UbuntuPackagingWidget::updateFrameworkList()
+{
+    const UbuntuClickTool::Target *t = 0;
+    ProjectExplorer::Project* startupProject = ProjectExplorer::SessionManager::startupProject();
+    if (startupProject)
+        t = UbuntuClickTool::clickTargetFromTarget(startupProject->activeTarget());
+
+    ui->comboBoxFramework->blockSignals(true);
+    ui->comboBoxFramework->clear();
+    ui->comboBoxFramework->addItems(UbuntuClickTool::getSupportedFrameworks(t));
+    ui->comboBoxFramework->blockSignals(false);
 }
 
=== modified file 'src/ubuntu/ubuntupackagingwidget.h'
--- src/ubuntu/ubuntupackagingwidget.h	2014-07-10 13:20:17 +0000
+++ src/ubuntu/ubuntupackagingwidget.h	2014-07-23 14:19:54 +0000
@@ -85,6 +85,8 @@
     void on_pushButton_addpolicy_clicked();
     void on_pushButtonClickPackage_clicked();
     void on_pushButtonReviewersTools_clicked();
+    void onStartupProjectChanged ();
+    void onActiveTargetChanged   ();
 
     void on_pushButtonReload_clicked();
 
@@ -110,7 +112,8 @@
 
 private:
     void buildClickPackage ();
-    void clearAdditionalBuildSteps ();
+    void clearPackageBuildList ();
+    void updateFrameworkList ();
 
 private:
     bool m_reviewToolsInstalled;
@@ -130,8 +133,12 @@
     ClickRunChecksParser* m_inputParser;
 
     //packaging support with buildsteps
-    QList<QPointer<ProjectExplorer::BuildStep> > m_additionalPackagingBuildSteps;
+    QSharedPointer<ProjectExplorer::BuildStepList> m_packageBuildSteps;
     QMetaObject::Connection m_buildManagerConnection;
     ClickPackageTask m_postPackageTask;
+
+    //current used startup project and target
+    QPointer<ProjectExplorer::Project> m_currentProject;
+    QPointer<ProjectExplorer::Target>  m_currentTarget;
 };
 #endif // UBUNTUPACKAGINGWIDGET_H
 
=== modified file 'src/ubuntu/ubuntuplugin.cpp'
--- src/ubuntu/ubuntuplugin.cpp	2014-07-07 06:33:37 +0000
+++ src/ubuntu/ubuntuplugin.cpp	2014-07-23 14:19:54 +0000
@@ -29,12 +29,13 @@
 #include "ubuntudevicefactory.h"
 #include "clicktoolchain.h"
 #include "ubuntucmakebuildconfiguration.h"
+#include "ubuntuhtmlbuildconfiguration.h"
 #include "ubunturemotedeployconfiguration.h"
 #include "ubuntulocaldeployconfiguration.h"
 #include "ubuntudevicesmodel.h"
 #include "localportsmanager.h"
 #include "ubuntubzr.h"
-
+#include "ubuntudeploystepfactory.h"
 #include <coreplugin/modemanager.h>
 #include <projectexplorer/kitmanager.h>
 #include <coreplugin/featureprovider.h>
@@ -134,6 +135,7 @@
     addAutoReleasedObject(new UbuntuCMakeToolFactory);
     addAutoReleasedObject(new UbuntuCMakeMakeStepFactory);
     addAutoReleasedObject(new UbuntuCMakeBuildConfigurationFactory);
+    addAutoReleasedObject(new UbuntuHtmlBuildConfigurationFactory);
 
     //ubuntu device support
     addAutoReleasedObject(new UbuntuDeviceFactory);
@@ -148,8 +150,12 @@
                     QStringLiteral("ubuntu-project-cmake"),
                     Core::IWizard::ProjectWizard));
     addAutoReleasedObject(
-                new UbuntuWizardFactory<UbuntuProjectApplicationWizard,UbuntuProjectApplicationWizard::UbuntuProject>(
-                    QStringLiteral("ubuntu-project-plain"),
+                new UbuntuWizardFactory<UbuntuProjectApplicationWizard,UbuntuProjectApplicationWizard::UbuntuHTMLProject>(
+                    QStringLiteral("ubuntu-project-plain-html"),
+                    Core::IWizard::ProjectWizard));
+    addAutoReleasedObject(
+                new UbuntuWizardFactory<UbuntuProjectApplicationWizard,UbuntuProjectApplicationWizard::UbuntuQMLProject>(
+                    QStringLiteral("ubuntu-project-plain-qml"),
                     Core::IWizard::ProjectWizard));
     addAutoReleasedObject(
                 new UbuntuWizardFactory<UbuntuProjectApplicationWizard,UbuntuProjectApplicationWizard::GoProject>(
 
=== modified file 'src/ubuntu/ubuntuproject.cpp'
--- src/ubuntu/ubuntuproject.cpp	2014-07-03 13:03:47 +0000
+++ src/ubuntu/ubuntuproject.cpp	2014-07-23 14:19:54 +0000
@@ -20,7 +20,11 @@
 #include <coreplugin/modemanager.h>
 #include <projectexplorer/projectexplorerconstants.h>
 #include <projectexplorer/kitinformation.h>
+#include <projectexplorer/toolchain.h>
+#include <projectexplorer/projectmacroexpander.h>
 #include <qmljs/qmljssimplereader.h>
+#include <qtsupport/qtkitinformation.h>
+#include <qtsupport/qtsupportconstants.h>
 
 
 using namespace Ubuntu;
@@ -44,19 +48,6 @@
     m_rootNode = QSharedPointer<UbuntuProjectNode>(new UbuntuProjectNode(this, m_file.data()));
     m_manager->registerProject(this);
 
-    QList<ProjectExplorer::Kit *> kits = ProjectExplorer::KitManager::kits();
-    foreach (ProjectExplorer::Kit *kit, kits) {
-        //do not spawn invalid configurations
-        if(ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(kit) != ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE)
-            continue;
-
-        addTarget(createTarget(kit));
-    }
-
-    if (needsConfiguration()) {
-        Core::ModeManager::activateMode(ProjectExplorer::Constants::MODE_SESSION);
-    }
-
     extractProjectFileData(fileName);
 }
 
@@ -119,3 +110,66 @@
     enumChild(projectDir(), files);
     return files;
 }
+
+bool UbuntuProject::supportsKit(ProjectExplorer::Kit *k, QString *errorMessage) const
+{
+    UbuntuKitMatcher matcher;
+    if (!matcher.matches(k)) {
+        if(errorMessage)
+            *errorMessage = tr("Only Desktop and Ubuntu Kits are supported");
+        return false;
+    }
+
+    return true;
+}
+
+bool UbuntuProject::needsConfiguration() const
+{
+    return targets().size() == 0;
+}
+
+bool UbuntuProject::supportsNoTargetPanel() const
+{
+    return true;
+}
+
+ProjectExplorer::KitMatcher *UbuntuProject::createRequiredKitMatcher() const
+{
+    return new UbuntuKitMatcher();
+}
+
+ProjectExplorer::KitMatcher *UbuntuProject::createPreferredKitMatcher() const
+{
+    return new QtSupport::QtVersionKitMatcher(Core::FeatureSet(QtSupport::Constants::FEATURE_DESKTOP));
+}
+
+QString UbuntuProject::shadowBuildDirectory(const QString &proFilePath, const ProjectExplorer::Kit *k, const QString &suffix)
+{
+    if (proFilePath.isEmpty())
+        return QString();
+
+    QFileInfo info(proFilePath);
+
+    QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(k);
+    if (version && !version->supportsShadowBuilds())
+        return info.absolutePath();
+
+    const QString projectName = QFileInfo(proFilePath).completeBaseName();
+    ProjectExplorer::ProjectMacroExpander expander(proFilePath, projectName, k, suffix);
+    QDir projectDir = QDir(projectDirectory(proFilePath));
+    QString buildPath = Utils::expandMacros(Core::DocumentManager::buildDirectory(), &expander);
+    return QDir::cleanPath(projectDir.absoluteFilePath(buildPath));
+}
+
+
+bool UbuntuKitMatcher::matches(const ProjectExplorer::Kit *k) const
+{
+    ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(k);
+    if (tc->type() == QLatin1String(Ubuntu::Constants::UBUNTU_CLICK_TOOLCHAIN_ID))
+        return true;
+
+    if (ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(k) == ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE)
+        return true;
+
+    return false;
+}
 
=== modified file 'src/ubuntu/ubuntuproject.h'
--- src/ubuntu/ubuntuproject.h	2014-06-03 12:04:26 +0000
+++ src/ubuntu/ubuntuproject.h	2014-07-23 14:19:54 +0000
@@ -50,6 +50,14 @@
 class UbuntuProjectManager;
 class UbuntuProjectFile;
 class UbuntuProjectNode;
+
+class UbuntuKitMatcher : public ProjectExplorer::KitMatcher
+{
+public:
+    explicit UbuntuKitMatcher() { }
+    bool matches(const ProjectExplorer::Kit *k) const override;
+};
+
 class UbuntuProject : public ProjectExplorer::Project
 {
     Q_OBJECT
@@ -76,6 +84,14 @@
         return m_mainFile;
     }
 
+    // Project interface
+    virtual bool supportsKit(ProjectExplorer::Kit *k, QString *errorMessage) const override;
+    virtual bool needsConfiguration() const override;
+    virtual bool supportsNoTargetPanel() const override;
+    virtual ProjectExplorer::KitMatcher *createRequiredKitMatcher() const override;
+    virtual ProjectExplorer::KitMatcher *createPreferredKitMatcher() const override;
+
+    static QString shadowBuildDirectory(const QString &proFilePath, const ProjectExplorer::Kit *k, const QString &suffix = QString());
 private:
     void extractProjectFileData(const QString& filename);
 
@@ -86,7 +102,6 @@
 
     QString m_fileName;
     QSharedPointer<UbuntuProjectNode> m_rootNode;
-    
 };
 }
 }
 
=== modified file 'src/ubuntu/ubuntuprojectapplicationwizard.cpp'
--- src/ubuntu/ubuntuprojectapplicationwizard.cpp	2014-07-10 13:20:17 +0000
+++ src/ubuntu/ubuntuprojectapplicationwizard.cpp	2014-07-23 14:19:54 +0000
@@ -32,6 +32,9 @@
 #include <extensionsystem/pluginmanager.h>
 #include <cmakeprojectmanager/cmakekitinformation.h>
 
+#include <projectexplorer/kitinformation.h>
+#include <projectexplorer/toolchain.h>
+
 #include <QDir>
 
 
@@ -41,6 +44,7 @@
     debug = 0
 };
 
+
 UbuntuProjectApplicationWizard::UbuntuProjectApplicationWizard(ProjectType type)
     : m_type(type)
 {
@@ -167,7 +171,7 @@
 void UbuntuProjectApplicationWizardDialog::addTargetSetupPage(int id)
 {
     //no target setup page required for basic projects
-    if(m_type == UbuntuProjectApplicationWizard::UbuntuProject)
+    if(m_type == UbuntuProjectApplicationWizard::UbuntuQMLProject)
         return;
 
     m_targetSetupPage = new ProjectExplorer::TargetSetupPage;
@@ -207,6 +211,10 @@
                 m_targetSetupPage->setRequiredKitMatcher(new QtSupport::QtVersionKitMatcher(features));
             break;
         }
+        case UbuntuProjectApplicationWizard::UbuntuHTMLProject: {
+            m_targetSetupPage->setRequiredKitMatcher(new UbuntuKitMatcher());
+            break;
+        }
         default:
             break;
     }
@@ -237,6 +245,11 @@
                                           +projectName
                                           +QDir::separator()
                                           +QString::fromLatin1("%1.goproject").arg(projectName));
+    } else if (m_type == UbuntuProjectApplicationWizard::UbuntuHTMLProject) {
+        m_targetSetupPage->setProjectPath(path+QDir::separator()
+                                          +projectName
+                                          +QDir::separator()
+                                          +QString::fromLatin1("%1.ubuntuhtmlproject").arg(projectName));
     } else {
         m_targetSetupPage->setProjectPath(path+QDir::separator()+projectName+QDir::separator()+QLatin1String("CMakeLists.txt"));
     }
 
=== modified file 'src/ubuntu/ubuntuprojectapplicationwizard.h'
--- src/ubuntu/ubuntuprojectapplicationwizard.h	2014-06-30 15:20:18 +0000
+++ src/ubuntu/ubuntuprojectapplicationwizard.h	2014-07-23 14:19:54 +0000
@@ -41,7 +41,8 @@
 public:
 
     enum ProjectType{
-        UbuntuProject, //handles Qml, Html basic projects
+        UbuntuHTMLProject,
+        UbuntuQMLProject,
         CMakeProject,
         GoProject
     };
 
=== modified file 'src/ubuntu/ubunturemotedeployconfiguration.cpp'
--- src/ubuntu/ubunturemotedeployconfiguration.cpp	2014-06-17 11:53:03 +0000
+++ src/ubuntu/ubunturemotedeployconfiguration.cpp	2014-07-23 14:19:54 +0000
@@ -18,8 +18,9 @@
 #include "ubunturemotedeployconfiguration.h"
 #include "ubuntucmakebuildconfiguration.h"
 #include "ubuntucmakemakestep.h"
+#include "ubuntudirectuploadstep.h"
+#include "ubuntuprojectguesser.h"
 #include "ubuntuconstants.h"
-#include "ubuntuprojectguesser.h"
 #include "ubuntupackagestep.h"
 
 #include <utils/qtcassert.h>
@@ -31,13 +32,10 @@
 #include <projectexplorer/kitinformation.h>
 #include <projectexplorer/abi.h>
 #include <projectexplorer/buildstep.h>
-#include <projectexplorer/deployablefile.h>
-
-#include <remotelinux/remotelinuxdeployconfiguration.h>
+
+#include <cmakeprojectmanager/cmakeprojectconstants.h>
+
 #include <remotelinux/remotelinuxcheckforfreediskspacestep.h>
-#include <remotelinux/genericdirectuploadservice.h>
-
-#include <cmakeprojectmanager/cmakeprojectconstants.h>
 
 #include <QDir>
 
@@ -65,148 +63,6 @@
     return new ProjectExplorer::NamedWidget();
 }
 
-UbuntuDirectUploadStep::UbuntuDirectUploadStep(ProjectExplorer::BuildStepList *bsl)
-    : AbstractRemoteLinuxDeployStep(bsl, UbuntuDirectUploadStep::stepId())
-    , m_deployService(new RemoteLinux::GenericDirectUploadService(this))
-{
-    setDefaultDisplayName(displayName());
-}
-
-UbuntuDirectUploadStep::UbuntuDirectUploadStep(ProjectExplorer::BuildStepList *bsl, UbuntuDirectUploadStep *other)
-    : AbstractRemoteLinuxDeployStep(bsl, other)
-    , m_deployService(new RemoteLinux::GenericDirectUploadService(this))
-{
-    setDefaultDisplayName(displayName());
-
-    connect(target()->project(),SIGNAL(displayNameChanged()),this,SLOT(projectNameChanged()));
-    connect(target(),SIGNAL(applicationTargetsChanged()),this,SLOT(projectNameChanged()));
-}
-
-UbuntuDirectUploadStep::~UbuntuDirectUploadStep()
-{
-}
-
-void UbuntuDirectUploadStep::run(QFutureInterface<bool> &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();
-        return;
-    }
-
-
-    m_deployService->setIncrementalDeployment(false);
-    m_deployService->setIgnoreMissingFiles(false);
-
-    QString whyNot;
-    if(!deployService()->isDeploymentPossible(&whyNot)) {
-        emit addOutput(tr("Deploy step failed. %1").arg(whyNot), ErrorMessageOutput);
-        fi.reportResult(false);
-        emit finished();
-        return;
-    }
-
-    AbstractRemoteLinuxDeployStep::run(fi);
-}
-
-ProjectExplorer::BuildStepConfigWidget *UbuntuDirectUploadStep::createConfigWidget()
-{
-    return new ProjectExplorer::SimpleBuildStepConfigWidget(this);
-}
-
-bool UbuntuDirectUploadStep::initInternal(QString *error)
-{
-    Q_UNUSED(error)
-    return true;
-}
-
-RemoteLinux::AbstractRemoteLinuxDeployService *UbuntuDirectUploadStep::deployService() const
-{
-    return m_deployService;
-}
-
-bool UbuntuDirectUploadStep::fromMap(const QVariantMap &map)
-{
-    if (!AbstractRemoteLinuxDeployStep::fromMap(map))
-        return false;
-    return true;
-}
-
-QVariantMap UbuntuDirectUploadStep::toMap() const
-{
-    return AbstractRemoteLinuxDeployStep::toMap();
-}
-
-
-Core::Id UbuntuDirectUploadStep::stepId()
-{
-    return Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID;
-}
-
-QString UbuntuDirectUploadStep::displayName()
-{
-    return tr("Upload files to Ubuntu Device");
-}
-
-static void createFileList(const QDir &rootDir
-                           , const QString& subDir
-                           , const QString& remoteRoot
-                           , QList<ProjectExplorer::DeployableFile>* list)
-{
-    QDir currentDir(rootDir.absolutePath()+subDir);
-    if(!currentDir.exists())
-        return;
-
-    QFileInfoList entries = currentDir.entryInfoList(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot);
-    foreach (const QFileInfo &entry, entries) {
-        if(entry.isDir()) {
-            QString newSub = (subDir.endsWith(QLatin1String("/"))) ? (QString)(subDir+entry.fileName()) : (QString)(subDir+(QLatin1String("/")+entry.fileName()));
-            createFileList(rootDir,newSub,remoteRoot,list);
-        } else {
-            QString targetPath = QDir::cleanPath(remoteRoot
-                    + subDir
-                    + QLatin1String("/"));
-
-            if(debug) qDebug()<<"Uploading: "<<entry.fileName();
-            if(debug) qDebug()<<" to "<<targetPath;
-            list->append(ProjectExplorer::DeployableFile(entry.absoluteFilePath()
-                                                         , targetPath
-                                                         , entry.isExecutable() ? ProjectExplorer::DeployableFile::TypeExecutable
-                                                                                : ProjectExplorer::DeployableFile::TypeNormal));
-        }
-    }
-}
-
-void UbuntuDirectUploadStep::projectNameChanged()
-{
-    if(debug) qDebug()<<"------------------------ Updating DEPLOYLIST ---------------------------";
-    //iterate over the .deploy dir and put all files in the list
-    QDir d(target()->activeBuildConfiguration()->buildDirectory().toString()+QDir::separator()+QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR));
-    ProjectExplorer::BuildStepList *bsList = deployConfiguration()->stepList();
-
-    QList<ProjectExplorer::DeployableFile> list;
-    foreach(ProjectExplorer::BuildStep *currStep ,bsList->steps()) {
-        UbuntuPackageStep *pckStep = qobject_cast<UbuntuPackageStep*>(currStep);
-        if(!pckStep)
-            continue;
-
-        QFileInfo info(pckStep->packagePath());
-        if(info.exists()) {
-            list.append(ProjectExplorer::DeployableFile(info.filePath(),
-                                                        QStringLiteral("/tmp")));
-
-            list.append(ProjectExplorer::DeployableFile(QStringLiteral("%1/qtc_device_applaunch.py").arg(Constants::UBUNTU_SCRIPTPATH),
-                                                        QStringLiteral("/tmp")));
-            m_deployService->setDeployableFiles(list);
-            m_foundClickPackage = true;
-            break;
-        }
-    }
-}
-
 
 UbuntuRemoteDeployConfigurationFactory::UbuntuRemoteDeployConfigurationFactory(QObject *parent)
     : DeployConfigurationFactory(parent)
@@ -225,8 +81,11 @@
     if (!tc || tc->targetAbi().os() != ProjectExplorer::Abi::LinuxOS)
         return ids;
 
-    //for now only support cmake projects
-    if(parent->project()->id() != CMakeProjectManager::Constants::CMAKEPROJECT_ID)
+    Core::Id projectTypeId = parent->project()->id();
+
+    //for now only support cmake and ubuntu projects
+    if(projectTypeId != CMakeProjectManager::Constants::CMAKEPROJECT_ID
+            && projectTypeId != Ubuntu::Constants::UBUNTUPROJECT_ID)
         return ids;
 
     const Core::Id devType = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(parent->kit());
@@ -257,10 +116,9 @@
             = new UbuntuRemoteDeployConfiguration(parent);
 
     int step = 0;
-    if(parent->project()->id() == Core::Id(CMakeProjectManager::Constants::CMAKEPROJECT_ID)){
-        UbuntuPackageStep *pckStep = new UbuntuPackageStep(dc->stepList());
-        dc->stepList()->insertStep(0,pckStep);
-    }
+
+    UbuntuPackageStep *pckStep = new UbuntuPackageStep(dc->stepList());
+    dc->stepList()->insertStep(0,pckStep);
 
     RemoteLinux::RemoteLinuxCheckForFreeDiskSpaceStep *checkSpace = new RemoteLinux::RemoteLinuxCheckForFreeDiskSpaceStep(dc->stepList());
     checkSpace->setPathToCheck(QStringLiteral("/tmp"));
@@ -301,90 +159,5 @@
                                                            ,qobject_cast<RemoteLinux::RemoteLinuxDeployConfiguration *>(product));
 }
 
-QList<Core::Id> UbuntuDeployStepFactory::availableCreationIds(ProjectExplorer::BuildStepList *parent) const
-{
-    if(!canHandle(parent->target()))
-        return QList<Core::Id>();
-
-    return QList<Core::Id>()
-            <<Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID;
-}
-
-QString UbuntuDeployStepFactory::displayNameForId(const Core::Id id) const
-{
-    if(id == Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID)
-        return UbuntuDirectUploadStep::displayName();
-    return QString();
-}
-
-bool UbuntuDeployStepFactory::canCreate(ProjectExplorer::BuildStepList *parent, const Core::Id id) const
-{
-    if(!canHandle(parent->target()))
-        return false;
-
-    return availableCreationIds(parent).contains(id);
-}
-
-ProjectExplorer::BuildStep *UbuntuDeployStepFactory::create(ProjectExplorer::BuildStepList *parent, const Core::Id id)
-{
-    if (!canCreate(parent, id))
-        return 0;
-
-    if(id == Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID)
-        return new UbuntuDirectUploadStep(parent);
-    return 0;
-}
-
-bool UbuntuDeployStepFactory::canRestore(ProjectExplorer::BuildStepList *parent, const QVariantMap &map) const
-{
-    return canCreate(parent,ProjectExplorer::idFromMap(map));
-}
-
-ProjectExplorer::BuildStep *UbuntuDeployStepFactory::restore(ProjectExplorer::BuildStepList *parent, const QVariantMap &map)
-{
-    Core::Id id = ProjectExplorer::idFromMap(map);
-    if(!canCreate(parent,id))
-        return 0;
-
-    ProjectExplorer::BuildStep* step = create(parent,id);
-    if (!step->fromMap(map)) {
-        delete step;
-        return 0;
-    }
-
-    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))
-        return 0;
-
-    const Core::Id id = product->id();
-    if(id == Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID)
-        return new UbuntuDirectUploadStep(parent, static_cast<UbuntuDirectUploadStep *>(product));
-
-    return 0;
-}
-
-bool UbuntuDeployStepFactory::canHandle(const ProjectExplorer::Target *t) const
-{
-    QTC_ASSERT(t, return false);
-    if (!t->project()->supportsKit(t->kit()))
-        return false;
-
-    ProjectExplorer::ToolChain* tc = ProjectExplorer::ToolChainKitInformation::toolChain(t->kit());
-    if(!tc || tc->type() != QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID))
-        return false;
-
-    return (t->project()->id() == Core::Id(CMakeProjectManager::Constants::CMAKEPROJECT_ID)
-            && !UbuntuProjectGuesser::isScopesProject(t->project()));
-}
-
 } // namespace Internal
 } // namespace Ubuntu
 
=== modified file 'src/ubuntu/ubunturemotedeployconfiguration.h'
--- src/ubuntu/ubunturemotedeployconfiguration.h	2014-06-16 15:14:09 +0000
+++ src/ubuntu/ubunturemotedeployconfiguration.h	2014-07-23 14:19:54 +0000
@@ -20,13 +20,8 @@
 #define UBUNTU_INTERNAL_UBUNTUDEPLOYCONFIGURATION_H
 
 #include <projectexplorer/deployconfiguration.h>
-#include <remotelinux/abstractremotelinuxdeploystep.h>
 #include <remotelinux/remotelinuxdeployconfiguration.h>
 
-namespace RemoteLinux {
-class GenericDirectUploadService;
-}
-
 namespace Ubuntu {
 namespace Internal {
 
@@ -44,55 +39,6 @@
 
 };
 
-class UbuntuDirectUploadStep : public RemoteLinux::AbstractRemoteLinuxDeployStep
-{
-    Q_OBJECT
-
-public:
-    UbuntuDirectUploadStep(ProjectExplorer::BuildStepList *bsl);
-    UbuntuDirectUploadStep(ProjectExplorer::BuildStepList *bsl, UbuntuDirectUploadStep *other);
-    ~UbuntuDirectUploadStep();
-
-    // BuildStep interface
-    virtual void run(QFutureInterface<bool> &fi) override;
-
-    ProjectExplorer::BuildStepConfigWidget *createConfigWidget();
-    bool initInternal(QString *error = 0) override;
-
-    RemoteLinux::AbstractRemoteLinuxDeployService *deployService() const override;
-    bool fromMap(const QVariantMap &map) override;
-    QVariantMap toMap() const override;
-
-    static Core::Id stepId();
-    static QString displayName();
-
-private slots:
-    void projectNameChanged();
-
-private:
-    RemoteLinux::GenericDirectUploadService *m_deployService;
-    bool m_foundClickPackage;
-};
-
-class UbuntuDeployStepFactory : public ProjectExplorer::IBuildStepFactory
-{
-    Q_OBJECT
-
-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 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(const ProjectExplorer::Target *t) const;
-};
-
 class UbuntuRemoteDeployConfigurationFactory : public ProjectExplorer::DeployConfigurationFactory
 {
     Q_OBJECT
 
=== modified file 'src/ubuntu/ubunturemoterunconfiguration.cpp'
--- src/ubuntu/ubunturemoterunconfiguration.cpp	2014-06-18 07:29:05 +0000
+++ src/ubuntu/ubunturemoterunconfiguration.cpp	2014-07-23 14:19:54 +0000
@@ -31,6 +31,7 @@
 #include <remotelinux/remotelinuxenvironmentaspect.h>
 #include <utils/qtcprocess.h>
 #include <cmakeprojectmanager/cmakeproject.h>
+#include <cmakeprojectmanager/cmakeprojectconstants.h>
 
 #include <QFile>
 #include <QTextStream>
@@ -141,7 +142,7 @@
     m_appId.clear();
     m_clickPackage.clear();
 
-    QDir package_dir(target()->activeBuildConfiguration()->buildDirectory().toString()+QDir::separator()+QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR));
+    QDir package_dir(packageDir());
     if(!package_dir.exists()) {
         if(errorMessage)
             *errorMessage = tr("No packaging directory available, please check if the deploy configuration is correct.");
@@ -185,7 +186,8 @@
         return false;
 
     QFileInfo commInfo(command);
-    if(commInfo.completeBaseName().startsWith(QLatin1String("qmlscene"))) {
+    QString executor = commInfo.completeBaseName();
+    if(executor.startsWith(QStringLiteral("qmlscene"))) {
         ProjectExplorer::ToolChain* tc = ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit());
         if(tc->type() != QString::fromLatin1(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)) {
             if(errorMessage)
@@ -198,12 +200,12 @@
                 .arg(UbuntuClickTool::targetBasePath(clickTc->clickTarget()))
                 .arg(clickTc->gnutriplet());
 
-        m_remoteExecutable = QLatin1String("/usr/bin/qmlscene");
-        m_arguments = args;
-    } else if(commInfo.completeBaseName().startsWith(QLatin1String("ubuntu-html5-app-launcher"))) {
-        if(errorMessage)
-            *errorMessage = tr("Run support for remote html projects not available");
-        return false;
+        m_remoteExecutable = QStringLiteral("/usr/bin/qmlscene");
+        m_arguments = args;
+    } else if(executor.startsWith(QStringLiteral("ubuntu-html5-app-launcher"))
+              || executor.startsWith(QStringLiteral("webapp-container"))) {
+        m_remoteExecutable = QStringLiteral("");
+        m_arguments = args;
     } else {
         //looks like a application without a launcher
         CMakeProjectManager::CMakeProject* pro = static_cast<CMakeProjectManager::CMakeProject*> (target()->project());
@@ -261,5 +263,24 @@
     m_arguments = args;
 }
 
+QString UbuntuRemoteRunConfiguration::packageDir() const
+{
+    ProjectExplorer::Project *p = target()->project();
+    if (p->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID)
+        return target()->activeBuildConfiguration()->buildDirectory().toString()+QDir::separator()+QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR);
+    else if (p->id() == Ubuntu::Constants::UBUNTUPROJECT_ID) {
+        if (!target()->activeBuildConfiguration()) {
+            //backwards compatibility, try to not crash QtC for old projects
+            //they did not create a buildconfiguration back then
+            QDir pDir(p->projectDirectory());
+            return p->projectDirectory()+QDir::separator()+
+                    QStringLiteral("..")+QDir::separator()+
+                    pDir.dirName()+QStringLiteral("_build")+QDir::separator()+QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR);
+        } else
+            return target()->activeBuildConfiguration()->buildDirectory().toString()+QDir::separator()+QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR);
+    }
+    return QString();
+}
+
 } // namespace Internal
 } // namespace Ubuntu
 
=== modified file 'src/ubuntu/ubunturemoterunconfiguration.h'
--- src/ubuntu/ubunturemoterunconfiguration.h	2014-06-18 07:29:05 +0000
+++ src/ubuntu/ubunturemoterunconfiguration.h	2014-07-23 14:19:54 +0000
@@ -59,6 +59,8 @@
     static Core::Id typeId ();
     void setArguments (const QStringList &args);
 
+    QString packageDir () const;
+
 private:
     QString m_clickPackage;
     QString m_appId;
 
=== modified file 'tests/manifest/manifest.pro'
--- tests/manifest/manifest.pro	2014-06-25 11:33:20 +0000
+++ tests/manifest/manifest.pro	2014-07-23 14:19:54 +0000
@@ -10,6 +10,7 @@
 
 INCLUDEPATH += $${PLUGIN_SRC_ROOT}
 DEFINES += SRCDIR=\\\"$$PWD/\\\"
+DEFINES += IN_TEST_PROJECT
 
 SOURCES += \
     tst_manifest.cpp \