static bool readDomEnumerationValue(const DomProperty *p, const QDesignerPropertySheetExtension* sheet, QVariant &v) { switch (p->kind()) { case DomProperty::Set: { const int index = sheet->indexOf(p->attributeName()); if (index == -1) return false; const QVariant sheetValue = sheet->property(index); if (sheetValue.canConvert<PropertySheetFlagValue>()) { const PropertySheetFlagValue f = qvariant_cast<PropertySheetFlagValue>(sheetValue); bool ok = false; v = f.metaFlags.parseFlags(p->elementSet(), &ok); if (!ok) designerWarning(f.metaFlags.messageParseFailed(p->elementSet())); return true; } } break; case DomProperty::Enum: { const int index = sheet->indexOf(p->attributeName()); if (index == -1) return false; const QVariant sheetValue = sheet->property(index); if (sheetValue.canConvert<PropertySheetEnumValue>()) { const PropertySheetEnumValue e = qvariant_cast<PropertySheetEnumValue>(sheetValue); bool ok = false; v = e.metaEnum.parseEnum(p->elementEnum(), &ok); if (!ok) designerWarning(e.metaEnum.messageParseFailed(p->elementEnum())); return true; } } break; default: break; } return false; }
FontPropertyManager::FontPropertyManager() : m_createdFontProperty(0) { const int nameCount = sizeof(aliasingC)/sizeof(const char *); for (int i = 0; i < nameCount; i++) m_aliasingEnumNames.push_back(QCoreApplication::translate("FontPropertyManager", aliasingC[i])); QString errorMessage; if (!readFamilyMapping(&m_familyMappings, &errorMessage)) { designerWarning(errorMessage); } }
QDESIGNER_SHARED_EXPORT QDesignerWidgetDataBaseItemInterface * appendDerived(QDesignerWidgetDataBaseInterface *db, const QString &className, const QString &group, const QString &baseClassName, const QString &includeFile, bool promoted, bool custom) { if (debugWidgetDataBase) qDebug() << "appendDerived " << className << " derived from " << baseClassName; // Check. if (className.isEmpty() || baseClassName.isEmpty()) { qWarning("** WARNING %s called with an empty class names: '%s' extends '%s'.", Q_FUNC_INFO, className.toUtf8().constData(), baseClassName.toUtf8().constData()); return 0; } // Check whether item already exists. QDesignerWidgetDataBaseItemInterface *derivedItem = 0; const int existingIndex = db->indexOfClassName(className); if ( existingIndex != -1) derivedItem = db->item(existingIndex); if (derivedItem) { // Check the existing item for base class mismatch. This will likely // happen when loading a file written by an instance with missing plugins. // In that case, just warn and ignore the file properties. // // An empty base class indicates that it is not known (for example, for custom plugins). // In this case, the widget DB is later updated once the widget is created // by DOM (by querying the metaobject). Suppress the warning. const QString existingBaseClass = derivedItem->extends(); if (existingBaseClass.isEmpty() || baseClassName == existingBaseClass) return derivedItem; // Warn about mismatches designerWarning(QCoreApplication::translate("WidgetDataBase", "The file contains a custom widget '%1' whose base class (%2)" " differs from the current entry in the widget database (%3)." " The widget database is left unchanged."). arg(className, baseClassName, existingBaseClass)); return derivedItem; } // Create this item, inheriting its base properties const int baseIndex = db->indexOfClassName(baseClassName); if (baseIndex == -1) { if (debugWidgetDataBase) qDebug() << "appendDerived failed due to missing base class"; return 0; } const QDesignerWidgetDataBaseItemInterface *baseItem = db->item(baseIndex); derivedItem = WidgetDataBaseItem::clone(baseItem); // Sort of hack: If base class is QWidget, we most likely // do not want to inherit the container attribute. static const QString qWidgetName = QLatin1String("QWidget"); if (baseItem->name() == qWidgetName) derivedItem->setContainer(false); // set new props derivedItem->setName(className); derivedItem->setGroup(group); derivedItem->setCustom(custom); derivedItem->setPromoted(promoted); derivedItem->setExtends(baseClassName); derivedItem->setIncludeFile(includeFile); db->append(derivedItem); return derivedItem; }
void WidgetDataBase::loadPlugins() { typedef QMap<QString, int> NameIndexMap; typedef QList<QDesignerWidgetDataBaseItemInterface*> ItemList; typedef QMap<QString, QDesignerWidgetDataBaseItemInterface*> NameItemMap; typedef QSet<QString> NameSet; // 1) create a map of existing custom classes NameIndexMap existingCustomClasses; NameSet nonCustomClasses; const int count = m_items.size(); for (int i = 0; i < count; i++) { const QDesignerWidgetDataBaseItemInterface* item = m_items[i]; if (item->isCustom() && !item->isPromoted()) existingCustomClasses.insert(item->name(), i); else nonCustomClasses.insert(item->name()); } // 2) create a list plugins ItemList pluginList; const QDesignerPluginManager *pm = m_core->pluginManager(); foreach(QDesignerCustomWidgetInterface* c, pm->registeredCustomWidgets()) pluginList += createCustomWidgetItem(c, pm->customWidgetData(c)); // 3) replace custom classes or add new ones, remove them from existingCustomClasses, // leaving behind deleted items unsigned replacedPlugins = 0; unsigned addedPlugins = 0; unsigned removedPlugins = 0; if (!pluginList.empty()) { ItemList::const_iterator cend = pluginList.constEnd(); for (ItemList::const_iterator it = pluginList.constBegin();it != cend; ++it ) { QDesignerWidgetDataBaseItemInterface* pluginItem = *it; const QString pluginName = pluginItem->name(); NameIndexMap::iterator existingIt = existingCustomClasses.find(pluginName); if (existingIt == existingCustomClasses.end()) { // Add new class. if (nonCustomClasses.contains(pluginName)) { designerWarning(tr("A custom widget plugin whose class name (%1) matches that of an existing class has been found.").arg(pluginName)); } else { append(pluginItem); addedPlugins++; } } else { // replace existing info const int existingIndex = existingIt.value(); delete m_items[existingIndex]; m_items[existingIndex] = pluginItem; existingCustomClasses.erase(existingIt); replacedPlugins++; } } } // 4) remove classes that have not been matched. The stored indexes become invalid while deleting. if (!existingCustomClasses.empty()) { NameIndexMap::const_iterator cend = existingCustomClasses.constEnd(); for (NameIndexMap::const_iterator it = existingCustomClasses.constBegin();it != cend; ++it ) { const int index = indexOfClassName(it.key()); if (index != -1) { remove(index); removedPlugins++; } } } if (debugWidgetDataBase) qDebug() << "WidgetDataBase::loadPlugins(): " << addedPlugins << " added, " << replacedPlugins << " replaced, " << removedPlugins << "deleted."; }