nodeinstanceserverproxy.cpp 23.1 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 59
#include <nodeinstanceview.h>
#include <import.h>
#include <qmldesignerplugin.h>
60

61
#include <coreplugin/icore.h>
62
#include <utils/hostosinfo.h>
63
#include <coreplugin/messagebox.h>
64
#include <coreplugin/editormanager/editormanager.h>
65 66 67 68
#include <projectexplorer/kit.h>
#include <qtsupport/qtkitinformation.h>
#include <qtsupport/baseqtversion.h>
#include <qtsupport/qtsupportconstants.h>
69

Tim Jenssen's avatar
Tim Jenssen committed
70 71 72 73 74 75 76 77 78 79
#include <QLocalServer>
#include <QLocalSocket>
#include <QProcess>
#include <QCoreApplication>
#include <QUuid>
#include <QFileInfo>
#include <QDir>
#include <QTimer>
#include <QTextStream>
#include <QMessageBox>
80 81 82

namespace QmlDesigner {

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

    QmlDesignerPlugin::instance()->switchToTextModeDeferred();

}

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

111
   PuppetCreator puppetCreator(kit, QString(), nodeInstanceView->model());
112
   puppetCreator.setQrcMappingString(qrcMappingString());
113

114
   puppetCreator.createPuppetExecutableIfMissing();
115

116
   m_qmlPuppetEditorProcess = puppetCreator.createPuppetProcess("editormode",
117 118
                                                              socketToken,
                                                              this,
119
                                                              SLOT(printEditorProcessOutput()),
120 121 122
                                                              SLOT(processFinished(int,QProcess::ExitStatus)));

   if (runModus == NormalModus) {
123
       m_qmlPuppetRenderProcess = puppetCreator.createPuppetProcess("rendermode",
124 125
                                                                    socketToken,
                                                                    this,
126
                                                                    SLOT(printRenderProcessOutput()),
127
                                                                    SLOT(processFinished(int,QProcess::ExitStatus)));
128
       m_qmlPuppetPreviewProcess = puppetCreator.createPuppetProcess("previewmode",
129 130 131 132 133
                                                                     socketToken,
                                                                     this,
                                                                     SLOT(printPreviewProcessOutput()),
                                                                     SLOT(processFinished(int,QProcess::ExitStatus)));
   }
134

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

138 139 140
       if (runModus == NormalModus) {
           m_qmlPuppetPreviewProcess->waitForStarted();
           connect(m_qmlPuppetPreviewProcess.data(), SIGNAL(finished(int)), m_qmlPuppetPreviewProcess.data(),SLOT(deleteLater()));
141

142 143
           m_qmlPuppetRenderProcess->waitForStarted();
           connect(m_qmlPuppetRenderProcess.data(), SIGNAL(finished(int)), m_qmlPuppetRenderProcess.data(),SLOT(deleteLater()));
144
       }
145

146
       bool connectedToPuppet = true;
147

148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
       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();
178
       }
179

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

184
       QmlDesignerPlugin::instance()->switchToTextModeDeferred();
185
   }
186

187 188 189
   m_localServer->close();


190 191 192 193 194 195
   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;
   }
196 197 198 199 200

   m_firstTimer.setInterval(3000);
   m_secondTimer.setInterval(3000);
   m_thirdTimer.setInterval(3000);

201 202 203 204 205
   if (qgetenv("DEBUG_QML_PUPPET").isEmpty()) {
       connect(&m_firstTimer, SIGNAL(timeout()), this, SLOT(processFinished()));
       connect(&m_secondTimer, SIGNAL(timeout()), this, SLOT(processFinished()));
       connect(&m_thirdTimer, SIGNAL(timeout()), this, SLOT(processFinished()));
   }
206 207 208 209
}

NodeInstanceServerProxy::~NodeInstanceServerProxy()
{
210 211
    disconnect(this, SLOT(processFinished(int,QProcess::ExitStatus)));

212 213
    writeCommand(QVariant::fromValue(EndPuppetCommand()));

214 215
    if (m_firstSocket) {
        m_firstSocket->waitForBytesWritten(1000);
216
        m_firstSocket->abort();
217
    }
218

219 220
    if (m_secondSocket) {
        m_secondSocket->waitForBytesWritten(1000);
221
        m_secondSocket->abort();
222
    }
223

224 225
    if (m_thirdSocket) {
        m_thirdSocket->waitForBytesWritten(1000);
226
        m_thirdSocket->abort();
227
    }
228

229
    if (m_qmlPuppetEditorProcess) {
230
        QTimer::singleShot(3000, m_qmlPuppetEditorProcess.data(), SLOT(terminate()));
231 232
        QTimer::singleShot(6000, m_qmlPuppetEditorProcess.data(), SLOT(kill()));
    }
233

234
    if (m_qmlPuppetPreviewProcess) {
235
        QTimer::singleShot(3000, m_qmlPuppetPreviewProcess.data(), SLOT(terminate()));
236 237
        QTimer::singleShot(6000, m_qmlPuppetPreviewProcess.data(), SLOT(kill()));
    }
238

239
    if (m_qmlPuppetRenderProcess) {
240
         QTimer::singleShot(3000, m_qmlPuppetRenderProcess.data(), SLOT(terminate()));
241 242
         QTimer::singleShot(6000, m_qmlPuppetRenderProcess.data(), SLOT(kill()));
    }
243 244
}

245
void NodeInstanceServerProxy::dispatchCommand(const QVariant &command, PuppetStreamType puppetStreamType)
246 247 248 249
{
    static const int informationChangedCommandType = QMetaType::type("InformationChangedCommand");
    static const int valuesChangedCommandType = QMetaType::type("ValuesChangedCommand");
    static const int pixmapChangedCommandType = QMetaType::type("PixmapChangedCommand");
250
    static const int childrenChangedCommandType = QMetaType::type("ChildrenChangedCommand");
251
    static const int statePreviewImageChangedCommandType = QMetaType::type("StatePreviewImageChangedCommand");
252
    static const int componentCompletedCommandType = QMetaType::type("ComponentCompletedCommand");
253
    static const int synchronizeCommandType = QMetaType::type("SynchronizeCommand");
254
    static const int tokenCommandType = QMetaType::type("TokenCommand");
Marco Bubke's avatar
Marco Bubke committed
255
    static const int debugOutputCommandType = QMetaType::type("DebugOutputCommand");
256
    static const int puppetAliveCommandType = QMetaType::type("PuppetAliveCommand");
257

258
    if (command.userType() ==  informationChangedCommandType) {
259
        nodeInstanceClient()->informationChanged(command.value<InformationChangedCommand>());
260
    } else if (command.userType() ==  valuesChangedCommandType) {
261
        nodeInstanceClient()->valuesChanged(command.value<ValuesChangedCommand>());
262
    } else if (command.userType() ==  pixmapChangedCommandType) {
263
        nodeInstanceClient()->pixmapChanged(command.value<PixmapChangedCommand>());
264
    } else if (command.userType() == childrenChangedCommandType) {
265
        nodeInstanceClient()->childrenChanged(command.value<ChildrenChangedCommand>());
266
    } else if (command.userType() == statePreviewImageChangedCommandType) {
267
        nodeInstanceClient()->statePreviewImagesChanged(command.value<StatePreviewImageChangedCommand>());
268
    } else if (command.userType() == componentCompletedCommandType) {
269
        nodeInstanceClient()->componentCompleted(command.value<ComponentCompletedCommand>());
270
    } else if (command.userType() == tokenCommandType) {
271
        nodeInstanceClient()->token(command.value<TokenCommand>());
272
    } else if (command.userType() == debugOutputCommandType) {
Marco Bubke's avatar
Marco Bubke committed
273
        nodeInstanceClient()->debugOutput(command.value<DebugOutputCommand>());
274 275
    } else if (command.userType() == puppetAliveCommandType) {
        puppetAlive(puppetStreamType);
276
    } else if (command.userType() == synchronizeCommandType) {
277 278 279
        SynchronizeCommand synchronizeCommand = command.value<SynchronizeCommand>();
        m_synchronizeId = synchronizeCommand.synchronizeId();
    }  else
280 281 282 283 284 285 286 287
        Q_ASSERT(false);
}

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

288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
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;
    }
}

308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
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();
}

332 333 334 335 336
void NodeInstanceServerProxy::processFinished()
{
    processFinished(-1, QProcess::CrashExit);
}

337
static void writeCommandToIODecive(const QVariant &command, QIODevice *ioDevice, unsigned int commandCounter)
338
{
339
    if (ioDevice) {
340 341
        QByteArray block;
        QDataStream out(&block, QIODevice::WriteOnly);
342
        out.setVersion(QDataStream::Qt_4_8);
343
        out << quint32(0);
344
        out << quint32(commandCounter);
345 346 347 348
        out << command;
        out.device()->seek(0);
        out << quint32(block.size() - sizeof(quint32));

349
        ioDevice->write(block);
350
    }
351 352 353 354
}

void NodeInstanceServerProxy::writeCommand(const QVariant &command)
{
355 356 357 358 359
    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
360
        qDebug() << "Write stream to file: " << m_captureFileForTest.fileName();
361 362 363 364
        writeCommandToIODecive(command, &m_captureFileForTest, m_writeCommandCounter);
        qDebug() << "\twrite file: " << m_captureFileForTest.pos();
    }

365
    m_writeCommandCounter++;
366 367 368 369 370
    if (m_runModus == TestModus) {
        static int synchronizeId = 0;
        synchronizeId++;
        SynchronizeCommand synchronizeCommand(synchronizeId);

371
        writeCommandToIODecive(QVariant::fromValue(synchronizeCommand), m_firstSocket.data(), m_writeCommandCounter);
372
        m_writeCommandCounter++;
373

374
        while (m_firstSocket->waitForReadyRead(100)) {
375 376 377 378 379
                readFirstDataStream();
                if (m_synchronizeId == synchronizeId)
                    return;
        }
    }
380 381
}

382
void NodeInstanceServerProxy::processFinished(int exitCode, QProcess::ExitStatus exitStatus)
383
{
Tim Jenssen's avatar
Tim Jenssen committed
384 385 386 387 388
    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;
389

390 391 392
    if (m_captureFileForTest.isOpen()) {
        m_captureFileForTest.close();
        m_captureFileForTest.remove();
393
        Core::AsynchronousMessageBox::warning(tr("QML Emulation Layer (QML Puppet) Crashed"),
394
                             tr("You are recording a puppet stream and the emulations layer crashed. "
395
                                "It is recommended to reopen the Qt Quick Designer and start again."));
396 397 398
    }


399 400
    writeCommand(QVariant::fromValue(EndPuppetCommand()));

401 402
    if (m_firstSocket) {
        m_firstSocket->waitForBytesWritten(1000);
403
        m_firstSocket->abort();
404 405 406 407
    }

    if (m_secondSocket) {
        m_secondSocket->waitForBytesWritten(1000);
408
        m_secondSocket->abort();
409 410 411 412
    }

    if (m_thirdSocket) {
        m_thirdSocket->waitForBytesWritten(1000);
413
        m_thirdSocket->abort();
414
    }
415

416 417
    if (exitStatus == QProcess::CrashExit)
        emit processCrashed();
418 419
}

420

421 422 423 424 425 426 427 428 429
void NodeInstanceServerProxy::readFirstDataStream()
{
    QList<QVariant> commandList;

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

        QDataStream in(m_firstSocket.data());
430
        in.setVersion(QDataStream::Qt_4_8);
431

432
        if (m_firstBlockSize == 0)
433 434 435 436 437
            in >> m_firstBlockSize;

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

438 439 440 441 442 443 444 445
        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;


446 447 448 449 450 451 452 453
        QVariant command;
        in >> command;
        m_firstBlockSize = 0;

        commandList.append(command);
    }

    foreach (const QVariant &command, commandList) {
454
        dispatchCommand(command, FirstPuppetStream);
455 456 457 458
    }
}

void NodeInstanceServerProxy::readSecondDataStream()
459 460 461
{
    QList<QVariant> commandList;

462 463
    while (!m_secondSocket->atEnd()) {
        if (m_secondSocket->bytesAvailable() < int(sizeof(quint32)))
464 465
            break;

466
        QDataStream in(m_secondSocket.data());
467
        in.setVersion(QDataStream::Qt_4_8);
468

469
        if (m_secondBlockSize == 0)
470
            in >> m_secondBlockSize;
471

472
        if (m_secondSocket->bytesAvailable() < m_secondBlockSize)
473 474
            break;

475 476 477 478 479 480 481 482
        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;


483 484
        QVariant command;
        in >> command;
485
        m_secondBlockSize = 0;
486 487 488 489 490

        commandList.append(command);
    }

    foreach (const QVariant &command, commandList) {
491
        dispatchCommand(command, SecondPuppetStream);
492 493 494
    }
}

495 496 497 498 499 500 501 502 503
void NodeInstanceServerProxy::readThirdDataStream()
{
    QList<QVariant> commandList;

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

        QDataStream in(m_thirdSocket.data());
504
        in.setVersion(QDataStream::Qt_4_8);
505

506
        if (m_thirdBlockSize == 0)
507 508 509 510 511
            in >> m_thirdBlockSize;

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

512 513 514 515 516 517 518 519
        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;


520 521 522 523 524 525 526 527
        QVariant command;
        in >> command;
        m_thirdBlockSize = 0;

        commandList.append(command);
    }

    foreach (const QVariant &command, commandList) {
528
        dispatchCommand(command, ThirdPuppetStream);
529 530 531
    }
}

532 533
void NodeInstanceServerProxy::printEditorProcessOutput()
{
534
    while (m_qmlPuppetEditorProcess && m_qmlPuppetEditorProcess->canReadLine()) {
535 536 537 538 539 540 541 542 543
        QByteArray line = m_qmlPuppetEditorProcess->readLine();
        line.chop(1);
        qDebug().nospace() << "Editor Puppet: " << qPrintable(line);
    }
    qDebug() << "\n";
}

void NodeInstanceServerProxy::printPreviewProcessOutput()
{
544
    while (m_qmlPuppetPreviewProcess && m_qmlPuppetPreviewProcess->canReadLine()) {
545 546 547 548 549 550 551 552 553
        QByteArray line = m_qmlPuppetPreviewProcess->readLine();
        line.chop(1);
        qDebug().nospace() << "Preview Puppet: " << qPrintable(line);
    }
    qDebug() << "\n";
}

void NodeInstanceServerProxy::printRenderProcessOutput()
{
554
    while (m_qmlPuppetRenderProcess && m_qmlPuppetRenderProcess->canReadLine()) {
555 556 557 558 559 560 561 562
        QByteArray line = m_qmlPuppetRenderProcess->readLine();
        line.chop(1);
        qDebug().nospace() << "Render Puppet: " << qPrintable(line);
    }

    qDebug() << "\n";
}

563 564 565 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 597 598 599 600 601 602
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));
}

603 604 605 606 607
void NodeInstanceServerProxy::changeAuxiliaryValues(const ChangeAuxiliaryCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

608 609 610 611 612 613 614 615 616 617 618 619 620 621 622
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));
}

623 624 625 626
void NodeInstanceServerProxy::completeComponent(const CompleteComponentCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}
627

628
void NodeInstanceServerProxy::changeNodeSource(const ChangeNodeSourceCommand &command)
629 630 631 632
{
    writeCommand(QVariant::fromValue(command));
}

633 634 635 636 637
void NodeInstanceServerProxy::token(const TokenCommand &command)
{
    writeCommand(QVariant::fromValue(command));
}

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

643
} // namespace QmlDesigner