QmlDesigner: On demand compilation of the puppet

Before we had to provide the puppet in the packaging. Now we compile the puppet on demand so we can be sure it is always there in the right version and working. Task-number: QTCREATORBUG-11763 Change-Id: I8556ef677ed27fbcc8a7775dced60230104e3237 Reviewed-by: Thomas Hartmann <Thomas.Hartmann@digia.com>
2014-04-09 12:55:53 +02:00
parent 3db252ee6d
commit 38220ba4bb
10 changed files with 527 additions and 330 deletions
@@ -18,6 +18,8 @@ QT += core-private qml-private quick-private gui-private
    CONFIG += c++11
 }

+
+
 DEFINES += QWEAKPOINTER_ENABLE_ARROW
 DEFINES -= QT_CREATOR

@@ -37,9 +39,12 @@ SOURCES +=  $$PWD/qml2puppetmain.cpp
 RESOURCES +=  $$PWD/../qmlpuppet.qrc
 DEFINES -= QT_NO_CAST_FROM_ASCII

-OTHER_FILES += Info.plist.in
+OTHER_FILES += Info.plist
+
+
 macx {
-    QMAKE_INFO_PLIST = $$PWD/Info.plist
+    CONFIG -= app_bundle
+    QMAKE_LFLAGS += -sectcreate __TEXT __info_plist $$system_quote($$PWD/Info.plist)
 } else {
    target.path  = $$QTC_PREFIX/bin
    INSTALLS    += target
@@ -3,8 +3,6 @@ TARGET = qml2puppet
 TEMPLATE = app
 CONFIG += console

-DESTDIR = $$[QT_INSTALL_BINS]
-
 build_all:!build_pass {
    CONFIG -= build_all
    CONFIG += release
@@ -22,9 +22,10 @@ SOURCES += $$PWD/qmlpuppetmain.cpp
 RESOURCES += $$PWD/../qmlpuppet.qrc
 DEFINES -= QT_NO_CAST_FROM_ASCII

-OTHER_FILES += Info.plist.in
+OTHER_FILES += Info.plist
 macx {
-    QMAKE_INFO_PLIST = $$PWD/Info.plist
+    CONFIG -= app_bundle
+    QMAKE_LFLAGS += -sectcreate __TEXT __info_plist $$system_quote($$PWD/Info.plist)
 } else {
    target.path  = $$QTC_PREFIX/bin
    INSTALLS    += target
@@ -2,8 +2,6 @@ TARGET = qmlpuppet

 TEMPLATE = app

-DESTDIR = $$[QT_INSTALL_BINS]
-
 build_all:!build_pass {
    CONFIG -= build_all
    CONFIG += release
@@ -13,4 +11,4 @@ greaterThan(QT_MAJOR_VERSION, 4) {
    DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x040900
 }

-include(qmlpuppet.pri)
+include(qmlpuppet.pri)
@@ -2,7 +2,9 @@ INCLUDEPATH += $$PWD/

 HEADERS += $$PWD/../include/nodeinstance.h
 HEADERS += $$PWD/nodeinstanceserverproxy.h
+HEADERS += $$PWD/puppetcreator.h

 SOURCES +=  $$PWD/nodeinstanceserverproxy.cpp
 SOURCES +=  $$PWD/nodeinstance.cpp
 SOURCES +=  $$PWD/nodeinstanceview.cpp
+SOURCES += $$PWD/puppetcreator.cpp
@@ -69,12 +69,12 @@

 #include "nodeinstanceview.h"

-#include "puppetdialog.h"
-
 #include "import.h"

 #include "qmldesignerplugin.h"

+#include "puppetcreator.h"
+
 #include <coreplugin/icore.h>
 #include <utils/hostosinfo.h>
 #include <projectexplorer/kit.h>
@@ -82,50 +82,9 @@
 #include <qtsupport/baseqtversion.h>
 #include <qtsupport/qtsupportconstants.h>

-#include <QMessageBox>
-
-namespace {
-#ifdef Q_OS_MAC
-#  define SHARE_PATH "/../Resources"
-#else
-#  define SHARE_PATH "/../share/qtcreator"
-#endif
-
-static QString applicationDirPath()
-{
-    return QCoreApplication::applicationDirPath();
-}
-
-static inline QString sharedDirPath()
-{
-    QString appPath = applicationDirPath();
-
-    return QFileInfo(appPath + SHARE_PATH).absoluteFilePath();
-}
-
-static QLatin1String qmlPuppetApplicationDirectoryForTests()
-{
-    if (Utils::HostOsInfo::isWindowsHost())
-        //one more - debug/release dir
-        return QLatin1String("/../../../../../../bin/");
-    return QLatin1String("/../../../../../bin/");
-}
-} //namespace

 namespace QmlDesigner {

-static bool hasQtQuick2(NodeInstanceView *nodeInstanceView)
-{
-    if (nodeInstanceView && nodeInstanceView->model()) {
-        foreach (const Import &import ,nodeInstanceView->model()->imports()) {
-            if (import.url() ==  "QtQuick" && import.version().toDouble() >= 2.0)
-                return true;
-        }
-    }
-
-    return false;
-}
-
 static bool hasQtQuick1(NodeInstanceView *nodeInstanceView)
 {
    if (nodeInstanceView && nodeInstanceView->model()) {
@@ -138,40 +97,6 @@ static bool hasQtQuick1(NodeInstanceView *nodeInstanceView)
    return false;
 }

-QString NodeInstanceServerProxy::creatorQmlPuppetPath()
-{
-    QString applicationPath =  QCoreApplication::applicationDirPath();
-    applicationPath = macOSBundlePath(applicationPath);
-    applicationPath += QLatin1Char('/') + qmlPuppetApplicationName();
-
-    return applicationPath;
-}
-
-bool NodeInstanceServerProxy::checkPuppetVersion(const QString &qmlPuppetPath)
-{
-    QProcess qmlPuppetVersionProcess;
-    qmlPuppetVersionProcess.start(qmlPuppetPath, QStringList() << "--version");
-    qmlPuppetVersionProcess.waitForReadyRead(6000);
-
-    QByteArray versionString = qmlPuppetVersionProcess.readAll();
-
-    bool canConvert;
-    unsigned int versionNumber = versionString.toUInt(&canConvert);
-
-    return canConvert && versionNumber == 2;
-}
-
-static QString getPathToQt(ProjectExplorer::Kit *kit)
-{
-    QtSupport::BaseQtVersion *currentQtVersion = QtSupport::QtKitInformation::qtVersion(kit);
-    if (currentQtVersion && (currentQtVersion->qtVersion() >= QtSupport::QtVersionNumber(4, 7, 1))
-            && (currentQtVersion->type() == QLatin1String(QtSupport::Constants::DESKTOPQT)
-                || currentQtVersion->type() == QLatin1String(QtSupport::Constants::SIMULATORQT)))
-        return currentQtVersion->qmakeProperty("QT_INSTALL_DATA");
-
-    return QString();
-}
-
 NodeInstanceServerProxy::NodeInstanceServerProxy(NodeInstanceView *nodeInstanceView, RunModus runModus, ProjectExplorer::Kit *kit)
    : NodeInstanceServerInterface(nodeInstanceView),
      m_localServer(new QLocalServer(this)),
@@ -186,146 +111,78 @@ NodeInstanceServerProxy::NodeInstanceServerProxy(NodeInstanceView *nodeInstanceV
      m_runModus(runModus),
      m_synchronizeId(-1)
 {
-   QString pathToQt = getPathToQt(kit);
+   PuppetCreator puppetCreator(kit, QString());

-   QString applicationPath =  pathToQt + QLatin1String("/bin");
-   if (runModus == TestModus) {
-       applicationPath = QCoreApplication::applicationDirPath()
-           + qmlPuppetApplicationDirectoryForTests()
-           + qmlPuppetApplicationName();
-   } else {
-       applicationPath = macOSBundlePath(applicationPath);
-       applicationPath += QLatin1Char('/') + qmlPuppetApplicationName();
+   QString socketToken(QUuid::createUuid().toString());
+   m_localServer->listen(socketToken);
+   m_localServer->setMaxPendingConnections(3);

+   PuppetCreator::QmlPuppetVersion puppetVersion = hasQtQuick1(nodeInstanceView) ? PuppetCreator::Qml1Puppet : PuppetCreator::Qml2Puppet;

-#if defined(QT_NO_DEBUG) || defined(SEARCH_PUPPET_IN_CREATOR_BINPATH) // to prevent of choosing the wrong puppet in debug
-       if (!QFileInfo(applicationPath).exists()) { //No qmlpuppet in Qt
-           //We have to find out how to give not too intrusive feedback
-           applicationPath = creatorQmlPuppetPath();
-       }
-#endif
+   m_qmlPuppetEditorProcess = puppetCreator.createPuppetProcess(puppetVersion,
+                                                                "editormode",
+                                                              socketToken,
+                                                              this,
+                                                              SLOT(printPreviewProcessOutput()),
+                                                              SLOT(processFinished(int,QProcess::ExitStatus)));
+
+   if (runModus == NormalModus) {
+       m_qmlPuppetRenderProcess = puppetCreator.createPuppetProcess(puppetVersion,
+                                                                    "rendermode",
+                                                                    socketToken,
+                                                                    this,
+                                                                    SLOT(printPreviewProcessOutput()),
+                                                                    SLOT(processFinished(int,QProcess::ExitStatus)));
+       m_qmlPuppetPreviewProcess = puppetCreator.createPuppetProcess(puppetVersion,
+                                                                     "previewmode",
+                                                                     socketToken,
+                                                                     this,
+                                                                     SLOT(printPreviewProcessOutput()),
+                                                                     SLOT(processFinished(int,QProcess::ExitStatus)));
   }

+   if (m_qmlPuppetEditorProcess->waitForStarted(10000)) {
+       connect(m_qmlPuppetEditorProcess.data(), SIGNAL(finished(int)), m_qmlPuppetEditorProcess.data(),SLOT(deleteLater()));

-   QByteArray envImportPath = qgetenv("QTCREATOR_QMLPUPPET_PATH");
-   if (!envImportPath.isEmpty())
-       applicationPath = envImportPath;
+       if (runModus == NormalModus) {
+           m_qmlPuppetPreviewProcess->waitForStarted();
+           connect(m_qmlPuppetPreviewProcess.data(), SIGNAL(finished(int)), m_qmlPuppetPreviewProcess.data(),SLOT(deleteLater()));

-   QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
-
-#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0)) && (defined(Q_OS_MAC) || defined(Q_OS_LINUX))
-   environment.insert(QLatin1String("DESIGNER_DONT_USE_SHARED_MEMORY"), QLatin1String("1"));
-#endif
-
-   if (QFileInfo(applicationPath).exists()) {
-       if (checkPuppetVersion(applicationPath)) {
-           QString socketToken(QUuid::createUuid().toString());
-           m_localServer->listen(socketToken);
-           m_localServer->setMaxPendingConnections(3);
-
-           m_qmlPuppetEditorProcess = new QProcess;
-           m_qmlPuppetEditorProcess->setProcessEnvironment(environment);
-           m_qmlPuppetEditorProcess->setObjectName("EditorProcess");
-           connect(m_qmlPuppetEditorProcess.data(), SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(processFinished(int,QProcess::ExitStatus)));
-           connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), m_qmlPuppetEditorProcess.data(), SLOT(kill()));
-           bool fowardQmlpuppetOutput = !qgetenv("FORWARD_QMLPUPPET_OUTPUT").isEmpty();
-           if (fowardQmlpuppetOutput) {
-               m_qmlPuppetEditorProcess->setProcessChannelMode(QProcess::MergedChannels);
-               connect(m_qmlPuppetEditorProcess.data(), SIGNAL(readyRead()), this, SLOT(printEditorProcessOutput()));
-           }
-           m_qmlPuppetEditorProcess->start(applicationPath, QStringList() << socketToken << "editormode" << "-graphicssystem raster");
-
-           if (runModus == NormalModus) {
-               m_qmlPuppetPreviewProcess = new QProcess;
-               m_qmlPuppetPreviewProcess->setProcessEnvironment(environment);
-               m_qmlPuppetPreviewProcess->setObjectName("PreviewProcess");
-               connect(m_qmlPuppetPreviewProcess.data(), SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(processFinished(int,QProcess::ExitStatus)));
-               connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), m_qmlPuppetPreviewProcess.data(), SLOT(kill()));
-               if (fowardQmlpuppetOutput) {
-                   m_qmlPuppetPreviewProcess->setProcessChannelMode(QProcess::MergedChannels);
-                   connect(m_qmlPuppetPreviewProcess.data(), SIGNAL(readyRead()), this, SLOT(printPreviewProcessOutput()));
-               }
-               m_qmlPuppetPreviewProcess->start(applicationPath, QStringList() << socketToken << "previewmode" << "-graphicssystem raster");
-
-               m_qmlPuppetRenderProcess = new QProcess;
-               m_qmlPuppetRenderProcess->setProcessEnvironment(environment);
-               m_qmlPuppetRenderProcess->setObjectName("RenderProcess");
-               connect(m_qmlPuppetRenderProcess.data(), SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(processFinished(int,QProcess::ExitStatus)));
-               connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), m_qmlPuppetRenderProcess.data(), SLOT(kill()));
-               if (fowardQmlpuppetOutput) {
-                   m_qmlPuppetRenderProcess->setProcessChannelMode(QProcess::MergedChannels);
-                   connect(m_qmlPuppetRenderProcess.data(), SIGNAL(readyRead()), this, SLOT(printRenderProcessOutput()));
-               }
-               m_qmlPuppetRenderProcess->start(applicationPath, QStringList() << socketToken << "rendermode" << "-graphicssystem raster");
-
-           }
-
-           connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), this, SLOT(deleteLater()));
-
-           if (m_qmlPuppetEditorProcess->waitForStarted(10000)) {
-               connect(m_qmlPuppetEditorProcess.data(), SIGNAL(finished(int)), m_qmlPuppetEditorProcess.data(),SLOT(deleteLater()));
-
-               if (runModus == NormalModus) {
-                   m_qmlPuppetPreviewProcess->waitForStarted();
-                   connect(m_qmlPuppetPreviewProcess.data(), SIGNAL(finished(int)), m_qmlPuppetPreviewProcess.data(),SLOT(deleteLater()));
-
-                   m_qmlPuppetRenderProcess->waitForStarted();
-                   connect(m_qmlPuppetRenderProcess.data(), SIGNAL(finished(int)), m_qmlPuppetRenderProcess.data(),SLOT(deleteLater()));
-               }
-
-               if (!m_localServer->hasPendingConnections())
-                   m_localServer->waitForNewConnection(10000);
-
-               m_firstSocket = m_localServer->nextPendingConnection();
-               connect(m_firstSocket.data(), SIGNAL(readyRead()), this, SLOT(readFirstDataStream()));
-
-               if (runModus == NormalModus) {
-                   if (!m_localServer->hasPendingConnections())
-                       m_localServer->waitForNewConnection(10000);
-
-                   m_secondSocket = m_localServer->nextPendingConnection();
-                   connect(m_secondSocket.data(), SIGNAL(readyRead()), this, SLOT(readSecondDataStream()));
-
-                   if (!m_localServer->hasPendingConnections())
-                       m_localServer->waitForNewConnection(10000);
-
-                   m_thirdSocket = m_localServer->nextPendingConnection();
-                   connect(m_thirdSocket.data(), SIGNAL(readyRead()), this, SLOT(readThirdDataStream()));
-               }
-
-           } else {
-               PuppetDialog::warning(Core::ICore::dialogParent(),
-                                     tr("Cannot Start QML Puppet Executable"),
-                                     missingQmlPuppetErrorMessage(tr("The executable of the QML Puppet process (%1) cannot be started. "
-                                                                     "Please check your installation. "
-                                                                     "QML Puppet is a process which runs in the background to render the items."
-                                                                    ).arg(applicationPath)),
-                                     copyAndPasterMessage(pathToQt));
-
-               QmlDesignerPlugin::instance()->switchToTextModeDeferred();
-           }
-
-           m_localServer->close();
-
-       } else {
-           PuppetDialog::warning(Core::ICore::dialogParent(),
-                                 tr("Wrong QML Puppet Executable Version"),
-                                 missingQmlPuppetErrorMessage(tr("The QML Puppet version is incompatible with the Qt Creator version.")),
-                                 copyAndPasterMessage(pathToQt)
-                                 );
-           QmlDesignerPlugin::instance()->switchToTextModeDeferred();
+           m_qmlPuppetRenderProcess->waitForStarted();
+           connect(m_qmlPuppetRenderProcess.data(), SIGNAL(finished(int)), m_qmlPuppetRenderProcess.data(),SLOT(deleteLater()));
       }
+
+       if (!m_localServer->hasPendingConnections())
+           m_localServer->waitForNewConnection(10000);
+
+       m_firstSocket = m_localServer->nextPendingConnection();
+       connect(m_firstSocket.data(), SIGNAL(readyRead()), this, SLOT(readFirstDataStream()));
+
+       if (runModus == NormalModus) {
+           if (!m_localServer->hasPendingConnections())
+               m_localServer->waitForNewConnection(10000);
+
+           m_secondSocket = m_localServer->nextPendingConnection();
+           connect(m_secondSocket.data(), SIGNAL(readyRead()), this, SLOT(readSecondDataStream()));
+
+           if (!m_localServer->hasPendingConnections())
+               m_localServer->waitForNewConnection(10000);
+
+           m_thirdSocket = m_localServer->nextPendingConnection();
+           connect(m_thirdSocket.data(), SIGNAL(readyRead()), this, SLOT(readThirdDataStream()));
+       }
+
   } else {
-       PuppetDialog::warning(Core::ICore::dialogParent(),
-                             tr("Cannot Find QML Puppet Executable"),
-                             missingQmlPuppetErrorMessage(tr("The executable of the QML Puppet process (<code>%1</code>) cannot be found. "
-                                                             "Check your installation. "
-                                                            "QML Puppet is a process which runs in the background to render the items.").
-                                                         arg(QDir::toNativeSeparators(applicationPath))),
-                             copyAndPasterMessage(pathToQt));
+       QMessageBox::warning(Core::ICore::dialogParent(),
+                            tr("Cannot Start QML Puppet Executable"),
+                            tr("The executable of the QML Puppet process (%1) cannot be started."));
+
       QmlDesignerPlugin::instance()->switchToTextModeDeferred();
   }

+   m_localServer->close();
+
+
   int indexOfCapturePuppetStream = QCoreApplication::arguments().indexOf("-capture-puppet-stream");
   if (indexOfCapturePuppetStream > 0) {
       m_captureFileForTest.setFileName(QCoreApplication::arguments().at(indexOfCapturePuppetStream + 1));
@@ -400,77 +257,6 @@ NodeInstanceClientInterface *NodeInstanceServerProxy::nodeInstanceClient() const
    return m_nodeInstanceView.data();
 }

-static QString generatePuppetCompilingHelp(const QString &puppetName, const QString &pathToQt)
-{
-
-    QString buildDirectory =  QDir::toNativeSeparators(QDir::cleanPath(QDir::tempPath() + QStringLiteral("/") + puppetName));
-    QString qmakePath = QDir::toNativeSeparators(QDir::cleanPath(pathToQt + QStringLiteral("/bin/qmake -r ")));
-    QString projectPath = QDir::toNativeSeparators(QDir::cleanPath(sharedDirPath() + QStringLiteral("/qml/qmlpuppet/%1/%1.pro\n")));
-
-    QString puppetCompileHelp;
-
-    puppetCompileHelp.append(QStringLiteral("<p><code><pre>"));
-    puppetCompileHelp.append(QStringLiteral("<form><input></input></form>"));
-    puppetCompileHelp.append(QStringLiteral("mkdir ") + buildDirectory+ QStringLiteral("\n"));
-    puppetCompileHelp.append(QStringLiteral("cd ") + buildDirectory + QStringLiteral("\n"));
-    puppetCompileHelp.append(qmakePath + projectPath);
-    puppetCompileHelp.append(QStringLiteral("make"));
-    puppetCompileHelp.append(QStringLiteral("</pre></code></p>"));
-
-    puppetCompileHelp = puppetCompileHelp.arg(puppetName);
-
-    return puppetCompileHelp;
-}
-
-static void formatQmlPuppetCompilationMessage(const QString &puppetName,
-                                              const QString &sharedDirPath,
-                                              QTextStream &messageStream)
-{
-    const QString sourcePath = sharedDirPath + QStringLiteral("/qml/qmlpuppet/") + puppetName + QLatin1Char('/');
-
-    //: %1 Puppet binary name ("qmlpuppet", "qml2puppet"), %2 source path.
-    messageStream << QChar(' ') << NodeInstanceServerProxy::tr("You can build <code>%1</code> yourself with Qt 5.2.0 or higher. "
-                                                 "The source can be found in <code>%2</code>.")
-                     .arg(puppetName, QDir::toNativeSeparators(sourcePath))
-                  << QChar(' ') << NodeInstanceServerProxy::tr("<code>%1</code> will be installed to the <code>bin</code> directory of your Qt version. "
-                                                 "Qt Quick Designer will check the <code>bin</code> directory of the currently active Qt version "
-                                                 "of your project.").arg(puppetName);
-}
-
-QString NodeInstanceServerProxy::missingQmlPuppetErrorMessage(const QString &preMessage) const
-{
-    QString message;
-    QTextStream messageStream(&message);
-
-    messageStream << QStringLiteral("<html><head/><body><p>")
-                  << preMessage;
-
-    if (hasQtQuick2(m_nodeInstanceView.data()))
-        formatQmlPuppetCompilationMessage(QStringLiteral("qml2puppet"), sharedDirPath(), messageStream);
-    else if (hasQtQuick1(m_nodeInstanceView.data()))
-        formatQmlPuppetCompilationMessage(QStringLiteral("qmlpuppet"), sharedDirPath(), messageStream);
-
-    messageStream << QStringLiteral("</p></body></html>");
-
-    return message;
-}
-
-QString NodeInstanceServerProxy::copyAndPasterMessage(const QString &pathToQt) const
-{
-    QString message;
-    QTextStream messageStream(&message);
-    messageStream << QStringLiteral("<html><head/><body>");
-
-    if (hasQtQuick2(m_nodeInstanceView.data()))
-        messageStream << generatePuppetCompilingHelp(QStringLiteral("qmlpuppet2"), pathToQt);
-    else if (hasQtQuick1(m_nodeInstanceView.data()))
-        messageStream << generatePuppetCompilingHelp(QStringLiteral("qmlpuppet"), pathToQt);
-
-    messageStream << QStringLiteral("</body></html>");
-
-    return message;
-}
-
 static void writeCommandToIODecive(const QVariant &command, QIODevice *ioDevice, unsigned int commandCounter)
 {
    if (ioDevice) {
@@ -685,26 +471,6 @@ void NodeInstanceServerProxy::printRenderProcessOutput()
    qDebug() << "\n";
 }

-QString NodeInstanceServerProxy::qmlPuppetApplicationName() const
-{
-    if (hasQtQuick2(m_nodeInstanceView.data()))
-        return QLatin1String("qml2puppet" QTC_HOST_EXE_SUFFIX);
-    return QLatin1String("qmlpuppet" QTC_HOST_EXE_SUFFIX);
-}
-
-QString NodeInstanceServerProxy::macOSBundlePath(const QString &path) const
-{
-    QString applicationPath = path;
-    if (Utils::HostOsInfo::isMacHost()) {
-        if (hasQtQuick2(m_nodeInstanceView.data()))
-            applicationPath += QLatin1String("/qml2puppet.app/Contents/MacOS");
-        else
-            applicationPath += QLatin1String("/qmlpuppet.app/Contents/MacOS");
-
-    }
-   return applicationPath;
-}
-
 void NodeInstanceServerProxy::createInstances(const CreateInstancesCommand &command)
 {
    writeCommand(QVariant::fromValue(command));
@@ -79,12 +79,6 @@ protected:
    void writeCommand(const QVariant &command);
    void dispatchCommand(const QVariant &command);
    NodeInstanceClientInterface *nodeInstanceClient() const;
-    QString missingQmlPuppetErrorMessage(const QString &preMessage) const;
-    QString copyAndPasterMessage(const QString &pathToQt) const;
-    QString qmlPuppetApplicationName() const;
-    QString macOSBundlePath(const QString &path) const;
-    QString creatorQmlPuppetPath();
-    static bool checkPuppetVersion(const QString &qmlPuppetPath);

 signals:
    void processCrashed();
@@ -0,0 +1,330 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of Qt Creator.
+**
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+****************************************************************************/
+
+#include "puppetcreator.h"
+
+#include <QProcess>
+#include <QTemporaryDir>
+#include <QCoreApplication>
+#include <QCryptographicHash>
+
+#include <projectexplorer/kit.h>
+#include <projectexplorer/toolchain.h>
+#include <utils/environment.h>
+#include <coreplugin/icore.h>
+#include <qtsupport/baseqtversion.h>
+#include <qtsupport/qtkitinformation.h>
+#include <qtsupport/qtsupportconstants.h>
+
+#include <QtDebug>
+
+namespace QmlDesigner {
+
+bool PuppetCreator::m_useOnlyFallbackPuppet = !qgetenv("USE_ONLY_FALLBACK_PUPPET").isEmpty();
+
+static QByteArray getQtHash(ProjectExplorer::Kit *kit)
+{
+    QtSupport::BaseQtVersion *currentQtVersion = QtSupport::QtKitInformation::qtVersion(kit);
+    if (currentQtVersion)
+        return QCryptographicHash::hash(currentQtVersion->qmakeProperty("QT_INSTALL_DATA").toUtf8(), QCryptographicHash::Sha1).toBase64(QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);
+
+    return QByteArray();
+}
+
+PuppetCreator::PuppetCreator(ProjectExplorer::Kit *kit, const QString &qtCreatorVersion)
+    : m_qtCreatorVersion(qtCreatorVersion),
+      m_kit(kit)
+{
+}
+
+QProcess *PuppetCreator::createPuppetProcess(PuppetCreator::QmlPuppetVersion puppetVersion, const QString &puppetMode, const QString &socketToken, QObject *handlerObject, const char *outputSlot, const char *finishSlot) const
+{
+    if (puppetVersion == Qml1Puppet)
+        return qmlpuppetProcess(puppetMode, socketToken, handlerObject, outputSlot, finishSlot);
+    else
+        return qml2puppetProcess(puppetMode, socketToken, handlerObject, outputSlot, finishSlot);
+}
+
+
+QProcess *PuppetCreator::puppetProcess(const QString &puppetPath,
+                                       const QString &puppetMode,
+                                       const QString &socketToken,
+                                       QObject *handlerObject,
+                                       const char *outputSlot,
+                                       const char *finishSlot) const
+{
+    QProcess *puppetProcess = new QProcess;
+    puppetProcess->setObjectName(puppetMode);
+    puppetProcess->setProcessEnvironment(processEnvironment());
+    QObject::connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), puppetProcess, SLOT(kill()));
+    QObject::connect(puppetProcess, SIGNAL(finished(int,QProcess::ExitStatus)), handlerObject, finishSlot);
+    bool fowardQmlpuppetOutput = !qgetenv("FORWARD_QMLPUPPET_OUTPUT").isEmpty();
+    if (fowardQmlpuppetOutput) {
+        puppetProcess->setProcessChannelMode(QProcess::MergedChannels);
+        QObject::connect(puppetProcess, SIGNAL(readyRead()), handlerObject, outputSlot);
+    }
+    puppetProcess->start(puppetPath, QStringList() << socketToken << puppetMode << "-graphicssystem raster");
+
+    return puppetProcess;
+}
+
+QProcess *PuppetCreator::qmlpuppetProcess(const QString &puppetMode,
+                                          const QString &socketToken,
+                                          QObject *handlerObject,
+                                          const char *outputSlot,
+                                          const char *finishSlot) const
+{
+    Puppetype puppetType ;
+
+    if (!m_useOnlyFallbackPuppet && m_kit) {
+        if (checkQmlpuppetIsReady()) {
+            puppetType = UserSpacePuppet;
+        } else {
+            bool buildSucceeded = build(qmlpuppetProjectFile());
+            if (buildSucceeded)
+                puppetType = UserSpacePuppet;
+            else
+                puppetType = FallbackPuppet;
+        }
+    } else {
+        puppetType = FallbackPuppet;
+    }
+
+    return puppetProcess(qmlpuppetPath(puppetType),
+                         puppetMode,
+                         socketToken,
+                         handlerObject,
+                         outputSlot,
+                         finishSlot);
+}
+
+QProcess *PuppetCreator::qml2puppetProcess(const QString &puppetMode,
+                                           const QString &socketToken,
+                                           QObject *handlerObject,
+                                           const char *outputSlot,
+                                           const char *finishSlot) const
+{
+    Puppetype puppetType ;
+
+    if (!m_useOnlyFallbackPuppet && m_kit) {
+        if (checkQml2puppetIsReady()) {
+            puppetType = UserSpacePuppet;
+        } else {
+            bool buildSucceeded = build(qml2puppetProjectFile());
+            if (buildSucceeded)
+                puppetType = UserSpacePuppet;
+            else
+                puppetType = FallbackPuppet;
+        }
+    } else {
+        puppetType = FallbackPuppet;
+    }
+
+    return puppetProcess(qml2puppetPath(puppetType),
+                         puppetMode,
+                         socketToken,
+                         handlerObject,
+                         outputSlot,
+                         finishSlot);
+}
+
+bool PuppetCreator::build(const QString &qmlPuppetProjectFilePath) const
+{
+    m_compileLog.clear();
+
+    QTemporaryDir buildDirectory;
+
+    bool buildSucceeded = false;
+
+    if (qtIsSupported()) {
+        if (buildDirectory.isValid()) {
+            QStringList qmakeArguments;
+            qmakeArguments.append(QStringLiteral("-r"));
+            qmakeArguments.append(QStringLiteral("DESTDIR=") + qmlpuppetDirectory(UserSpacePuppet));
+            qmakeArguments.append(qmlPuppetProjectFilePath);
+            buildSucceeded = startBuildProcess(buildDirectory.path(), qmakeCommand(), qmakeArguments);
+            if (buildSucceeded)
+                buildSucceeded = startBuildProcess(buildDirectory.path(), buildCommand());
+        } else {
+            buildSucceeded = true;
+        }
+    }
+
+    m_useOnlyFallbackPuppet = !buildSucceeded;  // fall back to creator puppet and don't compile again
+
+    return buildSucceeded;
+}
+
+QString PuppetCreator::qmlpuppetDirectory(Puppetype puppetType) const
+{
+
+    if (puppetType == UserSpacePuppet)
+        return Core::ICore::userResourcePath()
+                + QStringLiteral("/qmlpuppet/")
+                + QCoreApplication::applicationVersion() + QStringLiteral("/")
+                + getQtHash(m_kit);
+
+
+    return qmlpuppetFallbackDirectory();
+}
+
+QString PuppetCreator::qmlpuppetFallbackDirectory() const
+{
+    return QCoreApplication::applicationDirPath();
+}
+
+QString PuppetCreator::qml2puppetPath(Puppetype puppetType) const
+{
+    return qmlpuppetDirectory(puppetType) + QStringLiteral("/qml2puppet") + QStringLiteral(QTC_HOST_EXE_SUFFIX);
+}
+
+QString PuppetCreator::qmlpuppetPath(Puppetype puppetType) const
+{
+    return qmlpuppetDirectory(puppetType) + QStringLiteral("/qmlpuppet") + QStringLiteral(QTC_HOST_EXE_SUFFIX);
+}
+
+QProcessEnvironment PuppetCreator::processEnvironment() const
+{
+    Utils::Environment environment = Utils::Environment::systemEnvironment();
+    m_kit->addToEnvironment(environment);
+
+    return environment.toProcessEnvironment();
+}
+
+QString PuppetCreator::buildCommand() const
+{
+    Utils::Environment environment = Utils::Environment::systemEnvironment();
+    m_kit->addToEnvironment(environment);
+
+    ProjectExplorer::ToolChain *toolChain = ProjectExplorer::ToolChainKitInformation::toolChain(m_kit);
+
+    if (toolChain)
+        return toolChain->makeCommand(environment);
+
+    return QString();
+}
+
+QString PuppetCreator::qmakeCommand() const
+{
+    QtSupport::BaseQtVersion *currentQtVersion = QtSupport::QtKitInformation::qtVersion(m_kit);
+    if (currentQtVersion)
+        return currentQtVersion->qmakeCommand().toString();
+
+    return QString();
+}
+
+QString PuppetCreator::compileLog() const
+{
+    return m_compileLog;
+}
+
+bool PuppetCreator::startBuildProcess(const QString &buildDirectoryPath,
+                                      const QString &command,
+                                      const QStringList &processArguments) const
+{
+    if (command.isEmpty())
+        return false;
+
+    QProcess process;
+    process.setProcessChannelMode(QProcess::MergedChannels);
+    process.setProcessEnvironment(processEnvironment());
+    process.setWorkingDirectory(buildDirectoryPath);
+    process.start(command, processArguments);
+    process.waitForFinished(-1);
+    m_compileLog.append(process.readAllStandardOutput());
+
+    if (process.exitStatus() == QProcess::NormalExit || process.exitCode() == 0)
+        return true;
+    else
+        return false;
+}
+
+QString PuppetCreator::puppetSourceDirectoryPath()
+{
+    return Core::ICore::resourcePath() + QStringLiteral("/qml/qmlpuppet");
+}
+
+QString PuppetCreator::qml2puppetProjectFile()
+{
+    return puppetSourceDirectoryPath() + QStringLiteral("/qml2puppet/qml2puppet.pro");
+}
+
+QString PuppetCreator::qmlpuppetProjectFile()
+{
+    return puppetSourceDirectoryPath() + QStringLiteral("/qmlpuppet/qmlpuppet.pro");
+}
+
+bool PuppetCreator::checkPuppetIsReady(const QString &puppetPath) const
+{
+    QFileInfo puppetFileInfo(puppetPath);
+
+    return puppetFileInfo.exists(); // && checkPuppetVersion(puppetPath);
+}
+
+bool PuppetCreator::checkQml2puppetIsReady() const
+{
+    return checkPuppetIsReady(qml2puppetPath(UserSpacePuppet));
+}
+
+bool PuppetCreator::checkQmlpuppetIsReady() const
+{
+    return checkPuppetIsReady(qmlpuppetPath(UserSpacePuppet));
+}
+
+bool PuppetCreator::qtIsSupported() const
+{
+    QtSupport::BaseQtVersion *currentQtVersion = QtSupport::QtKitInformation::qtVersion(m_kit);
+
+    if (currentQtVersion
+            && currentQtVersion->isValid()
+            && currentQtVersion->qtVersion() >= QtSupport::QtVersionNumber(5, 2, 0)
+            && (currentQtVersion->type() == QLatin1String(QtSupport::Constants::DESKTOPQT)
+                || currentQtVersion->type() == QLatin1String(QtSupport::Constants::SIMULATORQT)))
+        return true;
+
+    return false;
+}
+
+bool PuppetCreator::checkPuppetVersion(const QString &qmlPuppetPath)
+{
+
+    QProcess qmlPuppetVersionProcess;
+    qmlPuppetVersionProcess.start(qmlPuppetPath, QStringList() << "--version");
+    qmlPuppetVersionProcess.waitForReadyRead(6000);
+
+    QByteArray versionString = qmlPuppetVersionProcess.readAll();
+
+    bool canConvert;
+    unsigned int versionNumber = versionString.toUInt(&canConvert);
+
+    return canConvert && versionNumber == 2;
+
+}
+
+} // namespace QmlDesigner
@@ -0,0 +1,120 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of Qt Creator.
+**
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+****************************************************************************/
+
+#ifndef QMLDESIGNER_PUPPETCREATOR_H
+#define QMLDESIGNER_PUPPETCREATOR_H
+
+#include <QString>
+#include <QProcessEnvironment>
+
+namespace ProjectExplorer {
+class Kit;
+}
+
+namespace QmlDesigner {
+
+class PuppetCreator
+{
+    enum Puppetype {
+        FallbackPuppet,
+        UserSpacePuppet
+    };
+
+public:
+    enum QmlPuppetVersion {
+        Qml1Puppet,
+        Qml2Puppet
+    };
+
+    PuppetCreator(ProjectExplorer::Kit *kit, const QString &qtCreatorVersion);
+
+    QProcess *createPuppetProcess(QmlPuppetVersion puppetVersion,
+                                  const QString &puppetMode,
+                                  const QString &socketToken,
+                                  QObject *handlerObject,
+                                  const char *outputSlot,
+                                  const char *finishSlot) const;
+
+    QString compileLog() const;
+
+protected:
+    bool build(const QString &qmlPuppetProjectFilePath) const;
+
+    QString qmlpuppetDirectory(Puppetype puppetPathType) const;
+    QString qmlpuppetFallbackDirectory() const;
+    QString qml2puppetPath(Puppetype puppetType) const;
+    QString qmlpuppetPath(Puppetype puppetPathType) const;
+
+    bool startBuildProcess(const QString &buildDirectoryPath,
+                           const QString &command,
+                           const QStringList &processArguments = QStringList()) const;
+    static QString puppetSourceDirectoryPath();
+    static QString qml2puppetProjectFile();
+    static QString qmlpuppetProjectFile();
+
+    bool checkPuppetIsReady(const QString &puppetPath) const;
+    bool checkQml2puppetIsReady() const;
+    bool checkQmlpuppetIsReady() const;
+    bool qtIsSupported() const;
+    static bool checkPuppetVersion(const QString &qmlPuppetPath);
+    QProcess *puppetProcess(const QString &puppetPath,
+                            const QString &puppetMode,
+                            const QString &socketToken,
+                            QObject *handlerObject,
+                            const char *outputSlot,
+                            const char *finishSlot) const;
+
+    QProcess *qmlpuppetProcess(const QString &puppetMode,
+                               const QString &socketToken,
+                               QObject *handlerObject,
+                               const char *outputSlot,
+                               const char *finishSlot) const;
+
+    QProcess *qml2puppetProcess(const QString &puppetMode,
+                                const QString &socketToken,
+                                QObject *handlerObject,
+                                const char *outputSlot,
+                                const char *finishSlot) const;
+
+    QProcessEnvironment processEnvironment() const;
+
+    QString buildCommand() const;
+    QString qmakeCommand() const;
+
+private:
+    QString m_qtCreatorVersion;
+    mutable QString m_compileLog;
+    ProjectExplorer::Kit *m_kit;
+    static bool m_useOnlyFallbackPuppet;
+
+};
+
+} // namespace QmlDesigner
+
+#endif // QMLDESIGNER_PUPPETCREATOR_H
@@ -4,25 +4,8 @@ TEMPLATE = app

 include(../../../../qtcreator.pri)

-BUILD_PUPPET_IN_CREATOR_BINPATH = $$(BUILD_PUPPET_IN_CREATOR_BINPATH)
-CONFIG(debug, debug|release):isEmpty(BUILD_PUPPET_IN_CREATOR_BINPATH) {
-    QML_TARGET_PATH=$$[QT_INSTALL_BINS]/$$TARGET$$TARGET_EXT
-    if(write_file($$QML_TARGET_PATH)) {
-        CONVERTED_PATH=$$system_quote($$system_path($$QML_TARGET_PATH))
-        win32 {
-            system(del $$CONVERTED_PATH)
-        } else {
-            system(rm $$CONVERTED_PATH)
-        }
-        DESTDIR = $$[QT_INSTALL_BINS]
-        message("Build Qml Puppet to the Qt binary directory!")
-    } else {
-        message("Cannot create write Qml Puppet to the Qt binary directory!")
-    }
-} else {
-    DESTDIR = $$IDE_BIN_PATH
-    message("Build Qml Puppet to Qt Creator binary directory!")
-}
+DESTDIR = $$IDE_BIN_PATH
+
 include(../../../rpath.pri)

 include(../../../../share/qtcreator/qml/qmlpuppet/qml2puppet/qml2puppet.pri)