// Get XML for a new form from the widget box. Change objectName/geometry
// properties to be suitable for new forms
static QString xmlFromWidgetBox(const QDesignerFormEditorInterface *core, const QString &className, const QString &objectName)
{
typedef QList<DomProperty*> PropertyList;
QDesignerWidgetBoxInterface::Widget widget;
const bool found = QDesignerWidgetBox::findWidget(core->widgetBox(), className, QString(), &widget);
if (!found)
return QString();
QScopedPointer<DomUI> domUI(QDesignerWidgetBox::xmlToUi(className, widget.domXml(), false));
if (domUI.isNull())
return QString();
domUI->setAttributeVersion(QLatin1String("4.0"));
DomWidget *domWidget = domUI->elementWidget();
if (!domWidget)
return QString();
// Properties: Remove the "objectName" property in favour of the name attribute and check geometry.
domWidget->setAttributeName(objectName);
const QString geometryProperty = QLatin1String("geometry");
const QString objectNameProperty = QLatin1String("objectName");
PropertyList properties = domWidget->elementProperty();
for (PropertyList::iterator it = properties.begin(); it != properties.end(); ) {
DomProperty *property = *it;
if (property->attributeName() == objectNameProperty) { // remove "objectName"
it = properties.erase(it);
delete property;
} else {
if (property->attributeName() == geometryProperty) { // Make sure form is at least 400, 300
if (DomRect *geom = property->elementRect()) {
if (geom->elementWidth() < NewFormWidth)
geom->setElementWidth(NewFormWidth);
if (geom->elementHeight() < NewFormHeight)
geom->setElementHeight(NewFormHeight);
}
}
++it;
}
}
// Add a window title property
DomString *windowTitleString = new DomString;
windowTitleString->setText(objectName);
DomProperty *windowTitleProperty = new DomProperty;
windowTitleProperty->setAttributeName(QLatin1String("windowTitle"));
windowTitleProperty->setElementString(windowTitleString);
properties.push_back(windowTitleProperty);
// ------
domWidget->setElementProperty(properties);
// Embed in in DomUI and get string. Omit the version number.
domUI->setElementClass(objectName);
QString rc;
{ // Serialize domUI
QXmlStreamWriter writer(&rc);
writer.setAutoFormatting(true);
writer.setAutoFormattingIndent(1);
writer.writeStartDocument();
domUI->write(writer);
writer.writeEndDocument();
}
return rc;
}
bool Q3ListBoxExtraInfo::saveWidgetExtraInfo(DomWidget *ui_widget)
{
Q3ListBox *listBox = qobject_cast<Q3ListBox*>(widget());
Q_ASSERT(listBox != 0);
QList<DomItem *> items;
const int childCount = listBox->count();
for (int i = 0; i < childCount; ++i) {
DomItem *item = new DomItem();
QList<DomProperty*> properties;
DomString *str = new DomString();
str->setText(listBox->text(i));
DomProperty *ptext = new DomProperty();
ptext->setAttributeName(QLatin1String("text"));
ptext->setElementString(str);
properties.append(ptext);
item->setElementProperty(properties);
items.append(item);
}
ui_widget->setElementItem(items);
return true;
}
void DomElement::set_child_string_ns(const DomString &namespace_uri, const DomString &qualified_name, const DomString &value)
{
DomString local_name;
DomString::size_type pos = qualified_name.find(L':');
if (pos != DomString::npos)
local_name = qualified_name.substr(pos + 1);
else
local_name = qualified_name;
DomElement element = named_item_ns(namespace_uri, local_name).to_element();
if (element.is_null())
{
element = get_owner_document().create_element_ns(namespace_uri, qualified_name);
append_child(element);
}
DomText dom_text = get_owner_document().create_text_node(value);
if (element.get_first_child().is_text())
{
DomNode temp_domnode = element.get_first_child();
replace_child(dom_text, temp_domnode);
}
else
{
element.append_child(dom_text);
}
}
DomItem *Q3ListViewExtraInfo::saveQ3ListViewItem(Q3ListViewItem *item) const
{
DomItem *pitem = new DomItem();
QList<DomProperty *> properties;
const int columnCount = static_cast<Q3ListView*>(widget())->columns();
for (int i = 0; i < columnCount; ++i) {
DomString *str = new DomString();
str->setText(item->text(i));
DomProperty *ptext = new DomProperty();
ptext->setAttributeName(QLatin1String("text"));
ptext->setElementString(str);
properties.append(ptext);
}
pitem->setElementProperty(properties);
QList<DomItem *> items;
Q3ListViewItem *child = item->firstChild();
while (child) {
items.append(saveQ3ListViewItem(child));
child = child->nextSibling();
}
pitem->setElementItem(items);
return pitem;
}
int DomElement::get_child_int_ns(const DomString &namespace_uri, const DomString &local_name, int default_value) const
{
DomString value = get_child_string_ns(namespace_uri, local_name);
if (!value.empty())
return StringHelp::text_to_int(value);
else
return default_value;
}
float DomElement::get_attribute_float_ns(const DomString &namespace_uri, const DomString &local_name, float default_value) const
{
DomString value = get_attribute_ns(namespace_uri, local_name);
if (!value.empty())
return StringHelp::text_to_float(value);
else
return default_value;
}
float DomElement::get_attribute_float(const DomString &name, float default_value) const
{
DomString value = get_attribute(name);
if (!value.empty())
return StringHelp::text_to_float(value);
else
return default_value;
}
bool DomElement::get_attribute_bool_ns(const DomString &namespace_uri, const DomString &local_name, bool default_value) const
{
DomString value = get_attribute_ns(namespace_uri, local_name);
if (!value.empty())
return value == "true";
else
return default_value;
}
bool DomElement::get_attribute_bool(const DomString &name, bool default_value) const
{
DomString value = get_attribute(name);
if (!value.empty())
return value == "true";
else
return default_value;
}
int DomElement::get_child_int(const DomString &name, int default_value) const
{
DomString value = get_child_string(name);
if (!value.empty())
return StringHelp::text_to_int(value);
else
return default_value;
}
void DomCharacterData::insert_data(unsigned long offset, const DomString &arg)
{
if (impl)
{
DomString value = impl->get_tree_node()->get_node_value();
if (offset > value.length())
offset = value.length();
impl->get_tree_node()->node_value = value.substr(0, offset) + arg + value.substr(offset);
}
}
bool DomImplementation::has_feature(
const DomString &feature,
const DomString &version)
{
if (StringHelp::compare(feature, "xml") == 0 && (version == "1.0" || version.empty()))
return true;
if (StringHelp::compare(feature, "xml") == 0 && (version == "2.0" || version.empty()))
return true;
return false;
}
bool Q3ListViewExtraInfo::saveWidgetExtraInfo(DomWidget *ui_widget)
{
// ### finish me
Q3ListView *listView = qobject_cast<Q3ListView*>(widget());
Q_ASSERT(listView != 0);
QList<DomColumn*> columns;
Q3Header *header = listView->header();
for (int i=0; i<header->count(); ++i) {
DomColumn *c = new DomColumn();
QList<DomProperty*> properties;
DomString *str = new DomString();
str->setText(header->label(i));
DomProperty *ptext = new DomProperty();
ptext->setAttributeName(QLatin1String("text"));
ptext->setElementString(str);
DomProperty *pclickable = new DomProperty();
pclickable->setAttributeName(QLatin1String("clickable"));
pclickable->setElementBool(header->isClickEnabled(i) ? QLatin1String("true") : QLatin1String("false"));
DomProperty *presizable = new DomProperty();
presizable->setAttributeName(QLatin1String("resizable"));
presizable->setElementBool(header->isResizeEnabled(i) ? QLatin1String("true") : QLatin1String("false"));
properties.append(ptext);
properties.append(pclickable);
properties.append(presizable);
c->setElementProperty(properties);
columns.append(c);
}
ui_widget->setElementColumn(columns);
QList<DomItem *> items;
Q3ListViewItem *child = listView->firstChild();
while (child) {
items.append(saveQ3ListViewItem(child));
child = child->nextSibling();
}
ui_widget->setElementItem(items);
return true;
}
bool Q3IconViewExtraInfo::saveWidgetExtraInfo(DomWidget *ui_widget)
{
// ### finish me
Q3IconView *iconView = qobject_cast<Q3IconView*>(widget());
Q_ASSERT(iconView != 0);
QList<DomItem*> ui_items;
Q3IconViewItem *__item = iconView->firstItem();
while (__item != 0) {
DomItem *ui_item = new DomItem();
QList<DomProperty*> properties;
// text property
DomProperty *ptext = new DomProperty();
DomString *str = new DomString();
str->setText(__item->text());
ptext->setAttributeName(QLatin1String("text"));
ptext->setElementString(str);
properties.append(ptext);
ui_item->setElementProperty(properties);
ui_items.append(ui_item);
if (__item->pixmap() != 0 && core()->iconCache()) {
QPixmap pix = *__item->pixmap();
QString filePath = core()->iconCache()->pixmapToFilePath(pix);
QString qrcPath = core()->iconCache()->pixmapToQrcPath(pix);
DomResourcePixmap *ui_pix = new DomResourcePixmap();
if (!qrcPath.isEmpty())
ui_pix->setAttributeResource(qrcPath);
ui_pix->setText(filePath);
DomProperty *ppix = new DomProperty();
ppix->setAttributeName(QLatin1String("pixmap"));
ppix->setElementPixmap(ui_pix);
properties.append(ppix);
}
__item = __item->nextItem();
}
ui_widget->setElementItem(ui_items);
return true;
}
bool Q3TableExtraInfo::saveWidgetExtraInfo(DomWidget *ui_widget)
{
Q_UNUSED(ui_widget);
Q3Table *table = qobject_cast<Q3Table*>(widget());
Q_ASSERT(table != 0);
Q3Header *hHeader = table->horizontalHeader();
QList<DomColumn*> columns;
for (int i=0; i<hHeader->count(); ++i) {
DomColumn *column = new DomColumn();
QList<DomProperty *> properties;
DomProperty *property = new DomProperty();
DomString *string = new DomString();
string->setText(hHeader->label(i));
property->setElementString(string);
property->setAttributeName("text");
properties.append(property);
column->setElementProperty(properties);
columns.append(column);
}
ui_widget->setElementColumn(columns);
Q3Header *vHeader = table->verticalHeader();
QList<DomRow*> rows;
for (int i=0; i<vHeader->count(); ++i) {
DomRow *row = new DomRow();
QList<DomProperty *> properties;
DomProperty *property = new DomProperty();
DomString *string = new DomString();
string->setText(vHeader->label(i));
property->setElementString(string);
property->setAttributeName("text");
properties.append(property);
row->setElementProperty(properties);
rows.append(row);
}
ui_widget->setElementRow(rows);
return true;
}
DomString DomNode::find_namespace_uri(const DomString &qualified_name) const
{
static DomString xmlns_prefix("xmlns:");
static DomString xmlns_xml("xml");
static DomString xmlns_xml_uri("http://www.w3.org/XML/1998/namespace");
static DomString xmlns_xmlns("xmlns");
static DomString xmlns_xmlns_uri("http://www.w3.org/2000/xmlns/");
DomString prefix;
DomString::size_type pos = qualified_name.find(':');
if (pos != DomString::npos)
prefix = qualified_name.substr(0, pos);
if (prefix == xmlns_xml)
return xmlns_xml;
else if (prefix == xmlns_xmlns || qualified_name == xmlns_xmlns)
return xmlns_xmlns;
DomDocument_Impl *doc_impl = (DomDocument_Impl *)impl->owner_document.lock().get();
const DomTreeNode *cur = impl->get_tree_node();
while (cur)
{
const DomTreeNode *cur_attr = cur->get_first_attribute(doc_impl);
while (cur_attr)
{
std::string node_name = cur_attr->get_node_name();
if (prefix.empty())
{
if (node_name == xmlns_xmlns)
return cur_attr->get_node_value();
}
else
{
if (node_name.substr(0, 6) == xmlns_prefix && node_name.substr(6) == prefix)
return cur_attr->get_node_value();
}
cur_attr = cur_attr->get_next_sibling(doc_impl);
}
cur = cur->get_parent(doc_impl);
}
return DomString();
}
bool DomNode::is_supported(
const DomString &feature,
const DomString &version) const
{
if (StringHelp::compare(feature, "xml") == 0)
{
if (version.empty() || version == "1.0" || version == "2.0")
return true;
}
return false;
}
void DomCharacterData::delete_data(unsigned long offset, unsigned long count)
{
if (impl)
{
DomString value = impl->get_tree_node()->get_node_value();
if (offset > value.length())
offset = value.length();
if (offset + count > value.length())
count = value.length() - offset;
if (count == 0)
return;
if (count < value.length())
{
value = value.substr(0, offset) + value.substr(offset + count);
}
else
{
value = DomString();
}
impl->get_tree_node()->node_value = value;
}
}
// Apply a simple variant type to a DOM property
static bool applySimpleProperty(const QVariant &v, bool translateString, DomProperty *dom_prop)
{
switch (v.type()) {
case QVariant::String: {
DomString *str = new DomString();
str->setText(v.toString());
if (!translateString)
str->setAttributeNotr(QStringLiteral("true"));
dom_prop->setElementString(str);
}
return true;
case QVariant::ByteArray:
dom_prop->setElementCstring(QString::fromUtf8(v.toByteArray()));
return true;
case QVariant::Int:
dom_prop->setElementNumber(v.toInt());
return true;
case QVariant::UInt:
dom_prop->setElementUInt(v.toUInt());
return true;
case QVariant::LongLong:
dom_prop->setElementLongLong(v.toLongLong());
return true;
case QVariant::ULongLong:
dom_prop->setElementULongLong(v.toULongLong());
return true;
case QVariant::Double:
dom_prop->setElementDouble(v.toDouble());
return true;
case QVariant::Bool:
dom_prop->setElementBool(v.toBool() ? QFormBuilderStrings::instance().trueValue : QFormBuilderStrings::instance().falseValue);
return true;
case QVariant::Char: {
DomChar *ch = new DomChar();
const QChar character = v.toChar();
ch->setElementUnicode(character.unicode());
dom_prop->setElementChar(ch);
}
return true;
case QVariant::Point: {
DomPoint *pt = new DomPoint();
const QPoint point = v.toPoint();
pt->setElementX(point.x());
pt->setElementY(point.y());
dom_prop->setElementPoint(pt);
}
return true;
case QVariant::PointF: {
DomPointF *ptf = new DomPointF();
const QPointF pointf = v.toPointF();
ptf->setElementX(pointf.x());
ptf->setElementY(pointf.y());
dom_prop->setElementPointF(ptf);
}
return true;
case QVariant::Color: {
DomColor *clr = new DomColor();
const QColor color = qvariant_cast<QColor>(v);
clr->setElementRed(color.red());
clr->setElementGreen(color.green());
clr->setElementBlue(color.blue());
const int alphaChannel = color.alpha();
if (alphaChannel != 255)
clr->setAttributeAlpha(alphaChannel);
dom_prop->setElementColor(clr);
}
return true;
case QVariant::Size: {
DomSize *sz = new DomSize();
const QSize size = v.toSize();
sz->setElementWidth(size.width());
sz->setElementHeight(size.height());
dom_prop->setElementSize(sz);
}
return true;
case QVariant::SizeF: {
DomSizeF *szf = new DomSizeF();
const QSizeF sizef = v.toSizeF();
szf->setElementWidth(sizef.width());
szf->setElementHeight(sizef.height());
dom_prop->setElementSizeF(szf);
}
return true;
case QVariant::Rect: {
DomRect *rc = new DomRect();
const QRect rect = v.toRect();
rc->setElementX(rect.x());
rc->setElementY(rect.y());
rc->setElementWidth(rect.width());
rc->setElementHeight(rect.height());
dom_prop->setElementRect(rc);
}
return true;
case QVariant::RectF: {
DomRectF *rcf = new DomRectF();
const QRectF rectf = v.toRectF();
rcf->setElementX(rectf.x());
rcf->setElementY(rectf.y());
rcf->setElementWidth(rectf.width());
rcf->setElementHeight(rectf.height());
dom_prop->setElementRectF(rcf);
}
return true;
case QVariant::Font: {
DomFont *fnt = new DomFont();
const QFont font = qvariant_cast<QFont>(v);
const uint mask = font.resolve();
if (mask & QFont::WeightResolved) {
fnt->setElementBold(font.bold());
fnt->setElementWeight(font.weight());
}
if (mask & QFont::FamilyResolved)
fnt->setElementFamily(font.family());
if (mask & QFont::StyleResolved)
fnt->setElementItalic(font.italic());
if (mask & QFont::SizeResolved)
fnt->setElementPointSize(font.pointSize());
if (mask & QFont::StrikeOutResolved)
fnt->setElementStrikeOut(font.strikeOut());
if (mask & QFont::UnderlineResolved)
fnt->setElementUnderline(font.underline());
if (mask & QFont::KerningResolved)
fnt->setElementKerning(font.kerning());
if (mask & QFont::StyleStrategyResolved) {
const QMetaEnum styleStrategy_enum = metaEnum<QAbstractFormBuilderGadget>("styleStrategy");
fnt->setElementStyleStrategy(QLatin1String(styleStrategy_enum.valueToKey(font.styleStrategy())));
}
dom_prop->setElementFont(fnt);
}
return true;
#ifndef QT_NO_CURSOR
case QVariant::Cursor: {
const QMetaEnum cursorShape_enum = metaEnum<QAbstractFormBuilderGadget>("cursorShape");
dom_prop->setElementCursorShape(QLatin1String(cursorShape_enum.valueToKey(qvariant_cast<QCursor>(v).shape())));
}
return true;
#endif
case QVariant::KeySequence: {
DomString *s = new DomString();
s->setText(qvariant_cast<QKeySequence>(v).toString(QKeySequence::PortableText));
dom_prop->setElementString(s);
}
return true;
case QVariant::Locale: {
DomLocale *dom = new DomLocale();
const QLocale locale = qvariant_cast<QLocale>(v);
const QMetaEnum language_enum = metaEnum<QAbstractFormBuilderGadget>("language");
const QMetaEnum country_enum = metaEnum<QAbstractFormBuilderGadget>("country");
dom->setAttributeLanguage(QLatin1String(language_enum.valueToKey(locale.language())));
dom->setAttributeCountry(QLatin1String(country_enum.valueToKey(locale.country())));
dom_prop->setElementLocale(dom);
}
return true;
case QVariant::SizePolicy: {
DomSizePolicy *dom = new DomSizePolicy();
const QSizePolicy sizePolicy = qvariant_cast<QSizePolicy>(v);
dom->setElementHorStretch(sizePolicy.horizontalStretch());
dom->setElementVerStretch(sizePolicy.verticalStretch());
const QMetaEnum sizeType_enum = metaEnum<QAbstractFormBuilderGadget>("sizeType");
dom->setAttributeHSizeType(QLatin1String(sizeType_enum.valueToKey(sizePolicy.horizontalPolicy())));
dom->setAttributeVSizeType(QLatin1String(sizeType_enum.valueToKey(sizePolicy.verticalPolicy())));
dom_prop->setElementSizePolicy(dom);
}
return true;
case QVariant::Date: {
DomDate *dom = new DomDate();
const QDate date = qvariant_cast<QDate>(v);
dom->setElementYear(date.year());
dom->setElementMonth(date.month());
dom->setElementDay(date.day());
dom_prop->setElementDate(dom);
}
return true;
case QVariant::Time: {
DomTime *dom = new DomTime();
const QTime time = qvariant_cast<QTime>(v);
dom->setElementHour(time.hour());
dom->setElementMinute(time.minute());
dom->setElementSecond(time.second());
dom_prop->setElementTime(dom);
}
return true;
case QVariant::DateTime: {
DomDateTime *dom = new DomDateTime();
const QDateTime dateTime = qvariant_cast<QDateTime>(v);
dom->setElementHour(dateTime.time().hour());
dom->setElementMinute(dateTime.time().minute());
dom->setElementSecond(dateTime.time().second());
dom->setElementYear(dateTime.date().year());
dom->setElementMonth(dateTime.date().month());
dom->setElementDay(dateTime.date().day());
dom_prop->setElementDateTime(dom);
}
return true;
case QVariant::Url: {
DomUrl *dom = new DomUrl();
const QUrl url = v.toUrl();
DomString *str = new DomString();
str->setText(url.toString());
dom->setElementString(str);
dom_prop->setElementUrl(dom);
}
return true;
case QVariant::StringList: {
DomStringList *sl = new DomStringList;
sl->setElementString(qvariant_cast<QStringList>(v));
dom_prop->setElementStringList(sl);
}
return true;
default:
break;
}
return false;
}
