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

[Benjamin Zeller]

- Adding device runsupport for QML projects
- Create a QtVersion per chroot on the host
- Fix deprecated warnings in the SDK launcher

- Adding device runsupport for QML projects
- Create a QtVersion per chroot on the host

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:214
http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-ci/364/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-utopic-amd64-ci/132/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-utopic-armhf-ci/132/console

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

review: Needs Fixing (continuous-integration)

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

215. By Benjamin Zeller on 2014-07-29

Missing files

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

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

216. By Benjamin Zeller on 2014-07-30

- Fix templates to contain correct Exec line in desktop file
- make publish tab work with QML projects again
- Remove obsolete enties in the menu.json

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

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

217. By Benjamin Zeller on 2014-07-30

Adding the "first run" wizard

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

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

218. By Benjamin Zeller on 2014-07-31

- Add chroot creation to the project wizards
- Lead the user to the device creation page

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

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

219. By Benjamin Zeller on 2014-07-31

- Fixes text in the wizard pages
- Make sure parenting is correct
- Add a checkbox if the wizard should be shown again

220. By Benjamin Zeller on 2014-07-31

Some more text fixes

221. By Benjamin Zeller on 2014-07-31

- Show list of all devices
- Make sure the device list is up 2 date

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Zoltan Balogh (bzoltan)]

OK

review: Approve

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

=== modified file 'share/qtcreator/templates/wizards/ubuntu/simple/displayName.desktop'
--- share/qtcreator/templates/wizards/ubuntu/simple/displayName.desktop	2014-07-10 15:35:32 +0000
+++ share/qtcreator/templates/wizards/ubuntu/simple/displayName.desktop	2014-07-31 10:11:55 +0000
@@ -1,6 +1,6 @@
 [Desktop Entry]
 Name=%ClickHookName%
-Exec=/usr/bin/qmlscene $@ /usr/share/%ProjectName%/%ProjectName%.qml
+Exec=qmlscene $@ main.qml
 Icon=%ProjectName%.png
 Terminal=false
 Type=Application

=== modified file 'share/qtcreator/templates/wizards/ubuntu/tabs/displayName.desktop'
--- share/qtcreator/templates/wizards/ubuntu/tabs/displayName.desktop	2014-07-10 15:35:32 +0000
+++ share/qtcreator/templates/wizards/ubuntu/tabs/displayName.desktop	2014-07-31 10:11:55 +0000
@@ -1,6 +1,6 @@
 [Desktop Entry]
 Name=%ClickHookName%
-Exec=/usr/bin/qmlscene $@ /usr/share/%ProjectName%/%ProjectName%.qml
+Exec=qmlscene $@ main.qml
 Icon=%ProjectName%.png
 Terminal=false
 Type=Application

=== modified file 'share/qtcreator/ubuntu/devicespage/DevicePage.qml'
--- share/qtcreator/ubuntu/devicespage/DevicePage.qml	2014-07-28 09:25:34 +0000
+++ share/qtcreator/ubuntu/devicespage/DevicePage.qml	2014-07-31 10:11:55 +0000
@@ -11,7 +11,6 @@
     id: devicePage
     flickable: null
 
-
     Item {
         anchors.fill: parent
         visible: devicesModel.busy
@@ -146,6 +145,11 @@
                         iconSource: "qrc:/ubuntu/images/list-add.png"
                         onClicked: PopupUtils.open(resourceRoot+"/NewEmulatorDialog.qml",devicePage);
                     }
+
+                    Connections{
+                        target: deviceMode
+                        onOpenAddEmulatorDialog: PopupUtils.open(resourceRoot+"/NewEmulatorDialog.qml",devicePage);
+                    }
                 }
             }
         }

=== modified file 'share/qtcreator/ubuntu/menu.json'
--- share/qtcreator/ubuntu/menu.json	2014-07-15 13:20:19 +0000
+++ share/qtcreator/ubuntu/menu.json	2014-07-31 10:11:55 +0000
@@ -48,20 +48,6 @@
         "submenu": [
             {
                 "name": "Run Application on Device",
-                "id": "Ubuntu.Build.Run",
-                "workingDirectory": "%0/..",
-                "projectRequired": true,
-                "keysequence": "Ctrl+F12",
-                "deviceRequired": true,
-                "qmlProjectRequired": true,
-                "saveRequired": true,
-                "context" : ["QmlProject.ProjectContext"],
-                "actions": [
-                    "%SCRIPTDIRECTORY%/qtc_device_run_app_click %SERIALNUMBER% %FOLDERNAME% %USERNAME%@%IP% %PORT% /home/%USERNAME%/dev_tmp"
-                ]
-            },
-            {
-                "name": "Run Application on Device",
                 "id": "Ubuntu.Build.Run.Go",
                 "workingDirectory": "%0/..",
                 "projectRequired": true,
@@ -80,41 +66,18 @@
                 "projectRequired": true,
                 "deviceRequired": true,
                 "qmlProjectRequired": true,
+                "context": ["GoProject.ProjectContext"],
                 "actions": [
                     "%SCRIPTDIRECTORY%/qtc_device_close_all_apps %SERIALNUMBER% %DISPLAYNAME%"
                 ]
             },
             {
-                "name": "Create Application Package",
-                "id": "Ubuntu.Build.Package",
-                "workingDirectory": "%0/..",
-                "projectRequired": true,
-                "context": "QmlProject.ProjectContext",
-                "ubuntuProjectRequired": true,
-                "saveRequired": true,
-                "actions": [
-                    "%SCRIPTDIRECTORY%/qtc_project_click_create %FOLDERNAME% %BUILDDIR%"
-                ]
-            },
-            {
-                "name": "Install Application on Device",
-                "id": "Ubuntu.Build.PackageInstall",
-                "workingDirectory": "%0/..",
-                "projectRequired": true,
-                "deviceRequired": true,
-                "context": ["QmlProject.ProjectContext"],
-                "saveRequired": true,
-                "actions": [
-                    "%SCRIPTDIRECTORY%/qtc_project_click_createanddeploy %SERIALNUMBER% %FOLDERNAME% %USERNAME%@%IP% %PORT% /home/%USERNAME%/dev_tmp %USERNAME%"
-                ]
-            },
-            {
                 "name": "Install Application on Device",
                 "id": "Ubuntu.Build.PackageInstall.Html",
                 "workingDirectory": "%0/..",
                 "projectRequired": true,
                 "deviceRequired": true,
-                "context": ["UbuntuProject.ProjectContext"],
+                "context": ["UbuntuProject.ProjectContext","QmlProject.ProjectContext"],
                 "saveRequired": true,
                 "actions": [
                     {

=== modified file 'share/qtcreator/ubuntu/scripts/qtc_chroot_qmake' (properties changed: +x to -x)
--- share/qtcreator/ubuntu/scripts/qtc_chroot_qmake	2014-07-22 09:57:33 +0000
+++ share/qtcreator/ubuntu/scripts/qtc_chroot_qmake	2014-07-31 10:11:55 +0000
@@ -15,6 +15,10 @@
 #
 # Author: Zoltán Balogh <[e-mail]>
 
+
+CLICK_CHROOT_ARCH="%1"
+CLICK_CHROOT_FW="%2"
+
 if [ -z "$CLICK_CHROOT_ARCH" ]; then
     echo "Need to set CLICK_CHROOT_ARCH"
     exit 1

=== modified file 'share/qtcreator/ubuntu/scripts/qtc_device_applaunch.py'
--- share/qtcreator/ubuntu/scripts/qtc_device_applaunch.py	2014-07-03 13:03:47 +0000
+++ share/qtcreator/ubuntu/scripts/qtc_device_applaunch.py	2014-07-31 10:11:55 +0000
@@ -79,8 +79,11 @@
         sys.stdout.flush()
 
 def on_log_io(file, condition):
-    print (file.read().decode())
-    sys.stdout.flush()
+    output = file.read().decode()
+    if len(output) > 0:
+        print (output)
+        sys.stdout.flush()
+
     return True
 
 
@@ -212,7 +215,11 @@
 file_flags = fcntl.fcntl(logFileFd, fcntl.F_GETFL)
 fcntl.fcntl(logFileFd, fcntl.F_SETFL, file_flags | os.O_NDELAY)
 
-GObject.io_add_watch(logTailProc.stdout,GObject.IO_IN | GObject.IO_HUP,on_log_io)
+#since pygobject version 3.8 the old way of calling io_add_watch is deprecated
+if (GObject.pygobject_version[0] > 3 or (GObject.pygobject_version[0] == 3 and GObject.pygobject_version[1] >= 8)):
+    GLib.io_add_watch(logTailProc.stdout,GLib.PRIORITY_DEFAULT,GObject.IO_IN | GObject.IO_HUP,on_log_io)
+else:
+    GObject.io_add_watch(logTailProc.stdout,GObject.IO_IN | GObject.IO_HUP,on_log_io)
 
 state = {}
 state['loop'] = GLib.MainLoop()
@@ -222,9 +229,15 @@
 
 print ("Registering hooks")
 sys.stdout.flush()
-GLib.unix_signal_add_full(GLib.PRIORITY_HIGH, signal.SIGTERM, on_sigterm, state)
-GLib.unix_signal_add_full(GLib.PRIORITY_HIGH, signal.SIGINT, on_sigterm, state)
-GLib.unix_signal_add_full(GLib.PRIORITY_HIGH, signal.SIGHUP, on_sigterm, state)
+
+if "unix_signal_add" in dir(GLib):
+    GLib.unix_signal_add(GLib.PRIORITY_HIGH, signal.SIGTERM, on_sigterm, state)
+    GLib.unix_signal_add(GLib.PRIORITY_HIGH, signal.SIGINT, on_sigterm, state)
+    GLib.unix_signal_add(GLib.PRIORITY_HIGH, signal.SIGHUP, on_sigterm, state)
+else:
+    GLib.unix_signal_add_full(GLib.PRIORITY_HIGH, signal.SIGTERM, on_sigterm, state)
+    GLib.unix_signal_add_full(GLib.PRIORITY_HIGH, signal.SIGINT, on_sigterm, state)
+    GLib.unix_signal_add_full(GLib.PRIORITY_HIGH, signal.SIGHUP, on_sigterm, state)
 
 UAL.observer_add_app_failed(on_failed, state)
 UAL.observer_add_app_started(on_started, state)

=== modified file 'src/ubuntu/ubuntu.pro'
--- src/ubuntu/ubuntu.pro	2014-07-15 09:55:12 +0000
+++ src/ubuntu/ubuntu.pro	2014-07-31 10:11:55 +0000
@@ -117,9 +117,12 @@
     abstractremoterunsupport.cpp\
     ubuntushared.cpp \
     ubuntupackagestep.cpp \
+    ubuntuqtversion.cpp \
     ubuntudeploystepfactory.cpp \
     ubuntudirectuploadstep.cpp \
-    ubuntuhtmlbuildconfiguration.cpp
+    ubuntuhtmlbuildconfiguration.cpp \
+    ubuntuqmlbuildconfiguration.cpp \
+    ubuntufirstrunwizard.cpp
 
 HEADERS += \
     ubuntuplugin.h \
@@ -186,7 +189,10 @@
     ubunturemoterunner.h \
     abstractremoterunsupport.h \
     ubuntupackagestep.h \
+    ubuntuqtversion.h \
     ubuntudeploystepfactory.h \
     ubuntudirectuploadstep.h \
-    ubuntuhtmlbuildconfiguration.h
+    ubuntuhtmlbuildconfiguration.h \
+    ubuntuqmlbuildconfiguration.h \
+    ubuntufirstrunwizard.h
 

=== modified file 'src/ubuntu/ubuntuclickdialog.cpp'
--- src/ubuntu/ubuntuclickdialog.cpp	2014-07-22 07:33:23 +0000
+++ src/ubuntu/ubuntuclickdialog.cpp	2014-07-31 10:11:55 +0000
@@ -81,9 +81,9 @@
     m_process->start();
 }
 
-int UbuntuClickDialog::runClickModal(ProjectExplorer::ProcessParameters *params)
+int UbuntuClickDialog::runClickModal(ProjectExplorer::ProcessParameters *params, QWidget *parent)
 {
-    UbuntuClickDialog dlg(Core::ICore::mainWindow());
+    UbuntuClickDialog dlg( parent ? parent : Core::ICore::mainWindow());
     dlg.setParameters(params);
     QMetaObject::invokeMethod(&dlg,"runClick",Qt::QueuedConnection);
     dlg.exec();
@@ -91,17 +91,17 @@
     return dlg.m_exitCode;
 }
 
-bool UbuntuClickDialog::createClickChrootModal(bool redetectKits, const QString &arch)
+bool UbuntuClickDialog::createClickChrootModal(bool redetectKits, const QString &arch, QWidget *parent)
 {
 
     UbuntuClickTool::Target t;
-    if(!UbuntuCreateNewChrootDialog::getNewChrootTarget(&t,arch))
+    if(!UbuntuCreateNewChrootDialog::getNewChrootTarget(&t,arch,parent))
         return false;
 
     ProjectExplorer::ProcessParameters params;
     UbuntuClickTool::parametersForCreateChroot(t,&params);
 
-    bool success = (runClickModal(&params) == 0);
+    bool success = (runClickModal(&params,parent) == 0);
 
     if(success) {
         ClickToolChain* tc = new ClickToolChain(t, ProjectExplorer::ToolChain::AutoDetection);

=== modified file 'src/ubuntu/ubuntuclickdialog.h'
--- src/ubuntu/ubuntuclickdialog.h	2014-06-16 15:40:12 +0000
+++ src/ubuntu/ubuntuclickdialog.h	2014-07-31 10:11:55 +0000
@@ -49,8 +49,8 @@
 public slots:
     void runClick ();
 
-    static int runClickModal (ProjectExplorer::ProcessParameters* params);
-    static bool createClickChrootModal (bool redetectKits = true , const QString &arch = QString());
+    static int runClickModal (ProjectExplorer::ProcessParameters* params, QWidget *parent = 0);
+    static bool createClickChrootModal (bool redetectKits = true , const QString &arch = QString(),QWidget *parent = 0);
     static int maintainClickModal (const UbuntuClickTool::Target &target, const UbuntuClickTool::MaintainMode &mode);
 
     // QDialog interface

=== modified file 'src/ubuntu/ubuntuconstants.h'
--- src/ubuntu/ubuntuconstants.h	2014-07-28 07:58:53 +0000
+++ src/ubuntu/ubuntuconstants.h	2014-07-31 10:11:55 +0000
@@ -510,6 +510,7 @@
 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";
+const char UBUNTU_CLICK_QML_BC_ID[]      = "UbuntuProjectManager.UbuntuQml.BuildConfiguration";
 //Devicesupport
 const char UBUNTU_DEVICE_TYPE_ID[] = "UbuntuProjectManager.DeviceTypeId";
 const char UBUNTU_DEVICE_SSHIDENTITY[] = "%0/.config/ubuntu-sdk/ubuntudevice_id_rsa";
@@ -551,6 +552,11 @@
 
 const char UBUNTU_GO_BUILD_TARGETS[] = "%GOBUILDTARGETS%";
 
+//Qtversion support
+const char UBUNTU_QTVERSION_TYPE[]   = "UbuntuProjectManager.QtVersion";
+const char UBUNTU_PLATFORM_NAME[]    = "Ubuntu Phone";
+const char UBUNTU_PLATFORM_NAME_TR[] = QT_TRANSLATE_NOOP("UbuntuProjectManager", "Ubuntu Phone");
+
 } // namespace Ubuntu
 } // namespace Constants
 

=== modified file 'src/ubuntu/ubuntucreatenewchrootdialog.cpp'
--- src/ubuntu/ubuntucreatenewchrootdialog.cpp	2014-06-16 15:40:12 +0000
+++ src/ubuntu/ubuntucreatenewchrootdialog.cpp	2014-07-31 10:11:55 +0000
@@ -19,6 +19,9 @@
 #include "ui_ubuntucreatenewchrootdialog.h"
 
 #include "ubuntuconstants.h"
+
+#include <coreplugin/icore.h>
+
 namespace Ubuntu {
 
 namespace Constants {
@@ -66,9 +69,9 @@
  * Opens a dialog that lets the user select a new chroot, returns false
  * if the user pressed cancel
  */
-bool UbuntuCreateNewChrootDialog::getNewChrootTarget(UbuntuClickTool::Target *target, const QString &arch)
+bool UbuntuCreateNewChrootDialog::getNewChrootTarget(UbuntuClickTool::Target *target, const QString &arch, QWidget *parent)
 {
-    UbuntuCreateNewChrootDialog dlg(arch);
+    UbuntuCreateNewChrootDialog dlg(arch, parent ? parent : Core::ICore::mainWindow());
     if( dlg.exec() == QDialog::Accepted) {
         bool ok = false;
 

=== modified file 'src/ubuntu/ubuntucreatenewchrootdialog.h'
--- src/ubuntu/ubuntucreatenewchrootdialog.h	2014-06-16 15:40:12 +0000
+++ src/ubuntu/ubuntucreatenewchrootdialog.h	2014-07-31 10:11:55 +0000
@@ -38,7 +38,7 @@
     explicit UbuntuCreateNewChrootDialog(const QString &arch = QString(), QWidget *parent = 0);
     ~UbuntuCreateNewChrootDialog();
 
-    static bool getNewChrootTarget(UbuntuClickTool::Target *target, const QString &arch);
+    static bool getNewChrootTarget(UbuntuClickTool::Target *target, const QString &arch, QWidget *parent = 0);
 
 private:
     Ui::UbuntuCreateNewChrootDialog *ui;

=== modified file 'src/ubuntu/ubuntudeploystepfactory.cpp'
--- src/ubuntu/ubuntudeploystepfactory.cpp	2014-07-15 09:55:12 +0000
+++ src/ubuntu/ubuntudeploystepfactory.cpp	2014-07-31 10:11:55 +0000
@@ -35,7 +35,7 @@
     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";
+    bool isQML    = parent->target()->project()->id() == "QmlProjectManager.QmlProject";
 
     if (isRemote) {
         //IF we have a remote device we just support a ubuntu toolchain
@@ -47,7 +47,7 @@
     if(isRemote && isCMake && !UbuntuProjectGuesser::isScopesProject(parent->target()->project()))
         types << Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID
               << Constants::UBUNTU_CLICK_PACKAGESTEP_ID;
-    else if(isRemote && isHTML)
+    else if(isRemote && ( isHTML || isQML ) )
         types << Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID
               << Constants::UBUNTU_CLICK_PACKAGESTEP_ID;
 

=== modified file 'src/ubuntu/ubuntudevicemode.cpp'
--- src/ubuntu/ubuntudevicemode.cpp	2014-05-15 13:48:54 +0000
+++ src/ubuntu/ubuntudevicemode.cpp	2014-07-31 10:11:55 +0000
@@ -103,6 +103,11 @@
     emit updateDeviceActions ();
 }
 
+void UbuntuDeviceMode::showAddEmulatorDialog()
+{
+    m_qmlControl->showAddEmulatorDialog();
+}
+
 void UbuntuDeviceMode::modeChanged(Core::IMode *mode)
 {
     Q_UNUSED(mode);
@@ -125,6 +130,11 @@
 
 }
 
+void UbuntuQMLDeviceMode::showAddEmulatorDialog()
+{
+    emit openAddEmulatorDialog();
+}
+
 void UbuntuQMLDeviceMode::deviceSelected(const QVariant index)
 {
     m_mode->deviceSelected(index);

=== modified file 'src/ubuntu/ubuntudevicemode.h'
--- src/ubuntu/ubuntudevicemode.h	2014-05-14 14:18:55 +0000
+++ src/ubuntu/ubuntudevicemode.h	2014-07-31 10:11:55 +0000
@@ -37,6 +37,8 @@
 public:
     UbuntuQMLDeviceMode( UbuntuDeviceMode *parent );
 
+    void showAddEmulatorDialog ();
+
 public slots:
     void deviceSelected ( const QVariant index );
     void addText (const QString &arg);
@@ -45,6 +47,7 @@
 signals:
     void logChanged(const QString &arg);
     void appendText(const QString &newText);
+    void openAddEmulatorDialog ();
 
 private:
     UbuntuDeviceMode* m_mode;
@@ -64,6 +67,9 @@
 
     void deviceSelected ( const QVariant index );
 
+public slots:
+    void showAddEmulatorDialog ();
+
 signals:
     void updateDeviceActions ();
 

=== modified file 'src/ubuntu/ubuntudevicesmodel.cpp'
--- src/ubuntu/ubuntudevicesmodel.cpp	2014-07-28 09:38:41 +0000
+++ src/ubuntu/ubuntudevicesmodel.cpp	2014-07-31 10:11:55 +0000
@@ -726,23 +726,27 @@
     m_process->start(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_INSTALL_EMULATOR_PACKAGE));
 }
 
-void UbuntuDevicesModel::createEmulatorImage(const QString &name, const QString &arch, const QString &channel)
+void UbuntuDevicesModel::doCreateEmulatorImage(UbuntuProcess *process, const QString &name, const QString &arch, const QString &channel)
 {
-    setState(CreateEmulatorImage);
-    setCancellable(true);
-
-    beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_LOCAL_CREATE_EMULATOR));
-    m_process->stop();
+    process->stop();
     QString strEmulatorName = name;
     QString strEmulatorPath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation);
     strEmulatorPath += QDir::separator();
     strEmulatorPath += QLatin1String(Constants::DEFAULT_EMULATOR_PATH);
     strEmulatorPath += QDir::separator();
-    m_process->append(QStringList()
+    process->append(QStringList()
                       << QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_LOCAL_CREATE_EMULATOR_SCRIPT)
                       .arg(Ubuntu::Constants::UBUNTU_SCRIPTPATH).arg(strEmulatorPath).arg(strEmulatorName).arg(arch).arg(channel)
                       << QCoreApplication::applicationDirPath());
-    m_process->start(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_LOCAL_CREATE_EMULATOR));
+    process->start(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_LOCAL_CREATE_EMULATOR));
+}
+
+void UbuntuDevicesModel::createEmulatorImage(const QString &name, const QString &arch, const QString &channel)
+{
+    setState(CreateEmulatorImage);
+    setCancellable(true);
+    beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_LOCAL_CREATE_EMULATOR));
+    doCreateEmulatorImage(m_process,name,arch,channel);
 }
 
 void UbuntuDevicesModel::queryAdb()
@@ -1024,7 +1028,7 @@
 
                     if (lineData.count() == 2) {
                         QString sSerialNumber = lineData.takeFirst();
-                        QString sDeviceInfo = lineData.takeFirst();
+                        //QString sDeviceInfo = lineData.takeFirst();
 
                         //sometimes the adb server is not started when adb devices is
                         //executed, we just skip those lines

=== modified file 'src/ubuntu/ubuntudevicesmodel.h'
--- src/ubuntu/ubuntudevicesmodel.h	2014-07-28 07:28:56 +0000
+++ src/ubuntu/ubuntudevicesmodel.h	2014-07-31 10:11:55 +0000
@@ -81,6 +81,8 @@
     QString state() const;
     bool busy() const;
     bool emulatorInstalled() const;
+
+    static void doCreateEmulatorImage ( UbuntuProcess *process, const QString &name, const QString &arch, const QString &channel );
 signals:
     void logMessage (const QString &str);
     void stdOutMessage (const QString &str);

=== added file 'src/ubuntu/ubuntufirstrunwizard.cpp'
--- src/ubuntu/ubuntufirstrunwizard.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntufirstrunwizard.cpp	2014-07-31 10:11:55 +0000
@@ -0,0 +1,221 @@
+#include "ubuntufirstrunwizard.h"
+#include "ubuntuconstants.h"
+#include "ubuntukitmanager.h"
+#include "ubuntuclickdialog.h"
+#include "clicktoolchain.h"
+#include "ubuntudevicesmodel.h"
+#include "ubuntuprocess.h"
+#include "ubuntudevice.h"
+
+#include <projectexplorer/kitmanager.h>
+#include <projectexplorer/kitinformation.h>
+#include <projectexplorer/devicesupport/devicemanager.h>
+
+#include <QLabel>
+#include <QPushButton>
+#include <QVBoxLayout>
+#include <QTreeWidget>
+#include <QTreeWidgetItem>
+#include <QCheckBox>
+#include <QDebug>
+#include <QVariant>
+#include <QHeaderView>
+#include <QSpacerItem>
+
+namespace Ubuntu {
+namespace Internal {
+
+enum {
+    debug = 1
+};
+
+UbuntuFirstRunWizard::UbuntuFirstRunWizard(QWidget *parent) :
+    QWizard(parent)
+{
+    addPage(new UbuntuIntroductionWizardPage);
+    addPage(new UbuntuSetupChrootWizardPage);
+    addPage(new UbuntuSetupEmulatorWizardPage);
+
+    setMinimumSize(800,600);
+}
+
+
+
+UbuntuIntroductionWizardPage::UbuntuIntroductionWizardPage(QWidget *parent) :
+    QWizardPage(parent)
+{
+    QLabel *label = new QLabel(tr("<h1 style=\"text-align: center;\">Welcome to the Ubuntu-SDK</h1>"
+                               "<p>This Wizard will help to setup a development environment to create Applications for the Ubuntu platform.</p>"
+                               "<p>At any time later it is possible to create:"
+                               "<ul><li>new targets in the  &quot;Tools -&gt; Options -&gt; Ubuntu&quot; Settings Page,</li>"
+                               "<li>new emulators on the Devices pages by clicking on the &quot;+&quot; button</li></ul>"
+                               "</p>"
+                               "<p>Have a lot of fun!</p>"));
+    label->setWordWrap(true);
+
+    QCheckBox *check = new QCheckBox(tr("Do not show this Wizard the next time."));
+    check->setChecked(true);
+
+
+    registerField(QStringLiteral("disableWizard"),check);
+
+    QVBoxLayout *layout = new QVBoxLayout;
+    layout->addWidget(label);
+    layout->addStretch();
+    layout->addWidget(check);
+    setLayout(layout);
+}
+
+void UbuntuIntroductionWizardPage::initializePage()
+{
+
+}
+
+bool UbuntuIntroductionWizardPage::isComplete() const
+{
+    return true;
+}
+
+UbuntuSetupChrootWizardPage::UbuntuSetupChrootWizardPage(QWidget *parent)
+    : QWizardPage(parent) ,
+      m_complete(false)
+{
+
+    setTitle(tr("Build targets"));
+
+    QLabel *label = new QLabel(tr("<p>In order to create Apps for the Ubuntu platform, it is required to create Kits. Kits enable cross-platform and cross-configuration development. Kits consist of a set of values that define one environment, such as a target device, sysroot to build against,  toolchain to build with, platform specific API set, and some metadata.</p>"
+                                  "<p><strong>Note: </strong>It is recommended to create Kits for each possible traget architecture (i386, armhf). When developing with the emulator, the best experience is provided by using a i386 emulator and Kit</p>"));
+    label->setWordWrap(true);
+
+    m_kitExistsLabel = new QLabel(tr("These Kits are already available on the machine, but it is also possible to create new ones."));
+    m_kitExistsLabel->setWordWrap(true);
+    m_kitExistsLabel->setVisible(false);
+
+    m_kitList = new QTreeWidget;
+    m_kitList->setEditTriggers(QAbstractItemView::NoEditTriggers);
+    m_kitList->setSelectionMode(QAbstractItemView::NoSelection);
+    m_kitList->setItemsExpandable(false);
+    m_kitList->header()->setStretchLastSection(true);
+    m_kitList->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
+    m_kitList->setColumnCount(1);
+
+    QStringList headers;
+    headers << tr("Kit Name");
+    m_kitList->setHeaderLabels(headers);
+
+
+    m_createKitButton = new QPushButton(tr("Create new Kit"));
+    connect(m_createKitButton,SIGNAL(clicked()),this,SLOT(onCreateKitButtonClicked()));
+
+    QVBoxLayout *layout = new QVBoxLayout;
+    layout->addWidget(label);
+    layout->addWidget(m_kitExistsLabel);
+    layout->addWidget(m_kitList);
+    layout->addWidget(m_createKitButton);
+    setLayout(layout);
+}
+
+void UbuntuSetupChrootWizardPage::initializePage()
+{
+    QList<ProjectExplorer::Kit *> allKits = ProjectExplorer::KitManager::kits();
+    m_kitList->clear();
+
+    bool found = false;
+    foreach(ProjectExplorer::Kit *curr, allKits) {
+        ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(curr);
+        if (tc->type() == QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)) {
+            found = true;
+
+            QTreeWidgetItem* kitItem = new QTreeWidgetItem;
+            kitItem->setText(0,curr->displayName());
+            kitItem->setData(0,Qt::UserRole,curr->id().uniqueIdentifier());
+            m_kitList->addTopLevelItem(kitItem);
+        }
+    }
+
+    m_kitExistsLabel->setVisible(found);
+    if(m_complete != found) {
+        m_complete = found;
+        emit completeChanged();
+    }
+}
+
+bool UbuntuSetupChrootWizardPage::isComplete() const
+{
+    return m_complete;
+}
+
+void UbuntuSetupChrootWizardPage::onCreateKitButtonClicked()
+{
+    UbuntuClickDialog::createClickChrootModal(true,QString(),this);
+    initializePage();
+}
+
+UbuntuSetupEmulatorWizardPage::UbuntuSetupEmulatorWizardPage(QWidget *parent)
+    : QWizardPage(parent)
+{
+
+    QLabel *label = new QLabel(tr("<p>To be able to run applications either a physical device or a Ubuntu Emulator can be used.<br />"
+                                  "Please enable the checkbox below if a emulator should be created right away and after pressing the &quot;Finish&quot; button the device page will be opened.</p>"
+                                  "<p>Skip that step if only physical devices are used.</p>"
+                                  "<p><strong>Note: </strong>Currently we suggest to use only the i386 emulator, because it provides the best experience</p>"));
+    label->setWordWrap(true);
+
+    m_createEmulatorCheckBox = new QCheckBox(tr("Create emulator"));
+    registerField(QStringLiteral("createEmulator"),m_createEmulatorCheckBox);
+
+    m_devicesList =new QTreeWidget;
+    m_devicesList->setEditTriggers(QAbstractItemView::NoEditTriggers);
+    m_devicesList->setSelectionMode(QAbstractItemView::NoSelection);
+    m_devicesList->setItemsExpandable(false);
+    m_devicesList->header()->setStretchLastSection(true);
+    m_devicesList->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
+    m_devicesList->setColumnCount(1);
+
+    QStringList headers;
+    headers << tr("Device Name");
+    m_devicesList->setHeaderLabels(headers);
+
+    QVBoxLayout *layout = new QVBoxLayout;
+    layout->addWidget(label);
+    layout->addSpacing(10);
+    layout->addWidget(new QLabel(tr("List of available devices")));
+    layout->addWidget(m_devicesList);
+    layout->addWidget(m_createEmulatorCheckBox);
+    setLayout(layout);
+
+    connect(ProjectExplorer::DeviceManager::instance(),SIGNAL(deviceAdded(Core::Id)),this,SLOT(updateDevicesList()));
+    connect(ProjectExplorer::DeviceManager::instance(),SIGNAL(deviceRemoved(Core::Id)),this,SLOT(updateDevicesList()));
+    connect(ProjectExplorer::DeviceManager::instance(),SIGNAL(deviceListReplaced()),this,SLOT(updateDevicesList()));
+}
+
+void UbuntuSetupEmulatorWizardPage::updateDevicesList()
+{
+    m_devicesList->clear();
+    ProjectExplorer::DeviceManager *devMgr = ProjectExplorer::DeviceManager::instance();
+    for(int i = 0; i < devMgr->deviceCount(); i++) {
+        ProjectExplorer::IDevice::ConstPtr dev = devMgr->deviceAt(i);
+        if(!dev)
+            continue;
+
+        if(dev->type() != Constants::UBUNTU_DEVICE_TYPE_ID)
+            continue;
+
+        QTreeWidgetItem* devItem = new QTreeWidgetItem;
+        devItem->setText(0,dev->displayName());
+        m_devicesList->addTopLevelItem(devItem);
+    }
+}
+
+void UbuntuSetupEmulatorWizardPage::initializePage()
+{
+    updateDevicesList();
+}
+
+bool UbuntuSetupEmulatorWizardPage::isComplete() const
+{
+    return true;
+}
+
+} // namespace Internal
+} // namespace Ubuntu

=== added file 'src/ubuntu/ubuntufirstrunwizard.h'
--- src/ubuntu/ubuntufirstrunwizard.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntufirstrunwizard.h	2014-07-31 10:11:55 +0000
@@ -0,0 +1,86 @@
+#ifndef UBUNTU_INTERNAL_UBUNTUFIRSTRUNWIZARD_H
+#define UBUNTU_INTERNAL_UBUNTUFIRSTRUNWIZARD_H
+
+#include <QWizard>
+#include <QList>
+
+class QLabel;
+class QPushButton;
+class QTreeWidget;
+class QCheckBox;
+
+namespace ProjectExplorer {
+    class Kit;
+}
+
+namespace Ubuntu {
+namespace Internal {
+
+class UbuntuProcess;
+
+class UbuntuFirstRunWizard : public QWizard
+{
+    Q_OBJECT
+public:
+    explicit UbuntuFirstRunWizard(QWidget *parent = 0);
+
+signals:
+
+public slots:
+
+};
+
+class UbuntuIntroductionWizardPage : public QWizardPage
+{
+    Q_OBJECT
+public:
+    UbuntuIntroductionWizardPage (QWidget *parent = 0);
+
+    // QWizardPage interface
+    virtual void initializePage();
+    virtual bool isComplete() const;
+};
+
+
+class UbuntuSetupChrootWizardPage : public QWizardPage
+{
+    Q_OBJECT
+public:
+    UbuntuSetupChrootWizardPage (QWidget *parent = 0);
+
+    // QWizardPage interface
+    virtual void initializePage();
+    virtual bool isComplete() const;
+
+protected slots:
+    void onCreateKitButtonClicked ();
+
+private:
+    QLabel *m_kitExistsLabel;
+    QTreeWidget *m_kitList;
+    QPushButton *m_createKitButton;
+    bool m_complete;
+};
+
+class UbuntuSetupEmulatorWizardPage : public QWizardPage
+{
+    Q_OBJECT
+public:
+    UbuntuSetupEmulatorWizardPage (QWidget *parent = 0);
+
+    // QWizardPage interface
+    virtual void initializePage();
+    virtual bool isComplete() const;
+
+protected slots:
+    void updateDevicesList ();
+
+private:
+    QCheckBox *m_createEmulatorCheckBox;
+    QTreeWidget *m_devicesList;
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_UBUNTUFIRSTRUNWIZARD_H

=== modified file 'src/ubuntu/ubuntukitmanager.cpp'
--- src/ubuntu/ubuntukitmanager.cpp	2014-07-22 07:33:23 +0000
+++ src/ubuntu/ubuntukitmanager.cpp	2014-07-31 10:11:55 +0000
@@ -4,6 +4,7 @@
 #include "ubuntucmaketool.h"
 #include "ubuntudevice.h"
 #include "ubuntuclickdialog.h"
+#include "ubuntuqtversion.h"
 
 #include <projectexplorer/kitmanager.h>
 #include <projectexplorer/kit.h>
@@ -15,8 +16,10 @@
 #include <qtsupport/qtkitinformation.h>
 #include <cmakeprojectmanager/cmakekitinformation.h>
 #include <cmakeprojectmanager/cmaketoolmanager.h>
+#include <qtsupport/qtversionmanager.h>
 
 #include <QMessageBox>
+#include <QTextStream>
 
 namespace Ubuntu {
 namespace Internal {
@@ -64,6 +67,53 @@
     return toolchains;
 }
 
+UbuntuQtVersion *UbuntuKitManager::createOrFindQtVersion(ClickToolChain *tc)
+{
+
+    QString qmakePath = QStringLiteral("%1/.config/ubuntu-sdk/qmake-%2-%3")
+            .arg(QDir::homePath())
+            .arg(tc->clickTarget().framework)
+            .arg(tc->clickTarget().architecture);
+
+    if(!QFile::exists(qmakePath)) {
+        QFile qmakeTemplate(Constants::UBUNTU_RESOURCE_PATH+QStringLiteral("/ubuntu/scripts/qtc_chroot_qmake"));
+        if(qmakeTemplate.open(QIODevice::ReadOnly)) {
+
+            QTextStream in(&qmakeTemplate);
+            QString templ = in.readAll();
+
+            templ = templ
+                    .arg(tc->clickTarget().architecture)
+                    .arg(tc->clickTarget().framework);
+
+
+            QFile qmakeScript(qmakePath);
+
+            qmakeScript.open(QIODevice::WriteOnly);
+            qmakeScript.setPermissions(QFile::ExeUser | QFile::ReadUser | QFile::ReadGroup);
+
+            {
+                QTextStream out(&qmakeScript);
+                out << templ;
+            }
+
+            qmakeScript.close();
+        }
+    } else {
+        //try to find a already existing Qt Version for this chroot
+        foreach (QtSupport::BaseQtVersion *qtVersion, QtSupport::QtVersionManager::versions()) {
+            if (qtVersion->type() != QLatin1String(Constants::UBUNTU_QTVERSION_TYPE))
+                continue;
+            if (qtVersion->qmakeCommand().toFileInfo() == QFileInfo(qmakePath))
+                return static_cast<UbuntuQtVersion*> (qtVersion);
+        }
+    }
+
+    UbuntuQtVersion *qtVersion = new UbuntuQtVersion(Utils::FileName::fromString(qmakePath),false);
+    QtSupport::QtVersionManager::addVersion(qtVersion);
+    return qtVersion;
+}
+
 void UbuntuKitManager::autoCreateKit(UbuntuDevice::Ptr device)
 {
     ProjectExplorer::Abi requiredAbi = ClickToolChain::architectureNameToAbi(device->architecture());
@@ -265,8 +315,7 @@
     ProjectExplorer::SysRootKitInformation::setSysRoot(newKit,Utils::FileName::fromString(UbuntuClickTool::targetBasePath(tc->clickTarget())));
 
     //@TODO add gdbserver support
-    //@TODO add real qt version
-    QtSupport::QtKitInformation::setQtVersion(newKit, 0);
+    QtSupport::QtKitInformation::setQtVersion(newKit, createOrFindQtVersion(tc));
     return newKit;
 }
 
@@ -342,6 +391,9 @@
     k->setSticky(ProjectExplorer::SysRootKitInformation::id(),true);
     k->setMutable(ProjectExplorer::SysRootKitInformation::id(),false);
 
+    //make sure we use a ubuntu Qt version
+    QtSupport::QtKitInformation::setQtVersion(k, createOrFindQtVersion(tc));
+
 }
 
 } // namespace Internal

=== modified file 'src/ubuntu/ubuntukitmanager.h'
--- src/ubuntu/ubuntukitmanager.h	2014-04-17 14:38:15 +0000
+++ src/ubuntu/ubuntukitmanager.h	2014-07-31 10:11:55 +0000
@@ -29,6 +29,8 @@
 namespace Ubuntu {
 namespace Internal {
 
+class UbuntuQtVersion;
+
 class UbuntuKitManager : public QObject
 {
     Q_OBJECT
@@ -41,6 +43,7 @@
     static QVariant createOrFindDebugger(const Utils::FileName &path);
     static void fixKit (ProjectExplorer::Kit* k);
     static QList<ClickToolChain *> clickToolChains();
+    static UbuntuQtVersion *createOrFindQtVersion(ClickToolChain* tc);
 };
 
 } // namespace Internal

=== modified file 'src/ubuntu/ubuntulocalrunconfigurationfactory.cpp'
--- src/ubuntu/ubuntulocalrunconfigurationfactory.cpp	2014-07-14 15:39:54 +0000
+++ src/ubuntu/ubuntulocalrunconfigurationfactory.cpp	2014-07-31 10:11:55 +0000
@@ -51,9 +51,9 @@
     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";
+    bool isQML    = parent->project()->id() == "QmlProjectManager.QmlProject";
 
-    if (!isCMake && !isHTML)
+    if (!isCMake && !isHTML &&!isQML)
         return types;
 
     if (isRemote) {
@@ -78,7 +78,7 @@
     }
     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) {
+        if ((isCMake && isApp) || isHTML || isQML) {
             foreach (const UbuntuClickManifest::Hook &hook, hooks) {
                 types << UbuntuRemoteRunConfiguration::typeId().withSuffix(hook.appId);
             }

=== modified file 'src/ubuntu/ubuntupackagestep.cpp'
--- src/ubuntu/ubuntupackagestep.cpp	2014-07-15 09:55:12 +0000
+++ src/ubuntu/ubuntupackagestep.cpp	2014-07-31 10:11:55 +0000
@@ -457,7 +457,8 @@
 
     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);
+            (m_packageMode == AutoEnableDebugScript && bc->buildType() == ProjectExplorer::BuildConfiguration::Debug)
+            || (m_packageMode == AutoEnableDebugScript && bc->target()->project()->id() == "QmlProjectManager.QmlProject");
 
     //debughelper script name, source and destination path
     const QString debScript = QStringLiteral("qtc_device_debughelper.py");

=== modified file 'src/ubuntu/ubuntupackagingwidget.cpp'
--- src/ubuntu/ubuntupackagingwidget.cpp	2014-07-23 09:46:36 +0000
+++ src/ubuntu/ubuntupackagingwidget.cpp	2014-07-31 10:11:55 +0000
@@ -42,6 +42,7 @@
 #include <coreplugin/actionmanager/actioncontainer.h>
 #include <cmakeprojectmanager/cmakeprojectconstants.h>
 #include <ssh/sshconnection.h>
+#include <qmlprojectmanager/qmlprojectconstants.h>
 
 
 #include <QFileDialog>
@@ -187,7 +188,7 @@
 
 void UbuntuPackagingWidget::onMessage(QString msg)
 {
-    if(debug) printToOutputPane(msg);
+    printToOutputPane(msg);
     m_reply.append(msg);
     m_inputParser->addRecievedData(msg);
 }
@@ -700,7 +701,8 @@
 
     QString mimeType = project->projectManager()->mimeType();
     if(mimeType == QLatin1String(CMakeProjectManager::Constants::CMAKEMIMETYPE)
-       || mimeType == QLatin1String(Ubuntu::Constants::UBUNTUPROJECT_MIMETYPE) ) {
+       || mimeType == QLatin1String(Ubuntu::Constants::UBUNTUPROJECT_MIMETYPE)
+       || mimeType == QLatin1String(QmlProjectManager::Constants::QMLPROJECT_MIMETYPE)) {
         if(m_reviewToolsInstalled)
             m_postPackageTask = Verify;
         else
@@ -804,8 +806,9 @@
     QString mimeType = project->projectManager()->mimeType();
     bool isCMake = mimeType == QLatin1String(CMakeProjectManager::Constants::CMAKEMIMETYPE);
     bool isHtml  = mimeType == QLatin1String(Ubuntu::Constants::UBUNTUPROJECT_MIMETYPE);
+    bool isQml   = mimeType == QLatin1String(QmlProjectManager::Constants::QMLPROJECT_MIMETYPE);
 
-    if(isCMake || isHtml) {
+    if(isCMake || isHtml || isQml) {
         ProjectExplorer::Target* target = project->activeTarget();
         if(!target)
             return;

=== modified file 'src/ubuntu/ubuntuplugin.cpp'
--- src/ubuntu/ubuntuplugin.cpp	2014-07-15 09:55:12 +0000
+++ src/ubuntu/ubuntuplugin.cpp	2014-07-31 10:11:55 +0000
@@ -35,7 +35,11 @@
 #include "ubuntudevicesmodel.h"
 #include "localportsmanager.h"
 #include "ubuntubzr.h"
+#include "ubuntuqtversion.h"
 #include "ubuntudeploystepfactory.h"
+#include "ubuntuqmlbuildconfiguration.h"
+#include "ubuntufirstrunwizard.h"
+
 #include <coreplugin/modemanager.h>
 #include <projectexplorer/kitmanager.h>
 #include <coreplugin/featureprovider.h>
@@ -47,6 +51,7 @@
 #include <QFileInfo>
 #include <QGuiApplication>
 #include <QtQml>
+#include <QFile>
 #include <coreplugin/icore.h>
 
 using namespace Ubuntu;
@@ -136,6 +141,7 @@
     addAutoReleasedObject(new UbuntuCMakeMakeStepFactory);
     addAutoReleasedObject(new UbuntuCMakeBuildConfigurationFactory);
     addAutoReleasedObject(new UbuntuHtmlBuildConfigurationFactory);
+    addAutoReleasedObject(new UbuntuQmlBuildConfigurationFactory);
 
     //ubuntu device support
     addAutoReleasedObject(new UbuntuDeviceFactory);
@@ -162,6 +168,9 @@
                     QStringLiteral("ubuntu-project-go"),
                     Core::IWizard::ProjectWizard));
 
+    //register Qt version
+    addAutoReleasedObject(new Ubuntu::Internal::UbuntuQtVersionFactory);
+
     //disabled for now, keeping the code because we might need a deploy method
     //for local applications in the future
     //addAutoReleasedObject(new UbuntuLocalDeployConfigurationFactory);
@@ -190,6 +199,34 @@
     UbuntuKitManager::autoDetectKits();
     disconnect(ProjectExplorer::KitManager::instance(),SIGNAL(kitsLoaded())
                ,this,SLOT(onKitsLoaded()));
+
+    showFirstStartWizard();
+}
+
+void UbuntuPlugin::showFirstStartWizard()
+{
+    QString file = QStringLiteral("%1/.config/ubuntu-sdk/firstrun")
+            .arg(QDir::homePath());
+
+    if(!QFile::exists(file)) {
+        UbuntuFirstRunWizard wiz(Core::ICore::mainWindow());
+        if( wiz.exec() == QDialog::Accepted ) {
+            if (wiz.field(QStringLiteral("createEmulator")).toBool()) {
+                Core::ModeManager::activateMode(Ubuntu::Constants::UBUNTU_MODE_DEVICES);
+
+                //invoke the method the next time the event loop starts
+                QMetaObject::invokeMethod(m_ubuntuDeviceMode,"showAddEmulatorDialog",Qt::QueuedConnection);
+            }
+
+            if(wiz.field(QStringLiteral("disableWizard")).toBool()) {
+                QFile f(file);
+                if(f.open(QIODevice::WriteOnly)) {
+                    f.write("1");
+                    f.close();
+                }
+            }
+        }
+    }
 }
 
 Q_EXPORT_PLUGIN2(Ubuntu, UbuntuPlugin)

=== modified file 'src/ubuntu/ubuntuplugin.h'
--- src/ubuntu/ubuntuplugin.h	2014-06-04 15:35:40 +0000
+++ src/ubuntu/ubuntuplugin.h	2014-07-31 10:11:55 +0000
@@ -57,6 +57,7 @@
 
 private slots:
     void onKitsLoaded ();
+    void showFirstStartWizard ();
 
 protected:
     UbuntuDeviceMode*       m_ubuntuDeviceMode;

=== modified file 'src/ubuntu/ubuntuprojectapplicationwizard.cpp'
--- src/ubuntu/ubuntuprojectapplicationwizard.cpp	2014-07-15 09:55:12 +0000
+++ src/ubuntu/ubuntuprojectapplicationwizard.cpp	2014-07-31 10:11:55 +0000
@@ -21,6 +21,7 @@
 #include "ubuntuconstants.h"
 #include "ubuntuproject.h"
 #include "ubuntubzr.h"
+#include "ubuntufirstrunwizard.h"
 
 #include <coreplugin/mimedatabase.h>
 
@@ -57,6 +58,7 @@
     UbuntuProjectApplicationWizardDialog *projectDialog = new UbuntuProjectApplicationWizardDialog(parent,
                                                                                                    m_type ,
                                                                                                    wizardDialogParameters);
+    projectDialog->addChrootSetupPage(12);
     projectDialog->addTargetSetupPage(13);
 
     initProjectWizardDialog(projectDialog,
@@ -168,12 +170,30 @@
             this, SLOT(generateProfileName(QString,QString)));
 }
 
+void UbuntuProjectApplicationWizardDialog::addChrootSetupPage(int id)
+{
+    QList<ProjectExplorer::Kit *> allKits = ProjectExplorer::KitManager::kits();
+
+    bool found = false;
+    foreach(ProjectExplorer::Kit *curr, allKits) {
+        ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(curr);
+        if (tc->type() == QLatin1String(Constants::UBUNTU_CLICK_TOOLCHAIN_ID)) {
+            found = true;
+            break;
+        }
+    }
+
+    if(found)
+        return;
+
+    if (id >= 0)
+        setPage(id, new UbuntuSetupChrootWizardPage);
+    else
+        id = addPage(new UbuntuSetupChrootWizardPage);
+}
+
 void UbuntuProjectApplicationWizardDialog::addTargetSetupPage(int id)
 {
-    //no target setup page required for basic projects
-    if(m_type == UbuntuProjectApplicationWizard::UbuntuQMLProject)
-        return;
-
     m_targetSetupPage = new ProjectExplorer::TargetSetupPage;
     const QString platform = selectedPlatform();
 
@@ -211,6 +231,7 @@
                 m_targetSetupPage->setRequiredKitMatcher(new QtSupport::QtVersionKitMatcher(features));
             break;
         }
+        case UbuntuProjectApplicationWizard::UbuntuQMLProject:
         case UbuntuProjectApplicationWizard::UbuntuHTMLProject: {
             m_targetSetupPage->setRequiredKitMatcher(new UbuntuKitMatcher());
             break;
@@ -250,6 +271,11 @@
                                           +projectName
                                           +QDir::separator()
                                           +QString::fromLatin1("%1.ubuntuhtmlproject").arg(projectName));
+    } else if (m_type == UbuntuProjectApplicationWizard::UbuntuQMLProject) {
+        m_targetSetupPage->setProjectPath(path+QDir::separator()
+                                          +projectName
+                                          +QDir::separator()
+                                          +QString::fromLatin1("%1.qmlproject").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-07-15 09:55:12 +0000
+++ src/ubuntu/ubuntuprojectapplicationwizard.h	2014-07-31 10:11:55 +0000
@@ -68,6 +68,7 @@
                                                   const Core::WizardDialogParameters &parameters);
     virtual ~UbuntuProjectApplicationWizardDialog();
 
+    void addChrootSetupPage(int id = -1);
     void addTargetSetupPage(int id = -1);
 
     QList<Core::Id> selectedKits() const;

=== added file 'src/ubuntu/ubuntuqmlbuildconfiguration.cpp'
--- src/ubuntu/ubuntuqmlbuildconfiguration.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntuqmlbuildconfiguration.cpp	2014-07-31 10:11:55 +0000
@@ -0,0 +1,203 @@
+#include "ubuntuqmlbuildconfiguration.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 <qmlprojectmanager/qmlprojectconstants.h>
+
+#include <QFormLayout>
+
+namespace Ubuntu {
+namespace Internal {
+
+/*!
+ * \class UbuntuQmlBuildConfiguration
+ *
+ * Even though QML 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
+ */
+
+UbuntuQmlBuildConfiguration::UbuntuQmlBuildConfiguration(ProjectExplorer::Target *target)
+    : BuildConfiguration(target,Constants::UBUNTU_CLICK_QML_BC_ID)
+{
+}
+
+UbuntuQmlBuildConfiguration::UbuntuQmlBuildConfiguration(ProjectExplorer::Target *target, UbuntuQmlBuildConfiguration *source)
+    : BuildConfiguration(target,source)
+{
+
+}
+
+bool UbuntuQmlBuildConfiguration::fromMap(const QVariantMap &map)
+{
+    return BuildConfiguration::fromMap(map);
+}
+
+QVariantMap UbuntuQmlBuildConfiguration::toMap() const
+{
+    return BuildConfiguration::toMap();
+}
+
+ProjectExplorer::NamedWidget *UbuntuQmlBuildConfiguration::createConfigWidget()
+{
+    return new UbuntuQmlBuildSettingsWidget(this);
+}
+
+ProjectExplorer::BuildConfiguration::BuildType UbuntuQmlBuildConfiguration::buildType() const
+{
+    return Release;
+}
+
+UbuntuQmlBuildConfigurationFactory::UbuntuQmlBuildConfigurationFactory(QObject *parent)
+    : IBuildConfigurationFactory(parent)
+{
+
+}
+
+UbuntuQmlBuildConfigurationFactory::~UbuntuQmlBuildConfigurationFactory()
+{
+
+}
+
+int UbuntuQmlBuildConfigurationFactory::priority(const ProjectExplorer::Target *parent) const
+{
+    if (canHandle(parent))
+        return 100;
+    return -1;
+}
+
+QList<ProjectExplorer::BuildInfo *> UbuntuQmlBuildConfigurationFactory::availableBuilds(const ProjectExplorer::Target *parent) const
+{
+    if(!canHandle(parent))
+        return QList<ProjectExplorer::BuildInfo *>();
+    return createBuildInfos(parent->kit(),parent->project()->projectFilePath());
+}
+
+int UbuntuQmlBuildConfigurationFactory::priority(const ProjectExplorer::Kit *k, const QString &projectPath) const
+{
+    return (k && Core::MimeDatabase::findByFile(QFileInfo(projectPath))
+            .matchesType(QLatin1String(QmlProjectManager::Constants::QMLPROJECT_MIMETYPE))) ? 100 : -1;
+}
+
+QList<ProjectExplorer::BuildInfo *> UbuntuQmlBuildConfigurationFactory::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);
+}
+
+UbuntuQmlBuildConfiguration *UbuntuQmlBuildConfigurationFactory::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);
+
+    UbuntuQmlBuildConfiguration *conf = new UbuntuQmlBuildConfiguration(parent);
+    conf->setBuildDirectory(info->buildDirectory);
+    conf->setDefaultDisplayName(info->displayName);
+    conf->setDisplayName(info->displayName);
+
+    return conf;
+}
+
+bool UbuntuQmlBuildConfigurationFactory::canRestore(const ProjectExplorer::Target *parent, const QVariantMap &map) const
+{
+    if (!canHandle(parent))
+        return false;
+    return ProjectExplorer::idFromMap(map) == Constants::UBUNTU_CLICK_QML_BC_ID;
+}
+
+UbuntuQmlBuildConfiguration *UbuntuQmlBuildConfigurationFactory::restore(ProjectExplorer::Target *parent, const QVariantMap &map)
+{
+    if (!canRestore(parent,map) )
+        return 0;
+
+    UbuntuQmlBuildConfiguration *conf = new UbuntuQmlBuildConfiguration(parent);
+    if (conf->fromMap(map))
+        return conf;
+
+    delete conf;
+    return 0;
+}
+
+bool UbuntuQmlBuildConfigurationFactory::canClone(const ProjectExplorer::Target *parent, ProjectExplorer::BuildConfiguration *product) const
+{
+    if (!canHandle(parent))
+        return false;
+    if (product->id() != Constants::UBUNTU_CLICK_QML_BC_ID )
+        return false;
+
+    return true;
+}
+
+UbuntuQmlBuildConfiguration *UbuntuQmlBuildConfigurationFactory::clone(ProjectExplorer::Target *parent, ProjectExplorer::BuildConfiguration *product)
+{
+    if (!canClone(parent,product))
+        return 0;
+    return new UbuntuQmlBuildConfiguration(parent,static_cast<UbuntuQmlBuildConfiguration*>(product));
+}
+
+bool UbuntuQmlBuildConfigurationFactory::canHandle(const ProjectExplorer::Target *t) const
+{
+    UbuntuKitMatcher m;
+    if(!m.matches(t->kit()))
+        return false;
+
+    if (t->project()->id() != "QmlProjectManager.QmlProject")
+        return false;
+
+    return true;
+}
+
+QList<ProjectExplorer::BuildInfo *> UbuntuQmlBuildConfigurationFactory::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("Qml");
+    info->kitId    = k->id();
+    info->supportsShadowBuild = true;
+    info->displayName = tr("Default");
+
+    builds << info;
+    return builds;
+}
+
+UbuntuQmlBuildSettingsWidget::UbuntuQmlBuildSettingsWidget(UbuntuQmlBuildConfiguration *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 UbuntuQmlBuildSettingsWidget::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/ubuntuqmlbuildconfiguration.h'
--- src/ubuntu/ubuntuqmlbuildconfiguration.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntuqmlbuildconfiguration.h	2014-07-31 10:11:55 +0000
@@ -0,0 +1,71 @@
+#ifndef UBUNTU_INTERNAL_UBUNTUQMLBUILDCONFIGURATION_H
+#define UBUNTU_INTERNAL_UBUNTUQMLBUILDCONFIGURATION_H
+
+#include <projectexplorer/buildconfiguration.h>
+#include <utils/pathchooser.h>
+#include <projectexplorer/namedwidget.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+class UbuntuQmlBuildConfiguration : public ProjectExplorer::BuildConfiguration
+{
+    Q_OBJECT
+
+public:
+    UbuntuQmlBuildConfiguration(ProjectExplorer::Target *target);
+    UbuntuQmlBuildConfiguration(ProjectExplorer::Target *target, UbuntuQmlBuildConfiguration *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 UbuntuQmlBuildConfigurationFactory;
+};
+
+class UbuntuQmlBuildSettingsWidget : public ProjectExplorer::NamedWidget
+{
+    Q_OBJECT
+
+public:
+    explicit UbuntuQmlBuildSettingsWidget(UbuntuQmlBuildConfiguration *conf, QWidget *parent = 0);
+
+private slots:
+    void updateBuildDirectory () const;
+
+private:
+    Utils::PathChooser *m_pathChooser;
+    UbuntuQmlBuildConfiguration *m_buildConfiguration;
+};
+
+class UbuntuQmlBuildConfigurationFactory : public ProjectExplorer::IBuildConfigurationFactory
+{
+    Q_OBJECT
+public:
+    UbuntuQmlBuildConfigurationFactory(QObject *parent = 0);
+    ~UbuntuQmlBuildConfigurationFactory();
+
+    // 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 UbuntuQmlBuildConfiguration *create(ProjectExplorer::Target *parent, const ProjectExplorer::BuildInfo *info) const override;
+    virtual bool canRestore(const ProjectExplorer::Target *parent, const QVariantMap &map) const override;
+    virtual UbuntuQmlBuildConfiguration *restore(ProjectExplorer::Target *parent, const QVariantMap &map) override;
+    virtual bool canClone(const ProjectExplorer::Target *parent, ProjectExplorer::BuildConfiguration *product) const override;
+    virtual UbuntuQmlBuildConfiguration*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_UBUNTUQMLBUILDCONFIGURATION_H

=== added file 'src/ubuntu/ubuntuqtversion.cpp'
--- src/ubuntu/ubuntuqtversion.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntuqtversion.cpp	2014-07-31 10:11:55 +0000
@@ -0,0 +1,86 @@
+#include "ubuntuqtversion.h"
+#include "ubuntuconstants.h"
+
+#include <qtsupport/qtsupportconstants.h>
+
+#include <QCoreApplication>
+#include <QFileInfo>
+
+namespace Ubuntu {
+namespace Internal {
+
+UbuntuQtVersion::UbuntuQtVersion()
+    : BaseQtVersion()
+{ }
+
+UbuntuQtVersion::UbuntuQtVersion(const Utils::FileName &path, bool isAutodetected, const QString &autodetectionSource)
+    : BaseQtVersion(path, isAutodetected, autodetectionSource)
+{
+    setDisplayName(defaultDisplayName(qtVersionString(), path, false));
+}
+
+UbuntuQtVersion::~UbuntuQtVersion()
+{ }
+
+UbuntuQtVersion *UbuntuQtVersion::clone() const
+{
+    return new UbuntuQtVersion(*this);
+}
+
+QString UbuntuQtVersion::type() const
+{
+    return QLatin1String(Constants::UBUNTU_QTVERSION_TYPE);
+}
+
+QList<ProjectExplorer::Abi> UbuntuQtVersion::detectQtAbis() const
+{
+    return qtAbisFromLibrary(qtCorePaths(versionInfo(), qtVersionString()));
+}
+
+QString UbuntuQtVersion::description() const
+{
+    return QCoreApplication::translate("QtVersion", "Ubuntu Phone", "Qt Version is used for Ubuntu Phone development");
+}
+
+QString UbuntuQtVersion::platformName() const
+{
+    return QLatin1String(Constants::UBUNTU_PLATFORM_NAME);
+}
+
+QString UbuntuQtVersion::platformDisplayName() const
+{
+    return QLatin1String(Constants::UBUNTU_PLATFORM_NAME_TR);
+}
+
+bool UbuntuQtVersionFactory::canRestore(const QString &type)
+{
+    return type == QLatin1String(Constants::UBUNTU_QTVERSION_TYPE);
+}
+
+QtSupport::BaseQtVersion *UbuntuQtVersionFactory::restore(const QString &type, const QVariantMap &data)
+{
+    if(!canRestore(type))
+        return 0;
+
+    UbuntuQtVersion *v = new UbuntuQtVersion();
+    v->fromMap(data);
+    return v;
+}
+
+int UbuntuQtVersionFactory::priority() const
+{
+    return 100;
+}
+
+QtSupport::BaseQtVersion *UbuntuQtVersionFactory::create(const Utils::FileName &qmakePath, ProFileEvaluator *evaluator, bool isAutoDetected, const QString &autoDetectionSource)
+{
+    Q_UNUSED(evaluator);
+    //we only care about our qmakes
+    if(!qmakePath.toFileInfo().absolutePath().endsWith(QStringLiteral(".config/ubuntu-sdk")))
+        return 0;
+
+    return new UbuntuQtVersion(qmakePath,isAutoDetected,autoDetectionSource);
+}
+
+} // namespace Internal
+} // namespace Ubuntu

=== added file 'src/ubuntu/ubuntuqtversion.h'
--- src/ubuntu/ubuntuqtversion.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntuqtversion.h	2014-07-31 10:11:55 +0000
@@ -0,0 +1,41 @@
+#ifndef UBUNTU_INTERNAL_UBUNTUQTVERSION_H
+#define UBUNTU_INTERNAL_UBUNTUQTVERSION_H
+
+#include <qtsupport/baseqtversion.h>
+#include <qtsupport/qtversionfactory.h>
+
+namespace Ubuntu {
+namespace Internal {
+
+class UbuntuQtVersion : public QtSupport::BaseQtVersion
+{
+public:
+    UbuntuQtVersion();
+    UbuntuQtVersion(const Utils::FileName &path, bool isAutodetected = false, const QString &autodetectionSource = QString());
+    ~UbuntuQtVersion() override;
+    UbuntuQtVersion *clone() const override;
+
+    QString type() const override;
+
+    QList<ProjectExplorer::Abi> detectQtAbis() const override;
+
+    QString description() const override;
+
+    QString platformName() const override;
+    QString platformDisplayName() const override;
+};
+
+class UbuntuQtVersionFactory : public QtSupport::QtVersionFactory
+{
+public:
+    // QtVersionFactory interface
+    virtual bool canRestore(const QString &type) override;
+    virtual QtSupport::BaseQtVersion *restore(const QString &type, const QVariantMap &data) override;
+    virtual int priority() const override;
+    virtual QtSupport::BaseQtVersion *create(const Utils::FileName &qmakePath, ProFileEvaluator *evaluator, bool isAutoDetected, const QString &autoDetectionSource) override;
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_UBUNTUQTVERSION_H

=== modified file 'src/ubuntu/ubunturemotedeployconfiguration.cpp'
--- src/ubuntu/ubunturemotedeployconfiguration.cpp	2014-07-14 15:39:54 +0000
+++ src/ubuntu/ubunturemotedeployconfiguration.cpp	2014-07-31 10:11:55 +0000
@@ -85,7 +85,8 @@
 
     //for now only support cmake and ubuntu projects
     if(projectTypeId != CMakeProjectManager::Constants::CMAKEPROJECT_ID
-            && projectTypeId != Ubuntu::Constants::UBUNTUPROJECT_ID)
+            && projectTypeId != Ubuntu::Constants::UBUNTUPROJECT_ID
+            && projectTypeId != "QmlProjectManager.QmlProject")
         return ids;
 
     const Core::Id devType = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(parent->kit());

=== modified file 'src/ubuntu/ubunturemoterunconfiguration.cpp'
--- src/ubuntu/ubunturemoterunconfiguration.cpp	2014-07-15 09:55:12 +0000
+++ src/ubuntu/ubunturemoterunconfiguration.cpp	2014-07-31 10:11:55 +0000
@@ -268,7 +268,7 @@
     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) {
+    else if (p->id() == Ubuntu::Constants::UBUNTUPROJECT_ID || p->id() == "QmlProjectManager.QmlProject") {
         if (!target()->activeBuildConfiguration()) {
             //backwards compatibility, try to not crash QtC for old projects
             //they did not create a buildconfiguration back then