nodeinstanceserverproxy.cpp 25.7 KB
Newer Older
hjk's avatar
hjk committed
1
/****************************************************************************
2
**
3
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
hjk's avatar
hjk committed
4
** Contact: http://www.qt-project.org/legal
5
**
hjk's avatar
hjk committed
6
** This file is part of Qt Creator.
7
**
hjk's avatar
hjk committed
8 9 10 11 12 13 14
** 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.
15 16
**
** GNU Lesser General Public License Usage
hjk's avatar
hjk committed
17 18 19 20 21 22 23 24 25
** 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
26 27
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
hjk's avatar
hjk committed
28
****************************************************************************/
29

30 31 32 33 34 35 36
#include "nodeinstanceserverproxy.h"

#include <QLocalServer>
#include <QLocalSocket>
#include <QProcess>
#include <QCoreApplication>
#include <QUuid>
37
#include <QFileInfo>
38
#include <QDir>
39
#include <QTimer>
40
#include <QTextStream>
41
#include <QMessageBox>
42 43 44 45 46

#include "createinstancescommand.h"
#include "createscenecommand.h"
#include "changevaluescommand.h"
#include "changebindingscommand.h"
47
#include "changeauxiliarycommand.h"
48 49 50 51 52 53 54
#include "changefileurlcommand.h"
#include "removeinstancescommand.h"
#include "clearscenecommand.h"
#include "removepropertiescommand.h"
#include "reparentinstancescommand.h"
#include "changeidscommand.h"
#include "changestatecommand.h"
55
#include "completecomponentcommand.h"
56
#include "changenodesourcecommand.h"
57 58 59 60

#include "informationchangedcommand.h"
#include "pixmapchangedcommand.h"
#include "valueschangedcommand.h"
61
#include "childrenchangedcommand.h"
62
#include "statepreviewimagechangedcommand.h"
63
#include "componentcompletedcommand.h"
64
#include "tokencommand.h"
65
#include "removesharedmemorycommand.h"
66
#include "endpuppetcommand.h"
67
#include "synchronizecommand.h"
Marco Bubke's avatar
Marco Bubke committed
68
#include "debugoutputcommand.h"
69

70
#include "nodeinstanceview.h"
71 72

#include "import.h"
73

74 75
#include "qmldesignerplugin.h"

76 77
#include <utils/hostosinfo.h>

78 79
#include <QMessageBox>

80
namespace {
81
#ifdef Q_OS_MAC
82
#  define SHARE_PATH "/../Resources"
83
#else
84
#  define SHARE_PATH "/../share/qtcreator"
85 86 87 88 89 90 91 92 93 94 95 96 97 98
#endif

static QString applicationDirPath()
{
    return QCoreApplication::applicationDirPath();
}

static inline QString sharedDirPath()
{
    QString appPath = applicationDirPath();

    return QFileInfo(appPath + SHARE_PATH).absoluteFilePath();
}

99 100
static QLatin1String qmlPuppetApplicationDirectoryForTests()
{
101 102 103
    if (Utils::HostOsInfo::isWindowsHost())
        //one more - debug/release dir
        return QLatin1String("/../../../../../../bin/");
104 105 106
    return QLatin1String("/../../../../../bin/");
}
} //namespace
107 108 109

namespace QmlDesigner {

110
static bool hasQtQuick2(NodeInstanceView *nodeInstanceView)
111 112 113
{
    if (nodeInstanceView && nodeInstanceView->model()) {
        foreach (const Import &import ,nodeInstanceView->model()->imports()) {
114
            if (import.url() ==  "QtQuick" && import.version().toDouble() >= 2.0)
115 116 117 118 119 120 121
                return true;
        }
    }

    return false;
}

122 123 124 125 126 127 128 129 130
QString NodeInstanceServerProxy::creatorQmlPuppetPath()
{
    QString applicationPath =  QCoreApplication::applicationDirPath();
    applicationPath = macOSBundlePath(applicationPath);
    applicationPath += QLatin1Char('/') + qmlPuppetApplicationName();

    return applicationPath;
}

131 132 133 134 135 136 137 138 139 140 141
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);

142
    return canConvert && versionNumber == 3;
143 144
}

145
NodeInstanceServerProxy::NodeInstanceServerProxy(NodeInstanceView *nodeInstanceView, RunModus runModus, const QString &pathToQt)
146 147 148
    : NodeInstanceServerInterface(nodeInstanceView),
      m_localServer(new QLocalServer(this)),
      m_nodeInstanceView(nodeInstanceView),
149
      m_firstBlockSize(0),
150
      m_secondBlockSize(0),
151
      m_thirdBlockSize(0),
152 153 154 155
      m_writeCommandCounter(0),
      m_firstLastReadCommandCounter(0),
      m_secondLastReadCommandCounter(0),
      m_thirdLastReadCommandCounter(0),
156 157
      m_runModus(runModus),
      m_synchronizeId(-1)
158
{
159 160
   QString applicationPath =  pathToQt + QLatin1String("/bin");
   if (runModus == TestModus) {
161
       applicationPath = QCoreApplication::applicationDirPath()
162 163
           + qmlPuppetApplicationDirectoryForTests()
           + qmlPuppetApplicationName();
164
   } else {
165
       applicationPath = macOSBundlePath(applicationPath);
Robert Loehning's avatar
Robert Loehning committed
166
       applicationPath += QLatin1Char('/') + qmlPuppetApplicationName();
167 168 169


#if defined(QT_NO_DEBUG) || defined(SEARCH_PUPPET_IN_CREATOR_BINPATH) // to prevent of choosing the wrong puppet in debug
170 171
       if (!QFileInfo(applicationPath).exists()) { //No qmlpuppet in Qt
           //We have to find out how to give not too intrusive feedback
172
           applicationPath = creatorQmlPuppetPath();
173
       }
174
#endif
175
   }
176

177

178
   QByteArray envImportPath = qgetenv("QTCREATOR_QMLPUPPET_PATH");
179
   if (!envImportPath.isEmpty())
180 181
       applicationPath = envImportPath;

182
   QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
183

184
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0)) && (defined(Q_OS_MAC) || defined(Q_OS_LINUX))
Laurent Montel's avatar
Laurent Montel committed
185
   environment.insert(QLatin1String("DESIGNER_DONT_USE_SHARED_MEMORY"), QLatin1String("1"));
186 187
#endif

188
   if (QFileInfo(applicationPath).exists()) {
189
       if (checkPuppetVersion(applicationPath)) {
190 191 192 193
           QString socketToken(QUuid::createUuid().toString());
           m_localServer->listen(socketToken);
           m_localServer->setMaxPendingConnections(3);

194 195 196 197 198 199
           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();
200
           if (fowardQmlpuppetOutput) {
201 202
               m_qmlPuppetEditorProcess->setProcessChannelMode(QProcess::MergedChannels);
               connect(m_qmlPuppetEditorProcess.data(), SIGNAL(readyRead()), this, SLOT(printEditorProcessOutput()));
203
           }
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
           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");
228

229
           }
230

231
           connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), this, SLOT(deleteLater()));
232

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

236 237 238
               if (runModus == NormalModus) {
                   m_qmlPuppetPreviewProcess->waitForStarted();
                   connect(m_qmlPuppetPreviewProcess.data(), SIGNAL(finished(int)), m_qmlPuppetPreviewProcess.data(),SLOT(deleteLater()));
239

240 241 242
                   m_qmlPuppetRenderProcess->waitForStarted();
                   connect(m_qmlPuppetRenderProcess.data(), SIGNAL(finished(int)), m_qmlPuppetRenderProcess.data(),SLOT(deleteLater()));
               }
243

244 245
               if (!m_localServer->hasPendingConnections())
                   m_localServer->waitForNewConnection(10000);
246

247 248
               m_firstSocket = m_localServer->nextPendingConnection();
               connect(m_firstSocket.data(), SIGNAL(readyRead()), this, SLOT(readFirstDataStream()));
249

250 251 252
               if (runModus == NormalModus) {
                   if (!m_localServer->hasPendingConnections())
                       m_localServer->waitForNewConnection(10000);
253

254 255
                   m_secondSocket = m_localServer->nextPendingConnection();
                   connect(m_secondSocket.data(), SIGNAL(readyRead()), this, SLOT(readSecondDataStream()));
256

257 258
                   if (!m_localServer->hasPendingConnections())
                       m_localServer->waitForNewConnection(10000);
259

260 261 262
                   m_thirdSocket = m_localServer->nextPendingConnection();
                   connect(m_thirdSocket.data(), SIGNAL(readyRead()), this, SLOT(readThirdDataStream()));
               }
263

264 265 266 267 268 269
           } else {
               QMessageBox::warning(0, tr("Cannot Start QML Puppet Executable"),
                                    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));
270 271

               QmlDesignerPlugin::instance()->switchToTextModeDeferred();
272
           }
273

274
           m_localServer->close();
275

276
       } else {
277
           QMessageBox::warning(0, tr("Wrong QML Puppet Executable Version"), tr("The QML Puppet version is incompatible with the Qt Creator version."));
278
           QmlDesignerPlugin::instance()->switchToTextModeDeferred();
279 280
       }
   } else {
281
           QMessageBox::warning(0, tr("Cannot Find QML Puppet Executable"), missingQmlPuppetErrorMessage(applicationPath));
282
           QmlDesignerPlugin::instance()->switchToTextModeDeferred();
283
   }
284 285 286 287 288 289 290

   int indexOfCapturePuppetStream = QCoreApplication::arguments().indexOf("-capture-puppet-stream");
   if (indexOfCapturePuppetStream > 0) {
       m_captureFileForTest.setFileName(QCoreApplication::arguments().at(indexOfCapturePuppetStream + 1));
       bool isOpen = m_captureFileForTest.open(QIODevice::WriteOnly);
       qDebug() << "file is open: " << isOpen;
   }
291 292 293 294
}

NodeInstanceServerProxy::~NodeInstanceServerProxy()
{
295 296
    disconnect(this, SLOT(processFinished(int,QProcess::ExitStatus)));

297 298
    writeCommand(QVariant::fromValue(EndPuppetCommand()));

299 300 301 302 303 304
    if (m_firstSocket)
        m_firstSocket->close();

    if (m_secondSocket)
        m_secondSocket->close();

305
    if (m_thirdSocket)
306 307
        m_thirdSocket->close();

308

309
    if (m_qmlPuppetEditorProcess)
310
        QTimer::singleShot(3000, m_qmlPuppetEditorProcess.data(), SLOT(terminate()));
311

312
    if (m_qmlPuppetPreviewProcess)
313
        QTimer::singleShot(3000, m_qmlPuppetPreviewProcess.data(), SLOT(terminate()));
314 315

    if (m_qmlPuppetRenderProcess)
316
         QTimer::singleShot(3000, m_qmlPuppetRenderProcess.data(), SLOT(terminate()));
317 318 319 320 321 322 323
}

void NodeInstanceServerProxy::dispatchCommand(const QVariant &command)
{
    static const int informationChangedCommandType = QMetaType::type("InformationChangedCommand");
    static const int valuesChangedCommandType = QMetaType::type("ValuesChangedCommand");
    static const int pixmapChangedCommandType = QMetaType::type("PixmapChangedCommand");
324
    static const int childrenChangedCommandType = QMetaType::type("ChildrenChangedCommand");
325
    static const int statePreviewImageChangedCommandType = QMetaType::type("StatePreviewImageChangedCommand");
326
    static const int componentCompletedCommandType = QMetaType::type("ComponentCompletedCommand");
327
    static const int synchronizeCommandType = QMetaType::type("SynchronizeCommand");
328
    static const int tokenCommandType = QMetaType::type("TokenCommand");
Marco Bubke's avatar
Marco Bubke committed
329
    static const int debugOutputCommandType = QMetaType::type("DebugOutputCommand");
330

331
    if (command.userType() ==  informationChangedCommandType) {
332
        nodeInstanceClient()->informationChanged(command.value<InformationChangedCommand>());
333
    } else if (command.userType() ==  valuesChangedCommandType) {
334
        nodeInstanceClient()->valuesChanged(command.value<ValuesChangedCommand>());
335
    } else if (command.userType() ==  pixmapChangedCommandType) {
336
        nodeInstanceClient()->pixmapChanged(command.value<PixmapChangedCommand>());
337
    } else if (command.userType() == childrenChangedCommandType) {
338
        nodeInstanceClient()->childrenChanged(command.value<ChildrenChangedCommand>());
339
    } else if (command.userType() == statePreviewImageChangedCommandType) {
340
        nodeInstanceClient()->statePreviewImagesChanged(command.value<StatePreviewImageChangedCommand>());
341
    } else if (command.userType() == componentCompletedCommandType) {
342
        nodeInstanceClient()->componentCompleted(command.value<ComponentCompletedCommand>());
343
    } else if (command.userType() == tokenCommandType) {
344
        nodeInstanceClient()->token(command.value<TokenCommand>());
345
    } else if (command.userType() == debugOutputCommandType) {
Marco Bubke's avatar
Marco Bubke committed
346
        nodeInstanceClient()->debugOutput(command.value<DebugOutputCommand>());
347
    } else if (command.userType() == synchronizeCommandType) {
348 349 350
        SynchronizeCommand synchronizeCommand = command.value<SynchronizeCommand>();
        m_synchronizeId = synchronizeCommand.synchronizeId();
    }  else
351 352 353 354 355 356 357 358
        Q_ASSERT(false);
}

NodeInstanceClientInterface *NodeInstanceServerProxy::nodeInstanceClient() const
{
    return m_nodeInstanceView.data();
}

359 360
QString NodeInstanceServerProxy::missingQmlPuppetErrorMessage(const QString &applicationPath) const
{
361 362 363 364 365 366 367 368
    QString message;
    QTextStream str(&message);
    str << "<html><head/><body><p>"
        << 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))
        << "</p>";
369
    if (hasQtQuick2(m_nodeInstanceView.data())) {
370 371 372 373 374 375 376 377 378
        str << "<p>"
            << tr("You can build <code>qml2puppet</code> yourself with Qt 5.0.1 or higher. "
                 "The source can be found in <code>%1</code>.").
               arg(QDir::toNativeSeparators(sharedDirPath() + QLatin1String("/qml/qmlpuppet/qml2puppet/")))
            << "</p><p>"
            << tr("<code>qml2puppet</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.")
            << "</p>";
379
    }
380
    str << "</p></body></html>";
381 382 383
    return message;
}

384
static void writeCommandToIODecive(const QVariant &command, QIODevice *ioDevice, unsigned int commandCounter)
385
{
386
    if (ioDevice) {
387 388
        QByteArray block;
        QDataStream out(&block, QIODevice::WriteOnly);
389
        out.setVersion(QDataStream::Qt_4_8);
390
        out << quint32(0);
391
        out << quint32(commandCounter);
392 393 394 395
        out << command;
        out.device()->seek(0);
        out << quint32(block.size() - sizeof(quint32));

396
        ioDevice->write(block);
397
    }
398 399 400 401
}

void NodeInstanceServerProxy::writeCommand(const QVariant &command)
{
402 403 404 405 406 407 408 409 410 411
    writeCommandToIODecive(command, m_firstSocket.data(), m_writeCommandCounter);
    writeCommandToIODecive(command, m_secondSocket.data(), m_writeCommandCounter);
    writeCommandToIODecive(command, m_thirdSocket.data(), m_writeCommandCounter);

    if (m_captureFileForTest.isWritable()) {
        qDebug() << "Write strean to file: " << m_captureFileForTest.fileName();
        writeCommandToIODecive(command, &m_captureFileForTest, m_writeCommandCounter);
        qDebug() << "\twrite file: " << m_captureFileForTest.pos();
    }

412
    m_writeCommandCounter++;
413 414 415 416 417
    if (m_runModus == TestModus) {
        static int synchronizeId = 0;
        synchronizeId++;
        SynchronizeCommand synchronizeCommand(synchronizeId);

418
        writeCommandToIODecive(QVariant::fromValue(synchronizeCommand), m_firstSocket.data(), m_writeCommandCounter);
419
        m_writeCommandCounter++;
420

421
        while (m_firstSocket->waitForReadyRead(100)) {
422 423 424 425 426
                readFirstDataStream();
                if (m_synchronizeId == synchronizeId)
                    return;
        }
    }
427 428
}

429
void NodeInstanceServerProxy::processFinished(int /*exitCode*/, QProcess::ExitStatus exitStatus)
430
{
431
    qDebug() << "Process finished:" << sender();
432

433 434 435
    if (m_captureFileForTest.isOpen()) {
        m_captureFileForTest.close();
        m_captureFileForTest.remove();
436 437
        QMessageBox::warning(0, tr("QML Puppet Crashed"), tr("You are recording a puppet stream and the puppet crashed. "
                                                             "It is recommended to reopen the Qt Quick Designer and start again."));
438 439 440
    }


441 442
    writeCommand(QVariant::fromValue(EndPuppetCommand()));

443 444 445 446
    if (m_firstSocket)
        m_firstSocket->close();
    if (m_secondSocket)
        m_secondSocket->close();
447 448 449
    if (m_thirdSocket)
        m_thirdSocket->close();

450 451
    if (exitStatus == QProcess::CrashExit)
        emit processCrashed();
452 453
}

454

455 456 457 458 459 460 461 462 463
void NodeInstanceServerProxy::readFirstDataStream()
{
    QList<QVariant> commandList;

    while (!m_firstSocket->atEnd()) {
        if (m_firstSocket->bytesAvailable() < int(sizeof(quint32)))
            break;

        QDataStream in(m_firstSocket.data());
464
        in.setVersion(QDataStream::Qt_4_8);
465

466
        if (m_firstBlockSize == 0)
467 468 469 470 471
            in >> m_firstBlockSize;

        if (m_firstSocket->bytesAvailable() < m_firstBlockSize)
            break;

472 473 474 475 476 477 478 479
        quint32 commandCounter;
        in >> commandCounter;
        bool commandLost = !((m_firstLastReadCommandCounter == 0 && commandCounter == 0) || (m_firstLastReadCommandCounter + 1 == commandCounter));
        if (commandLost)
            qDebug() << "server command lost: " << m_firstLastReadCommandCounter <<  commandCounter;
        m_firstLastReadCommandCounter = commandCounter;


480 481 482 483 484 485 486 487 488 489 490 491 492
        QVariant command;
        in >> command;
        m_firstBlockSize = 0;

        commandList.append(command);
    }

    foreach (const QVariant &command, commandList) {
        dispatchCommand(command);
    }
}

void NodeInstanceServerProxy::readSecondDataStream()
493 494 495
{
    QList<QVariant> commandList;

496 497
    while (!m_secondSocket->atEnd()) {
        if (m_secondSocket->bytesAvailable() < int(sizeof(quint32)))
498 499
            break;

500
        QDataStream in(m_secondSocket.data());
501
        in.setVersion(QDataStream::Qt_4_8);
502

503
        if (m_secondBlockSize == 0)
504
            in >> m_secondBlockSize;
505

506
        if (m_secondSocket->bytesAvailable() < m_secondBlockSize)
507 508
            break;

509 510 511 512 513 514 515 516
        quint32 commandCounter;
        in >> commandCounter;
        bool commandLost = !((m_secondLastReadCommandCounter == 0 && commandCounter == 0) || (m_secondLastReadCommandCounter + 1 == commandCounter));
        if (commandLost)
            qDebug() << "server command lost: " << m_secondLastReadCommandCounter <<  commandCounter;
        m_secondLastReadCommandCounter = commandCounter;


517 518
        QVariant command;
        in >> command;
519
        m_secondBlockSize = 0;
520 521 522 523 524 525 526 527 528

        commandList.append(command);
    }

    foreach (const QVariant &command, commandList) {
        dispatchCommand(command);
    }
}

529 530 531 532 533 534 535 536 537
void NodeInstanceServerProxy::readThirdDataStream()
{
    QList<QVariant> commandList;

    while (!m_thirdSocket->atEnd()) {
        if (m_thirdSocket->bytesAvailable() < int(sizeof(quint32)))
            break;

        QDataStream in(m_thirdSocket.data());
538
        in.setVersion(QDataStream::Qt_4_8);
539

540
        if (m_thirdBlockSize == 0)
541 542 543 544 545
            in >> m_thirdBlockSize;

        if (m_thirdSocket->bytesAvailable() < m_thirdBlockSize)
            break;

546 547 548 549 550 551 552 553
        quint32 commandCounter;
        in >> commandCounter;
        bool commandLost = !((m_thirdLastReadCommandCounter == 0 && commandCounter == 0) || (m_thirdLastReadCommandCounter + 1 == commandCounter));
        if (commandLost)
            qDebug() << "server command lost: " << m_thirdLastReadCommandCounter <<  commandCounter;
        m_thirdLastReadCommandCounter = commandCounter;


554 555 556 557 558 559 560 561 562 563 564 565
        QVariant command;
        in >> command;
        m_thirdBlockSize = 0;

        commandList.append(command);
    }

    foreach (const QVariant &command, commandList) {
        dispatchCommand(command);
    }
}

566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
void NodeInstanceServerProxy::printEditorProcessOutput()
{
    while (m_qmlPuppetEditorProcess->canReadLine()) {
        QByteArray line = m_qmlPuppetEditorProcess->readLine();
        line.chop(1);
        qDebug().nospace() << "Editor Puppet: " << qPrintable(line);
    }
    qDebug() << "\n";
}

void NodeInstanceServerProxy::printPreviewProcessOutput()
{
    while (m_qmlPuppetPreviewProcess->canReadLine()) {
        QByteArray line = m_qmlPuppetPreviewProcess->readLine();
        line.chop(1);
        qDebug().nospace() << "Preview Puppet: " << qPrintable(line);
    }
    qDebug() << "\n";
}

void NodeInstanceServerProxy::printRenderProcessOutput()
{
    while (m_qmlPuppetRenderProcess->canReadLine()) {
        QByteArray line = m_qmlPuppetRenderProcess->readLine();
        line.chop(1);
        qDebug().nospace() << "Render Puppet: " << qPrintable(line);
    }

    qDebug() << "\n";
}

597 598
QString NodeInstanceServerProxy::qmlPuppetApplicationName() const
{
599 600 601
    if (hasQtQuick2(m_nodeInstanceView.data()))
        return QLatin1String("qml2puppet" QTC_HOST_EXE_SUFFIX);
    return QLatin1String("qmlpuppet" QTC_HOST_EXE_SUFFIX);
602 603 604 605 606
}

QString NodeInstanceServerProxy::macOSBundlePath(const QString &path) const
{
    QString applicationPath = path;
607 608 609 610 611 612 613
    if (Utils::HostOsInfo::isMacHost()) {
        if (hasQtQuick2(m_nodeInstanceView.data()))
            applicationPath += QLatin1String("/qml2puppet.app/Contents/MacOS");
        else
            applicationPath += QLatin1String("/qmlpuppet.app/Contents/MacOS");

    }
614 615
   return applicationPath;
}
616

617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656
void NodeInstanceServerProxy::createInstances(const CreateInstancesCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

void NodeInstanceServerProxy::changeFileUrl(const ChangeFileUrlCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

void NodeInstanceServerProxy::createScene(const CreateSceneCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

void NodeInstanceServerProxy::clearScene(const ClearSceneCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

void NodeInstanceServerProxy::removeInstances(const RemoveInstancesCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

void NodeInstanceServerProxy::removeProperties(const RemovePropertiesCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

void NodeInstanceServerProxy::changePropertyBindings(const ChangeBindingsCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

void NodeInstanceServerProxy::changePropertyValues(const ChangeValuesCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

657 658 659 660 661
void NodeInstanceServerProxy::changeAuxiliaryValues(const ChangeAuxiliaryCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
void NodeInstanceServerProxy::reparentInstances(const ReparentInstancesCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

void NodeInstanceServerProxy::changeIds(const ChangeIdsCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

void NodeInstanceServerProxy::changeState(const ChangeStateCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

677 678 679 680
void NodeInstanceServerProxy::completeComponent(const CompleteComponentCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}
681

682
void NodeInstanceServerProxy::changeNodeSource(const ChangeNodeSourceCommand &command)
683 684 685 686
{
    writeCommand(QVariant::fromValue(command));
}

687 688 689 690 691
void NodeInstanceServerProxy::token(const TokenCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

692 693 694 695 696
void NodeInstanceServerProxy::removeSharedMemory(const RemoveSharedMemoryCommand &command)
{
   writeCommand(QVariant::fromValue(command));
}

697
} // namespace QmlDesigner