nodeinstanceserverproxy.cpp 23.7 KB
Newer Older
hjk's avatar
hjk committed
1
/****************************************************************************
2
**
3 4
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
5
**
hjk's avatar
hjk committed
6
** This file is part of Qt Creator.
7
**
hjk's avatar
hjk committed
8 9 10 11
** 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
12 13 14
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
15
**
16 17
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
18 19 20 21 22
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
23
**
hjk's avatar
hjk committed
24
****************************************************************************/
25

26 27
#include "nodeinstanceserverproxy.h"

Tim Jenssen's avatar
Tim Jenssen committed
28
#include "puppetcreator.h"
29

Tim Jenssen's avatar
Tim Jenssen committed
30 31 32 33 34 35 36 37 38 39 40 41 42 43
#include <createinstancescommand.h>
#include <createscenecommand.h>
#include <changevaluescommand.h>
#include <changebindingscommand.h>
#include <changeauxiliarycommand.h>
#include <changefileurlcommand.h>
#include <removeinstancescommand.h>
#include <clearscenecommand.h>
#include <removepropertiescommand.h>
#include <reparentinstancescommand.h>
#include <changeidscommand.h>
#include <changestatecommand.h>
#include <completecomponentcommand.h>
#include <changenodesourcecommand.h>
44

Tim Jenssen's avatar
Tim Jenssen committed
45 46 47 48 49 50 51 52 53 54 55
#include <informationchangedcommand.h>
#include <pixmapchangedcommand.h>
#include <valueschangedcommand.h>
#include <childrenchangedcommand.h>
#include <statepreviewimagechangedcommand.h>
#include <componentcompletedcommand.h>
#include <tokencommand.h>
#include <removesharedmemorycommand.h>
#include <endpuppetcommand.h>
#include <synchronizecommand.h>
#include <debugoutputcommand.h>
56

Tim Jenssen's avatar
Tim Jenssen committed
57 58
#include <nodeinstanceview.h>
#include <import.h>
59 60 61
#include <rewriterview.h>

#ifndef QMLDESIGNER_TEST
Tim Jenssen's avatar
Tim Jenssen committed
62
#include <qmldesignerplugin.h>
63
#endif
64

65
#include <coreplugin/icore.h>
66
#include <utils/hostosinfo.h>
67
#include <coreplugin/messagebox.h>
68
#include <coreplugin/editormanager/editormanager.h>
69 70 71 72
#include <projectexplorer/kit.h>
#include <qtsupport/qtkitinformation.h>
#include <qtsupport/baseqtversion.h>
#include <qtsupport/qtsupportconstants.h>
73

Tim Jenssen's avatar
Tim Jenssen committed
74 75 76 77 78 79 80 81 82 83
#include <QLocalServer>
#include <QLocalSocket>
#include <QProcess>
#include <QCoreApplication>
#include <QUuid>
#include <QFileInfo>
#include <QDir>
#include <QTimer>
#include <QTextStream>
#include <QMessageBox>
84 85 86

namespace QmlDesigner {

87 88
static void showCannotConnectToPuppetWarningAndSwitchToEditMode()
{
89
#ifndef QMLDESIGNER_TEST
90
    Core::AsynchronousMessageBox::warning(QCoreApplication::translate("NodeInstanceServerProxy", "Cannot Connect to QML Emulation Layer (QML Puppet)"),
91 92
                                          QCoreApplication::translate("NodeInstanceServerProxy", "The executable of the QML emulation layer (QML Puppet) may not be responding. "
                                                                                                 "Switching to another kit might help."));
93 94

    QmlDesignerPlugin::instance()->switchToTextModeDeferred();
95
#endif
96 97 98

}

99
NodeInstanceServerProxy::NodeInstanceServerProxy(NodeInstanceView *nodeInstanceView, RunModus runModus, ProjectExplorer::Kit *kit)
100 101 102
    : NodeInstanceServerInterface(nodeInstanceView),
      m_localServer(new QLocalServer(this)),
      m_nodeInstanceView(nodeInstanceView),
103
      m_firstBlockSize(0),
104
      m_secondBlockSize(0),
105
      m_thirdBlockSize(0),
106 107 108 109
      m_writeCommandCounter(0),
      m_firstLastReadCommandCounter(0),
      m_secondLastReadCommandCounter(0),
      m_thirdLastReadCommandCounter(0),
110 111
      m_runModus(runModus),
      m_synchronizeId(-1)
112
{
113 114 115 116
   QString socketToken(QUuid::createUuid().toString());
   m_localServer->listen(socketToken);
   m_localServer->setMaxPendingConnections(3);

117
   PuppetCreator puppetCreator(kit, QString(), nodeInstanceView->model());
118
   puppetCreator.setQrcMappingString(qrcMappingString());
119

120
   puppetCreator.createPuppetExecutableIfMissing();
121

122
   m_qmlPuppetEditorProcess = puppetCreator.createPuppetProcess("editormode",
123 124
                                                              socketToken,
                                                              this,
125
                                                              SLOT(printEditorProcessOutput()),
126 127 128
                                                              SLOT(processFinished(int,QProcess::ExitStatus)));

   if (runModus == NormalModus) {
129
       m_qmlPuppetRenderProcess = puppetCreator.createPuppetProcess("rendermode",
130 131
                                                                    socketToken,
                                                                    this,
132
                                                                    SLOT(printRenderProcessOutput()),
133
                                                                    SLOT(processFinished(int,QProcess::ExitStatus)));
134
       m_qmlPuppetPreviewProcess = puppetCreator.createPuppetProcess("previewmode",
135 136 137 138 139
                                                                     socketToken,
                                                                     this,
                                                                     SLOT(printPreviewProcessOutput()),
                                                                     SLOT(processFinished(int,QProcess::ExitStatus)));
   }
140

141
   if (m_qmlPuppetEditorProcess->waitForStarted(10000)) {
142 143
       connect(m_qmlPuppetEditorProcess.data(), static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished),
            m_qmlPuppetEditorProcess.data(), &QProcess::deleteLater);
144

145 146
       if (runModus == NormalModus) {
           m_qmlPuppetPreviewProcess->waitForStarted();
147 148
           connect(m_qmlPuppetPreviewProcess.data(), static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished),
                m_qmlPuppetPreviewProcess.data(), &QProcess::deleteLater);
149

150
           m_qmlPuppetRenderProcess->waitForStarted();
151 152
           connect(m_qmlPuppetRenderProcess.data(), static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished),
                m_qmlPuppetRenderProcess.data(), &QProcess::deleteLater);
153
       }
154

155
       bool connectedToPuppet = true;
156

157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
       if (!m_localServer->hasPendingConnections())
           connectedToPuppet = m_localServer->waitForNewConnection(3000);

       if (connectedToPuppet) {
           m_firstSocket = m_localServer->nextPendingConnection();
           connect(m_firstSocket.data(), SIGNAL(readyRead()), this, SLOT(readFirstDataStream()));

           if (runModus == NormalModus) {
               if (!m_localServer->hasPendingConnections())
                   connectedToPuppet = m_localServer->waitForNewConnection(3000);

               if (connectedToPuppet) {
                   m_secondSocket = m_localServer->nextPendingConnection();
                   connect(m_secondSocket.data(), SIGNAL(readyRead()), this, SLOT(readSecondDataStream()));

                   if (!m_localServer->hasPendingConnections())
                        connectedToPuppet = m_localServer->waitForNewConnection(3000);

                   if (connectedToPuppet) {
                       m_thirdSocket = m_localServer->nextPendingConnection();
                       connect(m_thirdSocket.data(), SIGNAL(readyRead()), this, SLOT(readThirdDataStream()));
                   } else {
                       showCannotConnectToPuppetWarningAndSwitchToEditMode();
                   }
               } else {
                   showCannotConnectToPuppetWarningAndSwitchToEditMode();
               }
           }
       } else {
           showCannotConnectToPuppetWarningAndSwitchToEditMode();
187
       }
188

189
   } else {
190
       Core::AsynchronousMessageBox::warning(tr("Cannot Start QML Emulation Layer (QML Puppet)"),
191
                                              tr("The executable of the QML emulation layer (QML Puppet) process cannot be started or does not respond."));
192

193
#ifndef QMLDESIGNER_TEST
194
       QmlDesignerPlugin::instance()->switchToTextModeDeferred();
195
#endif
196
   }
197

198 199 200
   m_localServer->close();


201 202 203 204 205 206
   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;
   }
207

208
#ifndef QMLDESIGNER_TEST
209 210 211 212 213 214 215 216
   DesignerSettings settings = QmlDesignerPlugin::instance()->settings();
   int timeOutTime = settings.value(DesignerSettingsKey::PUPPET_KILL_TIMEOUT).toInt();
   m_firstTimer.setInterval(timeOutTime);
   m_secondTimer.setInterval(timeOutTime);
   m_thirdTimer.setInterval(timeOutTime);

    if (QmlDesignerPlugin::instance()->settings().value(DesignerSettingsKey::
            DEBUG_PUPPET).toString().isEmpty()) {
217 218 219 220
       connect(&m_firstTimer, SIGNAL(timeout()), this, SLOT(processFinished()));
       connect(&m_secondTimer, SIGNAL(timeout()), this, SLOT(processFinished()));
       connect(&m_thirdTimer, SIGNAL(timeout()), this, SLOT(processFinished()));
   }
221
#endif
222 223 224 225
}

NodeInstanceServerProxy::~NodeInstanceServerProxy()
{
226 227
    disconnect(this, SLOT(processFinished(int,QProcess::ExitStatus)));

228 229
    writeCommand(QVariant::fromValue(EndPuppetCommand()));

230 231
    if (m_firstSocket) {
        m_firstSocket->waitForBytesWritten(1000);
232
        m_firstSocket->abort();
233
    }
234

235 236
    if (m_secondSocket) {
        m_secondSocket->waitForBytesWritten(1000);
237
        m_secondSocket->abort();
238
    }
239

240 241
    if (m_thirdSocket) {
        m_thirdSocket->waitForBytesWritten(1000);
242
        m_thirdSocket->abort();
243
    }
244

245
    if (m_qmlPuppetEditorProcess) {
246
        QTimer::singleShot(3000, m_qmlPuppetEditorProcess.data(), SLOT(terminate()));
247 248
        QTimer::singleShot(6000, m_qmlPuppetEditorProcess.data(), SLOT(kill()));
    }
249

250
    if (m_qmlPuppetPreviewProcess) {
251
        QTimer::singleShot(3000, m_qmlPuppetPreviewProcess.data(), SLOT(terminate()));
252 253
        QTimer::singleShot(6000, m_qmlPuppetPreviewProcess.data(), SLOT(kill()));
    }
254

255
    if (m_qmlPuppetRenderProcess) {
256
         QTimer::singleShot(3000, m_qmlPuppetRenderProcess.data(), SLOT(terminate()));
257 258
         QTimer::singleShot(6000, m_qmlPuppetRenderProcess.data(), SLOT(kill()));
    }
259 260
}

261
void NodeInstanceServerProxy::dispatchCommand(const QVariant &command, PuppetStreamType puppetStreamType)
262 263 264 265
{
    static const int informationChangedCommandType = QMetaType::type("InformationChangedCommand");
    static const int valuesChangedCommandType = QMetaType::type("ValuesChangedCommand");
    static const int pixmapChangedCommandType = QMetaType::type("PixmapChangedCommand");
266
    static const int childrenChangedCommandType = QMetaType::type("ChildrenChangedCommand");
267
    static const int statePreviewImageChangedCommandType = QMetaType::type("StatePreviewImageChangedCommand");
268
    static const int componentCompletedCommandType = QMetaType::type("ComponentCompletedCommand");
269
    static const int synchronizeCommandType = QMetaType::type("SynchronizeCommand");
270
    static const int tokenCommandType = QMetaType::type("TokenCommand");
Marco Bubke's avatar
Marco Bubke committed
271
    static const int debugOutputCommandType = QMetaType::type("DebugOutputCommand");
272
    static const int puppetAliveCommandType = QMetaType::type("PuppetAliveCommand");
273

274
    if (command.userType() ==  informationChangedCommandType) {
275
        nodeInstanceClient()->informationChanged(command.value<InformationChangedCommand>());
276
    } else if (command.userType() ==  valuesChangedCommandType) {
277
        nodeInstanceClient()->valuesChanged(command.value<ValuesChangedCommand>());
278
    } else if (command.userType() ==  pixmapChangedCommandType) {
279
        nodeInstanceClient()->pixmapChanged(command.value<PixmapChangedCommand>());
280
    } else if (command.userType() == childrenChangedCommandType) {
281
        nodeInstanceClient()->childrenChanged(command.value<ChildrenChangedCommand>());
282
    } else if (command.userType() == statePreviewImageChangedCommandType) {
283
        nodeInstanceClient()->statePreviewImagesChanged(command.value<StatePreviewImageChangedCommand>());
284
    } else if (command.userType() == componentCompletedCommandType) {
285
        nodeInstanceClient()->componentCompleted(command.value<ComponentCompletedCommand>());
286
    } else if (command.userType() == tokenCommandType) {
287
        nodeInstanceClient()->token(command.value<TokenCommand>());
288
    } else if (command.userType() == debugOutputCommandType) {
Marco Bubke's avatar
Marco Bubke committed
289
        nodeInstanceClient()->debugOutput(command.value<DebugOutputCommand>());
290 291
    } else if (command.userType() == puppetAliveCommandType) {
        puppetAlive(puppetStreamType);
292
    } else if (command.userType() == synchronizeCommandType) {
293 294 295
        SynchronizeCommand synchronizeCommand = command.value<SynchronizeCommand>();
        m_synchronizeId = synchronizeCommand.synchronizeId();
    }  else
296 297 298 299 300 301 302 303
        Q_ASSERT(false);
}

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

304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
void NodeInstanceServerProxy::puppetAlive(NodeInstanceServerProxy::PuppetStreamType puppetStreamType)
{
    switch (puppetStreamType) {
    case FirstPuppetStream:
        m_firstTimer.stop();
        m_firstTimer.start();
        break;
    case SecondPuppetStream:
        m_secondTimer.stop();
        m_secondTimer.start();
        break;
    case ThirdPuppetStream:
        m_thirdTimer.stop();
        m_thirdTimer.start();
        break;
    default:
        break;
    }
}

324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
QString NodeInstanceServerProxy::qrcMappingString() const
{
    if (m_nodeInstanceView && m_nodeInstanceView.data()->model()) {
        RewriterView *rewriterView = m_nodeInstanceView.data()->model()->rewriterView();
        if (rewriterView) {
            QString mappingString;

            typedef QPair<QString, QString> StringPair;

            foreach (const StringPair &pair, rewriterView->qrcMapping()) {
                if (!mappingString.isEmpty())
                    mappingString.append(QLatin1String(","));
                mappingString.append(pair.first);
                mappingString.append(QLatin1String("="));
                mappingString.append(pair.second);
            }

            return mappingString;
        }
    }

    return QString();
}

348 349 350 351 352
void NodeInstanceServerProxy::processFinished()
{
    processFinished(-1, QProcess::CrashExit);
}

353
static void writeCommandToIODecive(const QVariant &command, QIODevice *ioDevice, unsigned int commandCounter)
354
{
355
    if (ioDevice) {
356 357
        QByteArray block;
        QDataStream out(&block, QIODevice::WriteOnly);
358
        out.setVersion(QDataStream::Qt_4_8);
359
        out << quint32(0);
360
        out << quint32(commandCounter);
361 362 363 364
        out << command;
        out.device()->seek(0);
        out << quint32(block.size() - sizeof(quint32));

365
        ioDevice->write(block);
366
    }
367 368 369 370
}

void NodeInstanceServerProxy::writeCommand(const QVariant &command)
{
371 372 373 374 375
    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()) {
Robert Loehning's avatar
Robert Loehning committed
376
        qDebug() << "Write stream to file: " << m_captureFileForTest.fileName();
377 378 379 380
        writeCommandToIODecive(command, &m_captureFileForTest, m_writeCommandCounter);
        qDebug() << "\twrite file: " << m_captureFileForTest.pos();
    }

381
    m_writeCommandCounter++;
382 383 384 385 386
    if (m_runModus == TestModus) {
        static int synchronizeId = 0;
        synchronizeId++;
        SynchronizeCommand synchronizeCommand(synchronizeId);

387
        writeCommandToIODecive(QVariant::fromValue(synchronizeCommand), m_firstSocket.data(), m_writeCommandCounter);
388
        m_writeCommandCounter++;
389

390
        while (m_firstSocket->waitForReadyRead(100)) {
391 392 393 394 395
                readFirstDataStream();
                if (m_synchronizeId == synchronizeId)
                    return;
        }
    }
396 397
}

398
void NodeInstanceServerProxy::processFinished(int exitCode, QProcess::ExitStatus exitStatus)
399
{
Tim Jenssen's avatar
Tim Jenssen committed
400 401 402 403 404
    QProcess* finishedProcess = qobject_cast<QProcess*>(sender());
    if (finishedProcess)
        qWarning() << "Process" << (exitStatus == QProcess::CrashExit ? "crashed:" : "finished:") << finishedProcess->arguments() << "exitCode:" << exitCode;
    else
        qWarning() << "Process" << (exitStatus == QProcess::CrashExit ? "crashed:" : "finished:") << sender() << "exitCode:" << exitCode;
405

406 407
    if (m_captureFileForTest.isOpen()) {
        m_captureFileForTest.close();
408
        Core::AsynchronousMessageBox::warning(tr("QML Emulation Layer (QML Puppet) Crashed"),
409
                             tr("You are recording a puppet stream and the emulations layer crashed. "
410
                                "It is recommended to reopen the Qt Quick Designer and start again."));
411 412 413
    }


414 415
    writeCommand(QVariant::fromValue(EndPuppetCommand()));

416 417
    if (m_firstSocket) {
        m_firstSocket->waitForBytesWritten(1000);
418
        m_firstSocket->abort();
419 420 421 422
    }

    if (m_secondSocket) {
        m_secondSocket->waitForBytesWritten(1000);
423
        m_secondSocket->abort();
424 425 426 427
    }

    if (m_thirdSocket) {
        m_thirdSocket->waitForBytesWritten(1000);
428
        m_thirdSocket->abort();
429
    }
430

431 432
    if (exitStatus == QProcess::CrashExit)
        emit processCrashed();
433 434
}

435

436 437 438 439 440 441 442 443 444
void NodeInstanceServerProxy::readFirstDataStream()
{
    QList<QVariant> commandList;

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

        QDataStream in(m_firstSocket.data());
445
        in.setVersion(QDataStream::Qt_4_8);
446

447
        if (m_firstBlockSize == 0)
448 449 450 451 452
            in >> m_firstBlockSize;

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

453 454 455 456 457 458 459 460
        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;


461 462 463 464 465 466 467 468
        QVariant command;
        in >> command;
        m_firstBlockSize = 0;

        commandList.append(command);
    }

    foreach (const QVariant &command, commandList) {
469
        dispatchCommand(command, FirstPuppetStream);
470 471 472 473
    }
}

void NodeInstanceServerProxy::readSecondDataStream()
474 475 476
{
    QList<QVariant> commandList;

477 478
    while (!m_secondSocket->atEnd()) {
        if (m_secondSocket->bytesAvailable() < int(sizeof(quint32)))
479 480
            break;

481
        QDataStream in(m_secondSocket.data());
482
        in.setVersion(QDataStream::Qt_4_8);
483

484
        if (m_secondBlockSize == 0)
485
            in >> m_secondBlockSize;
486

487
        if (m_secondSocket->bytesAvailable() < m_secondBlockSize)
488 489
            break;

490 491 492 493 494 495 496 497
        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;


498 499
        QVariant command;
        in >> command;
500
        m_secondBlockSize = 0;
501 502 503 504 505

        commandList.append(command);
    }

    foreach (const QVariant &command, commandList) {
506
        dispatchCommand(command, SecondPuppetStream);
507 508 509
    }
}

510 511 512 513 514 515 516 517 518
void NodeInstanceServerProxy::readThirdDataStream()
{
    QList<QVariant> commandList;

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

        QDataStream in(m_thirdSocket.data());
519
        in.setVersion(QDataStream::Qt_4_8);
520

521
        if (m_thirdBlockSize == 0)
522 523 524 525 526
            in >> m_thirdBlockSize;

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

527 528 529 530 531 532 533 534
        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;


535 536 537 538 539 540 541 542
        QVariant command;
        in >> command;
        m_thirdBlockSize = 0;

        commandList.append(command);
    }

    foreach (const QVariant &command, commandList) {
543
        dispatchCommand(command, ThirdPuppetStream);
544 545 546
    }
}

547 548
void NodeInstanceServerProxy::printEditorProcessOutput()
{
549
    while (m_qmlPuppetEditorProcess && m_qmlPuppetEditorProcess->canReadLine()) {
550 551
        QByteArray line = m_qmlPuppetEditorProcess->readLine();
        line.chop(1);
552
        qDebug().nospace() << "Editor Puppet: " << line;
553 554 555 556 557 558
    }
    qDebug() << "\n";
}

void NodeInstanceServerProxy::printPreviewProcessOutput()
{
559
    while (m_qmlPuppetPreviewProcess && m_qmlPuppetPreviewProcess->canReadLine()) {
560 561
        QByteArray line = m_qmlPuppetPreviewProcess->readLine();
        line.chop(1);
562
        qDebug().nospace() << "Preview Puppet: " << line;
563 564 565 566 567 568
    }
    qDebug() << "\n";
}

void NodeInstanceServerProxy::printRenderProcessOutput()
{
569
    while (m_qmlPuppetRenderProcess && m_qmlPuppetRenderProcess->canReadLine()) {
570 571
        QByteArray line = m_qmlPuppetRenderProcess->readLine();
        line.chop(1);
572
        qDebug().nospace() << "Render Puppet: " << line;
573 574 575 576 577
    }

    qDebug() << "\n";
}

578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
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));
}

618 619 620 621 622
void NodeInstanceServerProxy::changeAuxiliaryValues(const ChangeAuxiliaryCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
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));
}

638 639 640 641
void NodeInstanceServerProxy::completeComponent(const CompleteComponentCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}
642

643
void NodeInstanceServerProxy::changeNodeSource(const ChangeNodeSourceCommand &command)
644 645 646 647
{
    writeCommand(QVariant::fromValue(command));
}

648 649 650 651 652
void NodeInstanceServerProxy::token(const TokenCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

653 654 655 656 657
void NodeInstanceServerProxy::removeSharedMemory(const RemoveSharedMemoryCommand &command)
{
   writeCommand(QVariant::fromValue(command));
}

658
} // namespace QmlDesigner