62   m_watch(new QDeclarativeWatcher(this))

    64     m_watch(new QDeclarativeWatcher(this))

   433     }

   457     } else if (type == "SET_BINDING") {

   458         int objectId;

   459         QString propertyName;

   460         QVariant expr;

   461         bool isLiteralValue;

   462         ds >> objectId >> propertyName >> expr >> isLiteralValue;

   463         setBinding(objectId, propertyName, expr, isLiteralValue);

   464     } else if (type == "RESET_BINDING") {

   465         int objectId;

   466         QString propertyName;

   467         ds >> objectId >> propertyName;

   468         resetBinding(objectId, propertyName);

   469     } else if (type == "SET_METHOD_BODY") {

   470         int objectId;

   471         QString methodName;

   472         QString methodBody;

   473         ds >> objectId >> methodName >> methodBody;

   474         setMethodBody(objectId, methodName, methodBody);

   475     }

   476 }

   477 

   478 void QDeclarativeEngineDebugServer::setBinding(int objectId,

   479                                                const QString &propertyName,

   480                                                const QVariant &expression,

   481                                                bool isLiteralValue)

   482 {

   483     QObject *object = objectForId(objectId);

   484     QDeclarativeContext *context = qmlContext(object);

   485 

   486     if (object && context) {

   487 

   488         if (isLiteralValue) {

   489             QDeclarativeProperty literalProperty(object, propertyName, context);

   490             literalProperty.write(expression);

   491         } else {

   492             if (hasValidSignal(object, propertyName)) {

   493                 QDeclarativeProperty property(object, propertyName);

   494                 QDeclarativeExpression *declarativeExpression = new QDeclarativeExpression(context, object, expression.toString());

   495                 QDeclarativePropertyPrivate::setSignalExpression(property, declarativeExpression);

   496             } else {

   497                 QDeclarativeBinding *binding = new QDeclarativeBinding(expression.toString(), object, context);

   498                 QDeclarativeProperty property(object, propertyName, context);

   499                 binding->setTarget(property);

   500                 binding->setNotifyOnValueChanged(true);

   501                 QDeclarativeAbstractBinding *oldBinding = QDeclarativePropertyPrivate::setBinding(property, binding);

   502                 if (oldBinding)

   503                     oldBinding->destroy();

   504                 binding->update();

   505             }

   506         }

   507     }

   508 }

   509 

   510 void QDeclarativeEngineDebugServer::resetBinding(int objectId, const QString &propertyName)

   511 {

   512     QObject *object = objectForId(objectId);

   513     QDeclarativeContext *context = qmlContext(object);

   514 

   515     if (object && context) {

   516         if (object->property(propertyName.toLatin1()).isValid()) {

   517             QDeclarativeProperty property(object, propertyName);

   518             QDeclarativeAbstractBinding *oldBinding = QDeclarativePropertyPrivate::binding(property);

   519             if (oldBinding) {

   520                 QDeclarativeAbstractBinding *oldBinding = QDeclarativePropertyPrivate::setBinding(property, 0);

   521                 if (oldBinding)

   522                     oldBinding->destroy();

   523             } else {

   524                 if (property.isResettable()) {

   525                     property.reset();

   526                 }

   527             }

   528         }

   529     }

   530 }

   531 

   532 void QDeclarativeEngineDebugServer::setMethodBody(int objectId, const QString &method, const QString &body)

   533 {

   534     QObject *object = objectForId(objectId);

   535     QDeclarativeContext *context = qmlContext(object);

   536     if (!object || !context || !context->engine())

   537         return;

   538     QDeclarativeContextData *contextData = QDeclarativeContextData::get(context);

   539     if (!contextData)

   540         return;

   541 

   542     QDeclarativePropertyCache::Data dummy;

   543     QDeclarativePropertyCache::Data *prop = 

   544         QDeclarativePropertyCache::property(context->engine(), object, method, dummy);

   545 

   546     if (!prop || !(prop->flags & QDeclarativePropertyCache::Data::IsVMEFunction))

   547         return;

   548 

   549     QMetaMethod metaMethod = object->metaObject()->method(prop->coreIndex);

   550     QList<QByteArray> paramNames = metaMethod.parameterNames();

   551 

   552     QString paramStr;

   553     for (int ii = 0; ii < paramNames.count(); ++ii) {

   554         if (ii != 0) paramStr.append(QLatin1String(","));

   555         paramStr.append(QString::fromUtf8(paramNames.at(ii)));

   556     }

   557 

   558     QString jsfunction = QLatin1String("(function ") + method + QLatin1String("(") + paramStr + 

   559                          QLatin1String(") {");

   560     jsfunction += body;

   561     jsfunction += QLatin1String("\n})");

   562 

   563     QDeclarativeVMEMetaObject *vmeMetaObject = 

   564         static_cast<QDeclarativeVMEMetaObject*>(QObjectPrivate::get(object)->metaObject);

   565     Q_ASSERT(vmeMetaObject); // the fact we found the property above should guarentee this

   566 

   567     int lineNumber = vmeMetaObject->vmeMethodLineNumber(prop->coreIndex);

   568     vmeMetaObject->setVmeMethod(prop->coreIndex, QDeclarativeExpressionPrivate::evalInObjectScope(contextData, object, jsfunction, contextData->url.toString(), lineNumber, 0));