src/qml/debugger/qqmlenginedebug.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the QtQml module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** GNU Lesser General Public License Usage
  10 ** This file may be used under the terms of the GNU Lesser General Public
  11 ** License version 2.1 as published by the Free Software Foundation and
  12 ** appearing in the file LICENSE.LGPL included in the packaging of this
  13 ** file. Please review the following information to ensure the GNU Lesser
  14 ** General Public License version 2.1 requirements will be met:
  15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  16 **
  17 ** In addition, as a special exception, Nokia gives you certain additional
  18 ** rights. These rights are described in the Nokia Qt LGPL Exception
  19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  20 **
  21 ** GNU General Public License Usage
  22 ** Alternatively, this file may be used under the terms of the GNU General
  23 ** Public License version 3.0 as published by the Free Software Foundation
  24 ** and appearing in the file LICENSE.GPL included in the packaging of this
  25 ** file. Please review the following information to ensure the GNU General
  26 ** Public License version 3.0 requirements will be met:
  27 ** http://www.gnu.org/copyleft/gpl.html.
  28 **
  29 ** Other Usage
  30 ** Alternatively, this file may be used in accordance with the terms and
  31 ** conditions contained in a signed written agreement between you and Nokia.
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "qqmlenginedebug_p.h"
  43
  44 #include "qqmldebugclient_p.h"
  45
  46 #include "qqmlenginedebugservice_p.h"
  47
  48 #include <private/qobject_p.h>
  49
  50 QT_BEGIN_NAMESPACE
  51
  52 class QQmlEngineDebugClient : public QQmlDebugClient
  53 {
  54 public:
  55     QQmlEngineDebugClient(QQmlDebugConnection *client, QQmlEngineDebugPrivate *p);
  56
  57 protected:
  58     virtual void stateChanged(State state);
  59     virtual void messageReceived(const QByteArray &);
  60
  61 private:
  62     QQmlEngineDebugPrivate *priv;
  63     friend class QQmlEngineDebugPrivate;
  64 };
  65
  66 class QQmlEngineDebugPrivate : public QObjectPrivate
  67 {
  68     Q_DECLARE_PUBLIC(QQmlEngineDebug)
  69 public:
  70     QQmlEngineDebugPrivate(QQmlDebugConnection *);
  71     ~QQmlEngineDebugPrivate();
  72
  73     void stateChanged(QQmlEngineDebug::State status);
  74     void message(const QByteArray &);
  75
  76     QQmlEngineDebugClient *client;
  77     int nextId;
  78     int getId();
  79
  80     void decode(QDataStream &, QQmlDebugContextReference &);
  81     void decode(QDataStream &, QQmlDebugObjectReference &, bool simple);
  82
  83     static void remove(QQmlEngineDebug *, QQmlDebugEnginesQuery *);
  84     static void remove(QQmlEngineDebug *, QQmlDebugRootContextQuery *);
  85     static void remove(QQmlEngineDebug *, QQmlDebugObjectQuery *);
  86     static void remove(QQmlEngineDebug *, QQmlDebugExpressionQuery *);
  87     static void remove(QQmlEngineDebug *, QQmlDebugWatch *);
  88
  89     QHash<int, QQmlDebugEnginesQuery *> enginesQuery;
  90     QHash<int, QQmlDebugRootContextQuery *> rootContextQuery;
  91     QHash<int, QQmlDebugObjectQuery *> objectQuery;
  92     QHash<int, QQmlDebugExpressionQuery *> expressionQuery;
  93
  94     QHash<int, QQmlDebugWatch *> watched;
  95 };
  96
  97 QQmlEngineDebugClient::QQmlEngineDebugClient(QQmlDebugConnection *client,
  98                                                              QQmlEngineDebugPrivate *p)
  99     : QQmlDebugClient(QLatin1String("QDeclarativeEngine"), client), priv(p)
 100 {
 101 }
 102
 103 void QQmlEngineDebugClient::stateChanged(State status)
 104 {
 105     if (priv)
 106         priv->stateChanged(static_cast<QQmlEngineDebug::State>(status));
 107 }
 108
 109 void QQmlEngineDebugClient::messageReceived(const QByteArray &data)
 110 {
 111     if (priv)
 112         priv->message(data);
 113 }
 114
 115 QQmlEngineDebugPrivate::QQmlEngineDebugPrivate(QQmlDebugConnection *c)
 116     : client(new QQmlEngineDebugClient(c, this)), nextId(0)
 117 {
 118 }
 119
 120 QQmlEngineDebugPrivate::~QQmlEngineDebugPrivate()
 121 {
 122     if (client)
 123         client->priv = 0;
 124     delete client;
 125
 126     QHash<int, QQmlDebugEnginesQuery*>::iterator enginesIter = enginesQuery.begin();
 127     for (; enginesIter != enginesQuery.end(); ++enginesIter) {
 128         enginesIter.value()->m_client = 0;
 129         if (enginesIter.value()->state() == QQmlDebugQuery::Waiting)
 130             enginesIter.value()->setState(QQmlDebugQuery::Error);
 131     }
 132
 133     QHash<int, QQmlDebugRootContextQuery*>::iterator rootContextIter = rootContextQuery.begin();
 134     for (; rootContextIter != rootContextQuery.end(); ++rootContextIter) {
 135         rootContextIter.value()->m_client = 0;
 136         if (rootContextIter.value()->state() == QQmlDebugQuery::Waiting)
 137             rootContextIter.value()->setState(QQmlDebugQuery::Error);
 138     }
 139
 140     QHash<int, QQmlDebugObjectQuery*>::iterator objectIter = objectQuery.begin();
 141     for (; objectIter != objectQuery.end(); ++objectIter) {
 142         objectIter.value()->m_client = 0;
 143         if (objectIter.value()->state() == QQmlDebugQuery::Waiting)
 144             objectIter.value()->setState(QQmlDebugQuery::Error);
 145     }
 146
 147     QHash<int, QQmlDebugExpressionQuery*>::iterator exprIter = expressionQuery.begin();
 148     for (; exprIter != expressionQuery.end(); ++exprIter) {
 149         exprIter.value()->m_client = 0;
 150         if (exprIter.value()->state() == QQmlDebugQuery::Waiting)
 151             exprIter.value()->setState(QQmlDebugQuery::Error);
 152     }
 153
 154     QHash<int, QQmlDebugWatch*>::iterator watchIter = watched.begin();
 155     for (; watchIter != watched.end(); ++watchIter) {
 156         watchIter.value()->m_client = 0;
 157         watchIter.value()->setState(QQmlDebugWatch::Dead);
 158     }
 159 }
 160
 161 int QQmlEngineDebugPrivate::getId()
 162 {
 163     return nextId++;
 164 }
 165
 166 void QQmlEngineDebugPrivate::remove(QQmlEngineDebug *c, QQmlDebugEnginesQuery *q)
 167 {
 168     if (c && q) {
 169         QQmlEngineDebugPrivate *p = (QQmlEngineDebugPrivate *)QObjectPrivate::get(c);
 170         p->enginesQuery.remove(q->m_queryId);
 171     }
 172 }
 173
 174 void QQmlEngineDebugPrivate::remove(QQmlEngineDebug *c,
 175                                             QQmlDebugRootContextQuery *q)
 176 {
 177     if (c && q) {
 178         QQmlEngineDebugPrivate *p = (QQmlEngineDebugPrivate *)QObjectPrivate::get(c);
 179         p->rootContextQuery.remove(q->m_queryId);
 180     }
 181 }
 182
 183 void QQmlEngineDebugPrivate::remove(QQmlEngineDebug *c, QQmlDebugObjectQuery *q)
 184 {
 185     if (c && q) {
 186         QQmlEngineDebugPrivate *p = (QQmlEngineDebugPrivate *)QObjectPrivate::get(c);
 187         p->objectQuery.remove(q->m_queryId);
 188     }
 189 }
 190
 191 void QQmlEngineDebugPrivate::remove(QQmlEngineDebug *c, QQmlDebugExpressionQuery *q)
 192 {
 193     if (c && q) {
 194         QQmlEngineDebugPrivate *p = (QQmlEngineDebugPrivate *)QObjectPrivate::get(c);
 195         p->expressionQuery.remove(q->m_queryId);
 196     }
 197 }
 198
 199 void QQmlEngineDebugPrivate::remove(QQmlEngineDebug *c, QQmlDebugWatch *w)
 200 {
 201     if (c && w) {
 202         QQmlEngineDebugPrivate *p = (QQmlEngineDebugPrivate *)QObjectPrivate::get(c);
 203         p->watched.remove(w->m_queryId);
 204     }
 205 }
 206
 207 void QQmlEngineDebugPrivate::decode(QDataStream &ds, QQmlDebugObjectReference &o,
 208                                             bool simple)
 209 {
 210     QQmlEngineDebugService::QQmlObjectData data;
 211     ds >> data;
 212     o.m_debugId = data.objectId;
 213     o.m_class = data.objectType;
 214     o.m_idString = data.idString;
 215     o.m_name = data.objectName;
 216     o.m_source.m_url = data.url;
 217     o.m_source.m_lineNumber = data.lineNumber;
 218     o.m_source.m_columnNumber = data.columnNumber;
 219     o.m_contextDebugId = data.contextId;
 220
 221     if (simple)
 222         return;
 223
 224     int childCount;
 225     bool recur;
 226     ds >> childCount >> recur;
 227
 228     for (int ii = 0; ii < childCount; ++ii) {
 229         o.m_children.append(QQmlDebugObjectReference());
 230         decode(ds, o.m_children.last(), !recur);
 231     }
 232
 233     int propCount;
 234     ds >> propCount;
 235
 236     for (int ii = 0; ii < propCount; ++ii) {
 237         QQmlEngineDebugService::QQmlObjectProperty data;
 238         ds >> data;
 239         QQmlDebugPropertyReference prop;
 240         prop.m_objectDebugId = o.m_debugId;
 241         prop.m_name = data.name;
 242         prop.m_binding = data.binding;
 243         prop.m_hasNotifySignal = data.hasNotifySignal;
 244         prop.m_valueTypeName = data.valueTypeName;
 245         switch (data.type) {
 246         case QQmlEngineDebugService::QQmlObjectProperty::Basic:
 247         case QQmlEngineDebugService::QQmlObjectProperty::List:
 248         case QQmlEngineDebugService::QQmlObjectProperty::SignalProperty:
 249         {
 250             prop.m_value = data.value;
 251             break;
 252         }
 253         case QQmlEngineDebugService::QQmlObjectProperty::Object:
 254         {
 255             QQmlDebugObjectReference obj;
 256             obj.m_debugId = prop.m_value.toInt();
 257             prop.m_value = QVariant::fromValue(obj);
 258             break;
 259         }
 260         case QQmlEngineDebugService::QQmlObjectProperty::Unknown:
 261             break;
 262         }
 263         o.m_properties << prop;
 264     }
 265 }
 266
 267 void QQmlEngineDebugPrivate::decode(QDataStream &ds, QQmlDebugContextReference &c)
 268 {
 269     ds >> c.m_name >> c.m_debugId;
 270
 271     int contextCount;
 272     ds >> contextCount;
 273
 274     for (int ii = 0; ii < contextCount; ++ii) {
 275         c.m_contexts.append(QQmlDebugContextReference());
 276         decode(ds, c.m_contexts.last());
 277     }
 278
 279     int objectCount;
 280     ds >> objectCount;
 281
 282     for (int ii = 0; ii < objectCount; ++ii) {
 283         QQmlDebugObjectReference obj;
 284         decode(ds, obj, true);
 285
 286         obj.m_contextDebugId = c.m_debugId;
 287         c.m_objects << obj;
 288     }
 289 }
 290
 291 void QQmlEngineDebugPrivate::stateChanged(QQmlEngineDebug::State status)
 292 {
 293     emit q_func()->stateChanged(status);
 294 }
 295
 296 void QQmlEngineDebugPrivate::message(const QByteArray &data)
 297 {
 298     QDataStream ds(data);
 299
 300     QByteArray type;
 301     ds >> type;
 302
 303     //qDebug() << "QQmlEngineDebugPrivate::message()" << type;
 304
 305     if (type == "LIST_ENGINES_R") {
 306         int queryId;
 307         ds >> queryId;
 308
 309         QQmlDebugEnginesQuery *query = enginesQuery.value(queryId);
 310         if (!query)
 311             return;
 312         enginesQuery.remove(queryId);
 313
 314         int count;
 315         ds >> count;
 316
 317         for (int ii = 0; ii < count; ++ii) {
 318             QQmlDebugEngineReference ref;
 319             ds >> ref.m_name;
 320             ds >> ref.m_debugId;
 321             query->m_engines << ref;
 322         }
 323
 324         query->m_client = 0;
 325         query->setState(QQmlDebugQuery::Completed);
 326     } else if (type == "LIST_OBJECTS_R") {
 327         int queryId;
 328         ds >> queryId;
 329
 330         QQmlDebugRootContextQuery *query = rootContextQuery.value(queryId);
 331         if (!query)
 332             return;
 333         rootContextQuery.remove(queryId);
 334
 335         if (!ds.atEnd())
 336             decode(ds, query->m_context);
 337
 338         query->m_client = 0;
 339         query->setState(QQmlDebugQuery::Completed);
 340     } else if (type == "FETCH_OBJECT_R") {
 341         int queryId;
 342         ds >> queryId;
 343
 344         QQmlDebugObjectQuery *query = objectQuery.value(queryId);
 345         if (!query)
 346             return;
 347         objectQuery.remove(queryId);
 348
 349         if (!ds.atEnd())
 350             decode(ds, query->m_object, false);
 351
 352         query->m_client = 0;
 353         query->setState(QQmlDebugQuery::Completed);
 354     } else if (type == "EVAL_EXPRESSION_R") {
 355         int queryId;
 356         QVariant result;
 357         ds >> queryId >> result;
 358
 359         QQmlDebugExpressionQuery *query = expressionQuery.value(queryId);
 360         if (!query)
 361             return;
 362         expressionQuery.remove(queryId);
 363
 364         query->m_result = result;
 365         query->m_client = 0;
 366         query->setState(QQmlDebugQuery::Completed);
 367     } else if (type == "WATCH_PROPERTY_R") {
 368         int queryId;
 369         bool ok;
 370         ds >> queryId >> ok;
 371
 372         QQmlDebugWatch *watch = watched.value(queryId);
 373         if (!watch)
 374             return;
 375
 376         watch->setState(ok ? QQmlDebugWatch::Active : QQmlDebugWatch::Inactive);
 377     } else if (type == "WATCH_OBJECT_R") {
 378         int queryId;
 379         bool ok;
 380         ds >> queryId >> ok;
 381
 382         QQmlDebugWatch *watch = watched.value(queryId);
 383         if (!watch)
 384             return;
 385
 386         watch->setState(ok ? QQmlDebugWatch::Active : QQmlDebugWatch::Inactive);
 387     } else if (type == "WATCH_EXPR_OBJECT_R") {
 388         int queryId;
 389         bool ok;
 390         ds >> queryId >> ok;
 391
 392         QQmlDebugWatch *watch = watched.value(queryId);
 393         if (!watch)
 394             return;
 395
 396         watch->setState(ok ? QQmlDebugWatch::Active : QQmlDebugWatch::Inactive);
 397     } else if (type == "UPDATE_WATCH") {
 398         int queryId;
 399         int debugId;
 400         QByteArray name;
 401         QVariant value;
 402         ds >> queryId >> debugId >> name >> value;
 403
 404         QQmlDebugWatch *watch = watched.value(queryId, 0);
 405         if (!watch)
 406             return;
 407         emit watch->valueChanged(name, value);
 408     } else if (type == "OBJECT_CREATED") {
 409         emit q_func()->newObjects();
 410     }
 411 }
 412
 413 QQmlEngineDebug::QQmlEngineDebug(QQmlDebugConnection *client, QObject *parent)
 414     : QObject(*(new QQmlEngineDebugPrivate(client)), parent)
 415 {
 416 }
 417
 418 QQmlEngineDebug::~QQmlEngineDebug()
 419 {
 420 }
 421
 422 QQmlEngineDebug::State QQmlEngineDebug::state() const
 423 {
 424     Q_D(const QQmlEngineDebug);
 425
 426     return static_cast<QQmlEngineDebug::State>(d->client->state());
 427 }
 428
 429 QQmlDebugPropertyWatch *QQmlEngineDebug::addWatch(const QQmlDebugPropertyReference &property, QObject *parent)
 430 {
 431     Q_D(QQmlEngineDebug);
 432
 433     QQmlDebugPropertyWatch *watch = new QQmlDebugPropertyWatch(parent);
 434     if (d->client->state() == QQmlDebugClient::Enabled) {
 435         int queryId = d->getId();
 436         watch->m_queryId = queryId;
 437         watch->m_client = this;
 438         watch->m_objectDebugId = property.objectDebugId();
 439         watch->m_name = property.name();
 440         d->watched.insert(queryId, watch);
 441
 442         QByteArray message;
 443         QDataStream ds(&message, QIODevice::WriteOnly);
 444         ds << QByteArray("WATCH_PROPERTY") << queryId << property.objectDebugId() << property.name().toUtf8();
 445         d->client->sendMessage(message);
 446     } else {
 447         watch->m_state = QQmlDebugWatch::Dead;
 448     }
 449
 450     return watch;
 451 }
 452
 453 QQmlDebugWatch *QQmlEngineDebug::addWatch(const QQmlDebugContextReference &, const QString &, QObject *)
 454 {
 455     qWarning("QQmlEngineDebug::addWatch(): Not implemented");
 456     return 0;
 457 }
 458
 459 QQmlDebugObjectExpressionWatch *QQmlEngineDebug::addWatch(const QQmlDebugObjectReference &object, const QString &expr, QObject *parent)
 460 {
 461     Q_D(QQmlEngineDebug);
 462     QQmlDebugObjectExpressionWatch *watch = new QQmlDebugObjectExpressionWatch(parent);
 463     if (d->client->state() == QQmlDebugClient::Enabled) {
 464         int queryId = d->getId();
 465         watch->m_queryId = queryId;
 466         watch->m_client = this;
 467         watch->m_objectDebugId = object.debugId();
 468         watch->m_expr = expr;
 469         d->watched.insert(queryId, watch);
 470
 471         QByteArray message;
 472         QDataStream ds(&message, QIODevice::WriteOnly);
 473         ds << QByteArray("WATCH_EXPR_OBJECT") << queryId << object.debugId() << expr;
 474         d->client->sendMessage(message);
 475     } else {
 476         watch->m_state = QQmlDebugWatch::Dead;
 477     }
 478     return watch;
 479 }
 480
 481 QQmlDebugWatch *QQmlEngineDebug::addWatch(const QQmlDebugObjectReference &object, QObject *parent)
 482 {
 483     Q_D(QQmlEngineDebug);
 484
 485     QQmlDebugWatch *watch = new QQmlDebugWatch(parent);
 486     if (d->client->state() == QQmlDebugClient::Enabled) {
 487         int queryId = d->getId();
 488         watch->m_queryId = queryId;
 489         watch->m_client = this;
 490         watch->m_objectDebugId = object.debugId();
 491         d->watched.insert(queryId, watch);
 492
 493         QByteArray message;
 494         QDataStream ds(&message, QIODevice::WriteOnly);
 495         ds << QByteArray("WATCH_OBJECT") << queryId << object.debugId();
 496         d->client->sendMessage(message);
 497     } else {
 498         watch->m_state = QQmlDebugWatch::Dead;
 499     }
 500
 501     return watch;
 502 }
 503
 504 QQmlDebugWatch *QQmlEngineDebug::addWatch(const QQmlDebugFileReference &, QObject *)
 505 {
 506     qWarning("QQmlEngineDebug::addWatch(): Not implemented");
 507     return 0;
 508 }
 509
 510 void QQmlEngineDebug::removeWatch(QQmlDebugWatch *watch)
 511 {
 512     Q_D(QQmlEngineDebug);
 513
 514     if (!watch || !watch->m_client)
 515         return;
 516
 517     watch->m_client = 0;
 518     watch->setState(QQmlDebugWatch::Inactive);
 519
 520     d->watched.remove(watch->queryId());
 521
 522     if (d->client && d->client->state() == QQmlDebugClient::Enabled) {
 523         QByteArray message;
 524         QDataStream ds(&message, QIODevice::WriteOnly);
 525         ds << QByteArray("NO_WATCH") << watch->queryId();
 526         d->client->sendMessage(message);
 527     }
 528 }
 529
 530 QQmlDebugEnginesQuery *QQmlEngineDebug::queryAvailableEngines(QObject *parent)
 531 {
 532     Q_D(QQmlEngineDebug);
 533
 534     QQmlDebugEnginesQuery *query = new QQmlDebugEnginesQuery(parent);
 535     if (d->client->state() == QQmlDebugClient::Enabled) {
 536         query->m_client = this;
 537         int queryId = d->getId();
 538         query->m_queryId = queryId;
 539         d->enginesQuery.insert(queryId, query);
 540
 541         QByteArray message;
 542         QDataStream ds(&message, QIODevice::WriteOnly);
 543         ds << QByteArray("LIST_ENGINES") << queryId;
 544         d->client->sendMessage(message);
 545     } else {
 546         query->m_state = QQmlDebugQuery::Error;
 547     }
 548
 549     return query;
 550 }
 551
 552 QQmlDebugRootContextQuery *QQmlEngineDebug::queryRootContexts(const QQmlDebugEngineReference &engine, QObject *parent)
 553 {
 554     Q_D(QQmlEngineDebug);
 555
 556     QQmlDebugRootContextQuery *query = new QQmlDebugRootContextQuery(parent);
 557     if (d->client->state() == QQmlDebugClient::Enabled && engine.debugId() != -1) {
 558         query->m_client = this;
 559         int queryId = d->getId();
 560         query->m_queryId = queryId;
 561         d->rootContextQuery.insert(queryId, query);
 562
 563         QByteArray message;
 564         QDataStream ds(&message, QIODevice::WriteOnly);
 565         ds << QByteArray("LIST_OBJECTS") << queryId << engine.debugId();
 566         d->client->sendMessage(message);
 567     } else {
 568         query->m_state = QQmlDebugQuery::Error;
 569     }
 570
 571     return query;
 572 }
 573
 574 QQmlDebugObjectQuery *QQmlEngineDebug::queryObject(const QQmlDebugObjectReference &object, QObject *parent)
 575 {
 576     Q_D(QQmlEngineDebug);
 577
 578     QQmlDebugObjectQuery *query = new QQmlDebugObjectQuery(parent);
 579     if (d->client->state() == QQmlDebugClient::Enabled && object.debugId() != -1) {
 580         query->m_client = this;
 581         int queryId = d->getId();
 582         query->m_queryId = queryId;
 583         d->objectQuery.insert(queryId, query);
 584
 585         QByteArray message;
 586         QDataStream ds(&message, QIODevice::WriteOnly);
 587         ds << QByteArray("FETCH_OBJECT") << queryId << object.debugId()
 588            << false << true;
 589         d->client->sendMessage(message);
 590     } else {
 591         query->m_state = QQmlDebugQuery::Error;
 592     }
 593
 594     return query;
 595 }
 596
 597 QQmlDebugObjectQuery *QQmlEngineDebug::queryObjectRecursive(const QQmlDebugObjectReference &object, QObject *parent)
 598 {
 599     Q_D(QQmlEngineDebug);
 600
 601     QQmlDebugObjectQuery *query = new QQmlDebugObjectQuery(parent);
 602     if (d->client->state() == QQmlDebugClient::Enabled && object.debugId() != -1) {
 603         query->m_client = this;
 604         int queryId = d->getId();
 605         query->m_queryId = queryId;
 606         d->objectQuery.insert(queryId, query);
 607
 608         QByteArray message;
 609         QDataStream ds(&message, QIODevice::WriteOnly);
 610         ds << QByteArray("FETCH_OBJECT") << queryId << object.debugId()
 611            << true << true;
 612         d->client->sendMessage(message);
 613     } else {
 614         query->m_state = QQmlDebugQuery::Error;
 615     }
 616
 617     return query;
 618 }
 619
 620 QQmlDebugExpressionQuery *QQmlEngineDebug::queryExpressionResult(int objectDebugId, const QString &expr, QObject *parent)
 621 {
 622     Q_D(QQmlEngineDebug);
 623
 624     QQmlDebugExpressionQuery *query = new QQmlDebugExpressionQuery(parent);
 625     if (d->client->state() == QQmlDebugClient::Enabled && objectDebugId != -1) {
 626         query->m_client = this;
 627         query->m_expr = expr;
 628         int queryId = d->getId();
 629         query->m_queryId = queryId;
 630         d->expressionQuery.insert(queryId, query);
 631
 632         QByteArray message;
 633         QDataStream ds(&message, QIODevice::WriteOnly);
 634         ds << QByteArray("EVAL_EXPRESSION") << queryId << objectDebugId << expr;
 635         d->client->sendMessage(message);
 636     } else {
 637         query->m_state = QQmlDebugQuery::Error;
 638     }
 639
 640     return query;
 641 }
 642
 643 bool QQmlEngineDebug::setBindingForObject(int objectDebugId, const QString &propertyName,
 644                                                   const QVariant &bindingExpression,
 645                                                   bool isLiteralValue,
 646                                                   QString source, int line)
 647 {
 648     Q_D(QQmlEngineDebug);
 649
 650     if (d->client->state() == QQmlDebugClient::Enabled && objectDebugId != -1) {
 651         QByteArray message;
 652         QDataStream ds(&message, QIODevice::WriteOnly);
 653         ds << QByteArray("SET_BINDING") << objectDebugId << propertyName << bindingExpression << isLiteralValue << source << line;
 654         d->client->sendMessage(message);
 655         return true;
 656     } else {
 657         return false;
 658     }
 659 }
 660
 661 bool QQmlEngineDebug::resetBindingForObject(int objectDebugId, const QString &propertyName)
 662 {
 663     Q_D(QQmlEngineDebug);
 664
 665     if (d->client->state() == QQmlDebugClient::Enabled && objectDebugId != -1) {
 666         QByteArray message;
 667         QDataStream ds(&message, QIODevice::WriteOnly);
 668         ds << QByteArray("RESET_BINDING") << objectDebugId << propertyName;
 669         d->client->sendMessage(message);
 670         return true;
 671     } else {
 672         return false;
 673     }
 674 }
 675
 676 bool QQmlEngineDebug::setMethodBody(int objectDebugId, const QString &methodName,
 677                                             const QString &methodBody)
 678 {
 679     Q_D(QQmlEngineDebug);
 680
 681     if (d->client->state() == QQmlDebugClient::Enabled && objectDebugId != -1) {
 682         QByteArray message;
 683         QDataStream ds(&message, QIODevice::WriteOnly);
 684         ds << QByteArray("SET_METHOD_BODY") << objectDebugId << methodName << methodBody;
 685         d->client->sendMessage(message);
 686         return true;
 687     } else {
 688         return false;
 689     }
 690 }
 691
 692 QQmlDebugWatch::QQmlDebugWatch(QObject *parent)
 693     : QObject(parent), m_state(Waiting), m_queryId(-1), m_client(0), m_objectDebugId(-1)
 694 {
 695 }
 696
 697 QQmlDebugWatch::~QQmlDebugWatch()
 698 {
 699     if (m_client && m_queryId != -1)
 700         QQmlEngineDebugPrivate::remove(m_client, this);
 701 }
 702
 703 int QQmlDebugWatch::queryId() const
 704 {
 705     return m_queryId;
 706 }
 707
 708 int QQmlDebugWatch::objectDebugId() const
 709 {
 710     return m_objectDebugId;
 711 }
 712
 713 QQmlDebugWatch::State QQmlDebugWatch::state() const
 714 {
 715     return m_state;
 716 }
 717
 718 void QQmlDebugWatch::setState(State s)
 719 {
 720     if (m_state == s)
 721         return;
 722     m_state = s;
 723     emit stateChanged(m_state);
 724 }
 725
 726 QQmlDebugPropertyWatch::QQmlDebugPropertyWatch(QObject *parent)
 727     : QQmlDebugWatch(parent)
 728 {
 729 }
 730
 731 QString QQmlDebugPropertyWatch::name() const
 732 {
 733     return m_name;
 734 }
 735
 736
 737 QQmlDebugObjectExpressionWatch::QQmlDebugObjectExpressionWatch(QObject *parent)
 738     : QQmlDebugWatch(parent)
 739 {
 740 }
 741
 742 QString QQmlDebugObjectExpressionWatch::expression() const
 743 {
 744     return m_expr;
 745 }
 746
 747
 748 QQmlDebugQuery::QQmlDebugQuery(QObject *parent)
 749     : QObject(parent), m_state(Waiting)
 750 {
 751 }
 752
 753 QQmlDebugQuery::State QQmlDebugQuery::state() const
 754 {
 755     return m_state;
 756 }
 757
 758 bool QQmlDebugQuery::isWaiting() const
 759 {
 760     return m_state == Waiting;
 761 }
 762
 763 void QQmlDebugQuery::setState(State s)
 764 {
 765     if (m_state == s)
 766         return;
 767     m_state = s;
 768     emit stateChanged(m_state);
 769 }
 770
 771 QQmlDebugEnginesQuery::QQmlDebugEnginesQuery(QObject *parent)
 772     : QQmlDebugQuery(parent), m_client(0), m_queryId(-1)
 773 {
 774 }
 775
 776 QQmlDebugEnginesQuery::~QQmlDebugEnginesQuery()
 777 {
 778     if (m_client && m_queryId != -1)
 779         QQmlEngineDebugPrivate::remove(m_client, this);
 780 }
 781
 782 QList<QQmlDebugEngineReference> QQmlDebugEnginesQuery::engines() const
 783 {
 784     return m_engines;
 785 }
 786
 787 QQmlDebugRootContextQuery::QQmlDebugRootContextQuery(QObject *parent)
 788     : QQmlDebugQuery(parent), m_client(0), m_queryId(-1)
 789 {
 790 }
 791
 792 QQmlDebugRootContextQuery::~QQmlDebugRootContextQuery()
 793 {
 794     if (m_client && m_queryId != -1)
 795         QQmlEngineDebugPrivate::remove(m_client, this);
 796 }
 797
 798 QQmlDebugContextReference QQmlDebugRootContextQuery::rootContext() const
 799 {
 800     return m_context;
 801 }
 802
 803 QQmlDebugObjectQuery::QQmlDebugObjectQuery(QObject *parent)
 804     : QQmlDebugQuery(parent), m_client(0), m_queryId(-1)
 805 {
 806 }
 807
 808 QQmlDebugObjectQuery::~QQmlDebugObjectQuery()
 809 {
 810     if (m_client && m_queryId != -1)
 811         QQmlEngineDebugPrivate::remove(m_client, this);
 812 }
 813
 814 QQmlDebugObjectReference QQmlDebugObjectQuery::object() const
 815 {
 816     return m_object;
 817 }
 818
 819 QQmlDebugExpressionQuery::QQmlDebugExpressionQuery(QObject *parent)
 820     : QQmlDebugQuery(parent), m_client(0), m_queryId(-1)
 821 {
 822 }
 823
 824 QQmlDebugExpressionQuery::~QQmlDebugExpressionQuery()
 825 {
 826     if (m_client && m_queryId != -1)
 827         QQmlEngineDebugPrivate::remove(m_client, this);
 828 }
 829
 830 QVariant QQmlDebugExpressionQuery::expression() const
 831 {
 832     return m_expr;
 833 }
 834
 835 QVariant QQmlDebugExpressionQuery::result() const
 836 {
 837     return m_result;
 838 }
 839
 840 QQmlDebugEngineReference::QQmlDebugEngineReference()
 841     : m_debugId(-1)
 842 {
 843 }
 844
 845 QQmlDebugEngineReference::QQmlDebugEngineReference(int debugId)
 846     : m_debugId(debugId)
 847 {
 848 }
 849
 850 QQmlDebugEngineReference::QQmlDebugEngineReference(const QQmlDebugEngineReference &o)
 851     : m_debugId(o.m_debugId), m_name(o.m_name)
 852 {
 853 }
 854
 855 QQmlDebugEngineReference &
 856 QQmlDebugEngineReference::operator=(const QQmlDebugEngineReference &o)
 857 {
 858     m_debugId = o.m_debugId; m_name = o.m_name;
 859     return *this;
 860 }
 861
 862 int QQmlDebugEngineReference::debugId() const
 863 {
 864     return m_debugId;
 865 }
 866
 867 QString QQmlDebugEngineReference::name() const
 868 {
 869     return m_name;
 870 }
 871
 872 QQmlDebugObjectReference::QQmlDebugObjectReference()
 873     : m_debugId(-1), m_contextDebugId(-1)
 874 {
 875 }
 876
 877 QQmlDebugObjectReference::QQmlDebugObjectReference(int debugId)
 878     : m_debugId(debugId), m_contextDebugId(-1)
 879 {
 880 }
 881
 882 QQmlDebugObjectReference::QQmlDebugObjectReference(const QQmlDebugObjectReference &o)
 883     : m_debugId(o.m_debugId), m_class(o.m_class), m_idString(o.m_idString),
 884       m_name(o.m_name), m_source(o.m_source), m_contextDebugId(o.m_contextDebugId),
 885       m_properties(o.m_properties), m_children(o.m_children)
 886 {
 887 }
 888
 889 QQmlDebugObjectReference &
 890 QQmlDebugObjectReference::operator=(const QQmlDebugObjectReference &o)
 891 {
 892     m_debugId = o.m_debugId; m_class = o.m_class; m_idString = o.m_idString;
 893     m_name = o.m_name; m_source = o.m_source; m_contextDebugId = o.m_contextDebugId;
 894     m_properties = o.m_properties; m_children = o.m_children;
 895     return *this;
 896 }
 897
 898 int QQmlDebugObjectReference::debugId() const
 899 {
 900     return m_debugId;
 901 }
 902
 903 QString QQmlDebugObjectReference::className() const
 904 {
 905     return m_class;
 906 }
 907
 908 QString QQmlDebugObjectReference::idString() const
 909 {
 910     return m_idString;
 911 }
 912
 913 QString QQmlDebugObjectReference::name() const
 914 {
 915     return m_name;
 916 }
 917
 918 QQmlDebugFileReference QQmlDebugObjectReference::source() const
 919 {
 920     return m_source;
 921 }
 922
 923 int QQmlDebugObjectReference::contextDebugId() const
 924 {
 925     return m_contextDebugId;
 926 }
 927
 928 QList<QQmlDebugPropertyReference> QQmlDebugObjectReference::properties() const
 929 {
 930     return m_properties;
 931 }
 932
 933 QList<QQmlDebugObjectReference> QQmlDebugObjectReference::children() const
 934 {
 935     return m_children;
 936 }
 937
 938 QQmlDebugContextReference::QQmlDebugContextReference()
 939     : m_debugId(-1)
 940 {
 941 }
 942
 943 QQmlDebugContextReference::QQmlDebugContextReference(const QQmlDebugContextReference &o)
 944     : m_debugId(o.m_debugId), m_name(o.m_name), m_objects(o.m_objects), m_contexts(o.m_contexts)
 945 {
 946 }
 947
 948 QQmlDebugContextReference &QQmlDebugContextReference::operator=(const QQmlDebugContextReference &o)
 949 {
 950     m_debugId = o.m_debugId; m_name = o.m_name; m_objects = o.m_objects;
 951     m_contexts = o.m_contexts;
 952     return *this;
 953 }
 954
 955 int QQmlDebugContextReference::debugId() const
 956 {
 957     return m_debugId;
 958 }
 959
 960 QString QQmlDebugContextReference::name() const
 961 {
 962     return m_name;
 963 }
 964
 965 QList<QQmlDebugObjectReference> QQmlDebugContextReference::objects() const
 966 {
 967     return m_objects;
 968 }
 969
 970 QList<QQmlDebugContextReference> QQmlDebugContextReference::contexts() const
 971 {
 972     return m_contexts;
 973 }
 974
 975 QQmlDebugFileReference::QQmlDebugFileReference()
 976     : m_lineNumber(-1), m_columnNumber(-1)
 977 {
 978 }
 979
 980 QQmlDebugFileReference::QQmlDebugFileReference(const QQmlDebugFileReference &o)
 981     : m_url(o.m_url), m_lineNumber(o.m_lineNumber), m_columnNumber(o.m_columnNumber)
 982 {
 983 }
 984
 985 QQmlDebugFileReference &QQmlDebugFileReference::operator=(const QQmlDebugFileReference &o)
 986 {
 987     m_url = o.m_url; m_lineNumber = o.m_lineNumber; m_columnNumber = o.m_columnNumber;
 988     return *this;
 989 }
 990
 991 QUrl QQmlDebugFileReference::url() const
 992 {
 993     return m_url;
 994 }
 995
 996 void QQmlDebugFileReference::setUrl(const QUrl &u)
 997 {
 998     m_url = u;
 999 }
1000
1001 int QQmlDebugFileReference::lineNumber() const
1002 {
1003     return m_lineNumber;
1004 }
1005
1006 void QQmlDebugFileReference::setLineNumber(int l)
1007 {
1008     m_lineNumber = l;
1009 }
1010
1011 int QQmlDebugFileReference::columnNumber() const
1012 {
1013     return m_columnNumber;
1014 }
1015
1016 void QQmlDebugFileReference::setColumnNumber(int c)
1017 {
1018     m_columnNumber = c;
1019 }
1020
1021 QQmlDebugPropertyReference::QQmlDebugPropertyReference()
1022     : m_objectDebugId(-1), m_hasNotifySignal(false)
1023 {
1024 }
1025
1026 QQmlDebugPropertyReference::QQmlDebugPropertyReference(const QQmlDebugPropertyReference &o)
1027     : m_objectDebugId(o.m_objectDebugId), m_name(o.m_name), m_value(o.m_value),
1028       m_valueTypeName(o.m_valueTypeName), m_binding(o.m_binding),
1029       m_hasNotifySignal(o.m_hasNotifySignal)
1030 {
1031 }
1032
1033 QQmlDebugPropertyReference &QQmlDebugPropertyReference::operator=(const QQmlDebugPropertyReference &o)
1034 {
1035     m_objectDebugId = o.m_objectDebugId; m_name = o.m_name; m_value = o.m_value;
1036     m_valueTypeName = o.m_valueTypeName; m_binding = o.m_binding;
1037     m_hasNotifySignal = o.m_hasNotifySignal;
1038     return *this;
1039 }
1040
1041 int QQmlDebugPropertyReference::objectDebugId() const
1042 {
1043     return m_objectDebugId;
1044 }
1045
1046 QString QQmlDebugPropertyReference::name() const
1047 {
1048     return m_name;
1049 }
1050
1051 QString QQmlDebugPropertyReference::valueTypeName() const
1052 {
1053     return m_valueTypeName;
1054 }
1055
1056 QVariant QQmlDebugPropertyReference::value() const
1057 {
1058     return m_value;
1059 }
1060
1061 QString QQmlDebugPropertyReference::binding() const
1062 {
1063     return m_binding;
1064 }
1065
1066 bool QQmlDebugPropertyReference::hasNotifySignal() const
1067 {
1068     return m_hasNotifySignal;
1069 }
1070
1071 QT_END_NAMESPACE
1072