bool QFormBuilderExtra::setGridLayoutColumnMinimumWidth(const QString &s, QGridLayout *grid) { const bool rc = parsePerCellProperty(grid, grid->columnCount(), &QGridLayout::setColumnMinimumWidth, s); if (!rc) uiLibWarning(msgInvalidMinimumSize(grid->objectName(), s)); return rc; }
bool QFormBuilderExtra::setGridLayoutRowMinimumHeight(const QString &s, QGridLayout *grid) { const bool rc = parsePerCellProperty(grid, grid->rowCount(), &QGridLayout::setRowMinimumHeight, s); if (!rc) uiLibWarning(msgInvalidMinimumSize(grid->objectName(), s)); return rc; }
bool QFormBuilderExtra::setBoxLayoutStretch(const QString &s, QBoxLayout *box) { const bool rc = parsePerCellProperty(box, box->count(), &QBoxLayout::setStretch, s); if (!rc) uiLibWarning(msgInvalidStretch(box->objectName(), s)); return rc; }
// Convert complex variant types to DOM properties with the help of QAbstractFormBuilder // Does not perform a check using QAbstractFormBuilder::checkProperty(). DomProperty *variantToDomProperty(QAbstractFormBuilder *afb, const QMetaObject *meta, const QString &pname, const QVariant &v) { const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); DomProperty *dom_prop = new DomProperty(); dom_prop->setAttributeName(pname); const int pindex = meta->indexOfProperty(pname.toLatin1()); if (pindex != -1) { QMetaProperty meta_property = meta->property(pindex); if ((v.type() == QVariant::Int || v.type() == QVariant::UInt) && meta_property.isEnumType()) { const QMetaEnum e = meta_property.enumerator(); if (e.isFlag()) dom_prop->setElementSet(QString::fromAscii(e.valueToKeys(v.toInt()))); else dom_prop->setElementEnum(QString::fromAscii(e.valueToKey(v.toInt()))); return dom_prop; } if (!meta_property.hasStdCppSet() || (isOfType(meta, &QAbstractScrollArea::staticMetaObject) && pname == strings.cursorProperty)) dom_prop->setAttributeStdset(0); } // Try simple properties if (applySimpleProperty(v, isTranslatable(pname, v, meta), dom_prop)) return dom_prop; // Complex properties switch (v.type()) { case QVariant::Palette: { DomPalette *dom = new DomPalette(); QPalette palette = qvariant_cast<QPalette>(v); palette.setCurrentColorGroup(QPalette::Active); dom->setElementActive(afb->saveColorGroup(palette)); palette.setCurrentColorGroup(QPalette::Inactive); dom->setElementInactive(afb->saveColorGroup(palette)); palette.setCurrentColorGroup(QPalette::Disabled); dom->setElementDisabled(afb->saveColorGroup(palette)); dom_prop->setElementPalette(dom); } break; case QVariant::Brush: dom_prop->setElementBrush(afb->saveBrush(qvariant_cast<QBrush>(v))); break; default: delete dom_prop; if (afb->resourceBuilder()->isResourceType(v)) { dom_prop = afb->resourceBuilder()->saveResource(afb->workingDirectory(), v); if (dom_prop) dom_prop->setAttributeName(pname); break; } uiLibWarning(msgCannotWriteProperty(pname, v)); return 0; } return dom_prop; }
// Convert complex DOM types with the help of QAbstractFormBuilder QVariant domPropertyToVariant(QAbstractFormBuilder *afb,const QMetaObject *meta,const DomProperty *p) { // Complex types that need functions from QAbstractFormBuilder switch(p->kind()) { case DomProperty::String: { const int index = meta->indexOfProperty(p->attributeName().toUtf8()); if (index != -1 && meta->property(index).type() == QVariant::KeySequence) return QVariant::fromValue(QKeySequence(p->elementString()->text())); } break; case DomProperty::Palette: { const DomPalette *dom = p->elementPalette(); QPalette palette; if (dom->elementActive()) afb->setupColorGroup(palette, QPalette::Active, dom->elementActive()); if (dom->elementInactive()) afb->setupColorGroup(palette, QPalette::Inactive, dom->elementInactive()); if (dom->elementDisabled()) afb->setupColorGroup(palette, QPalette::Disabled, dom->elementDisabled()); palette.setCurrentColorGroup(QPalette::Active); return QVariant::fromValue(palette); } case DomProperty::Set: { const QByteArray pname = p->attributeName().toUtf8(); const int index = meta->indexOfProperty(pname); if (index == -1) { uiLibWarning(QCoreApplication::translate("QFormBuilder", "The set-type property %1 could not be read.").arg(p->attributeName())); return QVariant(); } const QMetaEnum e = meta->property(index).enumerator(); Q_ASSERT(e.isFlag() == true); return QVariant(e.keysToValue(p->elementSet().toUtf8())); } case DomProperty::Enum: { const QByteArray pname = p->attributeName().toUtf8(); const int index = meta->indexOfProperty(pname); QString enumValue = p->elementEnum(); // Triggers in case of objects in Designer like Spacer/Line for which properties // are serialized using language introspection. On preview, however, these objects are // emulated by hacks in the formbuilder (size policy/orientation) fixEnum(enumValue); if (index == -1) { // ### special-casing for Line (QFrame) -- fix for 4.2. Jambi hack for enumerations if (!qstrcmp(meta->className(), "QFrame") && (pname == QByteArray("orientation"))) { return QVariant(enumValue == QFormBuilderStrings::instance().horizontalPostFix ? QFrame::HLine : QFrame::VLine); } else { uiLibWarning(QCoreApplication::translate("QFormBuilder", "The enumeration-type property %1 could not be read.").arg(p->attributeName())); return QVariant(); } } const QMetaEnum e = meta->property(index).enumerator(); return QVariant(e.keyToValue(enumValue.toUtf8())); } case DomProperty::Brush: return QVariant::fromValue(afb->setupBrush(p->elementBrush())); default: if (afb->resourceBuilder()->isResourceProperty(p)) { return afb->resourceBuilder()->loadResource(afb->workingDirectory(), p); } break; } // simple type return domPropertyToVariant(p); }
// Convert simple DOM types QVariant domPropertyToVariant(const DomProperty *p) { // requires non-const virtual nameToIcon, etc. switch(p->kind()) { case DomProperty::Bool: return QVariant(p->elementBool() == QFormBuilderStrings::instance().trueValue); case DomProperty::Cstring: return QVariant(p->elementCstring().toUtf8()); case DomProperty::Point: { const DomPoint *point = p->elementPoint(); return QVariant(QPoint(point->elementX(), point->elementY())); } case DomProperty::PointF: { const DomPointF *pointf = p->elementPointF(); return QVariant(QPointF(pointf->elementX(), pointf->elementY())); } case DomProperty::Size: { const DomSize *size = p->elementSize(); return QVariant(QSize(size->elementWidth(), size->elementHeight())); } case DomProperty::SizeF: { const DomSizeF *sizef = p->elementSizeF(); return QVariant(QSizeF(sizef->elementWidth(), sizef->elementHeight())); } case DomProperty::Rect: { const DomRect *rc = p->elementRect(); const QRect g(rc->elementX(), rc->elementY(), rc->elementWidth(), rc->elementHeight()); return QVariant(g); } case DomProperty::RectF: { const DomRectF *rcf = p->elementRectF(); const QRectF g(rcf->elementX(), rcf->elementY(), rcf->elementWidth(), rcf->elementHeight()); return QVariant(g); } case DomProperty::String: return QVariant(p->elementString()->text()); case DomProperty::Number: return QVariant(p->elementNumber()); case DomProperty::UInt: return QVariant(p->elementUInt()); case DomProperty::LongLong: return QVariant(p->elementLongLong()); case DomProperty::ULongLong: return QVariant(p->elementULongLong()); case DomProperty::Double: return QVariant(p->elementDouble()); case DomProperty::Char: { const DomChar *character = p->elementChar(); const QChar c(character->elementUnicode()); return QVariant::fromValue(c); } case DomProperty::Color: { const DomColor *color = p->elementColor(); QColor c(color->elementRed(), color->elementGreen(), color->elementBlue()); if (color->hasAttributeAlpha()) c.setAlpha(color->attributeAlpha()); return QVariant::fromValue(c); } case DomProperty::Font: { const DomFont *font = p->elementFont(); QFont f; if (font->hasElementFamily() && !font->elementFamily().isEmpty()) f.setFamily(font->elementFamily()); if (font->hasElementPointSize() && font->elementPointSize() > 0) f.setPointSize(font->elementPointSize()); if (font->hasElementWeight() && font->elementWeight() > 0) f.setWeight(font->elementWeight()); if (font->hasElementItalic()) f.setItalic(font->elementItalic()); if (font->hasElementBold()) f.setBold(font->elementBold()); if (font->hasElementUnderline()) f.setUnderline(font->elementUnderline()); if (font->hasElementStrikeOut()) f.setStrikeOut(font->elementStrikeOut()); if (font->hasElementKerning()) f.setKerning(font->elementKerning()); if (font->hasElementAntialiasing()) f.setStyleStrategy(font->elementAntialiasing() ? QFont::PreferDefault : QFont::NoAntialias); if (font->hasElementStyleStrategy()) { f.setStyleStrategy(enumKeyOfObjectToValue<QAbstractFormBuilderGadget, QFont::StyleStrategy>("styleStrategy", font->elementStyleStrategy().toLatin1())); } return QVariant::fromValue(f); } case DomProperty::Date: { const DomDate *date = p->elementDate(); return QVariant(QDate(date->elementYear(), date->elementMonth(), date->elementDay())); } case DomProperty::Time: { const DomTime *t = p->elementTime(); return QVariant(QTime(t->elementHour(), t->elementMinute(), t->elementSecond())); } case DomProperty::DateTime: { const DomDateTime *dateTime = p->elementDateTime(); const QDate d(dateTime->elementYear(), dateTime->elementMonth(), dateTime->elementDay()); const QTime tm(dateTime->elementHour(), dateTime->elementMinute(), dateTime->elementSecond()); return QVariant(QDateTime(d, tm)); } case DomProperty::Url: { const DomUrl *url = p->elementUrl(); return QVariant(QUrl(url->elementString()->text())); } #ifndef QT_NO_CURSOR case DomProperty::Cursor: return QVariant::fromValue(QCursor(static_cast<Qt::CursorShape>(p->elementCursor()))); case DomProperty::CursorShape: return QVariant::fromValue(QCursor(enumKeyOfObjectToValue<QAbstractFormBuilderGadget, Qt::CursorShape>("cursorShape", p->elementCursorShape().toLatin1()))); #endif case DomProperty::Locale: { const DomLocale *locale = p->elementLocale(); return QVariant::fromValue(QLocale(enumKeyOfObjectToValue<QAbstractFormBuilderGadget, QLocale::Language>("language", locale->attributeLanguage().toLatin1()), enumKeyOfObjectToValue<QAbstractFormBuilderGadget, QLocale::Country>("country", locale->attributeCountry().toLatin1()))); } case DomProperty::SizePolicy: { const DomSizePolicy *sizep = p->elementSizePolicy(); QSizePolicy sizePolicy; sizePolicy.setHorizontalStretch(sizep->elementHorStretch()); sizePolicy.setVerticalStretch(sizep->elementVerStretch()); const QMetaEnum sizeType_enum = metaEnum<QAbstractFormBuilderGadget>("sizeType"); if (sizep->hasElementHSizeType()) { sizePolicy.setHorizontalPolicy((QSizePolicy::Policy) sizep->elementHSizeType()); } else if (sizep->hasAttributeHSizeType()) { const QSizePolicy::Policy sp = enumKeyToValue<QSizePolicy::Policy>(sizeType_enum, sizep->attributeHSizeType().toLatin1()); sizePolicy.setHorizontalPolicy(sp); } if (sizep->hasElementVSizeType()) { sizePolicy.setVerticalPolicy((QSizePolicy::Policy) sizep->elementVSizeType()); } else if (sizep->hasAttributeVSizeType()) { const QSizePolicy::Policy sp = enumKeyToValue<QSizePolicy::Policy>(sizeType_enum, sizep->attributeVSizeType().toLatin1()); sizePolicy.setVerticalPolicy(sp); } return QVariant::fromValue(sizePolicy); } case DomProperty::StringList: return QVariant(p->elementStringList()->elementString()); default: uiLibWarning(QCoreApplication::translate("QFormBuilder", "Reading properties of the type %1 is not supported yet.").arg(p->kind())); break; } return QVariant(); }