src/declarative/debugger/qdeclarativeenginedebug.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 QtDeclarative 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 "qdeclarativeenginedebug_p.h"
  43
  44 #include "qdeclarativedebugclient_p.h"
  45
  46 #include "qdeclarativeenginedebugservice_p.h"
  47
  48 #include <private/qobject_p.h>
  49
  50 QT_BEGIN_NAMESPACE
  51
  52 class QDeclarativeEngineDebugClient : public QDeclarativeDebugClient
  53 {
  54 public:
  55     QDeclarativeEngineDebugClient(QDeclarativeDebugConnection *client, QDeclarativeEngineDebugPrivate *p);
  56
  57 protected:
  58     virtual void statusChanged(Status status);
  59     virtual void messageReceived(const QByteArray &);
  60
  61 private:
  62     QDeclarativeEngineDebugPrivate *priv;
  63     friend class QDeclarativeEngineDebugPrivate;
  64 };
  65
  66 class QDeclarativeEngineDebugPrivate : public QObjectPrivate
  67 {
  68     Q_DECLARE_PUBLIC(QDeclarativeEngineDebug)
  69 public:
  70     QDeclarativeEngineDebugPrivate(QDeclarativeDebugConnection *);
  71     ~QDeclarativeEngineDebugPrivate();
  72
  73     void statusChanged(QDeclarativeEngineDebug::Status status);
  74     void message(const QByteArray &);
  75
  76     QDeclarativeEngineDebugClient *client;
  77     int nextId;
  78     int getId();
  79
  80     void decode(QDataStream &, QDeclarativeDebugContextReference &);
  81     void decode(QDataStream &, QDeclarativeDebugObjectReference &, bool simple);
  82
  83     static void remove(QDeclarativeEngineDebug *, QDeclarativeDebugEnginesQuery *);
  84     static void remove(QDeclarativeEngineDebug *, QDeclarativeDebugRootContextQuery *);
  85     static void remove(QDeclarativeEngineDebug *, QDeclarativeDebugObjectQuery *);
  86     static void remove(QDeclarativeEngineDebug *, QDeclarativeDebugExpressionQuery *);
  87     static void remove(QDeclarativeEngineDebug *, QDeclarativeDebugWatch *);
  88
  89     QHash<int, QDeclarativeDebugEnginesQuery *> enginesQuery;
  90     QHash<int, QDeclarativeDebugRootContextQuery *> rootContextQuery;
  91     QHash<int, QDeclarativeDebugObjectQuery *> objectQuery;
  92     QHash<int, QDeclarativeDebugExpressionQuery *> expressionQuery;
  93
  94     QHash<int, QDeclarativeDebugWatch *> watched;
  95 };
  96
  97 QDeclarativeEngineDebugClient::QDeclarativeEngineDebugClient(QDeclarativeDebugConnection *client,
  98                                                              QDeclarativeEngineDebugPrivate *p)
  99     : QDeclarativeDebugClient(QLatin1String("QDeclarativeEngine"), client), priv(p)
 100 {
 101 }
 102
 103 void QDeclarativeEngineDebugClient::statusChanged(Status status)
 104 {
 105     if (priv)
 106         priv->statusChanged(static_cast<QDeclarativeEngineDebug::Status>(status));
 107 }
 108
 109 void QDeclarativeEngineDebugClient::messageReceived(const QByteArray &data)
 110 {
 111     if (priv)
 112         priv->message(data);
 113 }
 114
 115 QDeclarativeEngineDebugPrivate::QDeclarativeEngineDebugPrivate(QDeclarativeDebugConnection *c)
 116     : client(new QDeclarativeEngineDebugClient(c, this)), nextId(0)
 117 {
 118 }
 119
 120 QDeclarativeEngineDebugPrivate::~QDeclarativeEngineDebugPrivate()
 121 {
 122     if (client)
 123         client->priv = 0;
 124     delete client;
 125
 126     QHash<int, QDeclarativeDebugEnginesQuery*>::iterator enginesIter = enginesQuery.begin();
 127     for (; enginesIter != enginesQuery.end(); ++enginesIter) {
 128         enginesIter.value()->m_client = 0;
 129         if (enginesIter.value()->state() == QDeclarativeDebugQuery::Waiting)
 130             enginesIter.value()->setState(QDeclarativeDebugQuery::Error);
 131     }
 132
 133     QHash<int, QDeclarativeDebugRootContextQuery*>::iterator rootContextIter = rootContextQuery.begin();
 134     for (; rootContextIter != rootContextQuery.end(); ++rootContextIter) {
 135         rootContextIter.value()->m_client = 0;
 136         if (rootContextIter.value()->state() == QDeclarativeDebugQuery::Waiting)
 137             rootContextIter.value()->setState(QDeclarativeDebugQuery::Error);
 138     }
 139
 140     QHash<int, QDeclarativeDebugObjectQuery*>::iterator objectIter = objectQuery.begin();
 141     for (; objectIter != objectQuery.end(); ++objectIter) {
 142         objectIter.value()->m_client = 0;
 143         if (objectIter.value()->state() == QDeclarativeDebugQuery::Waiting)
 144             objectIter.value()->setState(QDeclarativeDebugQuery::Error);
 145     }
 146
 147     QHash<int, QDeclarativeDebugExpressionQuery*>::iterator exprIter = expressionQuery.begin();
 148     for (; exprIter != expressionQuery.end(); ++exprIter) {
 149         exprIter.value()->m_client = 0;
 150         if (exprIter.value()->state() == QDeclarativeDebugQuery::Waiting)
 151             exprIter.value()->setState(QDeclarativeDebugQuery::Error);
 152     }
 153
 154     QHash<int, QDeclarativeDebugWatch*>::iterator watchIter = watched.begin();
 155     for (; watchIter != watched.end(); ++watchIter) {
 156         watchIter.value()->m_client = 0;
 157         watchIter.value()->setState(QDeclarativeDebugWatch::Dead);
 158     }
 159 }
 160
 161 int QDeclarativeEngineDebugPrivate::getId()
 162 {
 163     return nextId++;
 164 }
 165
 166 void QDeclarativeEngineDebugPrivate::remove(QDeclarativeEngineDebug *c, QDeclarativeDebugEnginesQuery *q)
 167 {
 168     if (c && q) {
 169         QDeclarativeEngineDebugPrivate *p = (QDeclarativeEngineDebugPrivate *)QObjectPrivate::get(c);
 170         p->enginesQuery.remove(q->m_queryId);
 171     }
 172 }
 173
 174 void QDeclarativeEngineDebugPrivate::remove(QDeclarativeEngineDebug *c,
 175                                             QDeclarativeDebugRootContextQuery *q)
 176 {
 177     if (c && q) {
 178         QDeclarativeEngineDebugPrivate *p = (QDeclarativeEngineDebugPrivate *)QObjectPrivate::get(c);
 179         p->rootContextQuery.remove(q->m_queryId);
 180     }
 181 }
 182
 183 void QDeclarativeEngineDebugPrivate::remove(QDeclarativeEngineDebug *c, QDeclarativeDebugObjectQuery *q)
 184 {
 185     if (c && q) {
 186         QDeclarativeEngineDebugPrivate *p = (QDeclarativeEngineDebugPrivate *)QObjectPrivate::get(c);
 187         p->objectQuery.remove(q->m_queryId);
 188     }
 189 }
 190
 191 void QDeclarativeEngineDebugPrivate::remove(QDeclarativeEngineDebug *c, QDeclarativeDebugExpressionQuery *q)
 192 {
 193     if (c && q) {
 194         QDeclarativeEngineDebugPrivate *p = (QDeclarativeEngineDebugPrivate *)QObjectPrivate::get(c);
 195         p->expressionQuery.remove(q->m_queryId);
 196     }
 197 }
 198
 199 void QDeclarativeEngineDebugPrivate::remove(QDeclarativeEngineDebug *c, QDeclarativeDebugWatch *w)
 200 {
 201     if (c && w) {
 202         QDeclarativeEngineDebugPrivate *p = (QDeclarativeEngineDebugPrivate *)QObjectPrivate::get(c);
 203         p->watched.remove(w->m_queryId);
 204     }
 205 }
 206
 207 void QDeclarativeEngineDebugPrivate::decode(QDataStream &ds, QDeclarativeDebugObjectReference &o,
 208                                             bool simple)
 209 {
 210     QDeclarativeEngineDebugService::QDeclarativeObjectData 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(QDeclarativeDebugObjectReference());
 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         QDeclarativeEngineDebugService::QDeclarativeObjectProperty data;
 238         ds >> data;
 239         QDeclarativeDebugPropertyReference 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 QDeclarativeEngineDebugService::QDeclarativeObjectProperty::Basic:
 247         case QDeclarativeEngineDebugService::QDeclarativeObjectProperty::List:
 248         case QDeclarativeEngineDebugService::QDeclarativeObjectProperty::SignalProperty:
 249         {
 250             prop.m_value = data.value;
 251             break;
 252         }
 253         case QDeclarativeEngineDebugService::QDeclarativeObjectProperty::Object:
 254         {
 255             QDeclarativeDebugObjectReference obj;
 256             obj.m_debugId = prop.m_value.toInt();
 257             prop.m_value = QVariant::fromValue(obj);
 258             break;
 259         }
 260         case QDeclarativeEngineDebugService::QDeclarativeObjectProperty::Unknown:
 261             break;
 262         }
 263         o.m_properties << prop;
 264     }
 265 }
 266
 267 void QDeclarativeEngineDebugPrivate::decode(QDataStream &ds, QDeclarativeDebugContextReference &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(QDeclarativeDebugContextReference());
 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         QDeclarativeDebugObjectReference obj;
 284         decode(ds, obj, true);
 285
 286         obj.m_contextDebugId = c.m_debugId;
 287         c.m_objects << obj;
 288     }
 289 }
 290
 291 void QDeclarativeEngineDebugPrivate::statusChanged(QDeclarativeEngineDebug::Status status)
 292 {
 293     emit q_func()->statusChanged(status);
 294 }
 295
 296 void QDeclarativeEngineDebugPrivate::message(const QByteArray &data)
 297 {
 298     QDataStream ds(data);
 299
 300     QByteArray type;
 301     ds >> type;
 302
 303     //qDebug() << "QDeclarativeEngineDebugPrivate::message()" << type;
 304
 305     if (type == "LIST_ENGINES_R") {
 306         int queryId;
 307         ds >> queryId;
 308
 309         QDeclarativeDebugEnginesQuery *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             QDeclarativeDebugEngineReference 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(QDeclarativeDebugQuery::Completed);
 326     } else if (type == "LIST_OBJECTS_R") {
 327         int queryId;
 328         ds >> queryId;
 329
 330         QDeclarativeDebugRootContextQuery *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(QDeclarativeDebugQuery::Completed);
 340     } else if (type == "FETCH_OBJECT_R") {
 341         int queryId;
 342         ds >> queryId;
 343
 344         QDeclarativeDebugObjectQuery *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(QDeclarativeDebugQuery::Completed);
 354     } else if (type == "EVAL_EXPRESSION_R") {
 355         int queryId;
 356         QVariant result;
 357         ds >> queryId >> result;
 358
 359         QDeclarativeDebugExpressionQuery *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(QDeclarativeDebugQuery::Completed);
 367     } else if (type == "WATCH_PROPERTY_R") {
 368         int queryId;
 369         bool ok;
 370         ds >> queryId >> ok;
 371
 372         QDeclarativeDebugWatch *watch = watched.value(queryId);
 373         if (!watch)
 374             return;
 375
 376         watch->setState(ok ? QDeclarativeDebugWatch::Active : QDeclarativeDebugWatch::Inactive);
 377     } else if (type == "WATCH_OBJECT_R") {
 378         int queryId;
 379         bool ok;
 380         ds >> queryId >> ok;
 381
 382         QDeclarativeDebugWatch *watch = watched.value(queryId);
 383         if (!watch)
 384             return;
 385
 386         watch->setState(ok ? QDeclarativeDebugWatch::Active : QDeclarativeDebugWatch::Inactive);
 387     } else if (type == "WATCH_EXPR_OBJECT_R") {
 388         int queryId;
 389         bool ok;
 390         ds >> queryId >> ok;
 391
 392         QDeclarativeDebugWatch *watch = watched.value(queryId);
 393         if (!watch)
 394             return;
 395
 396         watch->setState(ok ? QDeclarativeDebugWatch::Active : QDeclarativeDebugWatch::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         QDeclarativeDebugWatch *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 QDeclarativeEngineDebug::QDeclarativeEngineDebug(QDeclarativeDebugConnection *client, QObject *parent)
 414     : QObject(*(new QDeclarativeEngineDebugPrivate(client)), parent)
 415 {
 416 }
 417
 418 QDeclarativeEngineDebug::~QDeclarativeEngineDebug()
 419 {
 420 }
 421
 422 QDeclarativeEngineDebug::Status QDeclarativeEngineDebug::status() const
 423 {
 424     Q_D(const QDeclarativeEngineDebug);
 425
 426     return static_cast<QDeclarativeEngineDebug::Status>(d->client->status());
 427 }
 428
 429 QDeclarativeDebugPropertyWatch *QDeclarativeEngineDebug::addWatch(const QDeclarativeDebugPropertyReference &property, QObject *parent)
 430 {
 431     Q_D(QDeclarativeEngineDebug);
 432
 433     QDeclarativeDebugPropertyWatch *watch = new QDeclarativeDebugPropertyWatch(parent);
 434     if (d->client->status() == QDeclarativeDebugClient::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 = QDeclarativeDebugWatch::Dead;
 448     }
 449
 450     return watch;
 451 }
 452
 453 QDeclarativeDebugWatch *QDeclarativeEngineDebug::addWatch(const QDeclarativeDebugContextReference &, const QString &, QObject *)
 454 {
 455     qWarning("QDeclarativeEngineDebug::addWatch(): Not implemented");
 456     return 0;
 457 }
 458
 459 QDeclarativeDebugObjectExpressionWatch *QDeclarativeEngineDebug::addWatch(const QDeclarativeDebugObjectReference &object, const QString &expr, QObject *parent)
 460 {
 461     Q_D(QDeclarativeEngineDebug);
 462     QDeclarativeDebugObjectExpressionWatch *watch = new QDeclarativeDebugObjectExpressionWatch(parent);
 463     if (d->client->status() == QDeclarativeDebugClient::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 = QDeclarativeDebugWatch::Dead;
 477     }
 478     return watch;
 479 }
 480
 481 QDeclarativeDebugWatch *QDeclarativeEngineDebug::addWatch(const QDeclarativeDebugObjectReference &object, QObject *parent)
 482 {
 483     Q_D(QDeclarativeEngineDebug);
 484
 485     QDeclarativeDebugWatch *watch = new QDeclarativeDebugWatch(parent);
 486     if (d->client->status() == QDeclarativeDebugClient::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 = QDeclarativeDebugWatch::Dead;
 499     }
 500
 501     return watch;
 502 }
 503
 504 QDeclarativeDebugWatch *QDeclarativeEngineDebug::addWatch(const QDeclarativeDebugFileReference &, QObject *)
 505 {
 506     qWarning("QDeclarativeEngineDebug::addWatch(): Not implemented");
 507     return 0;
 508 }
 509
 510 void QDeclarativeEngineDebug::removeWatch(QDeclarativeDebugWatch *watch)
 511 {
 512     Q_D(QDeclarativeEngineDebug);
 513
 514     if (!watch || !watch->m_client)
 515         return;
 516
 517     watch->m_client = 0;
 518     watch->setState(QDeclarativeDebugWatch::Inactive);
 519
 520     d->watched.remove(watch->queryId());
 521
 522     if (d->client && d->client->status() == QDeclarativeDebugClient::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 QDeclarativeDebugEnginesQuery *QDeclarativeEngineDebug::queryAvailableEngines(QObject *parent)
 531 {
 532     Q_D(QDeclarativeEngineDebug);
 533
 534     QDeclarativeDebugEnginesQuery *query = new QDeclarativeDebugEnginesQuery(parent);
 535     if (d->client->status() == QDeclarativeDebugClient::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 = QDeclarativeDebugQuery::Error;
 547     }
 548
 549     return query;
 550 }
 551
 552 QDeclarativeDebugRootContextQuery *QDeclarativeEngineDebug::queryRootContexts(const QDeclarativeDebugEngineReference &engine, QObject *parent)
 553 {
 554     Q_D(QDeclarativeEngineDebug);
 555
 556     QDeclarativeDebugRootContextQuery *query = new QDeclarativeDebugRootContextQuery(parent);
 557     if (d->client->status() == QDeclarativeDebugClient::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 = QDeclarativeDebugQuery::Error;
 569     }
 570
 571     return query;
 572 }
 573
 574 QDeclarativeDebugObjectQuery *QDeclarativeEngineDebug::queryObject(const QDeclarativeDebugObjectReference &object, QObject *parent)
 575 {
 576     Q_D(QDeclarativeEngineDebug);
 577
 578     QDeclarativeDebugObjectQuery *query = new QDeclarativeDebugObjectQuery(parent);
 579     if (d->client->status() == QDeclarativeDebugClient::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 = QDeclarativeDebugQuery::Error;
 592     }
 593
 594     return query;
 595 }
 596
 597 QDeclarativeDebugObjectQuery *QDeclarativeEngineDebug::queryObjectRecursive(const QDeclarativeDebugObjectReference &object, QObject *parent)
 598 {
 599     Q_D(QDeclarativeEngineDebug);
 600
 601     QDeclarativeDebugObjectQuery *query = new QDeclarativeDebugObjectQuery(parent);
 602     if (d->client->status() == QDeclarativeDebugClient::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 = QDeclarativeDebugQuery::Error;
 615     }
 616
 617     return query;
 618 }
 619
 620 QDeclarativeDebugExpressionQuery *QDeclarativeEngineDebug::queryExpressionResult(int objectDebugId, const QString &expr, QObject *parent)
 621 {
 622     Q_D(QDeclarativeEngineDebug);
 623
 624     QDeclarativeDebugExpressionQuery *query = new QDeclarativeDebugExpressionQuery(parent);
 625     if (d->client->status() == QDeclarativeDebugClient::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 = QDeclarativeDebugQuery::Error;
 638     }
 639
 640     return query;
 641 }
 642
 643 bool QDeclarativeEngineDebug::setBindingForObject(int objectDebugId, const QString &propertyName,
 644                                                   const QVariant &bindingExpression,
 645                                                   bool isLiteralValue,
 646                                                   QString source, int line)
 647 {
 648     Q_D(QDeclarativeEngineDebug);
 649
 650     if (d->client->status() == QDeclarativeDebugClient::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 QDeclarativeEngineDebug::resetBindingForObject(int objectDebugId, const QString &propertyName)
 662 {
 663     Q_D(QDeclarativeEngineDebug);
 664
 665     if (d->client->status() == QDeclarativeDebugClient::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 QDeclarativeEngineDebug::setMethodBody(int objectDebugId, const QString &methodName,
 677                                             const QString &methodBody)
 678 {
 679     Q_D(QDeclarativeEngineDebug);
 680
 681     if (d->client->status() == QDeclarativeDebugClient::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 QDeclarativeDebugWatch::QDeclarativeDebugWatch(QObject *parent)
 693     : QObject(parent), m_state(Waiting), m_queryId(-1), m_client(0), m_objectDebugId(-1)
 694 {
 695 }
 696
 697 QDeclarativeDebugWatch::~QDeclarativeDebugWatch()
 698 {
 699     if (m_client && m_queryId != -1)
 700         QDeclarativeEngineDebugPrivate::remove(m_client, this);
 701 }
 702
 703 int QDeclarativeDebugWatch::queryId() const
 704 {
 705     return m_queryId;
 706 }
 707
 708 int QDeclarativeDebugWatch::objectDebugId() const
 709 {
 710     return m_objectDebugId;
 711 }
 712
 713 QDeclarativeDebugWatch::State QDeclarativeDebugWatch::state() const
 714 {
 715     return m_state;
 716 }
 717
 718 void QDeclarativeDebugWatch::setState(State s)
 719 {
 720     if (m_state == s)
 721         return;
 722     m_state = s;
 723     emit stateChanged(m_state);
 724 }
 725
 726 QDeclarativeDebugPropertyWatch::QDeclarativeDebugPropertyWatch(QObject *parent)
 727     : QDeclarativeDebugWatch(parent)
 728 {
 729 }
 730
 731 QString QDeclarativeDebugPropertyWatch::name() const
 732 {
 733     return m_name;
 734 }
 735
 736
 737 QDeclarativeDebugObjectExpressionWatch::QDeclarativeDebugObjectExpressionWatch(QObject *parent)
 738     : QDeclarativeDebugWatch(parent)
 739 {
 740 }
 741
 742 QString QDeclarativeDebugObjectExpressionWatch::expression() const
 743 {
 744     return m_expr;
 745 }
 746
 747
 748 QDeclarativeDebugQuery::QDeclarativeDebugQuery(QObject *parent)
 749     : QObject(parent), m_state(Waiting)
 750 {
 751 }
 752
 753 QDeclarativeDebugQuery::State QDeclarativeDebugQuery::state() const
 754 {
 755     return m_state;
 756 }
 757
 758 bool QDeclarativeDebugQuery::isWaiting() const
 759 {
 760     return m_state == Waiting;
 761 }
 762
 763 void QDeclarativeDebugQuery::setState(State s)
 764 {
 765     if (m_state == s)
 766         return;
 767     m_state = s;
 768     emit stateChanged(m_state);
 769 }
 770
 771 QDeclarativeDebugEnginesQuery::QDeclarativeDebugEnginesQuery(QObject *parent)
 772     : QDeclarativeDebugQuery(parent), m_client(0), m_queryId(-1)
 773 {
 774 }
 775
 776 QDeclarativeDebugEnginesQuery::~QDeclarativeDebugEnginesQuery()
 777 {
 778     if (m_client && m_queryId != -1)
 779         QDeclarativeEngineDebugPrivate::remove(m_client, this);
 780 }
 781
 782 QList<QDeclarativeDebugEngineReference> QDeclarativeDebugEnginesQuery::engines() const
 783 {
 784     return m_engines;
 785 }
 786
 787 QDeclarativeDebugRootContextQuery::QDeclarativeDebugRootContextQuery(QObject *parent)
 788     : QDeclarativeDebugQuery(parent), m_client(0), m_queryId(-1)
 789 {
 790 }
 791
 792 QDeclarativeDebugRootContextQuery::~QDeclarativeDebugRootContextQuery()
 793 {
 794     if (m_client && m_queryId != -1)
 795         QDeclarativeEngineDebugPrivate::remove(m_client, this);
 796 }
 797
 798 QDeclarativeDebugContextReference QDeclarativeDebugRootContextQuery::rootContext() const
 799 {
 800     return m_context;
 801 }
 802
 803 QDeclarativeDebugObjectQuery::QDeclarativeDebugObjectQuery(QObject *parent)
 804     : QDeclarativeDebugQuery(parent), m_client(0), m_queryId(-1)
 805 {
 806 }
 807
 808 QDeclarativeDebugObjectQuery::~QDeclarativeDebugObjectQuery()
 809 {
 810     if (m_client && m_queryId != -1)
 811         QDeclarativeEngineDebugPrivate::remove(m_client, this);
 812 }
 813
 814 QDeclarativeDebugObjectReference QDeclarativeDebugObjectQuery::object() const
 815 {
 816     return m_object;
 817 }
 818
 819 QDeclarativeDebugExpressionQuery::QDeclarativeDebugExpressionQuery(QObject *parent)
 820     : QDeclarativeDebugQuery(parent), m_client(0), m_queryId(-1)
 821 {
 822 }
 823
 824 QDeclarativeDebugExpressionQuery::~QDeclarativeDebugExpressionQuery()
 825 {
 826     if (m_client && m_queryId != -1)
 827         QDeclarativeEngineDebugPrivate::remove(m_client, this);
 828 }
 829
 830 QVariant QDeclarativeDebugExpressionQuery::expression() const
 831 {
 832     return m_expr;
 833 }
 834
 835 QVariant QDeclarativeDebugExpressionQuery::result() const
 836 {
 837     return m_result;
 838 }
 839
 840 QDeclarativeDebugEngineReference::QDeclarativeDebugEngineReference()
 841     : m_debugId(-1)
 842 {
 843 }
 844
 845 QDeclarativeDebugEngineReference::QDeclarativeDebugEngineReference(int debugId)
 846     : m_debugId(debugId)
 847 {
 848 }
 849
 850 QDeclarativeDebugEngineReference::QDeclarativeDebugEngineReference(const QDeclarativeDebugEngineReference &o)
 851     : m_debugId(o.m_debugId), m_name(o.m_name)
 852 {
 853 }
 854
 855 QDeclarativeDebugEngineReference &
 856 QDeclarativeDebugEngineReference::operator=(const QDeclarativeDebugEngineReference &o)
 857 {
 858     m_debugId = o.m_debugId; m_name = o.m_name;
 859     return *this;
 860 }
 861
 862 int QDeclarativeDebugEngineReference::debugId() const
 863 {
 864     return m_debugId;
 865 }
 866
 867 QString QDeclarativeDebugEngineReference::name() const
 868 {
 869     return m_name;
 870 }
 871
 872 QDeclarativeDebugObjectReference::QDeclarativeDebugObjectReference()
 873     : m_debugId(-1), m_contextDebugId(-1)
 874 {
 875 }
 876
 877 QDeclarativeDebugObjectReference::QDeclarativeDebugObjectReference(int debugId)
 878     : m_debugId(debugId), m_contextDebugId(-1)
 879 {
 880 }
 881
 882 QDeclarativeDebugObjectReference::QDeclarativeDebugObjectReference(const QDeclarativeDebugObjectReference &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 QDeclarativeDebugObjectReference &
 890 QDeclarativeDebugObjectReference::operator=(const QDeclarativeDebugObjectReference &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 QDeclarativeDebugObjectReference::debugId() const
 899 {
 900     return m_debugId;
 901 }
 902
 903 QString QDeclarativeDebugObjectReference::className() const
 904 {
 905     return m_class;
 906 }
 907
 908 QString QDeclarativeDebugObjectReference::idString() const
 909 {
 910     return m_idString;
 911 }
 912
 913 QString QDeclarativeDebugObjectReference::name() const
 914 {
 915     return m_name;
 916 }
 917
 918 QDeclarativeDebugFileReference QDeclarativeDebugObjectReference::source() const
 919 {
 920     return m_source;
 921 }
 922
 923 int QDeclarativeDebugObjectReference::contextDebugId() const
 924 {
 925     return m_contextDebugId;
 926 }
 927
 928 QList<QDeclarativeDebugPropertyReference> QDeclarativeDebugObjectReference::properties() const
 929 {
 930     return m_properties;
 931 }
 932
 933 QList<QDeclarativeDebugObjectReference> QDeclarativeDebugObjectReference::children() const
 934 {
 935     return m_children;
 936 }
 937
 938 QDeclarativeDebugContextReference::QDeclarativeDebugContextReference()
 939     : m_debugId(-1)
 940 {
 941 }
 942
 943 QDeclarativeDebugContextReference::QDeclarativeDebugContextReference(const QDeclarativeDebugContextReference &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 QDeclarativeDebugContextReference &QDeclarativeDebugContextReference::operator=(const QDeclarativeDebugContextReference &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 QDeclarativeDebugContextReference::debugId() const
 956 {
 957     return m_debugId;
 958 }
 959
 960 QString QDeclarativeDebugContextReference::name() const
 961 {
 962     return m_name;
 963 }
 964
 965 QList<QDeclarativeDebugObjectReference> QDeclarativeDebugContextReference::objects() const
 966 {
 967     return m_objects;
 968 }
 969
 970 QList<QDeclarativeDebugContextReference> QDeclarativeDebugContextReference::contexts() const
 971 {
 972     return m_contexts;
 973 }
 974
 975 QDeclarativeDebugFileReference::QDeclarativeDebugFileReference()
 976     : m_lineNumber(-1), m_columnNumber(-1)
 977 {
 978 }
 979
 980 QDeclarativeDebugFileReference::QDeclarativeDebugFileReference(const QDeclarativeDebugFileReference &o)
 981     : m_url(o.m_url), m_lineNumber(o.m_lineNumber), m_columnNumber(o.m_columnNumber)
 982 {
 983 }
 984
 985 QDeclarativeDebugFileReference &QDeclarativeDebugFileReference::operator=(const QDeclarativeDebugFileReference &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 QDeclarativeDebugFileReference::url() const
 992 {
 993     return m_url;
 994 }
 995
 996 void QDeclarativeDebugFileReference::setUrl(const QUrl &u)
 997 {
 998     m_url = u;
 999 }
1000
1001 int QDeclarativeDebugFileReference::lineNumber() const
1002 {
1003     return m_lineNumber;
1004 }
1005
1006 void QDeclarativeDebugFileReference::setLineNumber(int l)
1007 {
1008     m_lineNumber = l;
1009 }
1010
1011 int QDeclarativeDebugFileReference::columnNumber() const
1012 {
1013     return m_columnNumber;
1014 }
1015
1016 void QDeclarativeDebugFileReference::setColumnNumber(int c)
1017 {
1018     m_columnNumber = c;
1019 }
1020
1021 QDeclarativeDebugPropertyReference::QDeclarativeDebugPropertyReference()
1022     : m_objectDebugId(-1), m_hasNotifySignal(false)
1023 {
1024 }
1025
1026 QDeclarativeDebugPropertyReference::QDeclarativeDebugPropertyReference(const QDeclarativeDebugPropertyReference &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 QDeclarativeDebugPropertyReference &QDeclarativeDebugPropertyReference::operator=(const QDeclarativeDebugPropertyReference &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 QDeclarativeDebugPropertyReference::objectDebugId() const
1042 {
1043     return m_objectDebugId;
1044 }
1045
1046 QString QDeclarativeDebugPropertyReference::name() const
1047 {
1048     return m_name;
1049 }
1050
1051 QString QDeclarativeDebugPropertyReference::valueTypeName() const
1052 {
1053     return m_valueTypeName;
1054 }
1055
1056 QVariant QDeclarativeDebugPropertyReference::value() const
1057 {
1058     return m_value;
1059 }
1060
1061 QString QDeclarativeDebugPropertyReference::binding() const
1062 {
1063     return m_binding;
1064 }
1065
1066 bool QDeclarativeDebugPropertyReference::hasNotifySignal() const
1067 {
1068     return m_hasNotifySignal;
1069 }
1070
1071 QT_END_NAMESPACE
1072