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

[Benjamin Zeller]

Make use of the new qmake-cross-armhf binary and add support for qmake
projects

Make use of the new qmake-cross-armhf binary and add support for qmake
projects

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

302. By Benjamin Zeller on 2014-11-06

fix legacy script calling

303. By Benjamin Zeller on 2014-11-13

Add qmake template and support in the plugin for handling it correctly

304. By Benjamin Zeller on 2014-11-13

Merge with trunk

305. By Benjamin Zeller on 2014-11-14

- use switch to specify click chroot name
- test if the command is available in the chroot (if cross qmake)
- get correct scriptpath to call legacy script

306. By Benjamin Zeller on 2014-11-14

- Make desktop qmake target work correctly
- Handle more corner cases of cmake vs qmake
- rename UbuntuProjectGuesser to UbuntuProjectHelper, since we don't
guess project types anymore

307. By Benjamin Zeller on 2014-11-14

- Use a better comparation to find out if the gcc wrapper is obsolete

308. By Benjamin Zeller on 2014-11-19

Some fixes, correct qmake name

309. By Benjamin Zeller on 2014-11-19

Merge

310. By Benjamin Zeller on 2014-11-19

Compile error fix

311. By Benjamin Zeller on 2014-11-19

Fix packaging

312. By Benjamin Zeller on 2014-11-19

Fix launcher

313. By Benjamin Zeller on 2014-11-20

Do not ship qmake templates in a seperate category

314. By Benjamin Zeller on 2014-11-21

Qmake wizard should use the fw selection box too

[Zoltan Balogh (bzoltan)]

let's push it

review: Approve

=== modified file 'debian/qtcreator-plugin-ubuntu-common.install'
--- debian/qtcreator-plugin-ubuntu-common.install	2014-10-14 09:33:05 +0000
+++ debian/qtcreator-plugin-ubuntu-common.install	2014-11-21 08:06:27 +0000
@@ -8,4 +8,5 @@
 usr/share/qtcreator/templates/wizards/ubuntu/goproject
 usr/share/qtcreator/templates/wizards/ubuntu/share
 usr/share/qtcreator/templates/wizards/ubuntu/simplei18n
+usr/share/qtcreator/templates/wizards/ubuntu/bin_app-qmake
 usr/share/qtcreator/ubuntu

=== added directory 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake'
=== added directory 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName'
=== added file 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.apparmor'
--- share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.apparmor	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.apparmor	2014-11-21 08:06:27 +0000
@@ -0,0 +1,8 @@
+{
+    "policy_groups": [
+        "networking"
+    ],
+    "policy_version": 1.2
+}
+
+

=== added file 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.desktop'
--- share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.desktop	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.desktop	2014-11-21 08:06:27 +0000
@@ -0,0 +1,7 @@
+[Desktop Entry]
+Name=%ClickHookName%
+Exec=%ClickHookName%
+Icon=%ClickHookName%/%ClickHookName%.png
+Terminal=false
+Type=Application
+X-Ubuntu-Touch=true

=== added file 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.png'
Binary files share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.png	1970-01-01 00:00:00 +0000 and share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.png	2014-11-21 08:06:27 +0000 differ
=== added file 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.pro'
--- share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.pro	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.pro	2014-11-21 08:06:27 +0000
@@ -0,0 +1,21 @@
+TEMPLATE = app
+TARGET = %ClickHookName%
+
+QT += qml quick
+
+SOURCES += main.cpp
+
+RESOURCES += %ClickHookName%.qrc
+
+OTHER_FILES += %ClickHookName%.apparmor \
+               %ClickHookName%.desktop \
+               %ClickHookName%.png
+
+#specify where the config files are installed to
+config_files.path = /%ClickHookName%
+config_files.files += $${OTHER_FILES}
+message($$config_files.files)
+INSTALLS+=config_files
+
+# Default rules for deployment.
+include(../deployment.pri)

=== added file 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.qrc'
--- share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.qrc	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/appName.qrc	2014-11-21 08:06:27 +0000
@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/">
+        <file>main.qml</file>
+    </qresource>
+</RCC>

=== added file 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/main.cpp'
--- share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/main.cpp	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/main.cpp	2014-11-21 08:06:27 +0000
@@ -0,0 +1,14 @@
+#include <QGuiApplication>
+#include <QQmlApplicationEngine>
+#include <QQuickView>
+
+int main(int argc, char *argv[])
+{
+    QGuiApplication app(argc, argv);
+
+    QQuickView view;
+    view.setSource(QUrl(QStringLiteral("qrc:///main.qml")));
+    view.setResizeMode(QQuickView::SizeRootObjectToView);
+    view.show();
+    return app.exec();
+}

=== added file 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/main.qml'
--- share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/main.qml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/appName/main.qml	2014-11-21 08:06:27 +0000
@@ -0,0 +1,56 @@
+import QtQuick 2.0
+import Ubuntu.Components 1.1
+
+/*!
+    \brief MainView with a Label and Button elements.
+*/
+
+MainView {
+    // objectName for functional testing purposes (autopilot-qt5)
+    objectName: "mainView"
+    
+    // Note! applicationName needs to match the "name" field of the click manifest
+    applicationName: "%ClickDomain:l%.%ProjectName:l%"
+
+    /* 
+     This property enables the application to change orientation 
+     when the device is rotated. The default is false.
+    */
+    //automaticOrientation: true
+
+    // Removes the old toolbar and enables new features of the new header.                                                                                                                                  
+    useDeprecatedToolbar: false
+
+    width: units.gu(100)
+    height: units.gu(75)
+
+    Page {
+        title: i18n.tr("Simple")
+
+        Column {
+            spacing: units.gu(1)
+            anchors {
+                margins: units.gu(2)
+                fill: parent
+            }
+
+            Label {
+                id: label
+                objectName: "label"
+
+                text: i18n.tr("Hello..")
+            }
+
+            Button {
+                objectName: "button"
+                width: parent.width
+
+                text: i18n.tr("Tap me!")
+
+                onClicked: {
+                    label.text = i18n.tr("..world!")
+                }
+            }
+        }
+    }
+}

=== added file 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/deployment.pri'
--- share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/deployment.pri	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/deployment.pri	2014-11-21 08:06:27 +0000
@@ -0,0 +1,5 @@
+qt_install_libs = $$[QT_INSTALL_LIBS]
+target.path = /lib/$$basename(qt_install_libs)/bin
+export(target.path)
+INSTALLS += target
+

=== added directory 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/manifest'
=== added file 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/manifest/manifest.json.in'
--- share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/manifest/manifest.json.in	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/manifest/manifest.json.in	2014-11-21 08:06:27 +0000
@@ -0,0 +1,16 @@
+{
+    "name": "%ClickDomain:l%.%ProjectName:l%",
+    "description": "description of %ProjectName%",
+    "architecture": "@CLICK_ARCH@",
+    "title": "%ProjectName%",
+    "hooks": {
+        "%ClickHookName%": {
+            "apparmor": "%ClickHookName%/%ClickHookName%.apparmor",
+            "desktop":  "%ClickHookName%/%ClickHookName%.desktop"
+        }
+    },
+    "version": "0.1",
+    "maintainer": "%ClickMaintainer%",
+    "framework" : "%ClickFrameworkVersion%"
+}
+

=== added file 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/manifest/manifest.pro'
--- share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/manifest/manifest.pro	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/manifest/manifest.pro	2014-11-21 08:06:27 +0000
@@ -0,0 +1,27 @@
+#This creates the manifest.json file, it is the description file for the
+#click package.
+
+TEMPLATE = aux
+
+#figure out the current build architecture
+CLICK_ARCH=$$system(dpkg-architecture -qDEB_HOST_ARCH)
+
+
+# substitute the architecture in the manifest file
+manifest_file.output   = manifest.json
+manifest_file.CONFIG  += no_link \
+                         add_inputs_as_makefile_deps\
+                         target_predeps
+manifest_file.commands = sed s/@CLICK_ARCH@/$$CLICK_ARCH/g ${QMAKE_FILE_NAME} > ${QMAKE_FILE_OUT}
+manifest_file.input = UBUNTU_MANIFEST_FILE
+QMAKE_EXTRA_COMPILERS += manifest_file
+
+#do not remove this line, it is required by the IDE even if you do
+#not substitute variables in the manifest file
+UBUNTU_MANIFEST_FILE = $$PWD/manifest.json.in
+
+#installation path of the manifest file
+mfile.path = /
+mfile.CONFIG += no_check_exist
+mfile.files  += $$OUT_PWD/manifest.json
+INSTALLS+=mfile

=== added file 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/projectName.pro'
--- share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/projectName.pro	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/projectName.pro	2014-11-21 08:06:27 +0000
@@ -0,0 +1,9 @@
+#This is the basic qmake template for the Ubuntu-SDK
+#Now if you want to get started right click the project
+#and add the subproject you like (app,scope,helper,backend)
+
+TEMPLATE = subdirs
+
+SUBDIRS += %ClickHookName% \
+    manifest
+

=== added file 'share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/wizard.xml'
--- share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/wizard.xml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/templates/wizards/ubuntu/bin_app-qmake/wizard.xml	2014-11-21 08:06:27 +0000
@@ -0,0 +1,65 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wizard version="1" kind="project" firstpage="10" id="UbuntuAppSimpleQmake'" category="A.UbuntuProject"
+        platformIndependent="true" 
+        class="ubuntu-project-qmake"
+				featuresRequired=""
+        >
+    <icon>../share/ubuntu.png</icon>
+    <description>Creates a C++ Ubuntu application project with a sample UI containing a Label and a Button.
+
+This templates is built using qmake.
+</description>
+    <displayname>App with Simple UI (QMake)</displayname>
+    <displaycategory>Ubuntu</displaycategory>
+    <files>
+     	<file source="projectName.pro" 	         target="%ProjectName%.pro" openproject="true"/>
+     	<file source="deployment.pri"/>
+<!-- MANIFEST PARTS -->
+			<file source="manifest/manifest.json.in" openeditor="true"/>
+			<file source="manifest/manifest.pro"     openeditor="false"/>
+<!-- APP PARTS -->
+			<file source="appName/appName.pro"   		 target="%ClickHookName%/%ClickHookName%.pro" openeditor="false"/>
+			<file source="appName/appName.qrc"   		 target="%ClickHookName%/%ClickHookName%.qrc" openeditor="false"/>
+			<file source="appName/appName.png"   		 target="%ClickHookName%/%ClickHookName%.png" openeditor="false" binary="true"/>
+			<file source="appName/main.qml"          target="%ClickHookName%/main.qml" openeditor="true"/>
+			<file source="appName/main.cpp"          target="%ClickHookName%/main.cpp" openeditor="true"/>
+			<file source="appName/appName.desktop"   target="%ClickHookName%/%ClickHookName%.desktop"  openeditor="false"/>
+      <file source="appName/appName.apparmor"  target="%ClickHookName%/%ClickHookName%.apparmor" openeditor="false"/>
+   </files>
+
+	  <!-- Create a 2nd wizard page with click package parameters -->
+		<fieldpagetitle>Click package parameters</fieldpagetitle>
+		<fields>
+			<field mandatory="true" name="ClickDomain">
+			  <fieldcontrol class="QLineEdit" validator='^[A-Za-z0-9.-]+$'
+			                defaulttext="" placeholdertext="Domain"/>
+			  <fielddescription>Domain:</fielddescription>
+			</field>
+			<field mandatory="true" name="ClickMaintainer">
+			  <fieldcontrol class="QLineEdit" validator='^[^"]+$'
+			                defaulttext="" placeholdertext="Maintainer"/>
+			  <fielddescription>Maintainer:</fielddescription>
+			</field>
+			<field mandatory="true" name="ClickHookName">
+			  <fieldcontrol class="QLineEdit" validator='^[A-Za-z0-9.-]+$'
+			                defaulttext="app" placeholdertext="app hook name"/>
+			  <fielddescription>App name:</fielddescription>
+			</field>
+		  <field name="ClickFrameworkVersion">
+		      <fieldcontrol class="QComboBox" defaultindex="0">
+		          <comboentries>
+								<!-- Do not add any other frameworks here, they are populated at runtime, this is just a dummy framework to make sure we can find the combobox -->
+								<comboentry value="ubuntu-sdk-dummy-framework">
+		                <comboentrytext>Dummy Framework</comboentrytext>
+		            </comboentry>
+		          </comboentries>
+		      </fieldcontrol>
+		      <fielddescription>Framework:</fielddescription>
+		  </field>
+		</fields>
+    <validationrules>
+        <validationrule condition='/^(.*)\s+&lt;(.*@.*)&gt;$/.test("%ClickMaintainer%")'>
+            <message>Invalid format for maintainer (should be like "Joe Bloggs &lt;[e-mail]&gt;")</message>
+        </validationrule>
+    </validationrules>
+</wizard>

=== renamed file 'share/qtcreator/ubuntu/scripts/qtc_chroot_qmake' => 'share/qtcreator/ubuntu/scripts/qtc_chroot_qmake_legacy'
--- share/qtcreator/ubuntu/scripts/qtc_chroot_qmake	2014-09-29 11:28:19 +0000
+++ share/qtcreator/ubuntu/scripts/qtc_chroot_qmake_legacy	2014-11-21 08:06:27 +0000
@@ -15,10 +15,12 @@
 #
 # Author: Zoltán Balogh <[e-mail]>
 
-
-CLICK_CHROOT_ARCH="%1"
-CLICK_CHROOT_FW="%2"
-CLICK_CHROOT_NAME="%3"
+CLICK_CHROOT_FW=$1
+shift
+CLICK_CHROOT_ARCH=$1
+shift
+CLICK_CHROOT_NAME=$1
+shift
 
 if [ -z "$CLICK_CHROOT_ARCH" ]; then
     echo "Need to set CLICK_CHROOT_ARCH"

=== added file 'share/qtcreator/ubuntu/scripts/qtc_chroot_wrapper.py'
--- share/qtcreator/ubuntu/scripts/qtc_chroot_wrapper.py	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/scripts/qtc_chroot_wrapper.py	2014-11-21 08:06:27 +0000
@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# QTC device chroot wrapper
+# Copyright (C) 2014 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Benjamin Zeller <[e-mail]>
+
+# This script basically starts the tool passed in sys.argv[0] in a chroot
+# and tries to map all path that are printed to the console to the host
+# os. It is primarily used to teach qtcreator how to handle the chroots
+# approach we use in Ubuntu. The tool needs to be in PATH when logged into
+# the chroot. All arguments are forwarded
+
+import sys
+import os
+import shutil
+import subprocess
+import select
+import re
+import fcntl
+import uuid
+import signal
+
+#find out the directory holding the link
+dirname = os.path.basename(os.path.dirname(os.path.abspath(sys.argv[0])))
+idx = dirname.rfind("-")
+if(idx is -1):
+    print("The parent directory must contain the click chroot name (e.g ubuntu-sdk-14.10-armhf)")
+    sys.exit(1)
+
+#find out the path this script is in, required for local plugin installation
+scriptpath = os.path.dirname(os.path.realpath(__file__))
+
+#@BUG get this dynamically
+chroot_name_prefix = "click"
+
+architecture = dirname[idx+1:]
+framework    = dirname[0:idx]
+session_id   = str(uuid.uuid4())
+
+args    = sys.argv[1:]
+command = os.path.basename(sys.argv[0])
+
+if (command.startswith("qt5-qmake-cross")):
+    command_path="/var/lib/schroot/chroots/"+chroot_name_prefix+"-"+dirname+"/usr/bin/"+command
+    if (not os.path.isfile(command_path)):
+        legacy_script = scriptpath+"/qtc_chroot_qmake_legacy"
+        success = subprocess.call(["/bin/bash",legacy_script,framework,architecture,chroot_name_prefix]+args,stdout=sys.stdout,stderr=sys.stderr)
+        sys.exit(success)
+
+subproc = None
+
+click   = shutil.which("click")
+
+if( click is None ):
+    print("Could not find click in the path, please make sure it is installed")
+    sys.exit(1)
+
+def _doMapAllPaths (matchobj):
+    return matchobj.group(1)+"/var/lib/schroot/chroots/"+chroot_name_prefix+"-"+dirname+"/"+matchobj.group(2)
+
+def mapPaths (text):
+    paths = ["var","bin","boot","dev","etc","lib","lib64","media","mnt","opt","proc","root","run","sbin","srv","sys","usr"]
+    for path in paths:
+        text = re.sub("(^|[^\w+]|\s+|-\w)\/("+path+")", _doMapAllPaths , text)
+    return text
+
+def exit_gracefully(arg1,arg2):
+    if(subproc is not None):
+        subproc.kill()
+    subprocess.call([click, "chroot","-a",architecture,"-f",framework,"-n",chroot_name_prefix,"end-session",session_id],stdout=subprocess.DEVNULL)
+    sys.exit(1)
+
+signal.signal(signal.SIGTERM, exit_gracefully)
+signal.signal(signal.SIGINT , exit_gracefully)
+signal.signal(signal.SIGHUP , exit_gracefully)
+
+success = subprocess.call([click, "chroot","-a",architecture,"-f",framework,"-n",chroot_name_prefix,"begin-session",session_id],stdout=subprocess.DEVNULL)
+subproc = subprocess.Popen([click, "chroot","-a",architecture,"-f",framework,"-n",chroot_name_prefix,"run","-n",session_id]+[command]+args,stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+stdout = ""
+stderr = ""
+
+#even though after select a read should never block, it can happen sometimes
+#so better make them nonblocking
+stdoutfd = subproc.stdout.fileno()
+fl = fcntl.fcntl(stdoutfd, fcntl.F_GETFL)
+fcntl.fcntl(stdoutfd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
+
+stderrfd = subproc.stderr.fileno()
+fl = fcntl.fcntl(stderrfd, fcntl.F_GETFL)
+fcntl.fcntl(stderrfd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
+
+while True:
+    reads = [stdoutfd, stderrfd]
+    ret = select.select(reads, [], [])
+
+    for fd in ret[0]:
+        if fd == subproc.stdout.fileno():
+            read = subproc.stdout.read()
+            stdout += read.decode()
+            try:
+                while(True):
+                    idx = stdout.index("\n")
+                    line = stdout[0:idx+1]
+                    stdout = stdout[idx+1:]
+                    sys.stdout.write(mapPaths(line))
+            except ValueError:
+                pass
+        if fd == subproc.stderr.fileno():
+            read = subproc.stderr.read()
+            stderr += read.decode()
+            try:
+                while(True):
+                    idx = stderr.index("\n")
+                    line = stderr[0:idx+1]
+                    stderr = stderr[idx+1:]
+                    sys.stderr.write(mapPaths(line))
+            except ValueError:
+                pass
+
+    if subproc.poll() != None:
+        break
+
+if(len(stdout) != 0):
+    sys.stdout.write(mapPaths(stdout))
+
+if(len(stderr) != 0):
+    sys.stderr.write(mapPaths(stderr))
+
+subprocess.call([click, "chroot","-a",architecture,"-f",framework,"-n",chroot_name_prefix,"end-session",session_id],stdout=subprocess.DEVNULL)
+sys.exit(subproc.returncode)

=== modified file 'share/qtcreator/ubuntu/scripts/qtc_device_applaunch.py'
--- share/qtcreator/ubuntu/scripts/qtc_device_applaunch.py	2014-10-06 16:51:53 +0000
+++ share/qtcreator/ubuntu/scripts/qtc_device_applaunch.py	2014-11-21 08:06:27 +0000
@@ -353,6 +353,7 @@
 app_id   = None
 debug_file_name = None
 app_mode  = None
+powerd    = None
 
 loop = GLib.MainLoop()
 runner = None
@@ -375,7 +376,7 @@
 print("Sdk-Launcher> Installing application .....",flush=True)
 #we have all informations, now install the click package
 success = subprocess.call(
-    ["pkcon","--allow-untrusted","install-local",options.clickPck,"-p"],stdout=subprocess.DEVNULL)
+    ["pkcon","--allow-untrusted","install-local",options.clickPck,"-p"])
 if success != 0:
     print("Sdk-Launcher> Installing the application failed",flush=True)
     sys.exit(1)
@@ -406,7 +407,7 @@
     debug_file_name = tmp_dir+app_id+"_debug.json"
 
     if(not os.path.exists(tmp_dir)):
-        os.mkdir(tmp_dir)
+        os.makedirs(tmp_dir)
 
     print("Sdk-Launcher> AppId:                   "+app_id,flush=True)
     print("Sdk-Launcher> Architecture:            "+package_arch,flush=True,end="")

=== modified file 'src/ubuntu/clicktoolchain.cpp'
--- src/ubuntu/clicktoolchain.cpp	2014-06-17 09:25:03 +0000
+++ src/ubuntu/clicktoolchain.cpp	2014-11-21 08:06:27 +0000
@@ -24,6 +24,8 @@
 #include <QDebug>
 #include <QVariant>
 #include <QVariantMap>
+#include <QFile>
+#include <QFileInfo>
 
 namespace Ubuntu {
 namespace Internal {
@@ -68,7 +70,8 @@
 
 QList<Utils::FileName> ClickToolChain::suggestedMkspecList() const
 {
-    return QList<Utils::FileName>()<< Utils::FileName::fromString(QLatin1String("linux-g++"));
+    return ProjectExplorer::GccToolChain::suggestedMkspecList();
+    //return QList<Utils::FileName>()<< Utils::FileName::fromString(QLatin1String("linux-g++"));
 }
 
 Utils::FileName ClickToolChain::suggestedDebugger() const
@@ -101,8 +104,7 @@
 
 QString ClickToolChain::makeCommand(const Utils::Environment &) const
 {
-    QString command = QString::fromLatin1(Constants::UBUNTU_CLICK_MAKE_WRAPPER).arg(Constants::UBUNTU_SCRIPTPATH);
-    return command;
+    return UbuntuClickTool::findOrCreateMakeWrapper(clickTarget());
 }
 
 bool ClickToolChain::operator ==(const ProjectExplorer::ToolChain &tc) const
@@ -199,8 +201,8 @@
     , m_clickTarget(target)
 {
     setCompilerCommand(Utils::FileName::fromString(
-                           QString::fromLatin1(Constants::UBUNTU_CLICK_GCC_WRAPPER)
-                           .arg(Constants::UBUNTU_SCRIPTPATH)));
+                           UbuntuClickTool::findOrCreateGccWrapper(target)
+                           ));
 
     setDisplayName(QString::fromLatin1("Ubuntu GCC (%1-%2-%3)")
                    .arg(ProjectExplorer::Abi::toString(targetAbi().architecture()))
@@ -238,8 +240,21 @@
 ProjectExplorer::ToolChain *ClickToolChainFactory::restore(const QVariantMap &data)
 {
     ClickToolChain *tc = new ClickToolChain();
-    if (tc->fromMap(data))
+    if (tc->fromMap(data)) {
+        QFileInfo compilerCommand(tc->compilerCommand().toString());
+        //deprecated wrapper script, update to use the new one
+        if(compilerCommand.fileName() == QString::fromLatin1(Constants::UBUNTU_CLICK_GCC_WRAPPER)) {
+            QString wrapper = UbuntuClickTool::findOrCreateGccWrapper(tc->clickTarget());
+
+            //if we cannot create a good wrapper its better to drop the ToolChain
+            if(wrapper.isNull()) {
+                delete tc;
+                return 0;
+            }
+            tc->setCompilerCommand(Utils::FileName::fromString(wrapper));
+        }
         return tc;
+    }
 
     delete tc;
     return 0;
@@ -257,6 +272,9 @@
                 || target.maybeBroken)
             continue;
 
+        if(UbuntuClickTool::findOrCreateGccWrapper(target).isEmpty())
+            continue;
+
         ClickToolChain* tc = new ClickToolChain(target, ProjectExplorer::ToolChain::AutoDetection);
         toolChains.append(tc);
     }

=== modified file 'src/ubuntu/ubuntu.pro'
--- src/ubuntu/ubuntu.pro	2014-11-07 12:02:15 +0000
+++ src/ubuntu/ubuntu.pro	2014-11-21 08:06:27 +0000
@@ -103,7 +103,6 @@
     ubuntucmakemakestep.cpp \
     ubuntuemulatornotifier.cpp \
     localportsmanager.cpp \
-    ubuntuprojectguesser.cpp \
     ubuntulocaldeployconfiguration.cpp \
     ubunturemotedeployconfiguration.cpp \
     ubuntulocalrunconfigurationfactory.cpp \
@@ -134,7 +133,8 @@
     ubuntueditorfactory.cpp \
     ubuntucmakecache.cpp \
     ubuntutestcontrol.cpp \
-    ubuntupackageoutputparser.cpp
+    ubuntupackageoutputparser.cpp \
+    ubuntuprojecthelper.cpp
 
 HEADERS += \
     ubuntuplugin.h \
@@ -187,7 +187,6 @@
     ubuntucmakemakestep.h \
     ubuntuemulatornotifier.h \
     localportsmanager.h \
-    ubuntuprojectguesser.h \
     ubuntulocaldeployconfiguration.h \
     ubunturemotedeployconfiguration.h \
     ubuntulocalrunconfigurationfactory.h \
@@ -218,5 +217,6 @@
     ubuntucmakecache.h \
     ubuntutestcontrol.h \
     ubuntupackageoutputparser.h \
+    ubuntuprojecthelper.h \
     ubuntuscopefinalizer.h
 

=== modified file 'src/ubuntu/ubuntuclicktool.cpp'
--- src/ubuntu/ubuntuclicktool.cpp	2014-11-03 14:18:52 +0000
+++ src/ubuntu/ubuntuclicktool.cpp	2014-11-21 08:06:27 +0000
@@ -32,6 +32,8 @@
 #include <QTimer>
 #include <QFile>
 #include <QStandardPaths>
+#include <QDir>
+#include <QFile>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonParseError>
@@ -391,6 +393,71 @@
 #endif
 }
 
+QString UbuntuClickTool::findOrCreateGccWrapper (const UbuntuClickTool::Target &target)
+{
+    QString compiler;
+
+    if(target.architecture == QStringLiteral("armhf"))
+        compiler = QStringLiteral("arm-linux-gnueabihf-gcc");
+    else if(target.architecture == QStringLiteral("i386"))
+        compiler = QStringLiteral("i686-linux-gnu-gcc");
+    else if(target.architecture == QStringLiteral("amd64"))
+        compiler = QStringLiteral("x86_64-linux-gnu-gcc");
+    else {
+        qWarning()<<"Invalid architecture, can not create gcc wrapper link";
+        return QString();
+    }
+
+    return UbuntuClickTool::findOrCreateToolWrapper(compiler,target);
+}
+
+QString UbuntuClickTool::findOrCreateQMakeWrapper (const UbuntuClickTool::Target &target)
+{
+    QString qmake;
+
+    if(target.architecture == QStringLiteral("armhf"))
+        qmake = QStringLiteral("qt5-qmake-arm-linux-gnueabihf");
+    else
+        qmake = QStringLiteral("qmake");
+
+    return UbuntuClickTool::findOrCreateToolWrapper(qmake,target);
+}
+
+QString UbuntuClickTool::findOrCreateMakeWrapper (const UbuntuClickTool::Target &target)
+{
+    return UbuntuClickTool::findOrCreateToolWrapper(QStringLiteral("make"),target);
+}
+
+QString UbuntuClickTool::findOrCreateToolWrapper (const QString &tool, const UbuntuClickTool::Target &target)
+{
+    QString baseDir = QStringLiteral("%1/ubuntu-sdk/%2-%3").arg(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation))
+            .arg(target.framework)
+            .arg(target.architecture);
+
+    QDir d(baseDir);
+    if(!d.exists()) {
+        if(!d.mkpath(baseDir)){
+            qWarning()<<"Could not create config directory.";
+            return QString();
+        }
+    }
+
+    QString toolWrapper = (Utils::FileName::fromString(baseDir).appendPath(tool).toString());
+    if(!QFile::exists(toolWrapper)) {
+        //in case of a broken link QFile::exists also will return false
+        //lets try to delete it and ignore the error in case the file
+        //simply does not exist
+        QFile::remove(toolWrapper);
+        if(!QFile::link(QString::fromLatin1(Constants::UBUNTU_CLICK_CHROOT_WRAPPER)
+                        .arg(Constants::UBUNTU_SCRIPTPATH),toolWrapper)) {
+            qWarning()<<"Unable to create link for the tool wrapper: "<<toolWrapper;
+            return QString();
+        }
+
+    }
+    return toolWrapper;
+}
+
 QDebug operator<<(QDebug dbg, const UbuntuClickTool::Target& t)
 {
     dbg.nospace() << "("<<"series: "<<t.series<<" "
@@ -562,6 +629,18 @@
 
 QString UbuntuClickFrameworkProvider::frameworkPolicy(const QString &fw) const
 {
+#if 0
+    QProcess proc;
+    proc.setProgram(QStringLiteral("aa-clickquery"));
+    proc.setArguments(QStringList{
+                      QStringLiteral("--click-framework=%1").arg(fw),
+                      QStringLiteral("--query=policy_version")});
+    proc.start();
+    proc.waitForFinished();
+    if(proc.exitCode() == 0 && proc.exitStatus() == QProcess::NormalExit) {
+        return QString::fromUtf8(proc.readAllStandardOutput();
+    }
+#endif
     QString base = getBaseFramework(fw);
     if(m_policyCache.contains(base))
         return m_policyCache[base];

=== modified file 'src/ubuntu/ubuntuclicktool.h'
--- src/ubuntu/ubuntuclicktool.h	2014-11-03 14:18:52 +0000
+++ src/ubuntu/ubuntuclicktool.h	2014-11-21 08:06:27 +0000
@@ -74,6 +74,12 @@
 
     static QString targetBasePath (const Target& target);
     static bool getTargetFromUser (Target* target, const QString &framework=QString());
+    static QStringList getSupportedFrameworks (const Target *target);
+    static QString getMostRecentFramework ( const QString &subFramework, const Target *target );
+    static QString findOrCreateGccWrapper(const UbuntuClickTool::Target &target);
+    static QString findOrCreateToolWrapper(const QString &tool, const UbuntuClickTool::Target &target);
+    static QString findOrCreateQMakeWrapper(const UbuntuClickTool::Target &target);
+    static QString findOrCreateMakeWrapper(const UbuntuClickTool::Target &target);
 
     static bool          targetExists (const Target& target);
     static QList<Target> listAvailableTargets (const QString &framework=QString());

=== modified file 'src/ubuntu/ubuntucmakecache.cpp'
--- src/ubuntu/ubuntucmakecache.cpp	2014-08-20 07:38:07 +0000
+++ src/ubuntu/ubuntucmakecache.cpp	2014-11-21 08:06:27 +0000
@@ -37,7 +37,7 @@
 QVariant UbuntuCMakeCache::getValue(const QString &key, ProjectExplorer::BuildConfiguration *bc, const QVariant defaultValue)
 {
     UbuntuCMakeCache *inst = instance();
-    if(!inst)
+    if(!inst || !bc)
         return defaultValue;
 
     Utils::FileName cacheFile = bc->buildDirectory().appendPath(QStringLiteral("CMakeCache.txt"));

=== modified file 'src/ubuntu/ubuntucmakemakestep.cpp'
--- src/ubuntu/ubuntucmakemakestep.cpp	2014-08-21 16:56:53 +0000
+++ src/ubuntu/ubuntucmakemakestep.cpp	2014-11-21 08:06:27 +0000
@@ -17,7 +17,7 @@
  */
 #include "ubuntucmakemakestep.h"
 #include "ubuntuconstants.h"
-#include "ubuntuprojectguesser.h"
+#include "ubuntuprojecthelper.h"
 #include "clicktoolchain.h"
 #include "ubuntupackagestep.h"
 

=== modified file 'src/ubuntu/ubuntuconstants.h'
--- src/ubuntu/ubuntuconstants.h	2014-10-31 16:58:14 +0000
+++ src/ubuntu/ubuntuconstants.h	2014-11-21 08:06:27 +0000
@@ -519,8 +519,9 @@
 const char UBUNTU_CLICK_CMAKE_BC_ID[]       = "UbuntuProjectManager.UbuntuCMake.BuildConfiguration";
 const char UBUNTU_CLICK_CMAKE_MAKESTEP_ID[] = "UbuntuProjectManager.UbuntuCMake.MakeStep";
 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_MAKE_WRAPPER[]   = "%0/qtc_chroot_make2";  //deprecated
+const char UBUNTU_CLICK_GCC_WRAPPER[]    = "qtc_chroot_gcc";    //deprecated
+const char UBUNTU_CLICK_CHROOT_WRAPPER[] = "%0/qtc_chroot_wrapper.py";
 const char UBUNTU_CLICK_HTML_BC_ID[]     = "UbuntuProjectManager.UbuntuHTML5.BuildConfiguration";
 const char UBUNTU_CLICK_QML_BC_ID[]      = "UbuntuProjectManager.UbuntuQml.BuildConfiguration";
 //Devicesupport

=== modified file 'src/ubuntu/ubuntucreatenewchrootdialog.cpp'
--- src/ubuntu/ubuntucreatenewchrootdialog.cpp	2014-07-31 09:41:18 +0000
+++ src/ubuntu/ubuntucreatenewchrootdialog.cpp	2014-11-21 08:06:27 +0000
@@ -30,6 +30,7 @@
     //lists all currently supported targets by the plugin
     const char* UBUNTU_CLICK_SUPPORTED_TARGETS[][3]   = {
         //Series      Framework         Displayname
+        {"vivid","ubuntu-sdk-15.04","Framework-15.04"},
         {"utopic","ubuntu-sdk-14.10","Framework-14.10"},
         {"trusty","ubuntu-sdk-14.04","Framework-14.04"},
         {"saucy" ,"ubuntu-sdk-13.10","Framework-13.10"},

=== modified file 'src/ubuntu/ubuntudeploystepfactory.cpp'
--- src/ubuntu/ubuntudeploystepfactory.cpp	2014-08-21 16:56:53 +0000
+++ src/ubuntu/ubuntudeploystepfactory.cpp	2014-11-21 08:06:27 +0000
@@ -1,5 +1,5 @@
 #include "ubuntudeploystepfactory.h"
-#include "ubuntuprojectguesser.h"
+#include "ubuntuprojecthelper.h"
 #include "ubuntuconstants.h"
 #include "ubuntudirectuploadstep.h"
 #include "ubuntupackagestep.h"
@@ -17,6 +17,7 @@
 #include <qmlprojectmanager/qmlprojectconstants.h>
 
 #include <cmakeprojectmanager/cmakeprojectconstants.h>
+#include <qmakeprojectmanager/qmakeprojectmanagerconstants.h>
 
 namespace Ubuntu {
 namespace Internal {
@@ -36,6 +37,7 @@
     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 isQMake  = parent->target()->project()->id() == QmakeProjectManager::Constants::QMAKEPROJECT_ID;
 
     if (isRemote) {
         //IF we have a remote device we just support a ubuntu toolchain
@@ -44,7 +46,7 @@
             return types;
     }
 
-    if(isRemote && ( isHTML || isQML || isCMake) )
+    if(isRemote && ( isHTML || isQML || isCMake || isQMake ) )
         types << Constants::UBUNTU_DEPLOY_UPLOADSTEP_ID
               << Constants::UBUNTU_CLICK_PACKAGESTEP_ID;
 

=== modified file 'src/ubuntu/ubuntukitmanager.cpp'
--- src/ubuntu/ubuntukitmanager.cpp	2014-09-29 11:28:19 +0000
+++ src/ubuntu/ubuntukitmanager.cpp	2014-11-21 08:06:27 +0000
@@ -22,6 +22,7 @@
 #include <QMessageBox>
 #include <QRegularExpression>
 #include <QTextStream>
+#include <QStandardPaths>
 
 namespace Ubuntu {
 namespace Internal {
@@ -72,43 +73,17 @@
 UbuntuQtVersion *UbuntuKitManager::createOrFindQtVersion(ClickToolChain *tc)
 {
 
-    QString qmakePath = QStringLiteral("%1/.config/ubuntu-sdk/qmake-%2-%3-%4")
-            .arg(QDir::homePath())
-            .arg(tc->clickTarget().framework)
-            .arg(tc->clickTarget().architecture)
-            .arg(UbuntuClickTool::clickChrootSuffix());
-
+    QString qmakePath = UbuntuClickTool::findOrCreateQMakeWrapper(tc->clickTarget());
     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)
-                    .arg(UbuntuClickTool::clickChrootSuffix());
-
-
-            QFile qmakeScript(qmakePath);
-
-            qmakeScript.open(QIODevice::WriteOnly);
-            qmakeScript.setPermissions(QFile::ExeUser | QFile::ReadUser | QFile::ReadGroup);
-
-            {
-                QTextStream out(&qmakeScript);
-                out << templ;
-            }
-
-            qmakeScript.close();
-        }
+        return 0;
     } 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))
+
+            qDebug()<<qtVersion->qmakeCommand().toFileInfo().absoluteFilePath();
+            if (qtVersion->qmakeCommand().toFileInfo().absoluteFilePath() == QFileInfo(qmakePath).absoluteFilePath())
                 return static_cast<UbuntuQtVersion*> (qtVersion);
         }
     }
@@ -197,7 +172,6 @@
             //we need to remove that QtVersion
             QFile::remove(ver->qmakeCommand().toString());
             QtSupport::QtVersionManager::removeVersion(ver);
-
         }
     }
 

=== modified file 'src/ubuntu/ubuntulocaldeployconfiguration.cpp'
--- src/ubuntu/ubuntulocaldeployconfiguration.cpp	2014-08-21 16:56:53 +0000
+++ src/ubuntu/ubuntulocaldeployconfiguration.cpp	2014-11-21 08:06:27 +0000
@@ -16,7 +16,7 @@
  * Author: Benjamin Zeller <[e-mail]>
  */
 #include "ubuntulocaldeployconfiguration.h"
-#include "ubuntuprojectguesser.h"
+#include "ubuntuprojecthelper.h"
 #include "ubuntuconstants.h"
 #include "ubuntucmakemakestep.h"
 #include "ubuntupackagestep.h"

=== modified file 'src/ubuntu/ubuntulocalrunconfiguration.cpp'
--- src/ubuntu/ubuntulocalrunconfiguration.cpp	2014-09-10 06:58:03 +0000
+++ src/ubuntu/ubuntulocalrunconfiguration.cpp	2014-11-21 08:06:27 +0000
@@ -18,7 +18,7 @@
 
 #include "ubuntulocalrunconfiguration.h"
 #include "ubuntuproject.h"
-#include "ubuntuprojectguesser.h"
+#include "ubuntuprojecthelper.h"
 #include "ubuntuclickmanifest.h"
 #include "ubunturemoterunconfiguration.h"
 #include "ubuntucmakecache.h"
@@ -32,6 +32,9 @@
 #include <utils/qtcprocess.h>
 #include <cmakeprojectmanager/cmakeproject.h>
 #include <cmakeprojectmanager/cmakeprojectconstants.h>
+#include <qmakeprojectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakenodes.h>
+#include <qmakeprojectmanager/qmakeprojectmanagerconstants.h>
 using namespace Ubuntu::Internal;
 
 enum {
@@ -143,12 +146,12 @@
             QRegularExpression desktopFinder = QRegularExpression(QString::fromLatin1("^%1$")
                                                                   .arg(desktopFileName));
 
-            QFileInfo desktopInfo = UbuntuProjectGuesser::findFileRecursive(config->target()->activeBuildConfiguration()->buildDirectory(),
+            QFileInfo desktopInfo = UbuntuProjectHelper::findFileRecursive(config->target()->activeBuildConfiguration()->buildDirectory(),
                                                                             desktopFinder).toFileInfo();
             if (!desktopInfo.exists()) {
 
                 //search again in the project directory
-                desktopInfo = UbuntuProjectGuesser::findFileRecursive(Utils::FileName::fromString(config->target()->project()->projectDirectory()),
+                desktopInfo = UbuntuProjectHelper::findFileRecursive(Utils::FileName::fromString(config->target()->project()->projectDirectory()),
                                                                       desktopFinder).toFileInfo();
 
                 if(!desktopInfo.exists())
@@ -158,16 +161,17 @@
         };
 
         //first lets check if the informations in the manifest file are helpful
-        QVariant manifestPath = UbuntuCMakeCache::getValue(QStringLiteral("UBUNTU_MANIFEST_PATH"),
-                                                           config->target()->activeBuildConfiguration(),
-                                                           QStringLiteral("manifest.json"));
+        QString manifestPath = UbuntuProjectHelper::getManifestPath(config->target(),QStringLiteral("manifest.json"));
 
+        //make the path relative to the project dir
+        QDir projectDirDir(projectDir.toString());
+        manifestPath = projectDirDir.relativeFilePath(manifestPath);
 
         //search for the manifest file in the project dir AND in the builddir
         QList<Utils::FileName> searchPaths{
-            projectDir.appendPath(manifestPath.toString()),
+            projectDir.appendPath(manifestPath),
             config->target()->activeBuildConfiguration()->buildDirectory()
-                    .appendPath(QFileInfo(manifestPath.toString()).path())
+                    .appendPath(QFileInfo(manifestPath).path())
                     .appendPath(QStringLiteral("manifest.json"))
         };
 
@@ -331,7 +335,7 @@
             return false;
         }
 
-        QFileInfo mainFileInfo = UbuntuProjectGuesser::findFileRecursive(Utils::FileName::fromString(target()->project()->projectDirectory()),
+        QFileInfo mainFileInfo = UbuntuProjectHelper::findFileRecursive(Utils::FileName::fromString(target()->project()->projectDirectory()),
                                                                          QString::fromLatin1("^%1$").arg(mainQml)).toFileInfo();
 
         if(!mainFileInfo.exists()) {
@@ -352,25 +356,38 @@
         */
     } else {
         //looks like a application without a launcher
-        CMakeProjectManager::CMakeProject* proj = static_cast<CMakeProjectManager::CMakeProject*> (target()->project());
-        QList<CMakeProjectManager::CMakeBuildTarget> targets = proj->buildTargets();
-        foreach (const CMakeProjectManager::CMakeBuildTarget& t, targets) {
-            if(t.library)
-                continue;
-
-            QFileInfo targetInfo(t.executable);
-            if(!targetInfo.exists())
-                continue;
-
-            if(targetInfo.fileName() == commInfo.fileName()) {
-                m_executable = targetInfo.absoluteFilePath();
-                break;
+        if(target()->project()->id() == QmakeProjectManager::Constants::QMAKEPROJECT_ID) {
+            QmakeProjectManager::QmakeProject* pro = static_cast<QmakeProjectManager::QmakeProject*> (target()->project());
+            foreach(const QmakeProjectManager::QmakeProFileNode* applPro, pro->applicationProFiles()) {
+                QmakeProjectManager::TargetInformation info = applPro->targetInformation();
+                if(applPro->targetInformation().valid) {
+                    if(info.target == commInfo.fileName()) {
+                        m_executable = info.buildDir + QDir::separator() + info.target;
+                        break;
+                    }
+                }
+            }
+        } else {
+            CMakeProjectManager::CMakeProject* proj = static_cast<CMakeProjectManager::CMakeProject*> (target()->project());
+            QList<CMakeProjectManager::CMakeBuildTarget> targets = proj->buildTargets();
+            foreach (const CMakeProjectManager::CMakeBuildTarget& t, targets) {
+                if(t.library)
+                    continue;
+
+                QFileInfo targetInfo(t.executable);
+                if(!targetInfo.exists())
+                    continue;
+
+                if(targetInfo.fileName() == commInfo.fileName()) {
+                    m_executable = targetInfo.absoluteFilePath();
+                    break;
+                }
             }
         }
 
         if (m_executable.isEmpty()) {
             if(errorMessage)
-                tr("Could not find executable specified in the desktop file");
+                *errorMessage = tr("Could not find executable specified in the desktop file");
             return false;
         }
         m_args = args;
@@ -393,7 +410,7 @@
         return false;
     }
 
-    Utils::FileName iniFile = UbuntuProjectGuesser::findScopesIniRecursive(target()->activeBuildConfiguration()->buildDirectory(),appId());
+    Utils::FileName iniFile = UbuntuProjectHelper::findScopesIniRecursive(target()->activeBuildConfiguration()->buildDirectory(),appId());
     if(iniFile.toFileInfo().exists())
         m_args = QStringList()<<QString(iniFile.toFileInfo().absoluteFilePath());
 
@@ -438,27 +455,41 @@
 
 void UbuntuLocalRunConfiguration::addToBaseEnvironment(Utils::Environment &env) const
 {
-    if(id().toString().startsWith(QLatin1String(Constants::UBUNTUPROJECT_RUNCONTROL_APP_ID))
-            && target()->project()->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID) {
-        CMakeProjectManager::CMakeProject* proj = static_cast<CMakeProjectManager::CMakeProject*> (target()->project());
-        QList<CMakeProjectManager::CMakeBuildTarget> targets = proj->buildTargets();
-        QSet<QString> usedPaths;
-        foreach (const CMakeProjectManager::CMakeBuildTarget& t, targets) {
-            if(t.library) {
-                if(debug) qDebug()<<"Looking at executable "<<t.executable;
-                QFileInfo inf(t.executable);
-                if(inf.exists()) {
-                    QDir d = inf.absoluteDir();
-                    if(debug) qDebug()<<"Looking in the dir: "<<d.absolutePath();
-                    if(d.exists(QLatin1String("qmldir"))) {
-                        QString path = QDir::cleanPath(d.absolutePath()+QDir::separator()+QLatin1String(".."));
-                        if(usedPaths.contains(path))
-                            continue;
-
-                        env.appendOrSet(QStringLiteral("QML2_IMPORT_PATH"),path,QStringLiteral(":"));
-                        usedPaths.insert(path);
-                    }
-                }
+    QSet<QString> usedPaths;
+
+    //lambda checks if the executable is in a qmldir and add its to QML2_IMPORT_PATH if
+    //required
+    auto loc_addToImportPath = [&usedPaths,&env] (const QString &executable) {
+        if(debug) qDebug()<<"Looking at executable "<<executable;
+        QFileInfo inf(executable);
+        if(inf.exists()) {
+            QDir d = inf.absoluteDir();
+            if(debug) qDebug()<<"Looking in the dir: "<<d.absolutePath();
+            if(d.exists(QLatin1String("qmldir"))) {
+                QString path = QDir::cleanPath(d.absolutePath()+QDir::separator()+QLatin1String(".."));
+                if(usedPaths.contains(path))
+                    return;
+
+                env.appendOrSet(QStringLiteral("QML2_IMPORT_PATH"),path,QStringLiteral(":"));
+                usedPaths.insert(path);
+            }
+        }
+    };
+
+    if(id().toString().startsWith(QLatin1String(Constants::UBUNTUPROJECT_RUNCONTROL_APP_ID))) {
+        if(target()->project()->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID) {
+            CMakeProjectManager::CMakeProject* proj = static_cast<CMakeProjectManager::CMakeProject*> (target()->project());
+            QList<CMakeProjectManager::CMakeBuildTarget> targets = proj->buildTargets();
+            foreach (const CMakeProjectManager::CMakeBuildTarget& t, targets) {
+                if(t.library)
+                    loc_addToImportPath(t.executable);
+            }
+        } else if (target()->project()->id() == QmakeProjectManager::Constants::QMAKEPROJECT_ID) {
+            QmakeProjectManager::QmakeProject* pro = static_cast<QmakeProjectManager::QmakeProject*> (target()->project());
+            foreach(const QmakeProjectManager::QmakeProFileNode* applPro, pro->applicationProFiles()) {
+                QmakeProjectManager::TargetInformation info = applPro->targetInformation();
+                if(applPro->targetInformation().valid)
+                    loc_addToImportPath(info.buildDir + QDir::separator() + info.target);
             }
         }
     }

=== modified file 'src/ubuntu/ubuntulocalrunconfigurationfactory.cpp'
--- src/ubuntu/ubuntulocalrunconfigurationfactory.cpp	2014-08-21 16:56:53 +0000
+++ src/ubuntu/ubuntulocalrunconfigurationfactory.cpp	2014-11-21 08:06:27 +0000
@@ -18,7 +18,7 @@
 
 #include "ubuntulocalrunconfigurationfactory.h"
 #include "ubunturemoterunconfiguration.h"
-#include "ubuntuprojectguesser.h"
+#include "ubuntuprojecthelper.h"
 #include "ubuntudevice.h"
 #include "clicktoolchain.h"
 #include "ubuntuclickmanifest.h"
@@ -26,6 +26,7 @@
 
 #include <cmakeprojectmanager/cmakeproject.h>
 #include <cmakeprojectmanager/cmakeprojectconstants.h>
+#include <qmakeprojectmanager/qmakeprojectmanagerconstants.h>
 
 #include <projectexplorer/toolchain.h>
 #include <projectexplorer/kitinformation.h>
@@ -53,8 +54,9 @@
     bool isCMake  = parent->project()->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID;
     bool isHTML   = parent->project()->id() == Ubuntu::Constants::UBUNTUPROJECT_ID;
     bool isQML    = parent->project()->id() == "QmlProjectManager.QmlProject";
+    bool isQMake  = parent->project()->id() == QmakeProjectManager::Constants::QMAKEPROJECT_ID;
 
-    if (!isCMake && !isHTML &&!isQML)
+    if (!isCMake && !isHTML &&!isQML &&!isQMake)
         return types;
 
     if (isRemote) {
@@ -64,11 +66,14 @@
             return types;
     }
 
-    QString manifestPath = QDir::cleanPath(parent->project()->projectDirectory()
-                                           +QDir::separator()
-                                           +UbuntuCMakeCache::getValue(QStringLiteral("UBUNTU_MANIFEST_PATH"),
-                                                                       parent->activeBuildConfiguration(),
-                                                                       QStringLiteral("manifest.json")).toString());
+    QString defaultPath = QDir::cleanPath(parent->project()->projectDirectory()
+                                          +QDir::separator()
+                                          +QStringLiteral("manifest.json"));
+
+    QString manifestPath = UbuntuProjectHelper::getManifestPath(parent,defaultPath);
+
+    qDebug()<<"Using the manifest path: "<<manifestPath;
+
     UbuntuClickManifest manifest;
 
     //if we have no manifest, we can not query the app id's
@@ -85,7 +90,7 @@
         }
     }
     else if (isRemote) {
-        if (isCMake || isHTML || isQML) {
+        if (isCMake || isHTML || isQML || isQMake) {
             foreach (const UbuntuClickManifest::Hook &hook, hooks) {
                 if(hook.type() == UbuntuClickManifest::Hook::Application)
                     types << Core::Id(Constants::UBUNTUPROJECT_REMOTE_RUNCONTROL_APP_ID).withSuffix(hook.appId);

=== modified file 'src/ubuntu/ubuntumanifesteditorwidget.cpp'
--- src/ubuntu/ubuntumanifesteditorwidget.cpp	2014-10-31 16:58:14 +0000
+++ src/ubuntu/ubuntumanifesteditorwidget.cpp	2014-11-21 08:06:27 +0000
@@ -328,7 +328,7 @@
             m_ui->comboBoxFramework->removeItem(idx);
     }
 
-    QString v = policyForFramework(m_ui->comboBoxFramework->currentText());
+    QString v = UbuntuClickFrameworkProvider::instance()->frameworkPolicy(m_ui->comboBoxFramework->currentText());
     if(v.isEmpty())
         return;
 
@@ -336,8 +336,18 @@
     foreach(const UbuntuClickManifest::Hook &hook, hooks){
         QFileInfo mFile(textEditorWidget()->baseTextDocument()->filePath());
         QString aaFile = mFile.absolutePath()+QDir::separator()+hook.appArmorFile;
-        if(!QFile::exists(aaFile))
-            continue;
+        if(!QFile::exists(aaFile)) {
+
+            ProjectExplorer::Project *p = ubuntuProject(mFile.absolutePath());
+            if(!p)
+                continue;
+
+            //the aa file does not live in the same directory as the manifest file
+            //try if we can use the project root directory to find the file
+            aaFile = p->projectDirectory()+QDir::separator()+hook.appArmorFile;
+            if(!QFile::exists(aaFile))
+                continue;
+        }
 
         QList<Core::IEditor*> editors = model->editorsForFilePath(aaFile);
         if(editors.size()) {
@@ -494,53 +504,5 @@
     }
 }
 
-
-QString UbuntuManifestEditorWidget::policyForFramework(const QString &fw)
-{
-    if(fw.isEmpty())
-        return QString();
-
-#if 0
-    QProcess proc;
-    proc.setProgram(QStringLiteral("aa-clickquery"));
-    proc.setArguments(QStringList{
-                      QStringLiteral("--click-framework=%1").arg(fw),
-                      QStringLiteral("--query=policy_version")});
-    proc.start();
-    proc.waitForFinished();
-    if(proc.exitCode() == 0 && proc.exitStatus() == QProcess::NormalExit) {
-        m_apparmor.setPolicyVersion(QString::fromUtf8(proc.readAllStandardOutput()));
-        m_apparmor.save();
-    }
-#else
-    static const QMap<QString,QString> policy {
-        {QStringLiteral("ubuntu-sdk-13.10"),QStringLiteral("1.0")},
-        {QStringLiteral("ubuntu-sdk-14.04-dev1"),QStringLiteral("1.1")},
-        {QStringLiteral("ubuntu-sdk-14.04-html-dev1"),QStringLiteral("1.1")},
-        {QStringLiteral("ubuntu-sdk-14.04-html"),QStringLiteral("1.1")},
-        {QStringLiteral("ubuntu-sdk-14.04-papi-dev1"),QStringLiteral("1.1")},
-        {QStringLiteral("ubuntu-sdk-14.04-papi"),QStringLiteral("1.1")},
-        {QStringLiteral("ubuntu-sdk-14.04-qml-dev1"),QStringLiteral("1.1")},
-        {QStringLiteral("ubuntu-sdk-14.04-qml"),QStringLiteral("1.1")},
-        {QStringLiteral("ubuntu-sdk-14.04"),QStringLiteral("1.1")},
-        {QStringLiteral("ubuntu-sdk-14.10-dev1"),QStringLiteral("1.2")},
-        {QStringLiteral("ubuntu-sdk-14.10-dev2"),QStringLiteral("1.2")},
-        {QStringLiteral("ubuntu-sdk-14.10-html-dev1"),QStringLiteral("1.2")},
-        {QStringLiteral("ubuntu-sdk-14.10-html-dev2"),QStringLiteral("1.2")},
-        {QStringLiteral("ubuntu-sdk-14.10-papi-dev1"),QStringLiteral("1.2")},
-        {QStringLiteral("ubuntu-sdk-14.10-papi-dev2"),QStringLiteral("1.2")},
-        {QStringLiteral("ubuntu-sdk-14.10-qml-dev1"),QStringLiteral("1.2")},
-        {QStringLiteral("ubuntu-sdk-14.10-qml-dev2"),QStringLiteral("1.2")},
-        {QStringLiteral("ubuntu-sdk-14.10-qml-dev3"),QStringLiteral("1.2")}
-    };
-
-    if(policy.contains(fw)) {
-        return policy[fw];
-    }
-    return QString();
-#endif
-}
-
-
 } // namespace Internal
 } // namespace Ubuntu

=== modified file 'src/ubuntu/ubuntumanifesteditorwidget.h'
--- src/ubuntu/ubuntumanifesteditorwidget.h	2014-10-31 16:58:14 +0000
+++ src/ubuntu/ubuntumanifesteditorwidget.h	2014-11-21 08:06:27 +0000
@@ -55,8 +55,7 @@
     bool syncToWidgets (UbuntuClickManifest *source);
     void syncToSource  ();
     QWidget *createMainWidget();
-    void addMissingFieldsToManifest(QString fileName);    
-    QString policyForFramework(const QString &fw);
+    void addMissingFieldsToManifest(QString fileName);
 
 protected slots:
     void bzrChanged ();

=== modified file 'src/ubuntu/ubuntupackagestep.cpp'
--- src/ubuntu/ubuntupackagestep.cpp	2014-10-01 11:48:41 +0000
+++ src/ubuntu/ubuntupackagestep.cpp	2014-11-21 08:06:27 +0000
@@ -2,7 +2,7 @@
 #include "ui_ubuntupackagestepconfigwidget.h"
 #include "ubuntuconstants.h"
 #include "clicktoolchain.h"
-#include "ubuntuprojectguesser.h"
+#include "ubuntuprojecthelper.h"
 #include "ubuntuclickmanifest.h"
 #include "ubuntupackageoutputparser.h"
 
@@ -15,6 +15,7 @@
 #include <projectexplorer/ioutputparser.h>
 #include <utils/qtcprocess.h>
 #include <cmakeprojectmanager/cmakeprojectconstants.h>
+#include <qmakeprojectmanager/qmakeprojectmanagerconstants.h>
 
 #include <QDir>
 #include <QTimer>
@@ -75,6 +76,9 @@
     Utils::Environment env = Utils::Environment::systemEnvironment();
     Utils::AbstractMacroExpander *mExp = 0;
 
+    bool isCMake  = target()->project()->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID;
+    bool isQMake  = target()->project()->id() == QmakeProjectManager::Constants::QMAKEPROJECT_ID;
+
     {
         ProjectExplorer::BuildConfiguration *bc = target()->activeBuildConfiguration();
         if(bc) {
@@ -85,8 +89,8 @@
             env = bc->environment();
             mExp = bc->macroExpander();
         } else {
-            //cmake projects NEED a buildconfiguration
-            if (target()->project()->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID) {
+            //cmake and qmake projects NEED a buildconfiguration
+            if (isCMake || isQMake) {
                 ProjectExplorer::Task t(ProjectExplorer::Task::Error
                                         ,tr("No valid BuildConfiguration set for step: %1").arg(displayName())
                                         ,Utils::FileName(),-1
@@ -116,10 +120,16 @@
 
     //build the make process arguments
     {
-        if (target()->project()->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID) {
+        if (isCMake || isQMake) {
             QStringList arguments;
-            arguments << QStringLiteral("DESTDIR=%1").arg(QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR))
-                      << QStringLiteral("install");
+
+            if(isCMake) {
+                arguments << QStringLiteral("DESTDIR=%1").arg(QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR))
+                          << QStringLiteral("install");
+            } else {
+                arguments << QStringLiteral("INSTALL_ROOT=%1").arg(m_buildDir + QDir::separator() + QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR))
+                          << QStringLiteral("install");
+            }
 
             ProjectExplorer::ProcessParameters* params = &m_MakeParam;
             params->setMacroExpander(mExp);
@@ -487,7 +497,7 @@
 {
     if (tc)
         return tc->makeCommand(env);
-    return QString::fromLatin1(Constants::UBUNTU_CLICK_MAKE_WRAPPER).arg(Constants::UBUNTU_SCRIPTPATH);
+    return QString();
 }
 
 /*!

=== modified file 'src/ubuntu/ubuntupackagingwidget.cpp'
--- src/ubuntu/ubuntupackagingwidget.cpp	2014-10-14 09:31:18 +0000
+++ src/ubuntu/ubuntupackagingwidget.cpp	2014-11-21 08:06:27 +0000
@@ -28,6 +28,7 @@
 #include "ubuntupackagestep.h"
 #include "ubuntushared.h"
 #include "ubuntucmakecache.h"
+#include "ubuntuprojecthelper.h"
 
 #include <projectexplorer/projectexplorer.h>
 #include <projectexplorer/project.h>
@@ -45,7 +46,7 @@
 #include <cmakeprojectmanager/cmakeprojectconstants.h>
 #include <ssh/sshconnection.h>
 #include <qmlprojectmanager/qmlprojectconstants.h>
-
+#include <qmakeprojectmanager/qmakeprojectmanagerconstants.h>
 
 #include <QFileDialog>
 #include <QJsonDocument>
@@ -117,11 +118,25 @@
 
     ProjectExplorer::Project* startupProject = ProjectExplorer::SessionManager::startupProject();
 
-    QVariant manifestPath = UbuntuCMakeCache::getValue(QStringLiteral("UBUNTU_MANIFEST_PATH"),
-                                                       startupProject->activeTarget()->activeBuildConfiguration(),
-                                                       QStringLiteral("manifest.json"));
+    //first try to use the version in the deploy directory. It is always in the root of the click package
+    QString manifestPath;
+
+    if(startupProject->activeTarget() && startupProject->activeTarget()->activeBuildConfiguration()) {
+        manifestPath = startupProject->activeTarget()->activeBuildConfiguration()->buildDirectory()
+                .appendPath(QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR))
+                .appendPath(QStringLiteral("manifest.json"))
+                .toString();
+    }
+
+    if(!QFile::exists(manifestPath)) {
+        //fall back to the project directory
+        manifestPath = UbuntuProjectHelper::getManifestPath(startupProject->activeTarget(),
+                                                            Utils::FileName::fromString(startupProject->projectDirectory())
+                                                            .appendPath(QStringLiteral("manifest.json")).toString());
+    }
+
     UbuntuClickManifest manifest;
-    if(!manifest.load(startupProject->projectDirectory()+QDir::separator()+manifestPath.toString()))
+    if(!manifest.load(manifestPath))
         return;
 
     QString sClickPackageName;
@@ -259,7 +274,8 @@
     QString mimeType = project->projectManager()->mimeType();
     if(mimeType == QLatin1String(CMakeProjectManager::Constants::CMAKEMIMETYPE)
             || mimeType == QLatin1String(Ubuntu::Constants::UBUNTUPROJECT_MIMETYPE)
-            || mimeType == QLatin1String(QmlProjectManager::Constants::QMLPROJECT_MIMETYPE)) {
+            || mimeType == QLatin1String(QmlProjectManager::Constants::QMLPROJECT_MIMETYPE)
+            || mimeType == QLatin1String(QmakeProjectManager::Constants::PROFILE_MIMETYPE)) {
         if(m_reviewToolsInstalled)
             m_postPackageTask = Verify;
         else
@@ -385,8 +401,9 @@
     bool isCMake = mimeType == QLatin1String(CMakeProjectManager::Constants::CMAKEMIMETYPE);
     bool isHtml  = mimeType == QLatin1String(Ubuntu::Constants::UBUNTUPROJECT_MIMETYPE);
     bool isQml   = mimeType == QLatin1String(QmlProjectManager::Constants::QMLPROJECT_MIMETYPE);
+    bool isQmake = mimeType == QLatin1String(QmakeProjectManager::Constants::PROFILE_MIMETYPE);
 
-    if(isCMake || isHtml || isQml) {
+    if(isCMake || isHtml || isQml || isQmake) {
         ProjectExplorer::Target* target = project->activeTarget();
         if(!target)
             return;
@@ -420,7 +437,7 @@
         clearPackageBuildList();
 
         m_packageBuildSteps = QSharedPointer<ProjectExplorer::BuildStepList> (new ProjectExplorer::BuildStepList(bc,ProjectExplorer::Constants::BUILDSTEPS_BUILD));
-        if (isCMake) {
+        if (isCMake || isQmake) {
             //add the normal buildsteps
             m_packageBuildSteps->cloneSteps(bc->stepList(Core::Id(ProjectExplorer::Constants::BUILDSTEPS_BUILD)));
         }

=== modified file 'src/ubuntu/ubuntuplugin.cpp'
--- src/ubuntu/ubuntuplugin.cpp	2014-10-31 16:58:14 +0000
+++ src/ubuntu/ubuntuplugin.cpp	2014-11-21 08:06:27 +0000
@@ -175,6 +175,10 @@
                     QStringLiteral("ubuntu-project-cmake"),
                     Core::IWizard::ProjectWizard));
     addAutoReleasedObject(
+                new UbuntuWizardFactory<UbuntuProjectApplicationWizard,UbuntuProjectApplicationWizard::QMakeProject>(
+                    QStringLiteral("ubuntu-project-qmake"),
+                    Core::IWizard::ProjectWizard));
+    addAutoReleasedObject(
                 new UbuntuWizardFactory<UbuntuProjectApplicationWizard,UbuntuProjectApplicationWizard::UbuntuHTMLProject>(
                     QStringLiteral("ubuntu-project-plain-html"),
                     Core::IWizard::ProjectWizard));

=== modified file 'src/ubuntu/ubuntuprojectapplicationwizard.cpp'
--- src/ubuntu/ubuntuprojectapplicationwizard.cpp	2014-11-17 14:24:59 +0000
+++ src/ubuntu/ubuntuprojectapplicationwizard.cpp	2014-11-21 08:06:27 +0000
@@ -271,6 +271,7 @@
                 m_targetSetupPage->setRequiredKitMatcher(new QtSupport::QtVersionKitMatcher(features));
             break;
         }
+        case UbuntuProjectApplicationWizard::QMakeProject:
         case UbuntuProjectApplicationWizard::UbuntuQMLProject:
         case UbuntuProjectApplicationWizard::UbuntuHTMLProject: {
             m_targetSetupPage->setRequiredKitMatcher(new UbuntuKitMatcher());
@@ -301,22 +302,37 @@
     if(!m_targetSetupPage)
         return;
 
-    if(m_type == UbuntuProjectApplicationWizard::GoProject) {
-        m_targetSetupPage->setProjectPath(path+QDir::separator()
-                                          +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 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"));
+    switch(m_type) {
+        case UbuntuProjectApplicationWizard::QMakeProject: {
+            m_targetSetupPage->setProjectPath(path+QDir::separator()
+                                              +projectName
+                                              +QDir::separator()
+                                              +QString::fromLatin1("%1.pro").arg(projectName));
+            break;
+        }
+        case UbuntuProjectApplicationWizard::GoProject: {
+            m_targetSetupPage->setProjectPath(path+QDir::separator()
+                                              +projectName
+                                              +QDir::separator()
+                                              +QString::fromLatin1("%1.goproject").arg(projectName));
+            break;
+        }
+        case UbuntuProjectApplicationWizard::UbuntuHTMLProject: {
+            m_targetSetupPage->setProjectPath(path+QDir::separator()
+                                              +projectName
+                                              +QDir::separator()
+                                              +QString::fromLatin1("%1.ubuntuhtmlproject").arg(projectName));
+            break;
+        }
+        case UbuntuProjectApplicationWizard::UbuntuQMLProject: {
+            m_targetSetupPage->setProjectPath(path+QDir::separator()
+                                              +projectName
+                                              +QDir::separator()
+                                              +QString::fromLatin1("%1.qmlproject").arg(projectName));
+            break;
+        }
+        default: {
+            m_targetSetupPage->setProjectPath(path+QDir::separator()+projectName+QDir::separator()+QLatin1String("CMakeLists.txt"));
+        }
     }
 }

=== modified file 'src/ubuntu/ubuntuprojectapplicationwizard.h'
--- src/ubuntu/ubuntuprojectapplicationwizard.h	2014-11-17 14:24:59 +0000
+++ src/ubuntu/ubuntuprojectapplicationwizard.h	2014-11-21 08:06:27 +0000
@@ -44,7 +44,8 @@
         UbuntuHTMLProject,
         UbuntuQMLProject,
         CMakeProject,
-        GoProject
+        GoProject,
+        QMakeProject
     };
 
     UbuntuProjectApplicationWizard(ProjectType type);

=== renamed file 'src/ubuntu/ubuntuprojectguesser.cpp' => 'src/ubuntu/ubuntuprojecthelper.cpp'
--- src/ubuntu/ubuntuprojectguesser.cpp	2014-09-02 15:06:34 +0000
+++ src/ubuntu/ubuntuprojecthelper.cpp	2014-11-21 08:06:27 +0000
@@ -15,13 +15,21 @@
  *
  * Author: Benjamin Zeller <[e-mail]>
  */
-#include "ubuntuprojectguesser.h"
+#include "ubuntuprojecthelper.h"
 #include "ubuntucmakecache.h"
 
 #include <projectexplorer/project.h>
 #include <projectexplorer/target.h>
 #include <projectexplorer/buildconfiguration.h>
+
 #include <cmakeprojectmanager/cmakeproject.h>
+#include <cmakeprojectmanager/cmakeprojectconstants.h>
+
+#include <qmakeprojectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakeprojectmanagerconstants.h>
+#include <qmakeprojectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakenodes.h>
+
 #include <QDebug>
 
 #include <QFile>
@@ -36,26 +44,22 @@
     debug = 0
 };
 
-const char SCOPES_TYPE_CACHE_PROPERTY[]    = "__ubuntu_sdk_is_scopes_project_property";
-const char SCOPES_INIFILE_CACHE_PROPERTY[] = "__ubuntu_sdk_scopes_project_inifile_property";
-const char CLICK_TYPE_CACHE_PROPERTY[]     = "__ubuntu_sdk_is_click_project_property";
-
-UbuntuProjectGuesser::UbuntuProjectGuesser()
+UbuntuProjectHelper::UbuntuProjectHelper()
 {
 }
 
-Utils::FileName UbuntuProjectGuesser::findScopesIniRecursive(const Utils::FileName &searchdir, const QString &appid)
+Utils::FileName UbuntuProjectHelper::findScopesIniRecursive(const Utils::FileName &searchdir, const QString &appid)
 {
     return findFileRecursive(searchdir,QStringLiteral("^.*_%1\\.ini.*$").arg(appid));
 }
 
-Utils::FileName UbuntuProjectGuesser::findFileRecursive(const Utils::FileName &searchdir, const QString &regexp)
+Utils::FileName UbuntuProjectHelper::findFileRecursive(const Utils::FileName &searchdir, const QString &regexp)
 {
     QRegularExpression regex(regexp);
     return findFileRecursive(searchdir,regex);
 }
 
-Utils::FileName UbuntuProjectGuesser::findFileRecursive(const Utils::FileName &searchdir, const QRegularExpression &regexp)
+Utils::FileName UbuntuProjectHelper::findFileRecursive(const Utils::FileName &searchdir, const QRegularExpression &regexp)
 {
     QFileInfo dirInfo = searchdir.toFileInfo();
     if(!dirInfo.exists())
@@ -65,7 +69,7 @@
         return Utils::FileName();
 
     QDir dir(dirInfo.absoluteFilePath());
-    QStringList entries = dir.entryList(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files);
+    QStringList entries = dir.entryList(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files | QDir::Hidden);
 
     foreach (const QString& entry, entries) {
         QFileInfo info(dir.absoluteFilePath(entry));
@@ -86,7 +90,7 @@
     return Utils::FileName();
 }
 
-QList<Utils::FileName> UbuntuProjectGuesser::findFilesRecursive(const Utils::FileName &searchdir, const QRegularExpression &regexp)
+QList<Utils::FileName> UbuntuProjectHelper::findFilesRecursive(const Utils::FileName &searchdir, const QRegularExpression &regexp)
 {
     QList<Utils::FileName> result;
     QFileInfo dirInfo = searchdir.toFileInfo();
@@ -115,30 +119,51 @@
     return result;
 }
 
-QString UbuntuProjectGuesser::projectTypeFromCacheOrProject(ProjectExplorer::Project *project)
+QString UbuntuProjectHelper::getManifestPath(ProjectExplorer::Target *target, const QString &defaultValue)
 {
-    //First try to get the variable from the Cache file
-    if(project->activeTarget()
-            && project->activeTarget()->activeBuildConfiguration())
-    {
-        QVariant val = UbuntuCMakeCache::getValue(QStringLiteral("UBUNTU_PROJECT_TYPE"),project->activeTarget()->activeBuildConfiguration());
-        if(val.isValid())
-            return val.toString();
-    }
-
-    QFile projectFile(project->projectFilePath());
-    if (projectFile.exists() && projectFile.open(QIODevice::ReadOnly)) {
-        QRegularExpression regExp(QLatin1String("^\\s*SET\\s*\\(\\s*UBUNTU_PROJECT_TYPE\\s*\"?(\\S*)\"?"));
-        QTextStream in(&projectFile);
-        while (!in.atEnd()) {
-            QString contents = in.readLine();
-            QRegularExpressionMatch m = regExp.match(contents);
-            if(m.hasMatch()) {
-                return m.captured(1);
+    if(target && target->project()->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID ) {
+        QVariant manifestPath = UbuntuCMakeCache::getValue(QStringLiteral("UBUNTU_MANIFEST_PATH"),
+                                                           target->activeBuildConfiguration(),
+                                                           defaultValue);
+
+        Utils::FileName projectDir = Utils::FileName::fromString(target->project()->projectDirectory());
+        return projectDir.appendPath(manifestPath.toString()).toString();
+    } else if (target && target->project()->id() == QmakeProjectManager::Constants::QMAKEPROJECT_ID ) {
+        QmakeProjectManager::QmakeProject *qmakeProj = static_cast<QmakeProjectManager::QmakeProject *>(target->project());
+        QList<QmakeProjectManager::QmakeProFileNode *> nodes = qmakeProj->allProFiles();
+
+        QString manifestFilePath; //empty
+        foreach (QmakeProjectManager::QmakeProFileNode *node, nodes) {
+            if(!node)
+                continue;
+
+            manifestFilePath = node->singleVariableValue(QmakeProjectManager::UbuntuManifestFile);
+            if(manifestFilePath.isEmpty()) {
+                continue;
+            } else if(QDir::isRelativePath(manifestFilePath)) {
+                manifestFilePath = QDir::cleanPath(node->sourceDir()
+                                                   +QDir::separator()
+                                                   +manifestFilePath);
+                break;
+            } else {
+                manifestFilePath = QDir::cleanPath(manifestFilePath);
+                break;
             }
         }
+
+        if(manifestFilePath.isEmpty())
+            return defaultValue;
+        return manifestFilePath;
     }
-    return QString();
+    return defaultValue;
+}
+
+QString UbuntuProjectHelper::getManifestPath(ProjectExplorer::Project *p, const QString &defaultValue)
+{
+    if(!p)
+        return defaultValue;
+
+    return getManifestPath(p->activeTarget(),defaultValue);
 }
 
 } // namespace Internal

=== renamed file 'src/ubuntu/ubuntuprojectguesser.h' => 'src/ubuntu/ubuntuprojecthelper.h'
--- src/ubuntu/ubuntuprojectguesser.h	2014-09-02 15:06:34 +0000
+++ src/ubuntu/ubuntuprojecthelper.h	2014-11-21 08:06:27 +0000
@@ -25,21 +25,22 @@
 
 namespace ProjectExplorer {
     class Project;
+    class Target;
 }
 
 namespace Ubuntu {
 namespace Internal {
 
-class UbuntuProjectGuesser
+class UbuntuProjectHelper
 {
 public:
-    UbuntuProjectGuesser();
+    UbuntuProjectHelper();
     static Utils::FileName findScopesIniRecursive (const Utils::FileName &searchdir, const QString &appid);
     static Utils::FileName findFileRecursive (const Utils::FileName &searchdir, const QString &regexp);
     static Utils::FileName findFileRecursive (const Utils::FileName &searchdir, const QRegularExpression &regexp);
     static QList<Utils::FileName> findFilesRecursive(const Utils::FileName &searchdir, const QRegularExpression &regexp);
-    static QString projectTypeFromCacheOrProject (ProjectExplorer::Project* project);
-
+    static QString getManifestPath (ProjectExplorer::Project * p, const QString &defaultValue);
+    static QString getManifestPath(ProjectExplorer::Target *target, const QString &defaultValue);
 };
 
 } // namespace Internal

=== modified file 'src/ubuntu/ubuntuqtversion.cpp'
--- src/ubuntu/ubuntuqtversion.cpp	2014-09-29 11:28:19 +0000
+++ src/ubuntu/ubuntuqtversion.cpp	2014-11-21 08:06:27 +0000
@@ -5,6 +5,7 @@
 
 #include <QCoreApplication>
 #include <QFileInfo>
+#include <QDebug>
 
 namespace Ubuntu {
 namespace Internal {
@@ -16,7 +17,7 @@
  * Increment this version if all qmake scripts in ~/.config/ubuntu-sdk
  * need to be recreated
  */
-const int  MIN_SCRIPT_VERSION   = 1;
+const int  MIN_SCRIPT_VERSION   = 2;
 
 UbuntuQtVersion::UbuntuQtVersion()
     : BaseQtVersion(),
@@ -31,7 +32,7 @@
 }
 
 UbuntuQtVersion::~UbuntuQtVersion()
-{ }
+{}
 
 void UbuntuQtVersion::fromMap(const QVariantMap &map)
 {
@@ -115,7 +116,7 @@
 {
     Q_UNUSED(evaluator);
     //we only care about our qmakes
-    if(!qmakePath.toFileInfo().absolutePath().endsWith(QStringLiteral(".config/ubuntu-sdk")))
+    if(!qmakePath.toFileInfo().absolutePath().contains(QStringLiteral(".config/ubuntu-sdk")))
         return 0;
 
     return new UbuntuQtVersion(qmakePath,isAutoDetected,autoDetectionSource);

=== modified file 'src/ubuntu/ubunturemotedeployconfiguration.cpp'
--- src/ubuntu/ubunturemotedeployconfiguration.cpp	2014-08-21 16:56:53 +0000
+++ src/ubuntu/ubunturemotedeployconfiguration.cpp	2014-11-21 08:06:27 +0000
@@ -19,7 +19,7 @@
 #include "ubuntucmakebuildconfiguration.h"
 #include "ubuntucmakemakestep.h"
 #include "ubuntudirectuploadstep.h"
-#include "ubuntuprojectguesser.h"
+#include "ubuntuprojecthelper.h"
 #include "ubuntuconstants.h"
 #include "ubuntupackagestep.h"
 
@@ -35,6 +35,7 @@
 #include <projectexplorer/buildsteplist.h>
 
 #include <cmakeprojectmanager/cmakeprojectconstants.h>
+#include <qmakeprojectmanager/qmakeprojectmanagerconstants.h>
 
 #include <QDir>
 #include <QObject>
@@ -82,11 +83,13 @@
         return ids;
 
     Core::Id projectTypeId = parent->project()->id();
+    qDebug()<<"Project ID: "<<projectTypeId.toString();
 
-    //for now only support cmake and ubuntu projects
+    //for now only support cmake, qmake and ubuntu projects
     if(projectTypeId != CMakeProjectManager::Constants::CMAKEPROJECT_ID
             && projectTypeId != Ubuntu::Constants::UBUNTUPROJECT_ID
-            && projectTypeId != "QmlProjectManager.QmlProject")
+            && projectTypeId != "QmlProjectManager.QmlProject"
+            && projectTypeId != QmakeProjectManager::Constants::QMAKEPROJECT_ID)
         return ids;
 
     const Core::Id devType = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(parent->kit());

=== modified file 'src/ubuntu/ubunturemoterunconfiguration.cpp'
--- src/ubuntu/ubunturemoterunconfiguration.cpp	2014-09-24 14:31:46 +0000
+++ src/ubuntu/ubunturemoterunconfiguration.cpp	2014-11-21 08:06:27 +0000
@@ -34,6 +34,9 @@
 #include <utils/qtcprocess.h>
 #include <cmakeprojectmanager/cmakeproject.h>
 #include <cmakeprojectmanager/cmakeprojectconstants.h>
+#include <qmakeprojectmanager/qmakeprojectmanagerconstants.h>
+#include <qmakeprojectmanager/qmakeproject.h>
+#include <qmakeprojectmanager/qmakenodes.h>
 
 #include <QFile>
 #include <QTextStream>
@@ -115,7 +118,23 @@
                 paths << binary.absolutePath();
             }
         }
+    } else {
+        QmakeProjectManager::QmakeProject* qmakeProj =
+                qobject_cast<QmakeProjectManager::QmakeProject *>(target()->project());
+        if(qmakeProj) {
+            foreach (const QmakeProjectManager::QmakeProFileNode* pro, qmakeProj->allProFiles()) {
+                if(pro->projectType() == QmakeProjectManager::ApplicationTemplate
+                         || pro->projectType() == QmakeProjectManager::LibraryTemplate) {
+                    QmakeProjectManager::TargetInformation info = pro->targetInformation();
+                    if(!info.valid)
+                        continue;
+                    if(debug) qDebug()<<"Adding path "<<info.buildDir<<" to solib-search-paths";
+                    paths << info.buildDir;
+                }
+            }
+        }
     }
+
     return paths;
 }
 
@@ -236,15 +255,28 @@
             m_arguments = args;
         } else {
             //looks like a application without a launcher
-            CMakeProjectManager::CMakeProject* pro = static_cast<CMakeProjectManager::CMakeProject*> (target()->project());
-            foreach(const CMakeProjectManager::CMakeBuildTarget &t, pro->buildTargets()) {
-                if(t.library || t.executable.isEmpty())
-                    continue;
-
-                QFileInfo execInfo(t.executable);
-
-                if(execInfo.fileName() == commInfo.fileName())
-                    m_localExecutable = t.executable;
+            if(target()->project()->id() == QmakeProjectManager::Constants::QMAKEPROJECT_ID) {
+                QmakeProjectManager::QmakeProject* pro = static_cast<QmakeProjectManager::QmakeProject*> (target()->project());
+                foreach(const QmakeProjectManager::QmakeProFileNode* applPro, pro->applicationProFiles()) {
+                    QmakeProjectManager::TargetInformation info = applPro->targetInformation();
+                    if(applPro->targetInformation().valid) {
+                        if(info.target == commInfo.fileName()) {
+                            m_localExecutable = info.buildDir + QDir::separator() + info.target;
+                            break;
+                        }
+                    }
+                }
+            } else {
+                CMakeProjectManager::CMakeProject* pro = static_cast<CMakeProjectManager::CMakeProject*> (target()->project());
+                foreach(const CMakeProjectManager::CMakeBuildTarget &t, pro->buildTargets()) {
+                    if(t.library || t.executable.isEmpty())
+                        continue;
+
+                    QFileInfo execInfo(t.executable);
+
+                    if(execInfo.fileName() == commInfo.fileName())
+                        m_localExecutable = t.executable;
+                }
             }
 
             if (m_localExecutable.isEmpty()) {
@@ -252,7 +284,6 @@
                     *errorMessage = tr("Could not find %1 in the project targets").arg(command);
                 return false;
             }
-
             m_remoteExecutable = command;
         }
         return true;
@@ -390,7 +421,7 @@
 QString UbuntuRemoteRunConfiguration::packageDir() const
 {
     ProjectExplorer::Project *p = target()->project();
-    if (p->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID)
+    if (p->id() == CMakeProjectManager::Constants::CMAKEPROJECT_ID || p->id() == QmakeProjectManager::Constants::QMAKEPROJECT_ID)
         return target()->activeBuildConfiguration()->buildDirectory().toString()+QDir::separator()+QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR);
     else if (p->id() == Ubuntu::Constants::UBUNTUPROJECT_ID || p->id() == "QmlProjectManager.QmlProject") {
         if (!target()->activeBuildConfiguration()) {