void initWidgetsArray(W * widgets[CHANNELS_NUM], W * w0, W * w1, W * w2) { widgets[0] = w0; widgets[1] = w1; widgets[2] = w2; // TODO: avoid this limitation Q_STATIC_ASSERT_X(CHANNELS_NUM == 3, "MainWindow::initWidgetsArray implementation assumes CHANNELS_NUM == 3"); }
void QDBusMetaObjectGenerator::write(QDBusMetaObject *obj) { // this code here is mostly copied from qaxbase.cpp // with a few modifications to make it cleaner QString className = interface; className.replace(QLatin1Char('.'), QLatin1String("::")); if (className.isEmpty()) className = QLatin1String("QDBusInterface"); QVarLengthArray<int> idata; idata.resize(sizeof(QDBusMetaObjectPrivate) / sizeof(int)); int methodParametersDataSize = ((aggregateParameterCount(signals_) + aggregateParameterCount(methods)) * 2) // types and parameter names - signals_.count() // return "parameters" don't have names - methods.count(); // ditto QDBusMetaObjectPrivate *header = reinterpret_cast<QDBusMetaObjectPrivate *>(idata.data()); Q_STATIC_ASSERT_X(QMetaObjectPrivate::OutputRevision == 7, "QtDBus meta-object generator should generate the same version as moc"); header->revision = QMetaObjectPrivate::OutputRevision; header->className = 0; header->classInfoCount = 0; header->classInfoData = 0; header->methodCount = signals_.count() + methods.count(); header->methodData = idata.size(); header->propertyCount = properties.count(); header->propertyData = header->methodData + header->methodCount * 5 + methodParametersDataSize; header->enumeratorCount = 0; header->enumeratorData = 0; header->constructorCount = 0; header->constructorData = 0; header->flags = RequiresVariantMetaObject; header->signalCount = signals_.count(); // These are specific to QDBusMetaObject: header->propertyDBusData = header->propertyData + header->propertyCount * 3; header->methodDBusData = header->propertyDBusData + header->propertyCount * intsPerProperty; int data_size = idata.size() + (header->methodCount * (5+intsPerMethod)) + methodParametersDataSize + (header->propertyCount * (3+intsPerProperty)); foreach (const Method &mm, signals_) data_size += 2 + mm.inputTypes.count() + mm.outputTypes.count(); foreach (const Method &mm, methods) data_size += 2 + mm.inputTypes.count() + mm.outputTypes.count(); idata.resize(data_size + 1); QMetaStringTable strings(className.toLatin1()); int offset = header->methodData; int parametersOffset = offset + header->methodCount * 5; int signatureOffset = header->methodDBusData; int typeidOffset = header->methodDBusData + header->methodCount * intsPerMethod; idata[typeidOffset++] = 0; // eod // add each method: for (int x = 0; x < 2; ++x) { // Signals must be added before other methods, to match moc. QMap<QByteArray, Method> &map = (x == 0) ? signals_ : methods; for (QMap<QByteArray, Method>::ConstIterator it = map.constBegin(); it != map.constEnd(); ++it) { const Method &mm = it.value(); int argc = mm.inputTypes.size() + qMax(0, mm.outputTypes.size() - 1); idata[offset++] = strings.enter(mm.name); idata[offset++] = argc; idata[offset++] = parametersOffset; idata[offset++] = strings.enter(mm.tag); idata[offset++] = mm.flags; // Parameter types for (int i = -1; i < argc; ++i) { int type; QByteArray typeName; if (i < 0) { // Return type if (!mm.outputTypes.isEmpty()) { type = mm.outputTypes.first(); if (type == -1) { type = IsUnresolvedType | strings.enter(mm.rawReturnType); } } else { type = QMetaType::Void; } } else if (i < mm.inputTypes.size()) { type = mm.inputTypes.at(i); } else { Q_ASSERT(mm.outputTypes.size() > 1); type = mm.outputTypes.at(i - mm.inputTypes.size() + 1); // Output parameters are references; type id not available typeName = QMetaType::typeName(type); typeName.append('&'); } Q_ASSERT(type != QMetaType::UnknownType); int typeInfo; if (!typeName.isEmpty()) typeInfo = IsUnresolvedType | strings.enter(typeName); else typeInfo = type; idata[parametersOffset++] = typeInfo; } // Parameter names for (int i = 0; i < argc; ++i) idata[parametersOffset++] = strings.enter(mm.parameterNames.at(i)); idata[signatureOffset++] = typeidOffset; idata[typeidOffset++] = mm.inputTypes.count(); memcpy(idata.data() + typeidOffset, mm.inputTypes.data(), mm.inputTypes.count() * sizeof(int)); typeidOffset += mm.inputTypes.count(); idata[signatureOffset++] = typeidOffset; idata[typeidOffset++] = mm.outputTypes.count(); memcpy(idata.data() + typeidOffset, mm.outputTypes.data(), mm.outputTypes.count() * sizeof(int)); typeidOffset += mm.outputTypes.count(); } } Q_ASSERT(offset == header->methodData + header->methodCount * 5); Q_ASSERT(parametersOffset == header->propertyData); Q_ASSERT(signatureOffset == header->methodDBusData + header->methodCount * intsPerMethod); Q_ASSERT(typeidOffset == idata.size()); offset += methodParametersDataSize; Q_ASSERT(offset == header->propertyData); // add each property signatureOffset = header->propertyDBusData; for (QMap<QByteArray, Property>::ConstIterator it = properties.constBegin(); it != properties.constEnd(); ++it) { const Property &mp = it.value(); // form is name, typeinfo, flags idata[offset++] = strings.enter(it.key()); // name Q_ASSERT(mp.type != QMetaType::UnknownType); idata[offset++] = mp.type; idata[offset++] = mp.flags; idata[signatureOffset++] = strings.enter(mp.signature); idata[signatureOffset++] = mp.type; } Q_ASSERT(offset == header->propertyDBusData); Q_ASSERT(signatureOffset == header->methodDBusData); char *string_data = new char[strings.blobSize()]; strings.writeBlob(string_data); uint *uint_data = new uint[idata.size()]; memcpy(uint_data, idata.data(), idata.size() * sizeof(int)); // put the metaobject together obj->d.data = uint_data; obj->d.relatedMetaObjects = 0; obj->d.static_metacall = 0; obj->d.extradata = 0; obj->d.stringdata = reinterpret_cast<const QByteArrayData *>(string_data); obj->d.superdata = &QDBusAbstractInterface::staticMetaObject; }