static int writeProperty(QObject *obj, const QByteArray &property_name, QVariant value, int propFlags = QDBusConnection::ExportAllProperties) { const QMetaObject *mo = obj->metaObject(); int pidx = mo->indexOfProperty(property_name); if (pidx == -1) { // this object has no property by that name return PropertyNotFound; } QMetaProperty mp = mo->property(pidx); // check if this property is exported bool isScriptable = mp.isScriptable(); if (!(propFlags & QDBusConnection::ExportScriptableProperties) && isScriptable) return PropertyNotFound; if (!(propFlags & QDBusConnection::ExportNonScriptableProperties) && !isScriptable) return PropertyNotFound; // we found our property // do we have the right type? int id = mp.type(); if (id == QVariant::UserType) { // dynamic type id = qDBusNameToTypeId(mp.typeName()); if (id == -1) { // type not registered? qWarning("QDBusConnection: Unable to handle unregistered datatype '%s' for property '%s::%s'", mp.typeName(), mo->className(), property_name.constData()); return PropertyWriteFailed; } } if (id != 0xff && value.userType() == QDBusMetaTypeId::argument) { // we have to demarshall before writing void *null = 0; QVariant other(id, null); if (!QDBusMetaType::demarshall(qvariant_cast<QDBusArgument>(value), id, other.data())) { qWarning("QDBusConnection: type `%s' (%d) is not registered with QtDBus. " "Use qDBusRegisterMetaType to register it", mp.typeName(), id); return PropertyWriteFailed; } value = other; } // the property type here should match return mp.write(obj, value) ? PropertyWriteSuccess : PropertyWriteFailed; }
QStringList propertyNameForWritableProperties(QObject *object, const QString &baseName = QString()) { QStringList propertyNameList; const QMetaObject *metaObject = object->metaObject(); for (int index = 0; index < metaObject->propertyCount(); ++index) { QMetaProperty metaProperty = metaObject->property(index); if (metaProperty.isReadable() && !metaProperty.isWritable()) { QObject *childObject = QDeclarativeMetaType::toQObject(metaProperty.read(object)); if (childObject) propertyNameList.append(propertyNameForWritableProperties(childObject, baseName + QString::fromUtf8(metaProperty.name()) + '.')); } else if (QDeclarativeValueTypeFactory::valueType(metaProperty.userType())) { QDeclarativeValueType *valueType = QDeclarativeValueTypeFactory::valueType(metaProperty.userType()); valueType->setValue(metaProperty.read(object)); propertyNameList.append(propertyNameForWritableProperties(valueType, baseName + QString::fromUtf8(metaProperty.name()) + '.')); } else if (metaProperty.isReadable() && metaProperty.isWritable()) { propertyNameList.append(baseName + QString::fromUtf8(metaProperty.name())); } } return propertyNameList; }
void MashListModel::mashChanged(QMetaProperty prop, QVariant val) { Mash* mSend = qobject_cast<Mash*>(sender()); // NOTE: how to get around the issue that the sender might live in // a different thread and therefore always cause sSend == 0? if( mSend == 0 ) return; QString propName(prop.name()); if( propName == "name" ) { int ndx = mashes.indexOf(mSend); if( ndx >= 0 ) emit dataChanged( createIndex(ndx,0), createIndex(ndx,0) ); } }
void listInterface(const QString &service, const QString &path, const QString &interface) { QDBusInterfacePtr iface(*connection, service, path, interface); if (!iface->isValid()) { QDBusError err(iface->lastError()); fprintf(stderr, "Interface '%s' not available in object %s at %s:\n%s (%s)\n", qPrintable(interface), qPrintable(path), qPrintable(service), qPrintable(err.name()), qPrintable(err.message())); exit(1); } const QMetaObject *mo = iface->metaObject(); // properties for (int i = mo->propertyOffset(); i < mo->propertyCount(); ++i) { QMetaProperty mp = mo->property(i); printf("property "); if (mp.isReadable() && mp.isWritable()) printf("readwrite"); else if (mp.isReadable()) printf("read"); else printf("write"); printf(" %s %s.%s\n", mp.typeName(), qPrintable(interface), mp.name()); } // methods (signals and slots) for (int i = mo->methodOffset(); i < mo->methodCount(); ++i) { QMetaMethod mm = mo->method(i); QByteArray signature = mm.signature(); signature.truncate(signature.indexOf('(')); printf("%s %s%s%s %s.%s(", mm.methodType() == QMetaMethod::Signal ? "signal" : "method", mm.tag(), *mm.tag() ? " " : "", *mm.typeName() ? mm.typeName() : "void", qPrintable(interface), signature.constData()); QList<QByteArray> types = mm.parameterTypes(); QList<QByteArray> names = mm.parameterNames(); bool first = true; for (int i = 0; i < types.count(); ++i) { printf("%s%s", first ? "" : ", ", types.at(i).constData()); if (!names.at(i).isEmpty()) printf(" %s", names.at(i).constData()); first = false; } printf(")\n"); } }
void QDeclarativeValueTypeScriptClass::setProperty(Object *obj, const Identifier &, const QScriptValue &value) { QDeclarativeValueTypeObject *o = static_cast<QDeclarativeValueTypeObject *>(obj); QVariant v = QDeclarativeEnginePrivate::get(engine)->scriptValueToVariant(value); if (o->objectType == QDeclarativeValueTypeObject::Reference) { QDeclarativeValueTypeReference *ref = static_cast<QDeclarativeValueTypeReference *>(obj); ref->type->read(ref->object, ref->property); QMetaProperty p = ref->type->metaObject()->property(m_lastIndex); QDeclarativeBinding *newBinding = 0; if (value.isFunction() && !value.isRegExp()) { QDeclarativeContextData *ctxt = QDeclarativeEnginePrivate::get(engine)->getContext(context()); QDeclarativePropertyCache::Data cacheData; cacheData.flags = QDeclarativePropertyCache::Data::IsWritable; cacheData.propType = ref->object->metaObject()->property(ref->property).userType(); cacheData.coreIndex = ref->property; QDeclarativePropertyCache::ValueTypeData valueTypeData; valueTypeData.valueTypeCoreIdx = m_lastIndex; valueTypeData.valueTypePropType = p.userType(); newBinding = new QDeclarativeBinding(value, ref->object, ctxt); QScriptContextInfo ctxtInfo(context()); newBinding->setSourceLocation(ctxtInfo.fileName(), ctxtInfo.functionStartLineNumber()); QDeclarativeProperty prop = QDeclarativePropertyPrivate::restore(cacheData, valueTypeData, ref->object, ctxt); newBinding->setTarget(prop); if (newBinding->expression().contains(QLatin1String("this"))) newBinding->setEvaluateFlags(newBinding->evaluateFlags() | QDeclarativeBinding::RequiresThisObject); } QDeclarativeAbstractBinding *delBinding = QDeclarativePropertyPrivate::setBinding(ref->object, ref->property, m_lastIndex, newBinding); if (delBinding) delBinding->destroy(); if (p.isEnumType() && (QMetaType::Type)v.type() == QMetaType::Double) v = v.toInt(); p.write(ref->type, v); ref->type->write(ref->object, ref->property, 0); } else { QDeclarativeValueTypeCopy *copy = static_cast<QDeclarativeValueTypeCopy *>(obj); copy->type->setValue(copy->value); QMetaProperty p = copy->type->metaObject()->property(m_lastIndex); p.write(copy->type, v); copy->value = copy->type->value(); } }
void ObjectControllerPrivate::slotValueChanged(QtProperty *property, const QVariant &value) { if (!m_propertyToIndex.contains(property)) return; int idx = m_propertyToIndex.value(property); const QMetaObject *metaObject = m_object->metaObject(); QMetaProperty metaProperty = metaObject->property(idx); if (metaProperty.isEnumType()) { if (metaProperty.isFlagType()) metaProperty.write(m_object, intToFlag(metaProperty.enumerator(), value.toInt())); else metaProperty.write(m_object, intToEnum(metaProperty.enumerator(), value.toInt())); } else { metaProperty.write(m_object, value); } updateClassProperties(metaObject, true); }
bool QDBusAbstractInterfacePrivate::setProperty(const QMetaProperty &mp, const QVariant &value) { if (!isValid || !canMakeCalls()) // can't make calls return false; // send the value QDBusMessage msg = QDBusMessage::createMethodCall(service, path, QLatin1String(DBUS_INTERFACE_PROPERTIES), QLatin1String("Set")); QDBusMessagePrivate::setParametersValidated(msg, true); msg << interface << QString::fromUtf8(mp.name()) << qVariantFromValue(QDBusVariant(value)); QDBusMessage reply = connection.call(msg, QDBus::Block); if (reply.type() != QDBusMessage::ReplyMessage) { lastError = reply; return false; } return true; }
ObjectMapperForwarder::ObjectMapperForwarder(ObjectMapper *m, QObject *o) : QObject(m), m_mapper(m), m_source(o) { for (int i = 0; i < o->metaObject()->propertyCount(); ++i) { QMetaProperty property = o->metaObject()->property(i); if (!property.isStored() || !property.isReadable() || !property.isWritable()) { continue; } if (!property.hasNotifySignal()) { DEBUG << "ObjectMapperForwarder: No notify signal for property " << property.name() << endl; continue; } // Signals can be connected to slots with fewer arguments, so // long as the arguments they do have match. So we connect // the property notify signal to our universal // property-changed slot, and use the sender() of that to // discover which object's property has changed. // Unfortunately, we don't then know which property it was // that changed, as the identity of the signal that activated // the slot is not available to us. The annoying part of this // is that Qt does actually store the identity of the signal // in the same structure as used for the sender() object data; // it just doesn't (at least as of Qt 4.5) make it available // through the public API. QString sig = QString("%1%2").arg(QSIGNAL_CODE) .arg(property.notifySignal().methodSignature().data()); QByteArray ba = sig.toLocal8Bit(); if (!connect(o, ba.data(), this, SLOT(objectModified()))) { std::cerr << "ObjectMapperForwarder: Failed to connect notify signal" << std::endl; } } connect(o, SIGNAL(destroyed(QObject *)), this, SLOT(objectDestroyed())); }
void BackGroundPropertyGridWidget::UpdateComboBoxWidgetWithPropertyValue(QComboBox* comboBoxWidget, const QMetaProperty& curProperty) { if (!this->activeMetadata) { return; } bool isPropertyValueDiffers = false; const QString& propertyName = curProperty.name(); int propertyValue = PropertiesHelper::GetPropertyValue<int>(this->activeMetadata, propertyName, isPropertyValueDiffers); // Firstly check the custom comboboxes. if (comboBoxWidget == ui->drawTypeComboBox) { UpdateWidgetPalette(comboBoxWidget, propertyName); return SetComboboxSelectedItem(comboBoxWidget, BackgroundGridWidgetHelper::GetDrawTypeDescByType((UIControlBackground::eDrawType)propertyValue)); } else if (comboBoxWidget == ui->colorInheritComboBox) { UpdateWidgetPalette(comboBoxWidget, propertyName); return SetComboboxSelectedItem(comboBoxWidget, BackgroundGridWidgetHelper::GetColorInheritTypeDescByType((UIControlBackground::eColorInheritType) propertyValue)); } else if (comboBoxWidget == ui->alignComboBox) { UpdateWidgetPalette(comboBoxWidget, propertyName); return SetComboboxSelectedItem(comboBoxWidget, BackgroundGridWidgetHelper::GetAlignTypeDescByType(propertyValue)); } else if (comboBoxWidget == ui->modificationComboBox) { UpdateWidgetPalette(comboBoxWidget, propertyName); return SetComboboxSelectedItem(comboBoxWidget, BackgroundGridWidgetHelper::GetModificationTypeDescByType(propertyValue)); } // Not related to the custom combobox - call the generic one. BasePropertyGridWidget::UpdateComboBoxWidgetWithPropertyValue(comboBoxWidget, curProperty); }
void tst_QMetaProperty::gadget() { const QMetaObject *mo = &MyGadget::staticMetaObject; QMetaProperty valueProp = mo->property(mo->indexOfProperty("value")); QVERIFY(valueProp.isValid()); { MyGadget g; QString hello = QLatin1Literal("hello"); QVERIFY(valueProp.writeOnGadget(&g, hello)); QCOMPARE(g.m_value, QLatin1String("hello")); QCOMPARE(valueProp.readOnGadget(&g), QVariant(hello)); QVERIFY(valueProp.resetOnGadget(&g)); QCOMPARE(valueProp.readOnGadget(&g), QVariant(QLatin1String("reset"))); } }
void ObjectEndPoint::propertyCall(const QServicePackage& p) { if(p.d->responseType == QServicePackage::NotAResponse) { //service side Q_ASSERT(d->endPointType == ObjectEndPoint::Service); QByteArray data = p.d->payload.toByteArray(); QDataStream stream(&data, QIODevice::ReadOnly); int metaIndex = -1; QVariant arg; int callType; stream >> metaIndex; stream >> arg; stream >> callType; const QMetaObject::Call c = (QMetaObject::Call) callType; QVariant result; QMetaProperty property = service->metaObject()->property(metaIndex); if (property.isValid()) { switch(c) { case QMetaObject::ReadProperty: result = property.read(service); break; case QMetaObject::WriteProperty: property.write(service, arg); break; case QMetaObject::ResetProperty: property.reset(service); break; default: break; } } if (c == QMetaObject::ReadProperty) { QServicePackage response = p.createResponse(); if (property.isValid()) { response.d->responseType = QServicePackage::Success; response.d->payload = result; } else { response.d->responseType = QServicePackage::Failed; } dispatch->writePackage(response); } } else {
const char *SettingsWidget::lookForWidgetState(QWidget *widget, const char *property, const char *signal) { const QMetaObject *meta = widget->metaObject(); WidgetInfo info = { widget, NULL, QVariant(), false }; bool free_signal = false; // Firstly try to search this widget in predefined classes if (!signal && !property) { for (int i = 0, size = sizeof(widget_infos) / sizeof(AbstractWidgetInfo*); i < size; i++) { if (widget_infos[i]->handle(widget)) { info.property = widget_infos[i]->property; signal = widget_infos[i]->signal; break; } } } // Then try to find "User" property with signal or signal by property if (!signal) { for (int i = 0, size = meta->propertyCount(); i < size; i++) { QMetaProperty prop = meta->property(i); if (prop.hasNotifySignal() && ((property && !qstrcmp(prop.name(), property)) || (!property && prop.isUser()))) { info.property = prop.name(); const char *sig = prop.notifySignal().signature(); int len = strlen(sig); char *str = (char *)qMalloc(sizeof(char) * (len + 2)); str[0] = QSIGNAL_CODE; qstrcpy(str + 1, sig); signal = str; free_signal = true; break; } } } bool result(signal); if (result) { p->mapper->setMapping(widget, p->infos.size()); connect(widget, signal, p->mapper, SLOT(map())); p->infos << info; } if (free_signal) qFree((void *)signal); return result ? info.property : 0; }
void TextPropertyGridWidget::UpdateComboBoxWidgetWithPropertyValue(QComboBox* comboBoxWidget, const QMetaProperty& curProperty) { if (!this->activeMetadata) { return; } bool isPropertyValueDiffers = false; const QString& propertyName = curProperty.name(); // Firstly check the custom comboboxes. if (comboBoxWidget == ui->alignComboBox) { int propertyValue = PropertiesHelper::GetPropertyValue<int>(this->activeMetadata, propertyName, isPropertyValueDiffers); UpdateWidgetPalette(comboBoxWidget, propertyName); return SetComboboxSelectedItem(comboBoxWidget, BackgroundGridWidgetHelper::GetAlignTypeDescByType(propertyValue)); } else if(comboBoxWidget == ui->fontPresetComboBox) { Font* propertyValue = PropertiesHelper::GetPropertyValue<Font*>(this->activeMetadata, propertyName, isPropertyValueDiffers); QString fontPresetName = QString::fromStdString(EditorFontManager::Instance()->GetLocalizedFontName(propertyValue)); UpdateWidgetPalette(comboBoxWidget, propertyName); // what is it for? - needed for controls like UIButton // int index = comboBoxWidget->findText(fontPresetName); //TODO: remove debug log // Logger::Debug("TextPropertyGridWidget::UpdateComboBoxWidgetWithPropertyValue %s index=%d", fontPresetName.toStdString().c_str(), index); return SetComboboxSelectedItem(ui->fontPresetComboBox, fontPresetName ); } // Not related to the custom combobox - call the generic one. BasePropertyGridWidget::UpdateComboBoxWidgetWithPropertyValue(comboBoxWidget, curProperty); }
void PropertyEditor::getProperties(QObject *obj) { mMetaProperties.clear(); mProperties.clear(); mPropertyDetails.clear(); if (!obj) return; const QMetaObject *mo = obj->metaObject(); for (int i = 0; i < mo->propertyCount(); ++i) { QMetaProperty mp = mo->property(mo->propertyOffset()+i); mMetaProperties.append(mp); QVariant v(mp.read(obj)); if (mp.isEnumType()) { mProperties.insert(QString::fromLatin1(mp.name()), v.toInt());//mp.enumerator().valueToKey(v.toInt())); //always use string } else { mProperties.insert(QString::fromLatin1(mp.name()), v); } const QVariant detail = obj->property(QByteArray("detail_").append(mp.name()).constData()); if (!detail.isNull()) mPropertyDetails.insert(QString::fromLatin1(mp.name()), detail.toString()); } mProperties.remove(QString::fromLatin1("objectName")); }
bool parseObject(const QVariant &source, QObject *target) { if (!source.isValid() || !source.canConvert(QVariant::Map)) { qDebug() << "[ObjectParser] Error: Invalid object... " << source.toByteArray(); return false; } const QVariantMap &map = source.toMap(); const QMetaObject *metaobject = target->metaObject(); QVariantMap::const_iterator it; QVariantMap::const_iterator end = map.constEnd(); for (it = map.constBegin(); it != end; ++it) { const int index = metaobject->indexOfProperty(it.key().toLatin1()); if (index < 0) { continue; } const QMetaProperty metaproperty = metaobject->property(index); const QVariant::Type type = metaproperty.type(); QVariant v = it.value(); if (v.canConvert(type)) { v.convert(type); metaproperty.write(target, v); } else if (QString(QLatin1String("QVariant")) .compare(QLatin1String(metaproperty.typeName())) == 0) { metaproperty.write(target, v); } else { qDebug() << "[ObjectParser] Warning: unable to map variable" << it.key() << "of type" << v.type() << "to type" << metaproperty.type() << "!"; metaproperty.write(target, QVariant()); } } return true; }
void tst_QMetaProperty::conversion() { if (qVersion() < QByteArray("5.6.0")) QSKIP("this is a test for a bug in 5.5"); QMetaType::registerConverter<QString, CustomType>(); QMetaType::registerConverter<CustomType, QString>(); QString hello = QStringLiteral("Hello"); // Write to a QString property using a CustomType in a QVariant QMetaProperty value7P = metaObject()->property(metaObject()->indexOfProperty("value7")); QVERIFY(value7P.isValid()); QVERIFY(value7P.write(this, QVariant::fromValue(CustomType(hello)))); QCOMPARE(value7, hello); // Write to a CustomType property using a QString in a QVariant QMetaProperty customP = metaObject()->property(metaObject()->indexOfProperty("custom")); QVERIFY(customP.isValid()); QVERIFY(customP.write(this, hello)); QCOMPARE(custom.str, hello); // Something that cannot be converted should fail QVERIFY(!customP.write(this, 45)); QVERIFY(!customP.write(this, QVariant::fromValue(this))); QVERIFY(!value7P.write(this, QVariant::fromValue(this))); QVERIFY(!value7P.write(this, QVariant::fromValue<QObject*>(this))); // none of this should have changed the values QCOMPARE(value7, hello); QCOMPARE(custom.str, hello); // Empty variant should be converted to default object QVERIFY(customP.write(this, QVariant())); QCOMPARE(custom.str, QString()); // or reset resetable QVERIFY(value7P.write(this, QVariant())); QCOMPARE(value7, QLatin1Literal("reset")); }
void JsonToProperties::parse(const QString& json, QObject* object) throw(ParseException) { QVariantMap dataMap = JsonToVariant::parse(json).toMap(); const QMetaObject* meta = object->metaObject(); for( int i = 0; i < meta->propertyCount(); ++i ) { QMetaProperty property = meta->property(i); if(dataMap.contains(property.name())) { QVariant data = dataMap[property.name()]; if(data.canConvert(property.type())) property.write(object, data); else qDebug() << QObject::tr("Found property %1 with incompatible data type.").arg(property.name()); } } }
void QDBusAbstractInterfacePrivate::property(const QMetaProperty &mp, QVariant &where) const { if (!isValid || !canMakeCalls()) { // can't make calls where.clear(); return; } // is this metatype registered? const char *expectedSignature = ""; if (mp.type() != 0xff) { expectedSignature = QDBusMetaType::typeToSignature(where.userType()); if (expectedSignature == 0) { qWarning("QDBusAbstractInterface: type %s must be registered with QtDBus before it can be " "used to read property %s.%s", mp.typeName(), qPrintable(interface), mp.name()); lastError = QDBusError(QDBusError::Failed, QString::fromLatin1("Unregistered type %1 cannot be handled") .arg(QLatin1String(mp.typeName()))); where.clear(); return; } } // try to read this property QDBusMessage msg = QDBusMessage::createMethodCall(service, path, QLatin1String(DBUS_INTERFACE_PROPERTIES), QLatin1String("Get")); QDBusMessagePrivate::setParametersValidated(msg, true); msg << interface << QString::fromUtf8(mp.name()); QDBusMessage reply = connection.call(msg, QDBus::Block); if (reply.type() != QDBusMessage::ReplyMessage) { lastError = reply; where.clear(); return; } if (reply.signature() != QLatin1String("v")) { QString errmsg = QLatin1String("Invalid signature `%1' in return from call to " DBUS_INTERFACE_PROPERTIES); lastError = QDBusError(QDBusError::InvalidSignature, errmsg.arg(reply.signature())); where.clear(); return; } QByteArray foundSignature; const char *foundType = 0; QVariant value = qvariant_cast<QDBusVariant>(reply.arguments().at(0)).variant(); if (value.userType() == where.userType() || mp.type() == 0xff || (expectedSignature[0] == 'v' && expectedSignature[1] == '\0')) { // simple match where = value; return; } if (value.userType() == qMetaTypeId<QDBusArgument>()) { QDBusArgument arg = qvariant_cast<QDBusArgument>(value); foundType = "user type"; foundSignature = arg.currentSignature().toLatin1(); if (foundSignature == expectedSignature) { // signatures match, we can demarshall QDBusMetaType::demarshall(arg, where.userType(), where.data()); return; } } else { foundType = value.typeName(); foundSignature = QDBusMetaType::typeToSignature(value.userType()); } // there was an error... QString errmsg = QLatin1String("Unexpected `%1' (%2) when retrieving property `%3.%4' " "(expected type `%5' (%6))"); lastError = QDBusError(QDBusError::InvalidSignature, errmsg.arg(QString::fromLatin1(foundType), QString::fromLatin1(foundSignature), interface, QString::fromUtf8(mp.name()), QString::fromLatin1(mp.typeName()), QString::fromLatin1(expectedSignature))); where.clear(); return; }
QObject *QDeclarativeVME::run(QDeclarativeVMEObjectStack &stack, QDeclarativeContextData *ctxt, QDeclarativeCompiledData *comp, int start, int count, const QBitField &bindingSkipList) { Q_ASSERT(comp); Q_ASSERT(ctxt); const QList<QDeclarativeCompiledData::TypeReference> &types = comp->types; const QList<QString> &primitives = comp->primitives; const QList<QByteArray> &datas = comp->datas; const QList<QDeclarativeCompiledData::CustomTypeData> &customTypeData = comp->customTypeData; const QList<int> &intData = comp->intData; const QList<float> &floatData = comp->floatData; const QList<QDeclarativePropertyCache *> &propertyCaches = comp->propertyCaches; const QList<QDeclarativeParser::Object::ScriptBlock> &scripts = comp->scripts; const QList<QUrl> &urls = comp->urls; QDeclarativeEnginePrivate::SimpleList<QDeclarativeAbstractBinding> bindValues; QDeclarativeEnginePrivate::SimpleList<QDeclarativeParserStatus> parserStatus; QDeclarativeVMEStack<ListInstance> qliststack; vmeErrors.clear(); QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(ctxt->engine); int status = -1; //for dbus QDeclarativePropertyPrivate::WriteFlags flags = QDeclarativePropertyPrivate::BypassInterceptor | QDeclarativePropertyPrivate::RemoveBindingOnAliasWrite; for (int ii = start; !isError() && ii < (start + count); ++ii) { const QDeclarativeInstruction &instr = comp->bytecode.at(ii); switch(instr.type) { case QDeclarativeInstruction::Init: { if (instr.init.bindingsSize) bindValues = QDeclarativeEnginePrivate::SimpleList<QDeclarativeAbstractBinding>(instr.init.bindingsSize); if (instr.init.parserStatusSize) parserStatus = QDeclarativeEnginePrivate::SimpleList<QDeclarativeParserStatus>(instr.init.parserStatusSize); if (instr.init.contextCache != -1) ctxt->setIdPropertyData(comp->contextCaches.at(instr.init.contextCache)); if (instr.init.compiledBinding != -1) ctxt->optimizedBindings = new QDeclarativeCompiledBindings(datas.at(instr.init.compiledBinding).constData(), ctxt, comp); } break; case QDeclarativeInstruction::CreateObject: { QBitField bindings; if (instr.create.bindingBits != -1) { const QByteArray &bits = datas.at(instr.create.bindingBits); bindings = QBitField((const quint32*)bits.constData(), bits.size() * 8); } if (stack.isEmpty()) bindings = bindings.united(bindingSkipList); QObject *o = types.at(instr.create.type).createInstance(ctxt, bindings, &vmeErrors); if (!o) { VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Unable to create object of type %1").arg(QString::fromLatin1(types.at(instr.create.type).className))); } QDeclarativeData *ddata = QDeclarativeData::get(o); Q_ASSERT(ddata); if (stack.isEmpty()) { if (ddata->context) { Q_ASSERT(ddata->context != ctxt); Q_ASSERT(ddata->outerContext); Q_ASSERT(ddata->outerContext != ctxt); QDeclarativeContextData *c = ddata->context; while (c->linkedContext) c = c->linkedContext; c->linkedContext = ctxt; } else { ctxt->addObject(o); } ddata->ownContext = true; } else if (!ddata->context) { ctxt->addObject(o); } ddata->setImplicitDestructible(); ddata->outerContext = ctxt; ddata->lineNumber = instr.line; ddata->columnNumber = instr.create.column; if (instr.create.data != -1) { QDeclarativeCustomParser *customParser = types.at(instr.create.type).type->customParser(); customParser->setCustomData(o, datas.at(instr.create.data)); } if (!stack.isEmpty()) { QObject *parent = stack.top(); if (o->isWidgetType()) { QWidget *widget = static_cast<QWidget*>(o); if (parent->isWidgetType()) { QWidget *parentWidget = static_cast<QWidget*>(parent); widget->setParent(parentWidget); } else { // TODO: parent might be a layout } } else { QDeclarative_setParent_noEvent(o, parent); } } stack.push(o); } break; case QDeclarativeInstruction::CreateSimpleObject: { QObject *o = (QObject *)operator new(instr.createSimple.typeSize + sizeof(QDeclarativeData)); ::memset(static_cast<void *>(o), 0, instr.createSimple.typeSize + sizeof(QDeclarativeData)); instr.createSimple.create(o); QDeclarativeData *ddata = (QDeclarativeData *)(((const char *)o) + instr.createSimple.typeSize); const QDeclarativeCompiledData::TypeReference &ref = types.at(instr.createSimple.type); if (!ddata->propertyCache && ref.typePropertyCache) { ddata->propertyCache = ref.typePropertyCache; ddata->propertyCache->addref(); } ddata->lineNumber = instr.line; ddata->columnNumber = instr.createSimple.column; QObjectPrivate::get(o)->declarativeData = ddata; ddata->context = ddata->outerContext = ctxt; ddata->nextContextObject = ctxt->contextObjects; if (ddata->nextContextObject) ddata->nextContextObject->prevContextObject = &ddata->nextContextObject; ddata->prevContextObject = &ctxt->contextObjects; ctxt->contextObjects = ddata; QObject *parent = stack.top(); QDeclarative_setParent_noEvent(o, parent); stack.push(o); } break; case QDeclarativeInstruction::SetId: { QObject *target = stack.top(); ctxt->setIdProperty(instr.setId.index, target); } break; case QDeclarativeInstruction::SetDefault: { ctxt->contextObject = stack.top(); } break; case QDeclarativeInstruction::CreateComponent: { QDeclarativeComponent *qcomp = new QDeclarativeComponent(ctxt->engine, comp, ii + 1, instr.createComponent.count, stack.isEmpty() ? 0 : stack.top()); QDeclarativeData *ddata = QDeclarativeData::get(qcomp, true); Q_ASSERT(ddata); ctxt->addObject(qcomp); if (stack.isEmpty()) ddata->ownContext = true; ddata->setImplicitDestructible(); ddata->outerContext = ctxt; ddata->lineNumber = instr.line; ddata->columnNumber = instr.create.column; QDeclarativeComponentPrivate::get(qcomp)->creationContext = ctxt; stack.push(qcomp); ii += instr.createComponent.count; } break; case QDeclarativeInstruction::StoreMetaObject: { QObject *target = stack.top(); QMetaObject mo; const QByteArray &metadata = datas.at(instr.storeMeta.data); QMetaObjectBuilder::fromRelocatableData(&mo, 0, metadata); const QDeclarativeVMEMetaData *data = (const QDeclarativeVMEMetaData *)datas.at(instr.storeMeta.aliasData).constData(); (void)new QDeclarativeVMEMetaObject(target, &mo, data, comp); if (instr.storeMeta.propertyCache != -1) { QDeclarativeData *ddata = QDeclarativeData::get(target, true); if (ddata->propertyCache) ddata->propertyCache->release(); ddata->propertyCache = propertyCaches.at(instr.storeMeta.propertyCache); ddata->propertyCache->addref(); } } break; case QDeclarativeInstruction::StoreVariant: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeString.propertyIndex); // XXX - can be more efficient QVariant v = QDeclarativeStringConverters::variantFromString(primitives.at(instr.storeString.value)); void *a[] = { &v, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeString.propertyIndex, a); } break; case QDeclarativeInstruction::StoreVariantInteger: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeString.propertyIndex); QVariant v(instr.storeInteger.value); void *a[] = { &v, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeString.propertyIndex, a); } break; case QDeclarativeInstruction::StoreVariantDouble: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeString.propertyIndex); QVariant v(instr.storeDouble.value); void *a[] = { &v, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeString.propertyIndex, a); } break; case QDeclarativeInstruction::StoreVariantBool: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeString.propertyIndex); QVariant v(instr.storeBool.value); void *a[] = { &v, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeString.propertyIndex, a); } break; case QDeclarativeInstruction::StoreString: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeString.propertyIndex); void *a[] = { (void *)&primitives.at(instr.storeString.value), 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeString.propertyIndex, a); } break; case QDeclarativeInstruction::StoreUrl: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeUrl.propertyIndex); void *a[] = { (void *)&urls.at(instr.storeUrl.value), 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeUrl.propertyIndex, a); } break; case QDeclarativeInstruction::StoreFloat: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeFloat.propertyIndex); float f = instr.storeFloat.value; void *a[] = { &f, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeFloat.propertyIndex, a); } break; case QDeclarativeInstruction::StoreDouble: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeDouble.propertyIndex); double d = instr.storeDouble.value; void *a[] = { &d, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeDouble.propertyIndex, a); } break; case QDeclarativeInstruction::StoreBool: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeBool.propertyIndex); void *a[] = { (void *)&instr.storeBool.value, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeBool.propertyIndex, a); } break; case QDeclarativeInstruction::StoreInteger: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeInteger.propertyIndex); void *a[] = { (void *)&instr.storeInteger.value, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeInteger.propertyIndex, a); } break; case QDeclarativeInstruction::StoreColor: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeColor.propertyIndex); QColor c = QColor::fromRgba(instr.storeColor.value); void *a[] = { &c, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeColor.propertyIndex, a); } break; case QDeclarativeInstruction::StoreDate: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeDate.propertyIndex); QDate d = QDate::fromJulianDay(instr.storeDate.value); void *a[] = { &d, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeDate.propertyIndex, a); } break; case QDeclarativeInstruction::StoreTime: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeTime.propertyIndex); QTime t; t.setHMS(intData.at(instr.storeTime.valueIndex), intData.at(instr.storeTime.valueIndex+1), intData.at(instr.storeTime.valueIndex+2), intData.at(instr.storeTime.valueIndex+3)); void *a[] = { &t, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeTime.propertyIndex, a); } break; case QDeclarativeInstruction::StoreDateTime: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeDateTime.propertyIndex); QTime t; t.setHMS(intData.at(instr.storeDateTime.valueIndex+1), intData.at(instr.storeDateTime.valueIndex+2), intData.at(instr.storeDateTime.valueIndex+3), intData.at(instr.storeDateTime.valueIndex+4)); QDateTime dt(QDate::fromJulianDay(intData.at(instr.storeDateTime.valueIndex)), t); void *a[] = { &dt, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeDateTime.propertyIndex, a); } break; case QDeclarativeInstruction::StorePoint: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeRealPair.propertyIndex); QPoint p = QPointF(floatData.at(instr.storeRealPair.valueIndex), floatData.at(instr.storeRealPair.valueIndex+1)).toPoint(); void *a[] = { &p, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeRealPair.propertyIndex, a); } break; case QDeclarativeInstruction::StorePointF: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeRealPair.propertyIndex); QPointF p(floatData.at(instr.storeRealPair.valueIndex), floatData.at(instr.storeRealPair.valueIndex+1)); void *a[] = { &p, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeRealPair.propertyIndex, a); } break; case QDeclarativeInstruction::StoreSize: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeRealPair.propertyIndex); QSize p = QSizeF(floatData.at(instr.storeRealPair.valueIndex), floatData.at(instr.storeRealPair.valueIndex+1)).toSize(); void *a[] = { &p, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeRealPair.propertyIndex, a); } break; case QDeclarativeInstruction::StoreSizeF: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeRealPair.propertyIndex); QSizeF s(floatData.at(instr.storeRealPair.valueIndex), floatData.at(instr.storeRealPair.valueIndex+1)); void *a[] = { &s, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeRealPair.propertyIndex, a); } break; case QDeclarativeInstruction::StoreRect: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeRect.propertyIndex); QRect r = QRectF(floatData.at(instr.storeRect.valueIndex), floatData.at(instr.storeRect.valueIndex+1), floatData.at(instr.storeRect.valueIndex+2), floatData.at(instr.storeRect.valueIndex+3)).toRect(); void *a[] = { &r, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeRect.propertyIndex, a); } break; case QDeclarativeInstruction::StoreRectF: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeRect.propertyIndex); QRectF r(floatData.at(instr.storeRect.valueIndex), floatData.at(instr.storeRect.valueIndex+1), floatData.at(instr.storeRect.valueIndex+2), floatData.at(instr.storeRect.valueIndex+3)); void *a[] = { &r, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeRect.propertyIndex, a); } break; case QDeclarativeInstruction::StoreVector3D: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeVector3D.propertyIndex); QVector3D p(floatData.at(instr.storeVector3D.valueIndex), floatData.at(instr.storeVector3D.valueIndex+1), floatData.at(instr.storeVector3D.valueIndex+2)); void *a[] = { &p, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeVector3D.propertyIndex, a); } break; case QDeclarativeInstruction::StoreObject: { QObject *assignObj = stack.pop(); QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeObject.propertyIndex); void *a[] = { (void *)&assignObj, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeObject.propertyIndex, a); } break; case QDeclarativeInstruction::AssignCustomType: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.assignCustomType.propertyIndex); QDeclarativeCompiledData::CustomTypeData data = customTypeData.at(instr.assignCustomType.valueIndex); const QString &primitive = primitives.at(data.index); QDeclarativeMetaType::StringConverter converter = QDeclarativeMetaType::customStringConverter(data.type); QVariant v = (*converter)(primitive); QMetaProperty prop = target->metaObject()->property(instr.assignCustomType.propertyIndex); if (v.isNull() || ((int)prop.type() != data.type && prop.userType() != data.type)) VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign value %1 to property %2").arg(primitive).arg(QString::fromUtf8(prop.name()))); void *a[] = { (void *)v.data(), 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.assignCustomType.propertyIndex, a); } break; case QDeclarativeInstruction::AssignSignalObject: { // XXX optimize QObject *assign = stack.pop(); QObject *target = stack.top(); int sigIdx = instr.assignSignalObject.signal; const QByteArray &pr = datas.at(sigIdx); QDeclarativeProperty prop(target, QString::fromUtf8(pr)); if (prop.type() & QDeclarativeProperty::SignalProperty) { QMetaMethod method = QDeclarativeMetaType::defaultMethod(assign); if (method.signature() == 0) VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign object type %1 with no default method").arg(QString::fromLatin1(assign->metaObject()->className()))); if (!QMetaObject::checkConnectArgs(prop.method().signature(), method.signature())) VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot connect mismatched signal/slot %1 %vs. %2").arg(QString::fromLatin1(method.signature())).arg(QString::fromLatin1(prop.method().signature()))); QDeclarativePropertyPrivate::connect(target, prop.index(), assign, method.methodIndex()); } else { VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign an object to signal property %1").arg(QString::fromUtf8(pr))); } } break; case QDeclarativeInstruction::StoreSignal: { QObject *target = stack.top(); QObject *context = stack.at(stack.count() - 1 - instr.storeSignal.context); QMetaMethod signal = target->metaObject()->method(instr.storeSignal.signalIndex); QDeclarativeBoundSignal *bs = new QDeclarativeBoundSignal(target, signal, target); QDeclarativeExpression *expr = new QDeclarativeExpression(ctxt, context, primitives.at(instr.storeSignal.value)); expr->setSourceLocation(comp->name, instr.line); static_cast<QDeclarativeExpressionPrivate *>(QObjectPrivate::get(expr))->name = datas.at(instr.storeSignal.name); bs->setExpression(expr); } break; case QDeclarativeInstruction::StoreImportedScript: { ctxt->addImportedScript(scripts.at(instr.storeScript.value)); } break; case QDeclarativeInstruction::StoreScriptString: { QObject *target = stack.top(); QObject *scope = stack.at(stack.count() - 1 - instr.storeScriptString.scope); QDeclarativeScriptString ss; ss.setContext(ctxt->asQDeclarativeContext()); ss.setScopeObject(scope); ss.setScript(primitives.at(instr.storeScriptString.value)); void *a[] = { &ss, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeScriptString.propertyIndex, a); } break; case QDeclarativeInstruction::BeginObject: { QObject *target = stack.top(); QDeclarativeParserStatus *status = reinterpret_cast<QDeclarativeParserStatus *>(reinterpret_cast<char *>(target) + instr.begin.castValue); parserStatus.append(status); status->d = &parserStatus.values[parserStatus.count - 1]; status->classBegin(); } break; case QDeclarativeInstruction::StoreBinding: case QDeclarativeInstruction::StoreBindingOnAlias: { QObject *target = stack.at(stack.count() - 1 - instr.assignBinding.owner); QObject *context = stack.at(stack.count() - 1 - instr.assignBinding.context); QDeclarativeProperty mp = QDeclarativePropertyPrivate::restore(datas.at(instr.assignBinding.property), target, ctxt); int coreIndex = mp.index(); if ((stack.count() - instr.assignBinding.owner) == 1 && bindingSkipList.testBit(coreIndex)) break; QDeclarativeBinding *bind = new QDeclarativeBinding((void *)datas.at(instr.assignBinding.value).constData(), comp, context, ctxt, comp->name, instr.line, 0); bindValues.append(bind); bind->m_mePtr = &bindValues.values[bindValues.count - 1]; bind->setTarget(mp); if (instr.type == QDeclarativeInstruction::StoreBindingOnAlias) { QDeclarativeAbstractBinding *old = QDeclarativePropertyPrivate::setBindingNoEnable(target, coreIndex, QDeclarativePropertyPrivate::valueTypeCoreIndex(mp), bind); if (old) { old->destroy(); } } else { bind->addToObject(target, QDeclarativePropertyPrivate::bindingIndex(mp)); } } break; case QDeclarativeInstruction::StoreCompiledBinding: { QObject *target = stack.at(stack.count() - 1 - instr.assignBinding.owner); QObject *scope = stack.at(stack.count() - 1 - instr.assignBinding.context); int property = instr.assignBinding.property; if (stack.count() == 1 && bindingSkipList.testBit(property & 0xFFFF)) break; QDeclarativeAbstractBinding *binding = ctxt->optimizedBindings->configBinding(instr.assignBinding.value, target, scope, property); bindValues.append(binding); binding->m_mePtr = &bindValues.values[bindValues.count - 1]; binding->addToObject(target, property); } break; case QDeclarativeInstruction::StoreValueSource: { QObject *obj = stack.pop(); QDeclarativePropertyValueSource *vs = reinterpret_cast<QDeclarativePropertyValueSource *>(reinterpret_cast<char *>(obj) + instr.assignValueSource.castValue); QObject *target = stack.at(stack.count() - 1 - instr.assignValueSource.owner); QDeclarativeProperty prop = QDeclarativePropertyPrivate::restore(datas.at(instr.assignValueSource.property), target, ctxt); obj->setParent(target); vs->setTarget(prop); } break; case QDeclarativeInstruction::StoreValueInterceptor: { QObject *obj = stack.pop(); QDeclarativePropertyValueInterceptor *vi = reinterpret_cast<QDeclarativePropertyValueInterceptor *>(reinterpret_cast<char *>(obj) + instr.assignValueInterceptor.castValue); QObject *target = stack.at(stack.count() - 1 - instr.assignValueInterceptor.owner); QDeclarativeProperty prop = QDeclarativePropertyPrivate::restore(datas.at(instr.assignValueInterceptor.property), target, ctxt); obj->setParent(target); vi->setTarget(prop); QDeclarativeVMEMetaObject *mo = static_cast<QDeclarativeVMEMetaObject *>((QMetaObject*)target->metaObject()); mo->registerInterceptor(prop.index(), QDeclarativePropertyPrivate::valueTypeCoreIndex(prop), vi); } break; case QDeclarativeInstruction::StoreObjectQList: { QObject *assign = stack.pop(); const ListInstance &list = qliststack.top(); list.qListProperty.append((QDeclarativeListProperty<void>*)&list.qListProperty, assign); } break; case QDeclarativeInstruction::AssignObjectList: { // This is only used for assigning interfaces QObject *assign = stack.pop(); const ListInstance &list = qliststack.top(); int type = list.type; void *ptr = 0; const char *iid = QDeclarativeMetaType::interfaceIId(type); if (iid) ptr = assign->qt_metacast(iid); if (!ptr) VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign object to list")); list.qListProperty.append((QDeclarativeListProperty<void>*)&list.qListProperty, ptr); } break; case QDeclarativeInstruction::StoreVariantObject: { QObject *assign = stack.pop(); QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeObject.propertyIndex); QVariant v = QVariant::fromValue(assign); void *a[] = { &v, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeObject.propertyIndex, a); } break; case QDeclarativeInstruction::StoreInterface: { QObject *assign = stack.pop(); QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeObject.propertyIndex); int coreIdx = instr.storeObject.propertyIndex; QMetaProperty prop = target->metaObject()->property(coreIdx); int t = prop.userType(); const char *iid = QDeclarativeMetaType::interfaceIId(t); bool ok = false; if (iid) { void *ptr = assign->qt_metacast(iid); if (ptr) { void *a[] = { &ptr, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, coreIdx, a); ok = true; } } if (!ok) VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign object to interface property")); } break; case QDeclarativeInstruction::FetchAttached: { QObject *target = stack.top(); QObject *qmlObject = qmlAttachedPropertiesObjectById(instr.fetchAttached.id, target); if (!qmlObject) VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Unable to create attached object")); stack.push(qmlObject); } break; case QDeclarativeInstruction::FetchQList: { QObject *target = stack.top(); qliststack.push(ListInstance(instr.fetchQmlList.type)); void *a[1]; a[0] = (void *)&(qliststack.top().qListProperty); QMetaObject::metacall(target, QMetaObject::ReadProperty, instr.fetchQmlList.property, a); } break; case QDeclarativeInstruction::FetchObject: { QObject *target = stack.top(); QObject *obj = 0; // NOTE: This assumes a cast to QObject does not alter the // object pointer void *a[1]; a[0] = &obj; QMetaObject::metacall(target, QMetaObject::ReadProperty, instr.fetch.property, a); if (!obj) VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot set properties on %1 as it is null").arg(QString::fromUtf8(target->metaObject()->property(instr.fetch.property).name()))); stack.push(obj); } break; case QDeclarativeInstruction::PopQList: { qliststack.pop(); } break; case QDeclarativeInstruction::Defer: { if (instr.defer.deferCount) { QObject *target = stack.top(); QDeclarativeData *data = QDeclarativeData::get(target, true); comp->addref(); data->deferredComponent = comp; data->deferredIdx = ii; ii += instr.defer.deferCount; } } break; case QDeclarativeInstruction::PopFetchedObject: { stack.pop(); } break; case QDeclarativeInstruction::FetchValueType: { QObject *target = stack.top(); if (instr.fetchValue.bindingSkipList != 0) { // Possibly need to clear bindings QDeclarativeData *targetData = QDeclarativeData::get(target); if (targetData) { QDeclarativeAbstractBinding *binding = QDeclarativePropertyPrivate::binding(target, instr.fetchValue.property, -1); if (binding && binding->bindingType() != QDeclarativeAbstractBinding::ValueTypeProxy) { QDeclarativePropertyPrivate::setBinding(target, instr.fetchValue.property, -1, 0); binding->destroy(); } else if (binding) { QDeclarativeValueTypeProxyBinding *proxy = static_cast<QDeclarativeValueTypeProxyBinding *>(binding); proxy->removeBindings(instr.fetchValue.bindingSkipList); } } } QDeclarativeValueType *valueHandler = ep->valueTypes[instr.fetchValue.type]; valueHandler->read(target, instr.fetchValue.property); stack.push(valueHandler); } break; case QDeclarativeInstruction::PopValueType: { QDeclarativeValueType *valueHandler = static_cast<QDeclarativeValueType *>(stack.pop()); QObject *target = stack.top(); valueHandler->write(target, instr.fetchValue.property, QDeclarativePropertyPrivate::BypassInterceptor); } break; default: qFatal("QDeclarativeCompiledData: Internal error - unknown instruction %d", instr.type); break; } } if (isError()) { if (!stack.isEmpty()) { delete stack.at(0); // ### What about failures in deferred creation? } else { ctxt->destroy(); } QDeclarativeEnginePrivate::clear(bindValues); QDeclarativeEnginePrivate::clear(parserStatus); return 0; } if (bindValues.count) ep->bindValues << bindValues; else if (bindValues.values) bindValues.clear(); if (parserStatus.count) ep->parserStatus << parserStatus; else if (parserStatus.values) parserStatus.clear(); Q_ASSERT(stack.count() == 1); return stack.top(); }
void QDeclarativePropertyCache::append(QDeclarativeEngine *engine, const QMetaObject *metaObject, int revision, Data::Flag propertyFlags, Data::Flag methodFlags, Data::Flag signalFlags) { Q_UNUSED(revision); allowedRevisionCache.append(0); QDeclarativeEnginePrivate *enginePriv = QDeclarativeEnginePrivate::get(engine); int methodCount = metaObject->methodCount(); // 3 to block the destroyed signal and the deleteLater() slot int methodOffset = qMax(3, metaObject->methodOffset()); methodIndexCache.resize(methodCount); for (int ii = methodOffset; ii < methodCount; ++ii) { QMetaMethod m = metaObject->method(ii); if (m.access() == QMetaMethod::Private) continue; QString methodName = QString::fromUtf8(m.signature()); int parenIdx = methodName.indexOf(QLatin1Char('(')); Q_ASSERT(parenIdx != -1); methodName = methodName.left(parenIdx); RData *data = new RData; data->identifier = enginePriv->objectClass->createPersistentIdentifier(methodName); methodIndexCache[ii] = data; data->load(m); if (m.methodType() == QMetaMethod::Slot || m.methodType() == QMetaMethod::Method) data->flags |= methodFlags; else if (m.methodType() == QMetaMethod::Signal) data->flags |= signalFlags; data->metaObjectOffset = allowedRevisionCache.count() - 1; if (stringCache.contains(methodName)) { RData *old = stringCache[methodName]; // We only overload methods in the same class, exactly like C++ if (old->flags & Data::IsFunction && old->coreIndex >= methodOffset) data->relatedIndex = old->coreIndex; data->overrideIndexIsProperty = !bool(old->flags & Data::IsFunction); data->overrideIndex = old->coreIndex; stringCache[methodName]->release(); identifierCache[data->identifier.identifier]->release(); } stringCache.insert(methodName, data); identifierCache.insert(data->identifier.identifier, data); data->addref(); data->addref(); } int propCount = metaObject->propertyCount(); int propOffset = metaObject->propertyOffset(); indexCache.resize(propCount); for (int ii = propOffset; ii < propCount; ++ii) { QMetaProperty p = metaObject->property(ii); if (!p.isScriptable()) continue; QString propName = QString::fromUtf8(p.name()); RData *data = new RData; data->identifier = enginePriv->objectClass->createPersistentIdentifier(propName); indexCache[ii] = data; data->load(p, engine); data->flags |= propertyFlags; data->metaObjectOffset = allowedRevisionCache.count() - 1; if (stringCache.contains(propName)) { RData *old = stringCache[propName]; data->overrideIndexIsProperty = !bool(old->flags & Data::IsFunction); data->overrideIndex = old->coreIndex; stringCache[propName]->release(); identifierCache[data->identifier.identifier]->release(); } stringCache.insert(propName, data); identifierCache.insert(data->identifier.identifier, data); data->addref(); data->addref(); } }
void AcceleratorManagerPrivate::manageWidget(QWidget *w, Item *item) { // first treat the special cases QTabBar *tabBar = qobject_cast<QTabBar*>(w); if (tabBar) { manageTabBar(tabBar, item); return; } QStackedWidget *wds = qobject_cast<QStackedWidget*>( w ); if ( wds ) { QWidgetStackAccelManager::manage( wds ); // return; } QDockWidget *dock = qobject_cast<QDockWidget*>( w ); if ( dock ) { //QWidgetStackAccelManager::manage( wds ); manageDockWidget(dock, item); } QMenu *popupMenu = qobject_cast<QMenu*>(w); if (popupMenu) { // create a popup accel manager that can deal with dynamic menus PopupAccelManager::manage(popupMenu); return; } QStackedWidget *wdst = qobject_cast<QStackedWidget*>( w ); if ( wdst ) { QWidgetStackAccelManager::manage( wdst ); // return; } QMenuBar *menuBar = qobject_cast<QMenuBar*>(w); if (menuBar) { manageMenuBar(menuBar, item); return; } if (qobject_cast<QComboBox*>(w) || qobject_cast<QLineEdit*>(w) || w->inherits("Q3TextEdit") || qobject_cast<QTextEdit*>(w) || qobject_cast<QAbstractSpinBox*>(w) || w->inherits( "KMultiTabBar" ) ) return; if ( w->inherits("KUrlRequester") ) { traverseChildren(w, item); return; } if ( qobject_cast<PathRequester*>(w) ) { traverseChildren(w, item); return; } // now treat 'ordinary' widgets QLabel *label = qobject_cast<QLabel*>(w); if ( label ) { if ( !label->buddy() ) return; else { if ( label->textFormat() == Qt::RichText || ( label->textFormat() == Qt::AutoText && Qt::mightBeRichText( label->text() ) ) ) return; } } if (w->focusPolicy() != Qt::NoFocus || label || qobject_cast<QGroupBox*>(w) || qobject_cast<QRadioButton*>( w )) { QString content; QVariant variant; int tprop = w->metaObject()->indexOfProperty("text"); if (tprop != -1) { QMetaProperty p = w->metaObject()->property( tprop ); if ( p.isValid() && p.isWritable() ) variant = p.read (w); else tprop = -1; } if (tprop == -1) { tprop = w->metaObject()->indexOfProperty("title"); if (tprop != -1) { QMetaProperty p = w->metaObject()->property( tprop ); if ( p.isValid() && p.isWritable() ) variant = p.read (w); } } if (variant.isValid()) content = variant.toString(); if (!content.isEmpty()) { Item *i = new Item; i->m_widget = w; // put some more weight on the usual action elements int weight = AccelManagerAlgorithm::DEFAULT_WEIGHT; if (qobject_cast<QPushButton*>(w) || qobject_cast<QCheckBox*>(w) || qobject_cast<QRadioButton*>(w) || qobject_cast<QLabel*>(w)) weight = AccelManagerAlgorithm::ACTION_ELEMENT_WEIGHT; // don't put weight on non-checkable group boxes, // as usually the contents are more important QGroupBox *groupBox = qobject_cast<QGroupBox*>(w); if (groupBox) { if (groupBox->isCheckable()) weight = AccelManagerAlgorithm::CHECKABLE_GROUP_BOX_WEIGHT; else weight = AccelManagerAlgorithm::GROUP_BOX_WEIGHT; } i->m_content = AccelString(content, weight); item->addChild(i); } } traverseChildren(w, item); }
/* We catch all qt_metacall invocations */ extern "C" SEXP qt_qmetacall(SEXP x, SEXP s_call, SEXP s_id, SEXP s_args) { SmokeObject *so = SmokeObject::fromSexp(x); QMetaObject::Call call = enum_from_sexp<QMetaObject::Call>(s_call, SmokeType()); int id = from_sexp<int>(s_id); void **args = reinterpret_cast<void **>(from_sexp<void *>(s_args)); // Assume the target slot is a C++ one Smoke::StackItem i[4]; i[1].s_enum = call; i[2].s_int = id; i[3].s_voidp = args; so->invokeMethod("qt_metacall$$?", i); int ret = i[0].s_int; if (ret < 0) { return ScalarInteger(ret); } QObject * qobj = reinterpret_cast<QObject *>(so->castPtr("QObject")); // get obj metaobject with a virtual call const QMetaObject *metaobject = qobj->metaObject(); if (call == QMetaObject::ReadProperty || call == QMetaObject::WriteProperty) { MocStack mocStack = MocStack(args, 1); QMetaProperty metaProp = metaobject->property(id); Property *prop = so->klass()->property(metaProp.name()); SmokeType type(so->smoke(), metaProp.typeName(), metaobject->className()); if (call == QMetaObject::ReadProperty) { Smoke::StackItem item = prop->read(so); mocStack.returnFromSmoke(SmokeStack(&item, 1), type); } else if (call == QMetaObject::WriteProperty) { QVector<SmokeType> types; types += type; prop->write(so, mocStack.toSmoke(types).ret()); } } if (call != QMetaObject::InvokeMetaMethod) return ScalarInteger(id); // get method count int count = metaobject->methodCount(); QMetaMethod method = metaobject->method(id); if (method.methodType() == QMetaMethod::Signal) { // FIXME: this overload of 'activate' is obsolete metaobject->activate(qobj, id, (void**) args); return ScalarInteger(id - count); } MocDynamicBinding binding(MocMethod(so->smoke(), metaobject, id)); binding.invoke(qobj, args); /* DynamicBinding binding(MocMethod(so->smoke(), metaobject, id)); QVector<SmokeType> stackTypes = binding.types(); MocStack mocStack = MocStack(args, stackTypes.size()); SmokeStack smokeStack = mocStack.toSmoke(stackTypes); binding.invoke(so, smokeStack.items()); mocStack.returnFromSmoke(smokeStack, stackTypes[0]); */ if (binding.lastError() == Method::NoError) warning("Slot invocation failed for %s::%s", so->klass()->name(), binding.name()); return ScalarInteger(id - count); }
int Dialog::showDialog(const QString& view, QObject* viewModel, int type) { QDialog* dialog = NULL; QMainWindow* mainWindow = NULL; QWidget* windowWidget = NULL; QWidget* layoutWidget = NULL; switch (type) { case Dialog::MainWindow: mainWindow = new QMainWindow(); windowWidget = mainWindow; layoutWidget = new QWidget(windowWidget); mainWindow->setCentralWidget(layoutWidget); break; case Dialog::ModalDialog: dialog = new QDialog(QApplication::activeWindow()); windowWidget = dialog; layoutWidget = dialog; break; default: dialog = new QDialog(); windowWidget = dialog; layoutWidget = dialog; break; } QGridLayout* layout = new QGridLayout(layoutWidget); // Create view QDeclarativeView* v = new QDeclarativeView(layoutWidget); if (viewModel) { int count = viewModel->metaObject()->propertyCount(); for (int i = 0; i < count; ++i) { QMetaProperty p = viewModel->metaObject()->property(i); if (p.isReadable() && p.typeName() == QString("QDeclarativeImageProvider*")) { QString name = p.name(); QDeclarativeImageProvider* value = p.read(viewModel).value<QDeclarativeImageProvider*>(); v->engine()->addImageProvider(name.toLatin1(), new ProxyImageProvider(value)); } } v->rootContext()->setContextProperty("dataContext", viewModel); } QString path; foreach (path, importPaths) v->engine()->addImportPath(path); foreach (path, pluginPaths) v->engine()->addPluginPath(path); v->setSource(QUrl(view)); v->setResizeMode(QDeclarativeView::SizeRootObjectToView); // Initialize dialog QGraphicsObject* root = v->rootObject(); QVariant property = root->property("dialogTitle"); if (property.isValid()) windowWidget->setWindowTitle(property.toString()); property = root->property("dialogMinWidth"); if (property.isValid()) layoutWidget->setMinimumWidth(property.toInt()); property = root->property("dialogMinHeight"); if (property.isValid()) layoutWidget->setMinimumHeight(property.toInt()); property = root->property("dialogMaxWidth"); if (property.isValid()) layoutWidget->setMaximumWidth(property.toInt()); property = root->property("dialogMaxHeight"); if (property.isValid()) layoutWidget->setMaximumHeight(property.toInt()); property = root->property("dialogResizable"); if (property.isValid() && !property.toBool()) layout->setSizeConstraint(QLayout::SetFixedSize); Qt::WindowStates states = windowWidget->windowState(); Qt::WindowFlags flags = windowWidget->windowFlags(); property = root->property("dialogMinimizeButton"); if (property.isValid()) flags = property.toBool() ? flags | Qt::WindowMinimizeButtonHint : flags & ~Qt::WindowMinimizeButtonHint; property = root->property("dialogMaximizeButton"); if (property.isValid()) flags = property.toBool() ? flags | Qt::WindowMaximizeButtonHint : flags & ~Qt::WindowMaximizeButtonHint; property = root->property("dialogCloseButton"); if (property.isValid()) flags = property.toBool() ? flags | Qt::WindowCloseButtonHint : flags & ~Qt::WindowCloseButtonHint; property = root->property("dialogFullScreen"); if (property.isValid()) states = property.toBool() ? states | Qt::WindowFullScreen : states & ~Qt::WindowFullScreen; flags = flags & ~Qt::WindowContextHelpButtonHint; windowWidget->setWindowFlags(flags); windowWidget->setWindowState(states); property = root->property("dialogToolBar"); if (type == Dialog::MainWindow && property.isValid() && property.typeName() == QString("QDeclarativeListProperty<QDeclarativeItem>")) { QToolBar* toolbar = new QToolBar(mainWindow); toolbar->setMovable(false); toolbar->setFloatable(false); toolbar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon); toolbar->setAllowedAreas(Qt::TopToolBarArea); QDeclarativeListProperty<QDeclarativeItem> btnList = property.value< QDeclarativeListProperty<QDeclarativeItem> >(); int btnCount = btnList.count(&btnList); for (int i = 0; i < btnCount; ++i) { QDeclarativeItem* item = btnList.at(&btnList, i); if (!item->property("text").isValid()) continue; QString itemText = item->property("text").toString(); QString itemTooltip = item->property("tooltip").isValid() ? item->property("tooltip").toString() : ""; QString itemIconSource = item->property("iconSource").isValid() ? item->property("iconSource").toString() : ""; int itemIconSize = item->property("iconSize").isValid() ? item->property("iconSize").toInt() : -1; if (itemText == "|") { toolbar->addSeparator(); } else if (itemText == "-") { QWidget* spacer = new QWidget(); spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum); toolbar->addWidget(spacer); } else { QAction* action = new QAction(mainWindow); action->setText(itemText); action->setToolTip(itemTooltip); action->setIcon(QIcon(itemIconSource)); QObject::connect(action, SIGNAL(triggered()), item, SLOT(trigger())); if (item->property("enabled").isValid()) new PropertyBinding(action, "enabled", item, "enabled", PropertyBinding::OneWay, NULL, this); if (item->property("visible").isValid()) new PropertyBinding(action, "visible", item, "visible", PropertyBinding::OneWay, NULL, this); toolbar->addAction(action); } if (itemIconSize != -1) toolbar->setIconSize(QSize(itemIconSize, itemIconSize)); } mainWindow->setUnifiedTitleAndToolBarOnMac(true); mainWindow->addToolBar(toolbar); } property = root->property("dialogMenu"); if (type == Dialog::MainWindow && property.isValid() && property.typeName() == QString("QDeclarativeListProperty<QDeclarativeItem>")) { QDeclarativeListProperty<QDeclarativeItem> list = property.value< QDeclarativeListProperty<QDeclarativeItem> >(); int count = list.count(&list); for (int i = 0; i < count; ++i) { QDeclarativeItem* item = list.at(&list, i); if (!item->property("text").isValid()) continue; QString itemText = item->property("text").toString(); QMenu * menuItem = mainWindow->menuBar()->addMenu(itemText); if (!item->property("submenu").isValid() || item->property("submenu").typeName() != QString("QDeclarativeListProperty<QDeclarativeItem>")) continue; QDeclarativeListProperty<QDeclarativeItem> innerList = item->property("submenu").value< QDeclarativeListProperty<QDeclarativeItem> >(); int innerCount = innerList.count(&innerList); for (int j = 0; j < innerCount; ++j) { QDeclarativeItem* innerItem = innerList.at(&innerList, j); if (!innerItem->property("text").isValid()) continue; QString innerItemText = innerItem->property("text").toString(); QString innerItemShortcut = innerItem->property("shortcut").isValid() ? innerItem->property("shortcut").toString() : ""; QString innerItemIconSource = innerItem->property("iconSource").isValid() ? innerItem->property("iconSource").toString() : ""; if (innerItemText == "-") { menuItem->addSeparator(); } else { QAction * action = menuItem->addAction(QIcon(innerItemIconSource), innerItemText); action->setShortcut(QKeySequence(innerItemShortcut)); QObject::connect(action, SIGNAL(triggered()), innerItem, SLOT(trigger())); if (innerItem->property("enabled").isValid()) new PropertyBinding(action, "enabled", innerItem, "enabled", PropertyBinding::OneWay, NULL, this); if (innerItem->property("visible").isValid()) new PropertyBinding(action, "visible", innerItem, "visible", PropertyBinding::OneWay, NULL, this); } } } } new DialogCallbacks(windowWidget, v, root); // Initialize layout layout->setMargin(0); layout->addWidget(v, 0, 0); // Execute switch (type) { case Dialog::ModalDialog: dialog->exec(); break; case Dialog::MainWindow: { if (mainWindowGeometry.isEmpty()) { mainWindow->adjustSize(); mainWindow->move(QApplication::desktop()->screen()->rect().center() - mainWindow->rect().center()); } else mainWindow->restoreGeometry(mainWindowGeometry); } default: windowWidget->setAttribute(Qt::WA_DeleteOnClose); windowWidget->show(); break; } int result = 0; property = root->property("dialogResult"); if (property.isValid()) result = property.toInt(); if (type == Dialog::ModalDialog) delete dialog; return result; }
void QDeclarativePropertyPrivate::initProperty(QObject *obj, const QString &name) { if (!obj) return; QDeclarativeTypeNameCache *typeNameCache = context?context->imports:0; QStringList path = name.split(QLatin1Char('.')); if (path.isEmpty()) return; QObject *currentObject = obj; // Everything up to the last property must be an "object type" property for (int ii = 0; ii < path.count() - 1; ++ii) { const QString &pathName = path.at(ii); if (QDeclarativeTypeNameCache::Data *data = typeNameCache?typeNameCache->data(pathName):0) { if (data->type) { QDeclarativeAttachedPropertiesFunc func = data->type->attachedPropertiesFunction(); if (!func) return; // Not an attachable type currentObject = qmlAttachedPropertiesObjectById(data->type->index(), currentObject); if (!currentObject) return; // Something is broken with the attachable type } else { Q_ASSERT(data->typeNamespace); if ((ii + 1) == path.count()) return; // No type following the namespace ++ii; data = data->typeNamespace->data(path.at(ii)); if (!data || !data->type) return; // Invalid type in namespace QDeclarativeAttachedPropertiesFunc func = data->type->attachedPropertiesFunction(); if (!func) return; // Not an attachable type currentObject = qmlAttachedPropertiesObjectById(data->type->index(), currentObject); if (!currentObject) return; // Something is broken with the attachable type } } else { QDeclarativePropertyCache::Data local; QDeclarativePropertyCache::Data *property = QDeclarativePropertyCache::property(engine, obj, pathName, local); if (!property) return; // Not a property if (property->flags & QDeclarativePropertyCache::Data::IsFunction) return; // Not an object property if (ii == (path.count() - 2) && QDeclarativeValueTypeFactory::isValueType(property->propType)) { // We're now at a value type property. We can use a global valuetypes array as we // never actually use the objects, just look up their properties. QObject *typeObject = (*qmlValueTypes())[property->propType]; if (!typeObject) return; // Not a value type int idx = typeObject->metaObject()->indexOfProperty(path.last().toUtf8().constData()); if (idx == -1) return; // Value type property does not exist QMetaProperty vtProp = typeObject->metaObject()->property(idx); object = currentObject; core = *property; valueType.flags = QDeclarativePropertyCache::Data::flagsForProperty(vtProp); valueType.valueTypeCoreIdx = idx; valueType.valueTypePropType = vtProp.userType(); return; } else { if (!(property->flags & QDeclarativePropertyCache::Data::IsQObjectDerived)) return; // Not an object property void *args[] = { ¤tObject, 0 }; QMetaObject::metacall(currentObject, QMetaObject::ReadProperty, property->coreIndex, args); if (!currentObject) return; // No value } } } const QString &terminal = path.last(); if (terminal.count() >= 3 && terminal.at(0) == QLatin1Char('o') && terminal.at(1) == QLatin1Char('n') && terminal.at(2).isUpper()) { QString signalName = terminal.mid(2); signalName[0] = signalName.at(0).toLower(); QMetaMethod method = QDeclarativeCompiler::findSignalByName(currentObject->metaObject(), signalName.toLatin1().constData()); if (method.signature()) { object = currentObject; core.load(method); return; } } // Property QDeclarativePropertyCache::Data local; QDeclarativePropertyCache::Data *property = QDeclarativePropertyCache::property(engine, currentObject, terminal, local); if (property && !(property->flags & QDeclarativePropertyCache::Data::IsFunction)) { object = currentObject; core = *property; } }
int QDeclarativeVMEMetaObject::metaCall(QMetaObject::Call c, int _id, void **a) { int id = _id; if(c == QMetaObject::WriteProperty) { int flags = *reinterpret_cast<int*>(a[3]); if (!(flags & QDeclarativePropertyPrivate::BypassInterceptor) && !aInterceptors.isEmpty() && aInterceptors.testBit(id)) { QPair<int, QDeclarativePropertyValueInterceptor*> pair = interceptors.value(id); int valueIndex = pair.first; QDeclarativePropertyValueInterceptor *vi = pair.second; int type = property(id).userType(); if (type != QVariant::Invalid) { if (valueIndex != -1) { QDeclarativeEnginePrivate *ep = ctxt?QDeclarativeEnginePrivate::get(ctxt->engine):0; QDeclarativeValueType *valueType = 0; if (ep) valueType = ep->valueTypes[type]; else valueType = QDeclarativeValueTypeFactory::valueType(type); Q_ASSERT(valueType); valueType->setValue(QVariant(type, a[0])); QMetaProperty valueProp = valueType->metaObject()->property(valueIndex); vi->write(valueProp.read(valueType)); if (!ep) delete valueType; return -1; } else { vi->write(QVariant(type, a[0])); return -1; } } } } if(c == QMetaObject::ReadProperty || c == QMetaObject::WriteProperty) { if (id >= propOffset) { id -= propOffset; if (id < metaData->propertyCount) { int t = (metaData->propertyData() + id)->propertyType; bool needActivate = false; if (t == -1) { if (c == QMetaObject::ReadProperty) { *reinterpret_cast<QVariant *>(a[0]) = readVarPropertyAsVariant(id); } else if (c == QMetaObject::WriteProperty) { writeVarProperty(id, *reinterpret_cast<QVariant *>(a[0])); } } else { if (c == QMetaObject::ReadProperty) { switch(t) { case QVariant::Int: *reinterpret_cast<int *>(a[0]) = data[id].asInt(); break; case QVariant::Bool: *reinterpret_cast<bool *>(a[0]) = data[id].asBool(); break; case QVariant::Double: *reinterpret_cast<double *>(a[0]) = data[id].asDouble(); break; case QVariant::String: *reinterpret_cast<QString *>(a[0]) = data[id].asQString(); break; case QVariant::Url: *reinterpret_cast<QUrl *>(a[0]) = data[id].asQUrl(); break; case QVariant::Color: *reinterpret_cast<QColor *>(a[0]) = data[id].asQColor(); break; case QVariant::Date: *reinterpret_cast<QDate *>(a[0]) = data[id].asQDate(); break; case QVariant::DateTime: *reinterpret_cast<QDateTime *>(a[0]) = data[id].asQDateTime(); break; case QMetaType::QObjectStar: *reinterpret_cast<QObject **>(a[0]) = data[id].asQObject(); break; default: break; } if (t == qMetaTypeId<QDeclarativeListProperty<QObject> >()) { int listIndex = data[id].asInt(); const List *list = &listProperties.at(listIndex); *reinterpret_cast<QDeclarativeListProperty<QObject> *>(a[0]) = QDeclarativeListProperty<QObject>(object, (void *)list, list_append, list_count, list_at, list_clear); } } else if (c == QMetaObject::WriteProperty) { switch(t) { case QVariant::Int: needActivate = *reinterpret_cast<int *>(a[0]) != data[id].asInt(); data[id].setValue(*reinterpret_cast<int *>(a[0])); break; case QVariant::Bool: needActivate = *reinterpret_cast<bool *>(a[0]) != data[id].asBool(); data[id].setValue(*reinterpret_cast<bool *>(a[0])); break; case QVariant::Double: needActivate = *reinterpret_cast<double *>(a[0]) != data[id].asDouble(); data[id].setValue(*reinterpret_cast<double *>(a[0])); break; case QVariant::String: needActivate = *reinterpret_cast<QString *>(a[0]) != data[id].asQString(); data[id].setValue(*reinterpret_cast<QString *>(a[0])); break; case QVariant::Url: needActivate = *reinterpret_cast<QUrl *>(a[0]) != data[id].asQUrl(); data[id].setValue(*reinterpret_cast<QUrl *>(a[0])); break; case QVariant::Color: needActivate = *reinterpret_cast<QColor *>(a[0]) != data[id].asQColor(); data[id].setValue(*reinterpret_cast<QColor *>(a[0])); break; case QVariant::Date: needActivate = *reinterpret_cast<QDate *>(a[0]) != data[id].asQDate(); data[id].setValue(*reinterpret_cast<QDate *>(a[0])); break; case QVariant::DateTime: needActivate = *reinterpret_cast<QDateTime *>(a[0]) != data[id].asQDateTime(); data[id].setValue(*reinterpret_cast<QDateTime *>(a[0])); break; case QMetaType::QObjectStar: needActivate = *reinterpret_cast<QObject **>(a[0]) != data[id].asQObject(); data[id].setValue(*reinterpret_cast<QObject **>(a[0])); break; default: break; } } } if (c == QMetaObject::WriteProperty && needActivate) { activate(object, methodOffset + id, 0); } return -1; } id -= metaData->propertyCount; if (id < metaData->aliasCount) { QDeclarativeVMEMetaData::AliasData *d = metaData->aliasData() + id; if (d->flags & QML_ALIAS_FLAG_PTR && c == QMetaObject::ReadProperty) *reinterpret_cast<void **>(a[0]) = 0; if (!ctxt) return -1; QDeclarativeContext *context = ctxt->asQDeclarativeContext(); QDeclarativeContextPrivate *ctxtPriv = QDeclarativeContextPrivate::get(context); QObject *target = ctxtPriv->data->idValues[d->contextIdx].data(); if (!target) return -1; connectAlias(id); if (d->isObjectAlias()) { *reinterpret_cast<QObject **>(a[0]) = target; return -1; } // Remove binding (if any) on write if(c == QMetaObject::WriteProperty) { int flags = *reinterpret_cast<int*>(a[3]); if (flags & QDeclarativePropertyPrivate::RemoveBindingOnAliasWrite) { QDeclarativeData *targetData = QDeclarativeData::get(target); if (targetData && targetData->hasBindingBit(d->propertyIndex())) { QDeclarativeAbstractBinding *binding = QDeclarativePropertyPrivate::setBinding(target, d->propertyIndex(), d->isValueTypeAlias()?d->valueTypeIndex():-1, 0); if (binding) binding->destroy(); } } } if (d->isValueTypeAlias()) { // Value type property QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(ctxt->engine); QDeclarativeValueType *valueType = ep->valueTypes[d->valueType()]; Q_ASSERT(valueType); valueType->read(target, d->propertyIndex()); int rv = QMetaObject::metacall(valueType, c, d->valueTypeIndex(), a); if (c == QMetaObject::WriteProperty) valueType->write(target, d->propertyIndex(), 0x00); return rv; } else { return QMetaObject::metacall(target, c, d->propertyIndex(), a); } } return -1; } } else if(c == QMetaObject::InvokeMetaMethod) { if (id >= methodOffset) { id -= methodOffset; int plainSignals = metaData->signalCount + metaData->propertyCount + metaData->aliasCount; if (id < plainSignals) { QMetaObject::activate(object, _id, a); return -1; } id -= plainSignals; if (id < metaData->methodCount) { if (!ctxt->engine) return -1; // We can't run the method QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(ctxt->engine); QScriptValue function = method(id); QScriptValueList args; QDeclarativeVMEMetaData::MethodData *data = metaData->methodData() + id; if (data->parameterCount) { for (int ii = 0; ii < data->parameterCount; ++ii) { args << ep->scriptValueFromVariant(*(QVariant *)a[ii + 1]); } } QScriptValue rv = function.call(ep->objectClass->newQObject(object), args); if (a[0]) *reinterpret_cast<QVariant *>(a[0]) = ep->scriptValueToVariant(rv); return -1; } return -1; } } if (parent) return parent->metaCall(c, _id, a); else return object->qt_metacall(c, _id, a); }
QVariant QDBusAbstractInterfacePrivate::property(const QMetaProperty &mp) const { if (!connection.isConnected()) // not connected return QVariant(); // is this metatype registered? int mid; const char *expectedSignature; if (mp.type() == QVariant::LastType) { // We're asking to read a QVariant mid = qMetaTypeId<QDBusVariant>(); expectedSignature = "v"; } else { mid = QMetaType::type(mp.typeName()); expectedSignature = QDBusMetaType::typeToSignature(mid); if (expectedSignature == 0) { qWarning("QDBusAbstractInterface: type %s must be registered with QtDBus before it can be " "used to read property %s.%s", mp.typeName(), qPrintable(interface), mp.name()); return QVariant(); } } // try to read this property QDBusMessage msg = QDBusMessage::createMethodCall(service, path, QLatin1String(DBUS_INTERFACE_PROPERTIES), QLatin1String("Get")); msg << interface << QString::fromUtf8(mp.name()); QDBusMessage reply = connection.call(msg, QDBus::Block); if (reply.type() != QDBusMessage::ReplyMessage) { lastError = reply; return QVariant(); } if (reply.signature() != QLatin1String("v")) { QString errmsg = QLatin1String("Invalid signature `%1' in return from call to " DBUS_INTERFACE_PROPERTIES); lastError = QDBusError(QDBusError::InvalidSignature, errmsg.arg(reply.signature())); return QVariant(); } QByteArray foundSignature; const char *foundType = 0; QVariant value = qvariant_cast<QDBusVariant>(reply.arguments().at(0)).variant(); if (value.userType() == mid) return value; // simple match if (value.userType() == qMetaTypeId<QDBusArgument>()) { QDBusArgument arg = qvariant_cast<QDBusArgument>(value); foundType = "user type"; foundSignature = arg.currentSignature().toLatin1(); if (foundSignature == expectedSignature) { void *null = 0; QVariant result(mid, null); QDBusMetaType::demarshall(arg, mid, result.data()); if (mp.type() == QVariant::LastType) // special case: QVariant return qvariant_cast<QDBusVariant>(result).variant(); return result; } } else { foundType = value.typeName(); foundSignature = QDBusMetaType::typeToSignature(value.userType()); } // there was an error... QString errmsg = QLatin1String("Unexpected `%1' (%2) when retrieving property `%3.%4' " "(expected type `%5' (%6))"); lastError = QDBusError(QDBusError::InvalidSignature, errmsg.arg(QString::fromLatin1(foundType), QString::fromLatin1(foundSignature), interface, QString::fromUtf8(mp.name()), QString::fromLatin1(mp.typeName()), QString::fromLatin1(expectedSignature))); return QVariant(); }
bool operator==(const PropertyPair& other) const {return QString(other.Property.name()) == QString(Property.name());}
void QSAEditor::completeQMetaObject( const QMetaObject *meta, const QString &, QVector<CompletionEntry> &res, int flags, QSObject &obj ) { QMap<QString, bool> propMap; bool includeSuperClass = (flags & IncludeSuperClass) == IncludeSuperClass; // properties const QMetaObject *m = meta; int num = m->propertyCount(); for ( int j = 0; j < num; ++j ) { const QMetaProperty mp = m->property( j ); if ( propMap.find( QString::fromLatin1(mp.name()) ) != propMap.end() ) continue; CompletionEntry c; propMap[QLatin1String(mp.name())] = false; c.type = QLatin1String("property"); c.text = mp.name(); c.prefix = QString(); c.postfix2 = mp.typeName(); QuickInterpreter::cleanType( c.postfix2 ); if ( !c.postfix2.isEmpty() ) c.postfix2.prepend( QLatin1String(" : ") ); res.append( c ); } if ( includeSuperClass && obj.isValid() && !obj.isUndefined() ) { QStringList vars = interpreter()->variablesOf( obj, true ); QStringList::iterator it; for ( it = vars.begin(); it != vars.end(); ++it ) { CompletionEntry c; c.type = QLatin1String("variable"); c.text = *it; c.prefix = QString(); c.postfix2 = QString(); res << c; } } // functions QList<Property> lst; QList<Property>::Iterator pit; getSlots( meta, lst, includeSuperClass, false, false ); for ( pit = lst.begin(); pit != lst.end(); ++pit ) { CompletionEntry c; c.type = QLatin1String("function"); c.text = (*pit).name; c.postfix = QLatin1String("()"); c.postfix2 = (*pit).type; if ( !c.postfix2.isEmpty() ) c.postfix2.prepend( QString::fromLatin1(" : ") ); res << c; } if ( includeSuperClass && obj.isValid() && !obj.isUndefined() ) { QStringList funcs = interpreter()->functionsOf( obj, true, true, true ); QStringList::Iterator it; for ( it = funcs.begin(); it != funcs.end(); ++it ) { CompletionEntry c; c.type = QLatin1String("function"); c.text = *it; c.prefix = QString(); c.postfix2 = QString(); res << c; } } // enum values m = meta; for (int k=0; k<m->enumeratorCount(); ++k) { QMetaEnum me = m->enumerator(k); for (int l=0; l<me.keyCount(); ++l) { CompletionEntry c; c.type = QLatin1String("enum"); c.text = QLatin1String(me.key(l)); c.prefix = QString(); c.postfix2 = QLatin1String(me.name()); if (!c.postfix2.isEmpty()) c.postfix2.prepend( QString::fromLatin1(" : ") ); res << c; } } if ( includeSuperClass && obj.isValid() && !obj.isUndefined() ) { QStringList classes = interpreter()->classesOf( obj ); QStringList::Iterator it; for ( it = classes.begin(); it != classes.end(); ++it ) { CompletionEntry c; c.type = QLatin1String("class"); c.text = *it; c.prefix = QString(); c.postfix2 = QString(); res << c; } } }
void ControlInfo::setControl(QWidget *activex) { listInfo->clear(); const QMetaObject *mo = activex->metaObject(); QTreeWidgetItem *group = new QTreeWidgetItem(listInfo); group->setText(0, tr("Class Info")); group->setText(1, QString::number(mo->classInfoCount())); QTreeWidgetItem *item = 0; int i; int count; for (i = mo->classInfoOffset(); i < mo->classInfoCount(); ++i) { const QMetaClassInfo info = mo->classInfo(i); item = new QTreeWidgetItem(group); item->setText(0, QString::fromLatin1(info.name())); item->setText(1, QString::fromLatin1(info.value())); } group = new QTreeWidgetItem(listInfo); group->setText(0, tr("Signals")); count = 0; for (i = mo->methodOffset(); i < mo->methodCount(); ++i) { const QMetaMethod method = mo->method(i); if (method.methodType() == QMetaMethod::Signal) { ++count; item = new QTreeWidgetItem(group); item->setText(0, QString::fromLatin1(method.signature())); } } group->setText(1, QString::number(count)); group = new QTreeWidgetItem(listInfo); group->setText(0, tr("Slots")); count = 0; for (i = mo->methodOffset(); i < mo->methodCount(); ++i) { const QMetaMethod method = mo->method(i); if (method.methodType() == QMetaMethod::Slot) { ++count; item = new QTreeWidgetItem(group); item->setText(0, QString::fromLatin1(method.signature())); } } group->setText(1, QString::number(count)); group = new QTreeWidgetItem(listInfo); group->setText(0, tr("Properties")); count = 0; for (i = mo->propertyOffset(); i < mo->propertyCount(); ++i) { ++count; const QMetaProperty property = mo->property(i); item = new QTreeWidgetItem(group); item->setText(0, QString::fromLatin1(property.name())); item->setText(1, QString::fromLatin1(property.typeName())); if (!property.isDesignable()) { item->setTextColor(0, Qt::gray); item->setTextColor(1, Qt::gray); } } group->setText(1, QString::number(count)); }
void QDeclarativeExpressionPrivate::updateGuards(const QPODVector<QDeclarativeEnginePrivate::CapturedProperty> &properties) { Q_Q(QDeclarativeExpression); static int notifyIdx = -1; if (notifyIdx == -1) notifyIdx = QDeclarativeExpression::staticMetaObject.indexOfMethod("__q_notify()"); if (properties.count() != data->guardListLength) { QDeclarativeNotifierEndpoint *newGuardList = new QDeclarativeNotifierEndpoint[properties.count()]; for (int ii = 0; ii < qMin(data->guardListLength, properties.count()); ++ii) data->guardList[ii].copyAndClear(newGuardList[ii]); delete [] data->guardList; data->guardList = newGuardList; data->guardListLength = properties.count(); } bool outputWarningHeader = false; bool noChanges = true; for (int ii = 0; ii < properties.count(); ++ii) { QDeclarativeNotifierEndpoint &guard = data->guardList[ii]; const QDeclarativeEnginePrivate::CapturedProperty &property = properties.at(ii); guard.target = q; guard.targetMethod = notifyIdx; if (property.notifier != 0) { if (!noChanges && guard.isConnected(property.notifier)) { // Nothing to do } else { noChanges = false; bool existing = false; for (int jj = 0; !existing && jj < ii; ++jj) if (data->guardList[jj].isConnected(property.notifier)) existing = true; if (existing) { // duplicate guard.disconnect(); } else { guard.connect(property.notifier); } } } else if (property.notifyIndex != -1) { if (!noChanges && guard.isConnected(property.object, property.notifyIndex)) { // Nothing to do } else { noChanges = false; bool existing = false; for (int jj = 0; !existing && jj < ii; ++jj) if (data->guardList[jj].isConnected(property.object, property.notifyIndex)) existing = true; if (existing) { // duplicate guard.disconnect(); } else { guard.connect(property.object, property.notifyIndex); } } } else { if (!outputWarningHeader) { outputWarningHeader = true; qWarning() << "QDeclarativeExpression: Expression" << q->expression() << "depends on non-NOTIFYable properties:"; } const QMetaObject *metaObj = property.object->metaObject(); QMetaProperty metaProp = metaObj->property(property.coreIndex); qWarning().nospace() << " " << metaObj->className() << "::" << metaProp.name(); } } }