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.";
}