1	/****************************************************************************
2	**
3	** Copyright (C) 2016 The Qt Company Ltd.
4	** Contact: https://www.qt.io/licensing/
5	**
6	** This file is part of the Qt Designer of the Qt Toolkit.
7	**
8	** $QT_BEGIN_LICENSE:GPL-EXCEPT$
9	** Commercial License Usage
10	** Licensees holding valid commercial Qt licenses may use this file in
11	** accordance with the commercial license agreement provided with the
12	** Software or, alternatively, in accordance with the terms contained in
13	** a written agreement between you and The Qt Company. For licensing terms
14	** and conditions see https://www.qt.io/terms-conditions. For further
15	** information use the contact form at https://www.qt.io/contact-us.
16	**
17	** GNU General Public License Usage
18	** Alternatively, this file may be used under the terms of the GNU
19	** General Public License version 3 as published by the Free Software
20	** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
21	** included in the packaging of this file. Please review the following
22	** information to ensure the GNU General Public License requirements will
23	** be met: https://www.gnu.org/licenses/gpl-3.0.html.
24	**
25	** $QT_END_LICENSE$
26	**
27	****************************************************************************/
28
29	#include "qdesigner_resource.h"
30	#include "formwindow.h"
31	#include "dynamicpropertysheet.h"
32	#include "qdesigner_tabwidget_p.h"
33	#include "qdesigner_toolbox_p.h"
34	#include "qdesigner_stackedbox_p.h"
35	#include "qdesigner_toolbar_p.h"
36	#include "qdesigner_dockwidget_p.h"
37	#include "qdesigner_menu_p.h"
38	#include "qdesigner_menubar_p.h"
39	#include "qdesigner_membersheet_p.h"
40	#include "qtresourcemodel_p.h"
41	#include "qmdiarea_container.h"
42	#include "qwizard_container.h"
43	#include "layout_propertysheet.h"
44
45	#include <QtDesigner/private/ui4_p.h>
46	#include <QtDesigner/private/formbuilderextra_p.h>
47	#include <QtDesigner/private/resourcebuilder_p.h>
48	#include <QtDesigner/private/textbuilder_p.h>
49	#include <qdesigner_widgetitem_p.h>
50
51	// shared
52	#include <widgetdatabase_p.h>
53	#include <metadatabase_p.h>
54	#include <layout_p.h>
55	#include <layoutinfo_p.h>
56	#include <spacer_widget_p.h>
57	#include <pluginmanager_p.h>
58	#include <widgetfactory_p.h>
59	#include <abstractlanguage.h>
60	#include <abstractintrospection_p.h>
61
62	#include <qlayout_widget_p.h>
63	#include <qdesigner_utils_p.h>
64	#include <QtDesigner/private/ui4_p.h>
65
66	// sdk
67	#include <QtDesigner/propertysheet.h>
68	#include <QtDesigner/abstractformeditor.h>
69	#include <QtDesigner/extrainfo.h>
70	#include <QtDesigner/abstractformwindowtool.h>
71	#include <QtDesigner/qextensionmanager.h>
72	#include <QtDesigner/container.h>
73	#include <abstractdialoggui_p.h>
74
75	#include <QtWidgets/qmenu.h>
76	#include <QtWidgets/qmessagebox.h>
77	#include <QtWidgets/qlayout.h>
78	#include <QtWidgets/qformlayout.h>
79	#include <QtWidgets/qtabwidget.h>
80	#include <QtWidgets/qtoolbox.h>
81	#include <QtWidgets/qstackedwidget.h>
82	#include <QtWidgets/qtoolbar.h>
83	#include <QtWidgets/qtabbar.h>
84	#include <QtWidgets/qaction.h>
85	#include <QtWidgets/qactiongroup.h>
86	#include <QtWidgets/qbuttongroup.h>
87	#include <QtWidgets/qapplication.h>
88	#include <QtWidgets/qmainwindow.h>
89	#include <QtWidgets/qsplitter.h>
90	#include <QtWidgets/qmdiarea.h>
91	#include <QtWidgets/qmenubar.h>
92	#include <QtWidgets/qfiledialog.h>
93	#include <QtWidgets/qheaderview.h>
94	#include <QtWidgets/qwizard.h>
95	#include <private/qlayoutengine_p.h>
96
97	#include <QtCore/qbuffer.h>
98	#include <QtCore/qdir.h>
99	#include <QtCore/qmetaobject.h>
100	#include <QtCore/qdebug.h>
101	#include <QtCore/qxmlstream.h>
102
103	#include <algorithm>
104	#include <iterator>
105
106	Q_DECLARE_METATYPE(QWidgetList)
107
108	QT_BEGIN_NAMESPACE
109
110	namespace {
111	using DomPropertyList = QList<DomProperty *>;
112	}
113
114	static const char *currentUiVersion = "4.0";
115	static const char *clipboardObjectName = "__qt_fake_top_level";
116
117	#define OLD_RESOURCE_FORMAT // Support pre 4.4 format.
118
119	namespace qdesigner_internal {
120
121	// -------------------- QDesignerResourceBuilder: A resource builder that works on the property sheet icon types.
122	class QDesignerResourceBuilder : public QResourceBuilder
123	{
124	public:
125	QDesignerResourceBuilder(QDesignerFormEditorInterface *core, DesignerPixmapCache *pixmapCache, DesignerIconCache *iconCache);
126
127	void setPixmapCache(DesignerPixmapCache *pixmapCache) { m_pixmapCache = pixmapCache; }
128	void setIconCache(DesignerIconCache *iconCache) { m_iconCache = iconCache; }
129	bool isSaveRelative() const { return m_saveRelative; }
130	void setSaveRelative(bool relative) { m_saveRelative = relative; }
131	QStringList usedQrcFiles() const { return m_usedQrcFiles.keys(); }
132	#ifdef OLD_RESOURCE_FORMAT
133	QStringList loadedQrcFiles() const { return m_loadedQrcFiles.keys(); } // needed only for loading old resource attribute of <iconset> tag.
134	#endif
135
136	QVariant loadResource(const QDir &workingDirectory, const DomProperty *icon) const override;
137
138	QVariant toNativeValue(const QVariant &value) const override;
139
140	DomProperty *saveResource(const QDir &workingDirectory, const QVariant &value) const override;
141
142	bool isResourceType(const QVariant &value) const override;
143	private:
144
145	QDesignerFormEditorInterface *m_core;
146	DesignerPixmapCache *m_pixmapCache;
147	DesignerIconCache *m_iconCache;
148	const QDesignerLanguageExtension *m_lang;
149	bool m_saveRelative;
150	mutable QMap<QString, bool> m_usedQrcFiles;
151	mutable QMap<QString, bool> m_loadedQrcFiles;
152	};
153
154	QDesignerResourceBuilder::QDesignerResourceBuilder(QDesignerFormEditorInterface *core, DesignerPixmapCache *pixmapCache, DesignerIconCache *iconCache) :
155	m_core(core),
156	m_pixmapCache(pixmapCache),
157	m_iconCache(iconCache),
158	m_lang(qt_extension<QDesignerLanguageExtension *>(manager: core->extensionManager(), object: core)),
159	m_saveRelative(true)
160	{
161	}
162
163	static inline void setIconPixmap(QIcon::Mode m, QIcon::State s, const QDir &workingDirectory,
164	QString path, PropertySheetIconValue &icon,
165	const QDesignerLanguageExtension *lang = nullptr)
166	{
167	if (lang == nullptr || !lang->isLanguageResource(path))
168	path = QFileInfo(workingDirectory, path).absoluteFilePath();
169	icon.setPixmap(mode: m, state: s, path: PropertySheetPixmapValue(path));
170	}
171
172	QVariant QDesignerResourceBuilder::loadResource(const QDir &workingDirectory, const DomProperty *property) const
173	{
174	switch (property->kind()) {
175	case DomProperty::Pixmap: {
176	PropertySheetPixmapValue pixmap;
177	DomResourcePixmap *dp = property->elementPixmap();
178	if (!dp->text().isEmpty()) {
179	if (m_lang != nullptr && m_lang->isLanguageResource(path: dp->text())) {
180	pixmap.setPath(dp->text());
181	} else {
182	pixmap.setPath(QFileInfo(workingDirectory, dp->text()).absoluteFilePath());
183	}
184	#ifdef OLD_RESOURCE_FORMAT
185	if (dp->hasAttributeResource())
186	m_loadedQrcFiles.insert(akey: QFileInfo(workingDirectory, dp->attributeResource()).absoluteFilePath(), avalue: false);
187	#endif
188	}
189	return QVariant::fromValue(value: pixmap);
190	}
191
192	case DomProperty::IconSet: {
193	PropertySheetIconValue icon;
194	DomResourceIcon *di = property->elementIconSet();
195	icon.setTheme(di->attributeTheme());
196	if (const int flags = iconStateFlags(resIcon: di)) { // new, post 4.4 format
197	if (flags & NormalOff)
198	setIconPixmap(m: QIcon::Normal, s: QIcon::Off, workingDirectory, path: di->elementNormalOff()->text(), icon, lang: m_lang);
199	if (flags & NormalOn)
200	setIconPixmap(m: QIcon::Normal, s: QIcon::On, workingDirectory, path: di->elementNormalOn()->text(), icon, lang: m_lang);
201	if (flags & DisabledOff)
202	setIconPixmap(m: QIcon::Disabled, s: QIcon::Off, workingDirectory, path: di->elementDisabledOff()->text(), icon, lang: m_lang);
203	if (flags & DisabledOn)
204	setIconPixmap(m: QIcon::Disabled, s: QIcon::On, workingDirectory, path: di->elementDisabledOn()->text(), icon, lang: m_lang);
205	if (flags & ActiveOff)
206	setIconPixmap(m: QIcon::Active, s: QIcon::Off, workingDirectory, path: di->elementActiveOff()->text(), icon, lang: m_lang);
207	if (flags & ActiveOn)
208	setIconPixmap(m: QIcon::Active, s: QIcon::On, workingDirectory, path: di->elementActiveOn()->text(), icon, lang: m_lang);
209	if (flags & SelectedOff)
210	setIconPixmap(m: QIcon::Selected, s: QIcon::Off, workingDirectory, path: di->elementSelectedOff()->text(), icon, lang: m_lang);
211	if (flags & SelectedOn)
212	setIconPixmap(m: QIcon::Selected, s: QIcon::On, workingDirectory, path: di->elementSelectedOn()->text(), icon, lang: m_lang);
213	} else {
214	#ifdef OLD_RESOURCE_FORMAT
215	setIconPixmap(m: QIcon::Normal, s: QIcon::Off, workingDirectory, path: di->text(), icon, lang: m_lang);
216	if (di->hasAttributeResource())
217	m_loadedQrcFiles.insert(akey: QFileInfo(workingDirectory, di->attributeResource()).absoluteFilePath(), avalue: false);
218	#endif
219	}
220	return QVariant::fromValue(value: icon);
221	}
222	default:
223	break;
224	}
225	return QVariant();
226	}
227
228	QVariant QDesignerResourceBuilder::toNativeValue(const QVariant &value) const
229	{
230	if (value.canConvert<PropertySheetPixmapValue>()) {
231	if (m_pixmapCache)
232	return m_pixmapCache->pixmap(value: qvariant_cast<PropertySheetPixmapValue>(v: value));
233	} else if (value.canConvert<PropertySheetIconValue>()) {
234	if (m_iconCache)
235	return m_iconCache->icon(value: qvariant_cast<PropertySheetIconValue>(v: value));
236	}
237	return value;
238	}
239
240	DomProperty *QDesignerResourceBuilder::saveResource(const QDir &workingDirectory, const QVariant &value) const
241	{
242	DomProperty *p = new DomProperty;
243	if (value.canConvert<PropertySheetPixmapValue>()) {
244	const PropertySheetPixmapValue pix = qvariant_cast<PropertySheetPixmapValue>(v: value);
245	DomResourcePixmap *rp = new DomResourcePixmap;
246	const QString pixPath = pix.path();
247	switch (pix.pixmapSource(core: m_core)) {
248	case PropertySheetPixmapValue::LanguageResourcePixmap:
249	rp->setText(pixPath);
250	break;
251	case PropertySheetPixmapValue::ResourcePixmap: {
252	rp->setText(pixPath);
253	const QString qrcFile = m_core->resourceModel()->qrcPath(file: pixPath);
254	if (!qrcFile.isEmpty()) {
255	m_usedQrcFiles.insert(akey: qrcFile, avalue: false);
256	#ifdef OLD_RESOURCE_FORMAT // Legacy: Add qrc path
257	rp->setAttributeResource(workingDirectory.relativeFilePath(fileName: qrcFile));
258	#endif
259	}
260	}
261	break;
262	case PropertySheetPixmapValue::FilePixmap:
263	rp->setText(m_saveRelative ? workingDirectory.relativeFilePath(fileName: pixPath) : pixPath);
264	break;
265	}
266	p->setElementPixmap(rp);
267	return p;
268	}
269	if (value.canConvert<PropertySheetIconValue>()) {
270	const PropertySheetIconValue icon = qvariant_cast<PropertySheetIconValue>(v: value);
271	const QMap<QPair<QIcon::Mode, QIcon::State>, PropertySheetPixmapValue> pixmaps = icon.paths();
272	const QString theme = icon.theme();
273	if (!pixmaps.isEmpty() || !theme.isEmpty()) {
274	DomResourceIcon *ri = new DomResourceIcon;
275	if (!theme.isEmpty())
276	ri->setAttributeTheme(theme);
277	for (auto itPix = pixmaps.cbegin(), end = pixmaps.cend(); itPix != end; ++itPix) {
278	const QIcon::Mode mode = itPix.key().first;
279	const QIcon::State state = itPix.key().second;
280	DomResourcePixmap *rp = new DomResourcePixmap;
281	const PropertySheetPixmapValue &pix = itPix.value();
282	const PropertySheetPixmapValue::PixmapSource ps = pix.pixmapSource(core: m_core);
283	const QString pixPath = pix.path();
284	rp->setText(ps == PropertySheetPixmapValue::FilePixmap && m_saveRelative ? workingDirectory.relativeFilePath(fileName: pixPath) : pixPath);
285	if (state == QIcon::Off) {
286	switch (mode) {
287	case QIcon::Normal:
288	ri->setElementNormalOff(rp);
289	#ifdef OLD_RESOURCE_FORMAT // Legacy: Set Normal off as text/path in old format.
290	ri->setText(rp->text());
291	#endif
292	if (ps == PropertySheetPixmapValue::ResourcePixmap) {
293	// Be sure that ri->text() file comes from active resourceSet (i.e. make appropriate
294	// resourceSet active before calling this method).
295	const QString qrcFile = m_core->resourceModel()->qrcPath(file: ri->text());
296	if (!qrcFile.isEmpty()) {
297	m_usedQrcFiles.insert(akey: qrcFile, avalue: false);
298	#ifdef OLD_RESOURCE_FORMAT // Legacy: Set Normal off as text/path in old format.
299	ri->setAttributeResource(workingDirectory.relativeFilePath(fileName: qrcFile));
300	#endif
301	}
302	}
303	break;
304	case QIcon::Disabled: ri->setElementDisabledOff(rp); break;
305	case QIcon::Active: ri->setElementActiveOff(rp); break;
306	case QIcon::Selected: ri->setElementSelectedOff(rp); break;
307	}
308	} else {
309	switch (mode) {
310	case QIcon::Normal: ri->setElementNormalOn(rp); break;
311	case QIcon::Disabled: ri->setElementDisabledOn(rp); break;
312	case QIcon::Active: ri->setElementActiveOn(rp); break;
313	case QIcon::Selected: ri->setElementSelectedOn(rp); break;
314	}
315	}
316	}
317	p->setElementIconSet(ri);
318	return p;
319	}
320	}
321	delete p;
322	return nullptr;
323	}
324
325	bool QDesignerResourceBuilder::isResourceType(const QVariant &value) const
326	{
327	return value.canConvert<PropertySheetPixmapValue>()
328	|| value.canConvert<PropertySheetIconValue>();
329	}
330	// ------------------------- QDesignerTextBuilder
331
332	template <class DomElement> // for DomString, potentially DomStringList
333	inline void translationParametersToDom(const PropertySheetTranslatableData &data, DomElement *e)
334	{
335	const QString propertyComment = data.disambiguation();
336	if (!propertyComment.isEmpty())
337	e->setAttributeComment(propertyComment);
338	const QString propertyExtracomment = data.comment();
339	if (!propertyExtracomment.isEmpty())
340	e->setAttributeExtraComment(propertyExtracomment);
341	const QString &id = data.id();
342	if (!id.isEmpty())
343	e->setAttributeId(id);
344	if (!data.translatable())
345	e->setAttributeNotr(QStringLiteral("true"));
346	}
347
348	template <class DomElement> // for DomString, potentially DomStringList
349	inline void translationParametersFromDom(const DomElement *e, PropertySheetTranslatableData *data)
350	{
351	if (e->hasAttributeComment())
352	data->setDisambiguation(e->attributeComment());
353	if (e->hasAttributeExtraComment())
354	data->setComment(e->attributeExtraComment());
355	if (e->hasAttributeId())
356	data->setId(e->attributeId());
357	if (e->hasAttributeNotr()) {
358	const QString notr = e->attributeNotr();
359	const bool translatable = !(notr == QStringLiteral("true") || notr == QStringLiteral("yes"));
360	data->setTranslatable(translatable);
361	}
362	}
363
364	class QDesignerTextBuilder : public QTextBuilder
365	{
366	public:
367	QDesignerTextBuilder() = default;
368
369	QVariant loadText(const DomProperty *icon) const override;
370
371	QVariant toNativeValue(const QVariant &value) const override;
372
373	DomProperty *saveText(const QVariant &value) const override;
374	};
375
376	QVariant QDesignerTextBuilder::loadText(const DomProperty *text) const
377	{
378	if (const DomString *domString = text->elementString()) {
379	PropertySheetStringValue stringValue(domString->text());
380	translationParametersFromDom(e: domString, data: &stringValue);
381	return QVariant::fromValue(value: stringValue);
382	}
383	return QVariant(QString());
384	}
385
386	QVariant QDesignerTextBuilder::toNativeValue(const QVariant &value) const
387	{
388	if (value.canConvert<PropertySheetStringValue>())
389	return QVariant::fromValue(value: qvariant_cast<PropertySheetStringValue>(v: value).value());
390	return value;
391	}
392
393	static inline DomProperty *stringToDomProperty(const QString &value)
394	{
395	DomString *domString = new DomString();
396	domString->setText(value);
397	DomProperty *property = new DomProperty();
398	property->setElementString(domString);
399	return property;
400	}
401
402	static inline DomProperty *stringToDomProperty(const QString &value,
403	const PropertySheetTranslatableData &translatableData)
404	{
405	DomString *domString = new DomString();
406	domString->setText(value);
407	translationParametersToDom(data: translatableData, e: domString);
408	DomProperty *property = new DomProperty();
409	property->setElementString(domString);
410	return property;
411	}
412
413	DomProperty *QDesignerTextBuilder::saveText(const QVariant &value) const
414	{
415	if (value.canConvert<PropertySheetStringValue>()) {
416	const PropertySheetStringValue str = qvariant_cast<PropertySheetStringValue>(v: value);
417	return stringToDomProperty(value: str.value(), translatableData: str);
418	}
419	if (value.canConvert<QString>())
420	return stringToDomProperty(value: value.toString());
421	return nullptr;
422	}
423
424	QDesignerResource::QDesignerResource(FormWindow *formWindow) :
425	QEditorFormBuilder(formWindow->core()),
426	m_formWindow(formWindow),
427	m_copyWidget(false),
428	m_selected(nullptr),
429	m_resourceBuilder(new QDesignerResourceBuilder(m_formWindow->core(), m_formWindow->pixmapCache(), m_formWindow->iconCache()))
430	{
431	// Check language unless extension present (Jambi)
432	QDesignerFormEditorInterface *core = m_formWindow->core();
433	if (const QDesignerLanguageExtension *le = qt_extension<QDesignerLanguageExtension*>(manager: core->extensionManager(), object: core))
434	d->m_language = le->name();
435
436	setWorkingDirectory(formWindow->absoluteDir());
437	setResourceBuilder(m_resourceBuilder);
438	setTextBuilder(new QDesignerTextBuilder());
439
440	// ### generalise
441	const QString designerWidget = QStringLiteral("QDesignerWidget");
442	const QString layoutWidget = QStringLiteral("QLayoutWidget");
443	const QString widget = QStringLiteral("QWidget");
444	m_internal_to_qt.insert(akey: layoutWidget, avalue: widget);
445	m_internal_to_qt.insert(akey: designerWidget, avalue: widget);
446	m_internal_to_qt.insert(QStringLiteral("QDesignerDialog"), QStringLiteral("QDialog"));
447	m_internal_to_qt.insert(QStringLiteral("QDesignerMenuBar"), QStringLiteral("QMenuBar"));
448	m_internal_to_qt.insert(QStringLiteral("QDesignerMenu"), QStringLiteral("QMenu"));
449	m_internal_to_qt.insert(QStringLiteral("QDesignerDockWidget"), QStringLiteral("QDockWidget"));
450
451	// invert
452	QHash<QString, QString>::const_iterator cend = m_internal_to_qt.constEnd();
453	for (QHash<QString, QString>::const_iterator it = m_internal_to_qt.constBegin();it != cend; ++it ) {
454	if (it.value() != designerWidget && it.value() != layoutWidget)
455	m_qt_to_internal.insert(akey: it.value(), avalue: it.key());
456
457	}
458	}
459
460	QDesignerResource::~QDesignerResource() = default;
461
462	DomUI *QDesignerResource::readUi(QIODevice *dev)
463	{
464	return d->readUi(dev);
465	}
466
467	static inline QString messageBoxTitle()
468	{
469	return QApplication::translate(context: "Designer", key: "Qt Designer");
470	}
471
472	void QDesignerResource::save(QIODevice *dev, QWidget *widget)
473	{
474	QAbstractFormBuilder::save(dev, widget);
475	}
476
477	void QDesignerResource::saveDom(DomUI *ui, QWidget *widget)
478	{
479	QAbstractFormBuilder::saveDom(ui, widget);
480
481	QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(manager: core()->extensionManager(), object: widget);
482	Q_ASSERT(sheet != nullptr);
483
484	const QVariant classVar = sheet->property(index: sheet->indexOf(QStringLiteral("objectName")));
485	QString classStr;
486	if (classVar.canConvert(targetTypeId: QVariant::String))
487	classStr = classVar.toString();
488	else
489	classStr = qvariant_cast<PropertySheetStringValue>(v: classVar).value();
490	ui->setElementClass(classStr);
491
492	for (int index = 0; index < m_formWindow->toolCount(); ++index) {
493	QDesignerFormWindowToolInterface *tool = m_formWindow->tool(index);
494	Q_ASSERT(tool != nullptr);
495	tool->saveToDom(ui, widget);
496	}
497
498	const QString author = m_formWindow->author();
499	if (!author.isEmpty()) {
500	ui->setElementAuthor(author);
501	}
502
503	const QString comment = m_formWindow->comment();
504	if (!comment.isEmpty()) {
505	ui->setElementComment(comment);
506	}
507
508	const QString exportMacro = m_formWindow->exportMacro();
509	if (!exportMacro.isEmpty()) {
510	ui->setElementExportMacro(exportMacro);
511	}
512
513	if (m_formWindow->useIdBasedTranslations())
514	ui->setAttributeIdbasedtr(true);
515	if (!m_formWindow->connectSlotsByName()) // Don't write out if true (default)
516	ui->setAttributeConnectslotsbyname(false);
517
518	const QVariantMap designerFormData = m_formWindow->formData();
519	if (!designerFormData.isEmpty()) {
520	DomPropertyList domPropertyList;
521	const QVariantMap::const_iterator cend = designerFormData.constEnd();
522	for (QVariantMap::const_iterator it = designerFormData.constBegin(); it != cend; ++it) {
523	if (DomProperty *prop = variantToDomProperty(abstractFormBuilder: this, meta: widget->metaObject(), propertyName: it.key(), value: it.value()))
524	domPropertyList += prop;
525	}
526	if (!domPropertyList.isEmpty()) {
527	DomDesignerData* domDesignerFormData = new DomDesignerData;
528	domDesignerFormData->setElementProperty(domPropertyList);
529	ui->setElementDesignerdata(domDesignerFormData);
530	}
531	}
532
533	if (!m_formWindow->includeHints().isEmpty()) {
534	const QString local = QStringLiteral("local");
535	const QString global = QStringLiteral("global");
536	QVector<DomInclude *> ui_includes;
537	const QStringList &includeHints = m_formWindow->includeHints();
538	ui_includes.reserve(asize: includeHints.size());
539	for (QString includeHint : includeHints) {
540	if (includeHint.isEmpty())
541	continue;
542	DomInclude *incl = new DomInclude;
543	const QString location = includeHint.at(i: 0) == QLatin1Char('<') ? global : local;
544	includeHint.remove(c: QLatin1Char('"'));
545	includeHint.remove(c: QLatin1Char('<'));
546	includeHint.remove(c: QLatin1Char('>'));
547	incl->setAttributeLocation(location);
548	incl->setText(includeHint);
549	ui_includes.append(t: incl);
550	}
551
552	DomIncludes *includes = new DomIncludes;
553	includes->setElementInclude(ui_includes);
554	ui->setElementIncludes(includes);
555	}
556
557	int defaultMargin = INT_MIN, defaultSpacing = INT_MIN;
558	m_formWindow->layoutDefault(margin: &defaultMargin, spacing: &defaultSpacing);
559
560	if (defaultMargin != INT_MIN || defaultSpacing != INT_MIN) {
561	DomLayoutDefault *def = new DomLayoutDefault;
562	if (defaultMargin != INT_MIN)
563	def->setAttributeMargin(defaultMargin);
564	if (defaultSpacing != INT_MIN)
565	def->setAttributeSpacing(defaultSpacing);
566	ui->setElementLayoutDefault(def);
567	}
568
569	QString marginFunction, spacingFunction;
570	m_formWindow->layoutFunction(margin: &marginFunction, spacing: &spacingFunction);
571	if (!marginFunction.isEmpty() || !spacingFunction.isEmpty()) {
572	DomLayoutFunction *def = new DomLayoutFunction;
573
574	if (!marginFunction.isEmpty())
575	def->setAttributeMargin(marginFunction);
576	if (!spacingFunction.isEmpty())
577	def->setAttributeSpacing(spacingFunction);
578	ui->setElementLayoutFunction(def);
579	}
580
581	QString pixFunction = m_formWindow->pixmapFunction();
582	if (!pixFunction.isEmpty()) {
583	ui->setElementPixmapFunction(pixFunction);
584	}
585
586	if (QDesignerExtraInfoExtension *extra = qt_extension<QDesignerExtraInfoExtension*>(manager: core()->extensionManager(), object: core()))
587	extra->saveUiExtraInfo(ui);
588
589	if (MetaDataBase *metaDataBase = qobject_cast<MetaDataBase *>(object: core()->metaDataBase())) {
590	const MetaDataBaseItem *item = metaDataBase->metaDataBaseItem(object: m_formWindow->mainContainer());
591	const QStringList fakeSlots = item->fakeSlots();
592	const QStringList fakeSignals =item->fakeSignals();
593	if (!fakeSlots.isEmpty() || !fakeSignals.isEmpty()) {
594	DomSlots *domSlots = new DomSlots();
595	domSlots->setElementSlot(fakeSlots);
596	domSlots->setElementSignal(fakeSignals);
597	ui->setElementSlots(domSlots);
598	}
599	}
600	}
601
602	QWidget *QDesignerResource::load(QIODevice *dev, QWidget *parentWidget)
603	{
604	QScopedPointer<DomUI> ui(readUi(dev));
605	return ui.isNull() ? nullptr : loadUi(ui: ui.data(), parentWidget);
606	}
607
608	QWidget *QDesignerResource::loadUi(DomUI *ui, QWidget *parentWidget)
609	{
610	QWidget *widget = create(ui, parentWidget);
611	// Store the class name as 'reset' value for the main container's object name.
612	if (widget)
613	widget->setProperty(name: "_q_classname", value: widget->objectName());
614	else if (d->m_errorString.isEmpty())
615	d->m_errorString = QFormBuilderExtra::msgInvalidUiFile();
616	return widget;
617	}
618
619	bool QDesignerResource::saveRelative() const
620	{
621	return m_resourceBuilder->isSaveRelative();
622	}
623
624	void QDesignerResource::setSaveRelative(bool relative)
625	{
626	m_resourceBuilder->setSaveRelative(relative);
627	}
628
629	QWidget *QDesignerResource::create(DomUI *ui, QWidget *parentWidget)
630	{
631	// Load extra info extension. This is used by Jambi for preventing
632	// C++ UI files from being loaded
633	if (QDesignerExtraInfoExtension *extra = qt_extension<QDesignerExtraInfoExtension*>(manager: core()->extensionManager(), object: core())) {
634	if (!extra->loadUiExtraInfo(ui)) {
635	const QString errorMessage = QApplication::translate(context: "Designer", key: "This file cannot be read because the extra info extension failed to load.");
636	core()->dialogGui()->message(parent: parentWidget->window(), context: QDesignerDialogGuiInterface::FormLoadFailureMessage,
637	icon: QMessageBox::Warning, title: messageBoxTitle(), text: errorMessage, buttons: QMessageBox::Ok);
638	return nullptr;
639	}
640	}
641
642	qdesigner_internal::WidgetFactory *factory = qobject_cast<qdesigner_internal::WidgetFactory*>(object: core()->widgetFactory());
643	Q_ASSERT(factory != nullptr);
644
645	QDesignerFormWindowInterface *previousFormWindow = factory->currentFormWindow(fw: m_formWindow);
646
647	m_isMainWidget = true;
648	QDesignerWidgetItemInstaller wii; // Make sure we use QDesignerWidgetItem.
649	QWidget *mainWidget = QAbstractFormBuilder::create(ui, parentWidget);
650
651	if (m_formWindow) {
652	m_formWindow->setUseIdBasedTranslations(ui->attributeIdbasedtr());
653	// Default to true unless set.
654	const bool connectSlotsByName = !ui->hasAttributeConnectslotsbyname() || ui->attributeConnectslotsbyname();
655	m_formWindow->setConnectSlotsByName(connectSlotsByName);
656	}
657
658	if (mainWidget && m_formWindow) {
659	m_formWindow->setAuthor(ui->elementAuthor());
660	m_formWindow->setComment(ui->elementComment());
661	m_formWindow->setExportMacro(ui->elementExportMacro());
662
663	// Designer data
664	QVariantMap designerFormData;
665	if (ui->hasElementDesignerdata()) {
666	const DomPropertyList domPropertyList = ui->elementDesignerdata()->elementProperty();
667	const DomPropertyList::const_iterator cend = domPropertyList.constEnd();
668	for (DomPropertyList::const_iterator it = domPropertyList.constBegin(); it != cend; ++it) {
669	const QVariant vprop = domPropertyToVariant(abstractFormBuilder: this, meta: mainWidget->metaObject(), property: *it);
670	if (vprop.type() != QVariant::Invalid)
671	designerFormData.insert(akey: (*it)->attributeName(), avalue: vprop);
672	}
673	}
674	m_formWindow->setFormData(designerFormData);
675
676	m_formWindow->setPixmapFunction(ui->elementPixmapFunction());
677
678	if (DomLayoutDefault *def = ui->elementLayoutDefault()) {
679	m_formWindow->setLayoutDefault(margin: def->attributeMargin(), spacing: def->attributeSpacing());
680	}
681
682	if (DomLayoutFunction *fun = ui->elementLayoutFunction()) {
683	m_formWindow->setLayoutFunction(margin: fun->attributeMargin(), spacing: fun->attributeSpacing());
684	}
685
686	if (DomIncludes *includes = ui->elementIncludes()) {
687	const QString global = QStringLiteral("global");
688	QStringList includeHints;
689	const auto &elementInclude = includes->elementInclude();
690	for (DomInclude *incl : elementInclude) {
691	QString text = incl->text();
692
693	if (text.isEmpty())
694	continue;
695
696	if (incl->hasAttributeLocation() && incl->attributeLocation() == global ) {
697	text = text.prepend(c: QLatin1Char('<')).append(c: QLatin1Char('>'));
698	} else {
699	text = text.prepend(c: QLatin1Char('"')).append(c: QLatin1Char('"'));
700	}
701
702	includeHints.append(t: text);
703	}
704
705	m_formWindow->setIncludeHints(includeHints);
706	}
707
708	// Register all button groups the form builder adds as children of the main container for them to be found
709	// in the signal slot editor
710	const QObjectList mchildren = mainWidget->children();
711	if (!mchildren.isEmpty()) {
712	QDesignerMetaDataBaseInterface *mdb = core()->metaDataBase();
713	const QObjectList::const_iterator cend = mchildren.constEnd();
714	for (QObjectList::const_iterator it = mchildren.constBegin(); it != cend; ++it)
715	if (QButtonGroup *bg = qobject_cast<QButtonGroup*>(object: *it))
716	mdb->add(object: bg);
717	}
718	// Load tools
719	for (int index = 0; index < m_formWindow->toolCount(); ++index) {
720	QDesignerFormWindowToolInterface *tool = m_formWindow->tool(index);
721	Q_ASSERT(tool != nullptr);
722	tool->loadFromDom(ui, mainWidget);
723	}
724	}
725
726	factory->currentFormWindow(fw: previousFormWindow);
727
728	if (const DomSlots *domSlots = ui->elementSlots()) {
729	if (MetaDataBase *metaDataBase = qobject_cast<MetaDataBase *>(object: core()->metaDataBase())) {
730	QStringList fakeSlots;
731	QStringList fakeSignals;
732	if (addFakeMethods(domSlots, fakeSlots, fakeSignals)) {
733	MetaDataBaseItem *item = metaDataBase->metaDataBaseItem(object: mainWidget);
734	item->setFakeSlots(fakeSlots);
735	item->setFakeSignals(fakeSignals);
736	}
737	}
738	}
739	if (mainWidget) {
740	// Initialize the mainwindow geometry. Has it been explicitly specified?
741	bool hasExplicitGeometry = false;
742	const auto &properties = ui->elementWidget()->elementProperty();
743	if (!properties.isEmpty()) {
744	const QString geometry = QStringLiteral("geometry");
745	for (const DomProperty *p : properties) {
746	if (p->attributeName() == geometry) {
747	hasExplicitGeometry = true;
748	break;
749	}
750	}
751	}
752	if (hasExplicitGeometry) {
753	// Geometry was specified explicitly: Verify that smartMinSize is respected
754	// (changed fonts, label wrapping policies, etc). This does not happen automatically in docked mode.
755	const QSize size = mainWidget->size();
756	const QSize minSize = size.expandedTo(otherSize: qSmartMinSize(w: mainWidget));
757	if (minSize != size)
758	mainWidget->resize(minSize);
759	} else {
760	// No explicit Geometry: perform an adjustSize() to resize the form correctly before embedding it into a container
761	// (which might otherwise squeeze the form)
762	mainWidget->adjustSize();
763	}
764	// Some integration wizards create forms with main containers
765	// based on derived classes of QWidget and load them into Designer
766	// without the plugin existing. This will trigger the auto-promotion
767	// mechanism of Designer, which will set container=false for
768	// QWidgets. For the main container, force container=true and warn.
769	const QDesignerWidgetDataBaseInterface *wdb = core()->widgetDataBase();
770	const int wdbIndex = wdb->indexOfObject(object: mainWidget);
771	if (wdbIndex != -1) {
772	QDesignerWidgetDataBaseItemInterface *item = wdb->item(index: wdbIndex);
773	// Promoted main container that is not of container type
774	if (item->isPromoted() && !item->isContainer()) {
775	item->setContainer(true);
776	qWarning(msg: "** WARNING The form's main container is an unknown custom widget '%s'."
777	" Defaulting to a promoted instance of '%s', assuming container.",
778	item->name().toUtf8().constData(), item->extends().toUtf8().constData());
779	}
780	}
781	}
782	return mainWidget;
783	}
784
785	QWidget *QDesignerResource::create(DomWidget *ui_widget, QWidget *parentWidget)
786	{
787	const QString className = ui_widget->attributeClass();
788	if (!m_isMainWidget && className == QStringLiteral("QWidget")
789	&& !ui_widget->elementLayout().isEmpty()
790	&& !ui_widget->hasAttributeNative()) {
791	// ### check if elementLayout.size() == 1
792
793	QDesignerContainerExtension *container = qt_extension<QDesignerContainerExtension*>(manager: core()->extensionManager(), object: parentWidget);
794
795	if (container == nullptr) {
796	// generate a QLayoutWidget iff the parent is not an QDesignerContainerExtension.
797	ui_widget->setAttributeClass(QStringLiteral("QLayoutWidget"));
798	}
799	}
800
801	// save the actions
802	const auto &actionRefs = ui_widget->elementAddAction();
803	ui_widget->setElementAddAction(QVector<DomActionRef *>());
804
805	QWidget *w = QAbstractFormBuilder::create(ui_widget, parentWidget);
806
807	// restore the actions
808	ui_widget->setElementAddAction(actionRefs);
809
810	if (w == nullptr)
811	return nullptr;
812
813	// ### generalize using the extension manager
814	QDesignerMenu *menu = qobject_cast<QDesignerMenu*>(object: w);
815	QDesignerMenuBar *menuBar = qobject_cast<QDesignerMenuBar*>(object: w);
816
817	if (menu)
818	menu->hide();
819
820	for (DomActionRef *ui_action_ref : actionRefs) {
821	const QString name = ui_action_ref->attributeName();
822	if (name == QStringLiteral("separator")) {
823	QAction *sep = new QAction(w);
824	sep->setSeparator(true);
825	w->addAction(action: sep);
826	addMenuAction(action: sep);
827	} else if (QAction *a = d->m_actions.value(akey: name)) {
828	w->addAction(action: a);
829	} else if (QActionGroup *g = d->m_actionGroups.value(akey: name)) {
830	w->addActions(actions: g->actions());
831	} else if (QMenu *menu = w->findChild<QMenu*>(aName: name)) {
832	w->addAction(action: menu->menuAction());
833	addMenuAction(action: menu->menuAction());
834	}
835	}
836
837	if (menu)
838	menu->adjustSpecialActions();
839	else if (menuBar)
840	menuBar->adjustSpecialActions();
841
842	ui_widget->setAttributeClass(className); // fix the class name
843	applyExtensionDataFromDOM(afb: this, core: core(), ui_widget, widget: w);
844
845	return w;
846	}
847
848	QLayout *QDesignerResource::create(DomLayout *ui_layout, QLayout *layout, QWidget *parentWidget)
849	{
850	QLayout *l = QAbstractFormBuilder::create(ui_layout, layout, parentWidget);
851
852	if (QGridLayout *gridLayout = qobject_cast<QGridLayout*>(object: l)) {
853	QLayoutSupport::createEmptyCells(gridLayout);
854	} else {
855	if (QFormLayout *formLayout = qobject_cast<QFormLayout*>(object: l))
856	QLayoutSupport::createEmptyCells(formLayout);
857	}
858	// While the actual values are applied by the form builder, we still need
859	// to mark them as 'changed'.
860	LayoutPropertySheet::markChangedStretchProperties(core: core(), lt: l, domLayout: ui_layout);
861	return l;
862	}
863
864	QLayoutItem *QDesignerResource::create(DomLayoutItem *ui_layoutItem, QLayout *layout, QWidget *parentWidget)
865	{
866	if (ui_layoutItem->kind() == DomLayoutItem::Spacer) {
867	const DomSpacer *domSpacer = ui_layoutItem->elementSpacer();
868	Spacer *spacer = static_cast<Spacer*>(core()->widgetFactory()->createWidget(QStringLiteral("Spacer"), parentWidget));
869	if (domSpacer->hasAttributeName())
870	changeObjectName(o: spacer, name: domSpacer->attributeName());
871	core()->metaDataBase()->add(object: spacer);
872
873	spacer->setInteractiveMode(false);
874	applyProperties(o: spacer, properties: ui_layoutItem->elementSpacer()->elementProperty());
875	spacer->setInteractiveMode(true);
876
877	if (m_formWindow) {
878	m_formWindow->manageWidget(w: spacer);
879	if (QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(manager: core()->extensionManager(), object: spacer))
880	sheet->setChanged(index: sheet->indexOf(QStringLiteral("orientation")), changed: true);
881	}
882
883	return new QWidgetItem(spacer);
884	}
885	if (ui_layoutItem->kind() == DomLayoutItem::Layout && parentWidget) {
886	DomLayout *ui_layout = ui_layoutItem->elementLayout();
887	QLayoutWidget *layoutWidget = new QLayoutWidget(m_formWindow, parentWidget);
888	core()->metaDataBase()->add(object: layoutWidget);
889	if (m_formWindow)
890	m_formWindow->manageWidget(w: layoutWidget);
891	(void) create(ui_layout, layout: nullptr, parentWidget: layoutWidget);
892	return new QWidgetItem(layoutWidget);
893	}
894	return QAbstractFormBuilder::create(ui_layoutItem, layout, parentWidget);
895	}
896
897	void QDesignerResource::changeObjectName(QObject *o, QString objName)
898	{
899	m_formWindow->unify(w: o, s&: objName, changeIt: true);
900	o->setObjectName(objName);
901
902	}
903
904	/* If the property is a enum or flag value, retrieve
905	* the existing enum/flag via property sheet and use it to convert */
906
907	static bool readDomEnumerationValue(const DomProperty *p,
908	const QDesignerPropertySheetExtension* sheet, int index,
909	QVariant &v)
910	{
911	switch (p->kind()) {
912	case DomProperty::Set: {
913	const QVariant sheetValue = sheet->property(index);
914	if (sheetValue.canConvert<PropertySheetFlagValue>()) {
915	const PropertySheetFlagValue f = qvariant_cast<PropertySheetFlagValue>(v: sheetValue);
916	bool ok = false;
917	v = f.metaFlags.parseFlags(s: p->elementSet(), ok: &ok);
918	if (!ok)
919	designerWarning(message: f.metaFlags.messageParseFailed(s: p->elementSet()));
920	return true;
921	}
922	}
923	break;
924	case DomProperty::Enum: {
925	const QVariant sheetValue = sheet->property(index);
926	if (sheetValue.canConvert<PropertySheetEnumValue>()) {
927	const PropertySheetEnumValue e = qvariant_cast<PropertySheetEnumValue>(v: sheetValue);
928	bool ok = false;
929	v = e.metaEnum.parseEnum(s: p->elementEnum(), ok: &ok);
930	if (!ok)
931	designerWarning(message: e.metaEnum.messageParseFailed(s: p->elementEnum()));
932	return true;
933	}
934	}
935	break;
936	default:
937	break;
938	}
939	return false;
940	}
941
942	void QDesignerResource::applyProperties(QObject *o, const QList<DomProperty*> &properties)
943	{
944	if (properties.isEmpty())
945	return;
946
947	QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(manager: core()->extensionManager(), object: o);
948	if (!sheet)
949	return;
950
951	QDesignerDynamicPropertySheetExtension *dynamicSheet = qt_extension<QDesignerDynamicPropertySheetExtension*>(manager: core()->extensionManager(), object: o);
952	const bool dynamicPropertiesAllowed = dynamicSheet && dynamicSheet->dynamicPropertiesAllowed();
953
954	const QString objectNameProperty = QStringLiteral("objectName");
955	for (DomProperty *p : properties) {
956	QString propertyName = p->attributeName();
957	if (propertyName == QLatin1String("numDigits") && o->inherits(classname: "QLCDNumber")) // Deprecated in Qt 4, removed in Qt 5.
958	propertyName = QLatin1String("digitCount");
959	const int index = sheet->indexOf(name: propertyName);
960	QVariant v;
961	if (!readDomEnumerationValue(p, sheet, index, v))
962	v = toVariant(meta: o->metaObject(), property: p);
963
964	switch (p->kind()) {
965	case DomProperty::String:
966	if (index != -1 && sheet->property(index).userType() == qMetaTypeId<PropertySheetKeySequenceValue>()) {
967	const DomString *key = p->elementString();
968	PropertySheetKeySequenceValue keyVal(QKeySequence(key->text()));
969	translationParametersFromDom(e: key, data: &keyVal);
970	v = QVariant::fromValue(value: keyVal);
971	} else {
972	const DomString *str = p->elementString();
973	PropertySheetStringValue strVal(v.toString());
974	translationParametersFromDom(e: str, data: &strVal);
975	v = QVariant::fromValue(value: strVal);
976	}
977	break;
978	case DomProperty::StringList: {
979	const DomStringList *list = p->elementStringList();
980	PropertySheetStringListValue listValue(list->elementString());
981	translationParametersFromDom(e: list, data: &listValue);
982	v = QVariant::fromValue(value: listValue);
983	}
984	break;
985	default:
986	break;
987	}
988
989	d->applyPropertyInternally(o, propertyName, value: v);
990	if (index != -1) {
991	sheet->setProperty(index, value: v);
992	sheet->setChanged(index, changed: true);
993	} else if (dynamicPropertiesAllowed) {
994	QVariant defaultValue = QVariant(v.type());
995	bool isDefault = (v == defaultValue);
996	if (v.canConvert<PropertySheetIconValue>()) {
997	defaultValue = QVariant(QVariant::Icon);
998	isDefault = (qvariant_cast<PropertySheetIconValue>(v) == PropertySheetIconValue());
999	} else if (v.canConvert<PropertySheetPixmapValue>()) {
1000	defaultValue = QVariant(QVariant::Pixmap);
1001	isDefault = (qvariant_cast<PropertySheetPixmapValue>(v) == PropertySheetPixmapValue());
1002	} else if (v.canConvert<PropertySheetStringValue>()) {
1003	defaultValue = QVariant(QVariant::String);
1004	isDefault = (qvariant_cast<PropertySheetStringValue>(v) == PropertySheetStringValue());
1005	} else if (v.canConvert<PropertySheetStringListValue>()) {
1006	defaultValue = QVariant(QVariant::StringList);
1007	isDefault = (qvariant_cast<PropertySheetStringListValue>(v) == PropertySheetStringListValue());
1008	} else if (v.canConvert<PropertySheetKeySequenceValue>()) {
1009	defaultValue = QVariant(QVariant::KeySequence);
1010	isDefault = (qvariant_cast<PropertySheetKeySequenceValue>(v) == PropertySheetKeySequenceValue());
1011	}
1012	if (defaultValue.type() != QVariant::UserType) {
1013	const int idx = dynamicSheet->addDynamicProperty(propertyName: p->attributeName(), value: defaultValue);
1014	if (idx != -1) {
1015	sheet->setProperty(index: idx, value: v);
1016	sheet->setChanged(index: idx, changed: !isDefault);
1017	}
1018	}
1019	}
1020
1021	if (propertyName == objectNameProperty)
1022	changeObjectName(o, objName: o->objectName());
1023	}
1024	}
1025
1026	QWidget *QDesignerResource::createWidget(const QString &widgetName, QWidget *parentWidget, const QString &_name)
1027	{
1028	QString name = _name;
1029	if (m_isMainWidget)
1030	m_isMainWidget = false;
1031
1032	QWidget *w = core()->widgetFactory()->createWidget(name: widgetName, parentWidget);
1033	if (!w)
1034	return nullptr;
1035
1036	if (name.isEmpty()) {
1037	QDesignerWidgetDataBaseInterface *db = core()->widgetDataBase();
1038	if (QDesignerWidgetDataBaseItemInterface *item = db->item(index: db->indexOfObject(object: w)))
1039	name = qtify(name: item->name());
1040	}
1041
1042	changeObjectName(o: w, objName: name);
1043
1044	QDesignerContainerExtension *container = qt_extension<QDesignerContainerExtension*>(manager: core()->extensionManager(), object: parentWidget);
1045	if (!qobject_cast<QMenu*>(object: w) && (!parentWidget || !container)) {
1046	m_formWindow->manageWidget(w);
1047	if (parentWidget) {
1048	QWidgetList list = qvariant_cast<QWidgetList>(v: parentWidget->property(name: "_q_widgetOrder"));
1049	list.append(t: w);
1050	parentWidget->setProperty(name: "_q_widgetOrder", value: QVariant::fromValue(value: list));
1051	QWidgetList zOrder = qvariant_cast<QWidgetList>(v: parentWidget->property(name: "_q_zOrder"));
1052	zOrder.append(t: w);
1053	parentWidget->setProperty(name: "_q_zOrder", value: QVariant::fromValue(value: zOrder));
1054	}
1055	} else {
1056	core()->metaDataBase()->add(object: w);
1057	}
1058
1059	w->setWindowFlags(w->windowFlags() & ~Qt::Window);
1060	// Make sure it is non-modal (for example, KDialog calls setModal(true) in the constructor).
1061	w->setWindowModality(Qt::NonModal);
1062
1063	return w;
1064	}
1065
1066	QLayout *QDesignerResource::createLayout(const QString &layoutName, QObject *parent, const QString &name)
1067	{
1068	QWidget *layoutBase = nullptr;
1069	QLayout *layout = qobject_cast<QLayout*>(object: parent);
1070
1071	if (parent->isWidgetType())
1072	layoutBase = static_cast<QWidget*>(parent);
1073	else {
1074	Q_ASSERT( layout != nullptr );
1075	layoutBase = layout->parentWidget();
1076	}
1077
1078	LayoutInfo::Type layoutType = LayoutInfo::layoutType(typeName: layoutName);
1079	if (layoutType == LayoutInfo::NoLayout) {
1080	designerWarning(message: QCoreApplication::translate(context: "QDesignerResource", key: "The layout type '%1' is not supported, defaulting to grid.").arg(a: layoutName));
1081	layoutType = LayoutInfo::Grid;
1082	}
1083	QLayout *lay = core()->widgetFactory()->createLayout(widget: layoutBase, layout, type: layoutType);
1084	if (lay != nullptr)
1085	changeObjectName(o: lay, objName: name);
1086
1087	return lay;
1088	}
1089
1090	// save
1091	DomWidget *QDesignerResource::createDom(QWidget *widget, DomWidget *ui_parentWidget, bool recursive)
1092	{
1093	QDesignerMetaDataBaseItemInterface *item = core()->metaDataBase()->item(object: widget);
1094	if (!item)
1095	return nullptr;
1096
1097	if (qobject_cast<Spacer*>(object: widget) && !m_copyWidget)
1098	return nullptr;
1099
1100	const QDesignerWidgetDataBaseInterface *wdb = core()->widgetDataBase();
1101	QDesignerWidgetDataBaseItemInterface *widgetInfo = nullptr;
1102	const int widgetInfoIndex = wdb->indexOfObject(object: widget, resolveName: false);
1103	if (widgetInfoIndex != -1) {
1104	widgetInfo = wdb->item(index: widgetInfoIndex);
1105	// Recursively add all dependent custom widgets
1106	QDesignerWidgetDataBaseItemInterface *customInfo = widgetInfo;
1107	while (customInfo && customInfo->isCustom()) {
1108	m_usedCustomWidgets.insert(akey: customInfo, avalue: true);
1109	const QString extends = customInfo->extends();
1110	if (extends == customInfo->name())
1111	break; // There are faulty files around that have name==extends
1112	const int extendsIndex = wdb->indexOfClassName(className: customInfo->extends());
1113	customInfo = extendsIndex != -1 ? wdb->item(index: extendsIndex) : nullptr;
1114	}
1115	}
1116
1117	DomWidget *w = nullptr;
1118
1119	if (QTabWidget *tabWidget = qobject_cast<QTabWidget*>(object: widget))
1120	w = saveWidget(widget: tabWidget, ui_parentWidget);
1121	else if (QStackedWidget *stackedWidget = qobject_cast<QStackedWidget*>(object: widget))
1122	w = saveWidget(widget: stackedWidget, ui_parentWidget);
1123	else if (QToolBox *toolBox = qobject_cast<QToolBox*>(object: widget))
1124	w = saveWidget(widget: toolBox, ui_parentWidget);
1125	else if (QToolBar *toolBar = qobject_cast<QToolBar*>(object: widget))
1126	w = saveWidget(toolBar, ui_parentWidget);
1127	else if (QDesignerDockWidget *dockWidget = qobject_cast<QDesignerDockWidget*>(object: widget))
1128	w = saveWidget(dockWidget, ui_parentWidget);
1129	else if (QDesignerContainerExtension *container = qt_extension<QDesignerContainerExtension*>(manager: core()->extensionManager(), object: widget))
1130	w = saveWidget(widget, container, ui_parentWidget);
1131	else if (QWizardPage *wizardPage = qobject_cast<QWizardPage*>(object: widget))
1132	w = saveWidget(wizardPage, ui_parentWidget);
1133	else
1134	w = QAbstractFormBuilder::createDom(widget, ui_parentWidget, recursive);
1135
1136	Q_ASSERT( w != nullptr );
1137
1138	if (!qobject_cast<QLayoutWidget*>(object: widget) && w->attributeClass() == QStringLiteral("QWidget")) {
1139	w->setAttributeNative(true);
1140	}
1141
1142	const QString className = w->attributeClass();
1143	if (m_internal_to_qt.contains(akey: className))
1144	w->setAttributeClass(m_internal_to_qt.value(akey: className));
1145
1146	w->setAttributeName(widget->objectName());
1147
1148	if (isPromoted( core: core(), w: widget)) { // is promoted?
1149	Q_ASSERT(widgetInfo != nullptr);
1150
1151	w->setAttributeName(widget->objectName());
1152	w->setAttributeClass(widgetInfo->name());
1153
1154	const auto &prop_list = w->elementProperty();
1155	for (DomProperty *prop : prop_list) {
1156	if (prop->attributeName() == QStringLiteral("geometry")) {
1157	if (DomRect *rect = prop->elementRect()) {
1158	rect->setElementX(widget->x());
1159	rect->setElementY(widget->y());
1160	}
1161	break;
1162	}
1163	}
1164	} else if (widgetInfo != nullptr && m_usedCustomWidgets.contains(akey: widgetInfo)) {
1165	if (widgetInfo->name() != w->attributeClass())
1166	w->setAttributeClass(widgetInfo->name());
1167	}
1168	addExtensionDataToDOM(afb: this, core: core(), ui_widget: w, widget);
1169	return w;
1170	}
1171
1172	DomLayout *QDesignerResource::createDom(QLayout *layout, DomLayout *ui_parentLayout, DomWidget *ui_parentWidget)
1173	{
1174	QDesignerMetaDataBaseItemInterface *item = core()->metaDataBase()->item(object: layout);
1175
1176	if (item == nullptr) {
1177	layout = layout->findChild<QLayout*>();
1178	// refresh the meta database item
1179	item = core()->metaDataBase()->item(object: layout);
1180	}
1181
1182	if (item == nullptr) {
1183	// nothing to do.
1184	return nullptr;
1185	}
1186
1187	if (qobject_cast<QSplitter*>(object: layout->parentWidget()) != 0) {
1188	// nothing to do.
1189	return nullptr;
1190	}
1191
1192	m_chain.push(t: layout);
1193
1194	DomLayout *l = QAbstractFormBuilder::createDom(layout, ui_layout: ui_parentLayout, ui_parentWidget);
1195	Q_ASSERT(l != nullptr);
1196	LayoutPropertySheet::stretchAttributesToDom(core: core(), lt: layout, domLayout: l);
1197
1198	m_chain.pop();
1199
1200	return l;
1201	}
1202
1203	DomLayoutItem *QDesignerResource::createDom(QLayoutItem *item, DomLayout *ui_layout, DomWidget *ui_parentWidget)
1204	{
1205	DomLayoutItem *ui_item = nullptr;
1206
1207	if (Spacer *s = qobject_cast<Spacer*>(object: item->widget())) {
1208	if (!core()->metaDataBase()->item(object: s))
1209	return nullptr;
1210
1211	DomSpacer *spacer = new DomSpacer();
1212	const QString objectName = s->objectName();
1213	if (!objectName.isEmpty())
1214	spacer->setAttributeName(objectName);
1215	// ### filter the properties
1216	spacer->setElementProperty(computeProperties(obj: item->widget()));
1217
1218	ui_item = new DomLayoutItem();
1219	ui_item->setElementSpacer(spacer);
1220	d->m_laidout.insert(akey: item->widget(), avalue: true);
1221	} else if (QLayoutWidget *layoutWidget = qobject_cast<QLayoutWidget*>(object: item->widget())) {
1222	// Do not save a QLayoutWidget if it is within a layout (else it is saved as "QWidget"
1223	Q_ASSERT(layoutWidget->layout());
1224	DomLayout *l = createDom(layout: layoutWidget->layout(), ui_parentLayout: ui_layout, ui_parentWidget);
1225	ui_item = new DomLayoutItem();
1226	ui_item->setElementLayout(l);
1227	d->m_laidout.insert(akey: item->widget(), avalue: true);
1228	} else if (!item->spacerItem()) { // we use spacer as fake item in the Designer
1229	ui_item = QAbstractFormBuilder::createDom(item, ui_parentLayout: ui_layout, ui_parentWidget);
1230	} else {
1231	return nullptr;
1232	}
1233	return ui_item;
1234	}
1235
1236	void QDesignerResource::createCustomWidgets(DomCustomWidgets *dom_custom_widgets)
1237	{
1238	QSimpleResource::handleDomCustomWidgets(core: core(), dom_custom_widgets);
1239	}
1240
1241	DomTabStops *QDesignerResource::saveTabStops()
1242	{
1243	QDesignerMetaDataBaseItemInterface *item = core()->metaDataBase()->item(object: m_formWindow);
1244	Q_ASSERT(item);
1245
1246	QStringList tabStops;
1247	const QWidgetList &tabOrder = item->tabOrder();
1248	for (QWidget *widget : tabOrder) {
1249	if (m_formWindow->mainContainer()->isAncestorOf(child: widget))
1250	tabStops.append(t: widget->objectName());
1251	}
1252
1253	if (tabStops.count()) {
1254	DomTabStops *dom = new DomTabStops;
1255	dom->setElementTabStop(tabStops);
1256	return dom;
1257	}
1258
1259	return nullptr;
1260	}
1261
1262	void QDesignerResource::applyTabStops(QWidget *widget, DomTabStops *tabStops)
1263	{
1264	if (!tabStops)
1265	return;
1266
1267	QWidgetList tabOrder;
1268	const QStringList &elementTabStop = tabStops->elementTabStop();
1269	for (const QString &widgetName : elementTabStop) {
1270	if (QWidget *w = widget->findChild<QWidget*>(aName: widgetName)) {
1271	tabOrder.append(t: w);
1272	}
1273	}
1274
1275	QDesignerMetaDataBaseItemInterface *item = core()->metaDataBase()->item(object: m_formWindow);
1276	Q_ASSERT(item);
1277	item->setTabOrder(tabOrder);
1278	}
1279
1280	/* Unmanaged container pages occur when someone adds a page in a custom widget
1281	* constructor. They don't have a meta DB entry which causes createDom
1282	* to return 0. */
1283	inline QString msgUnmanagedPage(QDesignerFormEditorInterface *core,
1284	QWidget *container, int index, QWidget *page)
1285	{
1286	return QCoreApplication::translate(context: "QDesignerResource",
1287	key: "The container extension of the widget '%1' (%2) returned a widget not managed by Designer '%3' (%4) when queried for page #%5.\n"
1288	"Container pages should only be added by specifying them in XML returned by the domXml() method of the custom widget.").
1289	arg(args: container->objectName(), args: WidgetFactory::classNameOf(core, o: container),
1290	args: page->objectName(), args: WidgetFactory::classNameOf(core, o: page)).
1291	arg(a: index);
1292	}
1293
1294	DomWidget *QDesignerResource::saveWidget(QWidget *widget, QDesignerContainerExtension *container, DomWidget *ui_parentWidget)
1295	{
1296	DomWidget *ui_widget = QAbstractFormBuilder::createDom(widget, ui_parentWidget, recursive: false);
1297	QVector<DomWidget *> ui_widget_list;
1298
1299	for (int i=0; i<container->count(); ++i) {
1300	QWidget *page = container->widget(index: i);
1301	Q_ASSERT(page);
1302
1303	if (DomWidget *ui_page = createDom(widget: page, ui_parentWidget: ui_widget)) {
1304	ui_widget_list.append(t: ui_page);
1305	} else {
1306	designerWarning(message: msgUnmanagedPage(core: core(), container: widget, index: i, page));
1307	}
1308	}
1309
1310	ui_widget->setElementWidget(ui_widget_list);
1311
1312	return ui_widget;
1313	}
1314
1315	DomWidget *QDesignerResource::saveWidget(QStackedWidget *widget, DomWidget *ui_parentWidget)
1316	{
1317	DomWidget *ui_widget = QAbstractFormBuilder::createDom(widget, ui_parentWidget, recursive: false);
1318	QVector<DomWidget *> ui_widget_list;
1319	if (QDesignerContainerExtension *container = qt_extension<QDesignerContainerExtension*>(manager: core()->extensionManager(), object: widget)) {
1320	for (int i=0; i<container->count(); ++i) {
1321	QWidget *page = container->widget(index: i);
1322	Q_ASSERT(page);
1323	if (DomWidget *ui_page = createDom(widget: page, ui_parentWidget: ui_widget)) {
1324	ui_widget_list.append(t: ui_page);
1325	} else {
1326	designerWarning(message: msgUnmanagedPage(core: core(), container: widget, index: i, page));
1327	}
1328	}
1329	}
1330
1331	ui_widget->setElementWidget(ui_widget_list);
1332
1333	return ui_widget;
1334	}
1335
1336	DomWidget *QDesignerResource::saveWidget(QToolBar *toolBar, DomWidget *ui_parentWidget)
1337	{
1338	DomWidget *ui_widget = QAbstractFormBuilder::createDom(widget: toolBar, ui_parentWidget, recursive: false);
1339	if (const QMainWindow *mainWindow = qobject_cast<QMainWindow*>(object: toolBar->parentWidget())) {
1340	const bool toolBarBreak = mainWindow->toolBarBreak(toolbar: toolBar);
1341	const Qt::ToolBarArea area = mainWindow->toolBarArea(toolbar: toolBar);
1342
1343	auto attributes = ui_widget->elementAttribute();
1344
1345	DomProperty *attr = new DomProperty();
1346	attr->setAttributeName(QStringLiteral("toolBarArea"));
1347	attr->setElementEnum(QLatin1String(toolBarAreaMetaEnum().valueToKey(value: area)));
1348	attributes << attr;
1349
1350	attr = new DomProperty();
1351	attr->setAttributeName(QStringLiteral("toolBarBreak"));
1352	attr->setElementBool(toolBarBreak ? QLatin1String("true") : QLatin1String("false"));
1353	attributes << attr;
1354	ui_widget->setElementAttribute(attributes);
1355	}
1356
1357	return ui_widget;
1358	}
1359
1360	DomWidget *QDesignerResource::saveWidget(QDesignerDockWidget *dockWidget, DomWidget *ui_parentWidget)
1361	{
1362	DomWidget *ui_widget = QAbstractFormBuilder::createDom(widget: dockWidget, ui_parentWidget, recursive: true);
1363	if (QMainWindow *mainWindow = qobject_cast<QMainWindow*>(object: dockWidget->parentWidget())) {
1364	const Qt::DockWidgetArea area = mainWindow->dockWidgetArea(dockwidget: dockWidget);
1365	DomProperty *attr = new DomProperty();
1366	attr->setAttributeName(QStringLiteral("dockWidgetArea"));
1367	attr->setElementNumber(int(area));
1368	ui_widget->setElementAttribute(ui_widget->elementAttribute() << attr);
1369	}
1370
1371	return ui_widget;
1372	}
1373
1374	DomWidget *QDesignerResource::saveWidget(QTabWidget *widget, DomWidget *ui_parentWidget)
1375	{
1376	DomWidget *ui_widget = QAbstractFormBuilder::createDom(widget, ui_parentWidget, recursive: false);
1377	QVector<DomWidget *> ui_widget_list;
1378
1379	if (QDesignerContainerExtension *container = qt_extension<QDesignerContainerExtension*>(manager: core()->extensionManager(), object: widget)) {
1380	const int current = widget->currentIndex();
1381	for (int i=0; i<container->count(); ++i) {
1382	QWidget *page = container->widget(index: i);
1383	Q_ASSERT(page);
1384
1385	DomWidget *ui_page = createDom(widget: page, ui_parentWidget: ui_widget);
1386	if (!ui_page) {
1387	designerWarning(message: msgUnmanagedPage(core: core(), container: widget, index: i, page));
1388	continue;
1389	}
1390	QList<DomProperty*> ui_attribute_list;
1391
1392	const QFormBuilderStrings &strings = QFormBuilderStrings::instance();
1393	// attribute `icon'
1394	widget->setCurrentIndex(i);
1395	QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(manager: core()->extensionManager(), object: widget);
1396	PropertySheetIconValue icon = qvariant_cast<PropertySheetIconValue>(v: sheet->property(index: sheet->indexOf(QStringLiteral("currentTabIcon"))));
1397	DomProperty *p = resourceBuilder()->saveResource(workingDirectory: workingDirectory(), value: QVariant::fromValue(value: icon));
1398	if (p) {
1399	p->setAttributeName(strings.iconAttribute);
1400	ui_attribute_list.append(t: p);
1401	}
1402	// attribute `title'
1403	p = textBuilder()->saveText(value: sheet->property(index: sheet->indexOf(QStringLiteral("currentTabText"))));
1404	if (p) {
1405	p->setAttributeName(strings.titleAttribute);
1406	ui_attribute_list.append(t: p);
1407	}
1408
1409	// attribute `toolTip'
1410	QVariant v = sheet->property(index: sheet->indexOf(QStringLiteral("currentTabToolTip")));
1411	if (!qvariant_cast<PropertySheetStringValue>(v).value().isEmpty()) {
1412	p = textBuilder()->saveText(value: v);
1413	if (p) {
1414	p->setAttributeName(strings.toolTipAttribute);
1415	ui_attribute_list.append(t: p);
1416	}
1417	}
1418
1419	// attribute `whatsThis'
1420	v = sheet->property(index: sheet->indexOf(QStringLiteral("currentTabWhatsThis")));
1421	if (!qvariant_cast<PropertySheetStringValue>(v).value().isEmpty()) {
1422	p = textBuilder()->saveText(value: v);
1423	if (p) {
1424	p->setAttributeName(strings.whatsThisAttribute);
1425	ui_attribute_list.append(t: p);
1426	}
1427	}
1428
1429	ui_page->setElementAttribute(ui_attribute_list);
1430
1431	ui_widget_list.append(t: ui_page);
1432	}
1433	widget->setCurrentIndex(current);
1434	}
1435
1436	ui_widget->setElementWidget(ui_widget_list);
1437
1438	return ui_widget;
1439	}
1440
1441	DomWidget *QDesignerResource::saveWidget(QToolBox *widget, DomWidget *ui_parentWidget)
1442	{
1443	DomWidget *ui_widget = QAbstractFormBuilder::createDom(widget, ui_parentWidget, recursive: false);
1444	QVector<DomWidget *> ui_widget_list;
1445
1446	if (QDesignerContainerExtension *container = qt_extension<QDesignerContainerExtension*>(manager: core()->extensionManager(), object: widget)) {
1447	const int current = widget->currentIndex();
1448	for (int i=0; i<container->count(); ++i) {
1449	QWidget *page = container->widget(index: i);
1450	Q_ASSERT(page);
1451
1452	DomWidget *ui_page = createDom(widget: page, ui_parentWidget: ui_widget);
1453	if (!ui_page) {
1454	designerWarning(message: msgUnmanagedPage(core: core(), container: widget, index: i, page));
1455	continue;
1456	}
1457
1458	// attribute `label'
1459	QList<DomProperty*> ui_attribute_list;
1460
1461	const QFormBuilderStrings &strings = QFormBuilderStrings::instance();
1462
1463	// attribute `icon'
1464	widget->setCurrentIndex(i);
1465	QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(manager: core()->extensionManager(), object: widget);
1466	PropertySheetIconValue icon = qvariant_cast<PropertySheetIconValue>(v: sheet->property(index: sheet->indexOf(QStringLiteral("currentItemIcon"))));
1467	DomProperty *p = resourceBuilder()->saveResource(workingDirectory: workingDirectory(), value: QVariant::fromValue(value: icon));
1468	if (p) {
1469	p->setAttributeName(strings.iconAttribute);
1470	ui_attribute_list.append(t: p);
1471	}
1472	p = textBuilder()->saveText(value: sheet->property(index: sheet->indexOf(QStringLiteral("currentItemText"))));
1473	if (p) {
1474	p->setAttributeName(strings.labelAttribute);
1475	ui_attribute_list.append(t: p);
1476	}
1477
1478	// attribute `toolTip'
1479	QVariant v = sheet->property(index: sheet->indexOf(QStringLiteral("currentItemToolTip")));
1480	if (!qvariant_cast<PropertySheetStringValue>(v).value().isEmpty()) {
1481	p = textBuilder()->saveText(value: v);
1482	if (p) {
1483	p->setAttributeName(strings.toolTipAttribute);
1484	ui_attribute_list.append(t: p);
1485	}
1486	}
1487
1488	ui_page->setElementAttribute(ui_attribute_list);
1489
1490	ui_widget_list.append(t: ui_page);
1491	}
1492	widget->setCurrentIndex(current);
1493	}
1494
1495	ui_widget->setElementWidget(ui_widget_list);
1496
1497	return ui_widget;
1498	}
1499
1500	DomWidget *QDesignerResource::saveWidget(QWizardPage *wizardPage, DomWidget *ui_parentWidget)
1501	{
1502	DomWidget *ui_widget = QAbstractFormBuilder::createDom(widget: wizardPage, ui_parentWidget, recursive: true);
1503	QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(manager: core()->extensionManager(), object: wizardPage);
1504	// Save the page id (string) attribute, append to existing attributes
1505	const QString pageIdPropertyName = QLatin1String(QWizardPagePropertySheet::pageIdProperty);
1506	const int pageIdIndex = sheet->indexOf(name: pageIdPropertyName);
1507	if (pageIdIndex != -1 && sheet->isChanged(index: pageIdIndex)) {
1508	DomProperty *property = variantToDomProperty(abstractFormBuilder: this, meta: wizardPage->metaObject(), propertyName: pageIdPropertyName, value: sheet->property(index: pageIdIndex));
1509	Q_ASSERT(property);
1510	property->elementString()->setAttributeNotr(QStringLiteral("true"));
1511	DomPropertyList attributes = ui_widget->elementAttribute();
1512	attributes.push_back(t: property);
1513	ui_widget->setElementAttribute(attributes);
1514	}
1515	return ui_widget;
1516	}
1517
1518	// Do not save the 'currentTabName' properties of containers
1519	static inline bool checkContainerProperty(const QWidget *w, const QString &propertyName)
1520	{
1521	if (qobject_cast<const QToolBox *>(object: w))
1522	return QToolBoxWidgetPropertySheet::checkProperty(propertyName);
1523	if (qobject_cast<const QTabWidget *>(object: w))
1524	return QTabWidgetPropertySheet::checkProperty(propertyName);
1525	if (qobject_cast<const QStackedWidget *>(object: w))
1526	return QStackedWidgetPropertySheet::checkProperty(propertyName);
1527	if (qobject_cast<const QMdiArea *>(object: w))
1528	return QMdiAreaPropertySheet::checkProperty(propertyName);
1529	return true;
1530	}
1531
1532	bool QDesignerResource::checkProperty(QObject *obj, const QString &prop) const
1533	{
1534	const QDesignerMetaObjectInterface *meta = core()->introspection()->metaObject(object: obj);
1535
1536	const int pindex = meta->indexOfProperty(name: prop);
1537	if (pindex != -1 && !(meta->property(index: pindex)->attributes(object: obj) & QDesignerMetaPropertyInterface::StoredAttribute))
1538	return false;
1539
1540	if (prop == QStringLiteral("objectName") || prop == QStringLiteral("spacerName")) // ### don't store the property objectName
1541	return false;
1542
1543	QWidget *check_widget = nullptr;
1544	if (obj->isWidgetType())
1545	check_widget = static_cast<QWidget*>(obj);
1546
1547	if (check_widget && prop == QStringLiteral("geometry")) {
1548	if (check_widget == m_formWindow->mainContainer())
1549	return true; // Save although maincontainer is technically laid-out by embedding container
1550	if (m_selected && m_selected == check_widget)
1551	return true;
1552
1553	return !LayoutInfo::isWidgetLaidout(core: core(), widget: check_widget);
1554	}
1555
1556	if (check_widget && !checkContainerProperty(w: check_widget, propertyName: prop))
1557	return false;
1558
1559	if (QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(manager: core()->extensionManager(), object: obj)) {
1560	QDesignerDynamicPropertySheetExtension *dynamicSheet = qt_extension<QDesignerDynamicPropertySheetExtension*>(manager: core()->extensionManager(), object: obj);
1561	const int pindex = sheet->indexOf(name: prop);
1562	if (sheet->isAttribute(index: pindex))
1563	return false;
1564
1565	if (!dynamicSheet || !dynamicSheet->isDynamicProperty(index: pindex))
1566	return sheet->isChanged(index: pindex);
1567	if (!sheet->isVisible(index: pindex))
1568	return false;
1569	return true;
1570	}
1571
1572	return false;
1573	}
1574
1575	bool QDesignerResource::addItem(DomLayoutItem *ui_item, QLayoutItem *item, QLayout *layout)
1576	{
1577	if (item->widget() == nullptr) {
1578	return false;
1579	}
1580
1581	QGridLayout *grid = qobject_cast<QGridLayout*>(object: layout);
1582	QBoxLayout *box = qobject_cast<QBoxLayout*>(object: layout);
1583
1584	if (grid != nullptr) {
1585	const int rowSpan = ui_item->hasAttributeRowSpan() ? ui_item->attributeRowSpan() : 1;
1586	const int colSpan = ui_item->hasAttributeColSpan() ? ui_item->attributeColSpan() : 1;
1587	grid->addWidget(item->widget(), row: ui_item->attributeRow(), column: ui_item->attributeColumn(), rowSpan, columnSpan: colSpan, item->alignment());
1588	return true;
1589	}
1590	if (box != nullptr) {
1591	box->addItem(item);
1592	return true;
1593	}
1594
1595	return QAbstractFormBuilder::addItem(ui_item, item, layout);
1596	}
1597
1598	bool QDesignerResource::addItem(DomWidget *ui_widget, QWidget *widget, QWidget *parentWidget)
1599	{
1600	core()->metaDataBase()->add(object: widget); // ensure the widget is in the meta database
1601
1602	if (! QAbstractFormBuilder::addItem(ui_widget, widget, parentWidget) || qobject_cast<QMainWindow*> (object: parentWidget)) {
1603	if (QDesignerContainerExtension *container = qt_extension<QDesignerContainerExtension*>(manager: core()->extensionManager(), object: parentWidget))
1604	container->addWidget(widget);
1605	}
1606
1607	if (QTabWidget *tabWidget = qobject_cast<QTabWidget*>(object: parentWidget)) {
1608	const int tabIndex = tabWidget->count() - 1;
1609	const int current = tabWidget->currentIndex();
1610
1611	tabWidget->setCurrentIndex(tabIndex);
1612
1613	const QFormBuilderStrings &strings = QFormBuilderStrings::instance();
1614
1615	const DomPropertyHash attributes = propertyMap(properties: ui_widget->elementAttribute());
1616	QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(manager: core()->extensionManager(), object: parentWidget);
1617	if (DomProperty *picon = attributes.value(akey: strings.iconAttribute)) {
1618	QVariant v = resourceBuilder()->loadResource(workingDirectory: workingDirectory(), property: picon);
1619	sheet->setProperty(index: sheet->indexOf(QStringLiteral("currentTabIcon")), value: v);
1620	}
1621	if (DomProperty *ptext = attributes.value(akey: strings.titleAttribute)) {
1622	QVariant v = textBuilder()->loadText(property: ptext);
1623	sheet->setProperty(index: sheet->indexOf(QStringLiteral("currentTabText")), value: v);
1624	}
1625	if (DomProperty *ptext = attributes.value(akey: strings.toolTipAttribute)) {
1626	QVariant v = textBuilder()->loadText(property: ptext);
1627	sheet->setProperty(index: sheet->indexOf(QStringLiteral("currentTabToolTip")), value: v);
1628	}
1629	if (DomProperty *ptext = attributes.value(akey: strings.whatsThisAttribute)) {
1630	QVariant v = textBuilder()->loadText(property: ptext);
1631	sheet->setProperty(index: sheet->indexOf(QStringLiteral("currentTabWhatsThis")), value: v);
1632	}
1633	tabWidget->setCurrentIndex(current);
1634	} else if (QToolBox *toolBox = qobject_cast<QToolBox*>(object: parentWidget)) {
1635	const int itemIndex = toolBox->count() - 1;
1636	const int current = toolBox->currentIndex();
1637
1638	toolBox->setCurrentIndex(itemIndex);
1639
1640	const QFormBuilderStrings &strings = QFormBuilderStrings::instance();
1641
1642	const DomPropertyHash attributes = propertyMap(properties: ui_widget->elementAttribute());
1643	QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(manager: core()->extensionManager(), object: parentWidget);
1644	if (DomProperty *picon = attributes.value(akey: strings.iconAttribute)) {
1645	QVariant v = resourceBuilder()->loadResource(workingDirectory: workingDirectory(), property: picon);
1646	sheet->setProperty(index: sheet->indexOf(QStringLiteral("currentItemIcon")), value: v);
1647	}
1648	if (DomProperty *ptext = attributes.value(akey: strings.labelAttribute)) {
1649	QVariant v = textBuilder()->loadText(property: ptext);
1650	sheet->setProperty(index: sheet->indexOf(QStringLiteral("currentItemText")), value: v);
1651	}
1652	if (DomProperty *ptext = attributes.value(akey: strings.toolTipAttribute)) {
1653	QVariant v = textBuilder()->loadText(property: ptext);
1654	sheet->setProperty(index: sheet->indexOf(QStringLiteral("currentItemToolTip")), value: v);
1655	}
1656	toolBox->setCurrentIndex(current);
1657	}
1658
1659	return true;
1660	}
1661
1662	bool QDesignerResource::copy(QIODevice *dev, const FormBuilderClipboard &selection)
1663	{
1664	m_copyWidget = true;
1665
1666	DomUI *ui = copy(selection);
1667
1668	d->m_laidout.clear();
1669	m_copyWidget = false;
1670
1671	if (!ui)
1672	return false;
1673
1674	QXmlStreamWriter writer(dev);
1675	writer.setAutoFormatting(true);
1676	writer.setAutoFormattingIndent(1);
1677	writer.writeStartDocument();
1678	ui->write(writer);
1679	writer.writeEndDocument();
1680	delete ui;
1681	return true;
1682	}
1683
1684	DomUI *QDesignerResource::copy(const FormBuilderClipboard &selection)
1685	{
1686	if (selection.empty())
1687	return nullptr;
1688
1689	m_copyWidget = true;
1690
1691	DomWidget *ui_widget = new DomWidget();
1692	ui_widget->setAttributeName(QLatin1String(clipboardObjectName));
1693	bool hasItems = false;
1694	// Widgets
1695	if (!selection.m_widgets.isEmpty()) {
1696	QVector<DomWidget *> ui_widget_list;
1697	const int size = selection.m_widgets.size();
1698	for (int i=0; i< size; ++i) {
1699	QWidget *w = selection.m_widgets.at(i);
1700	m_selected = w;
1701	DomWidget *ui_child = createDom(widget: w, ui_parentWidget: ui_widget);
1702	m_selected = nullptr;
1703	if (ui_child)
1704	ui_widget_list.append(t: ui_child);
1705	}
1706	if (!ui_widget_list.isEmpty()) {
1707	ui_widget->setElementWidget(ui_widget_list);
1708	hasItems = true;
1709	}
1710	}
1711	// actions
1712	if (!selection.m_actions.isEmpty()) {
1713	QVector<DomAction *> domActions;
1714	for (QAction* action : qAsConst(t: selection.m_actions)) {
1715	if (DomAction *domAction = createDom(action))
1716	domActions += domAction;
1717	}
1718	if (!domActions.isEmpty()) {
1719	ui_widget-> setElementAction(domActions);
1720	hasItems = true;
1721	}
1722	}
1723
1724	d->m_laidout.clear();
1725	m_copyWidget = false;
1726
1727	if (!hasItems) {
1728	delete ui_widget;
1729	return nullptr;
1730	}
1731	// UI
1732	DomUI *ui = new DomUI();
1733	ui->setAttributeVersion(QLatin1String(currentUiVersion));
1734	ui->setElementWidget(ui_widget);
1735	ui->setElementResources(saveResources(qrcPaths: m_resourceBuilder->usedQrcFiles()));
1736	if (DomCustomWidgets *cws = saveCustomWidgets())
1737	ui->setElementCustomWidgets(cws);
1738	return ui;
1739	}
1740
1741	FormBuilderClipboard QDesignerResource::paste(DomUI *ui, QWidget *widgetParent, QObject *actionParent)
1742	{
1743	QDesignerWidgetItemInstaller wii; // Make sure we use QDesignerWidgetItem.
1744	const int saved = m_isMainWidget;
1745	m_isMainWidget = false;
1746
1747	FormBuilderClipboard rc;
1748
1749	// Widgets
1750	const DomWidget *topLevel = ui->elementWidget();
1751	initialize(ui);
1752	const auto &domWidgets = topLevel->elementWidget();
1753	if (!domWidgets.isEmpty()) {
1754	const QPoint offset = m_formWindow->grid();
1755	for (DomWidget* domWidget : domWidgets) {
1756	if (QWidget *w = create(ui_widget: domWidget, parentWidget: widgetParent)) {
1757	w->move(w->pos() + offset);
1758	// ### change the init properties of w
1759	rc.m_widgets.append(t: w);
1760	}
1761	}
1762	}
1763	const auto domActions = topLevel->elementAction();
1764	for (DomAction *domAction : domActions) {
1765	if (QAction *a = create(ui_action: domAction, parent: actionParent))
1766	rc.m_actions .append(t: a);
1767	}
1768
1769	m_isMainWidget = saved;
1770
1771	if (QDesignerExtraInfoExtension *extra = qt_extension<QDesignerExtraInfoExtension*>(manager: core()->extensionManager(), object: core()))
1772	extra->loadUiExtraInfo(ui);
1773
1774	createResources(ui->elementResources());
1775
1776	return rc;
1777	}
1778
1779	FormBuilderClipboard QDesignerResource::paste(QIODevice *dev, QWidget *widgetParent, QObject *actionParent)
1780	{
1781	DomUI ui;
1782	QXmlStreamReader reader(dev);
1783	bool uiInitialized = false;
1784
1785	const QString uiElement = QStringLiteral("ui");
1786	while (!reader.atEnd()) {
1787	if (reader.readNext() == QXmlStreamReader::StartElement) {
1788	if (reader.name().compare(s: uiElement, cs: Qt::CaseInsensitive)) {
1789	ui.read(reader);
1790	uiInitialized = true;
1791	} else {
1792	//: Parsing clipboard contents
1793	reader.raiseError(message: QCoreApplication::translate(context: "QDesignerResource", key: "Unexpected element <%1>").arg(a: reader.name().toString()));
1794	}
1795	}
1796	}
1797	if (reader.hasError()) {
1798	//: Parsing clipboard contents
1799	designerWarning(message: QCoreApplication::translate(context: "QDesignerResource", key: "Error while pasting clipboard contents at line %1, column %2: %3")
1800	.arg(a: reader.lineNumber()).arg(a: reader.columnNumber())
1801	.arg(a: reader.errorString()));
1802	uiInitialized = false;
1803	} else if (!uiInitialized) {
1804	//: Parsing clipboard contents
1805	designerWarning(message: QCoreApplication::translate(context: "QDesignerResource", key: "Error while pasting clipboard contents: The root element <ui> is missing."));
1806	}
1807
1808	if (!uiInitialized)
1809	return FormBuilderClipboard();
1810
1811	FormBuilderClipboard clipBoard = paste(ui: &ui, widgetParent, actionParent);
1812
1813	return clipBoard;
1814	}
1815
1816	void QDesignerResource::layoutInfo(DomLayout *layout, QObject *parent, int *margin, int *spacing)
1817	{
1818	QAbstractFormBuilder::layoutInfo(layout, parent, margin, spacing);
1819	}
1820
1821	DomCustomWidgets *QDesignerResource::saveCustomWidgets()
1822	{
1823	if (m_usedCustomWidgets.isEmpty())
1824	return nullptr;
1825
1826	// We would like the list to be in order of the widget database indexes
1827	// to ensure that base classes come first (nice optics)
1828	QDesignerFormEditorInterface *core = m_formWindow->core();
1829	QDesignerWidgetDataBaseInterface *db = core->widgetDataBase();
1830	const bool isInternalWidgetDataBase = qobject_cast<const WidgetDataBase *>(object: db);
1831	typedef QMap<int,DomCustomWidget*> OrderedDBIndexDomCustomWidgetMap;
1832	OrderedDBIndexDomCustomWidgetMap orderedMap;
1833
1834	const QString global = QStringLiteral("global");
1835
1836	for (auto it = m_usedCustomWidgets.cbegin(), end = m_usedCustomWidgets.cend(); it != end; ++it) {
1837	QDesignerWidgetDataBaseItemInterface *item = it.key();
1838	const QString name = item->name();
1839	DomCustomWidget *custom_widget = new DomCustomWidget;
1840
1841	custom_widget->setElementClass(name);
1842	if (item->isContainer())
1843	custom_widget->setElementContainer(item->isContainer());
1844
1845	if (!item->includeFile().isEmpty()) {
1846	DomHeader *header = new DomHeader;
1847	const IncludeSpecification spec = includeSpecification(includeFile: item->includeFile());
1848	header->setText(spec.first);
1849	if (spec.second == IncludeGlobal) {
1850	header->setAttributeLocation(global);
1851	}
1852	custom_widget->setElementHeader(header);
1853	custom_widget->setElementExtends(item->extends());
1854	}
1855
1856	if (isInternalWidgetDataBase) {
1857	WidgetDataBaseItem *internalItem = static_cast<WidgetDataBaseItem *>(item);
1858	const QStringList fakeSlots = internalItem->fakeSlots();
1859	const QStringList fakeSignals = internalItem->fakeSignals();
1860	if (!fakeSlots.isEmpty() || !fakeSignals.isEmpty()) {
1861	DomSlots *domSlots = new DomSlots();
1862	domSlots->setElementSlot(fakeSlots);
1863	domSlots->setElementSignal(fakeSignals);
1864	custom_widget->setElementSlots(domSlots);
1865	}
1866	const QString addPageMethod = internalItem->addPageMethod();
1867	if (!addPageMethod.isEmpty())
1868	custom_widget->setElementAddPageMethod(addPageMethod);
1869	}
1870
1871	orderedMap.insert(akey: db->indexOfClassName(className: name), avalue: custom_widget);
1872	}
1873
1874	DomCustomWidgets *customWidgets = new DomCustomWidgets;
1875	customWidgets->setElementCustomWidget(orderedMap.values().toVector());
1876	return customWidgets;
1877	}
1878
1879	bool QDesignerResource::canCompressSpacings(QObject *object) const
1880	{
1881	if (QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(manager: core()->extensionManager(), object)) {
1882	if (qobject_cast<QGridLayout *>(object)) {
1883	const int h = sheet->property(index: sheet->indexOf(QStringLiteral("horizontalSpacing"))).toInt();
1884	const int v = sheet->property(index: sheet->indexOf(QStringLiteral("verticalSpacing"))).toInt();
1885	if (h == v)
1886	return true;
1887	}
1888	}
1889	return false;
1890	}
1891
1892	QList<DomProperty*> QDesignerResource::computeProperties(QObject *object)
1893	{
1894	QList<DomProperty*> properties;
1895	if (QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(manager: core()->extensionManager(), object)) {
1896	QDesignerDynamicPropertySheetExtension *dynamicSheet = qt_extension<QDesignerDynamicPropertySheetExtension*>(manager: core()->extensionManager(), object);
1897	const int count = sheet->count();
1898	QList<DomProperty *> spacingProperties;
1899	const bool compressSpacings = canCompressSpacings(object);
1900	for (int index = 0; index < count; ++index) {
1901	if (!sheet->isChanged(index) && (!dynamicSheet || !dynamicSheet->isDynamicProperty(index)))
1902	continue;
1903
1904	const QString propertyName = sheet->propertyName(index);
1905	// Suppress windowModality in legacy forms that have it set on child widgets
1906	if (propertyName == QStringLiteral("windowModality") && !sheet->isVisible(index))
1907	continue;
1908
1909	const QVariant value = sheet->property(index);
1910	if (DomProperty *p = createProperty(object, propertyName, value)) {
1911	if (compressSpacings && (propertyName == QStringLiteral("horizontalSpacing")
1912	|| propertyName == QStringLiteral("verticalSpacing"))) {
1913	spacingProperties.append(t: p);
1914	} else {
1915	properties.append(t: p);
1916	}
1917	}
1918	}
1919	if (compressSpacings) {
1920	if (spacingProperties.count() == 2) {
1921	DomProperty *spacingProperty = spacingProperties.at(i: 0);
1922	spacingProperty->setAttributeName(QStringLiteral("spacing"));
1923	properties.append(t: spacingProperty);
1924	delete spacingProperties.at(i: 1);
1925	} else {
1926	properties += spacingProperties;
1927	}
1928	}
1929	}
1930	return properties;
1931	}
1932
1933	DomProperty *QDesignerResource::applyProperStdSetAttribute(QObject *object, const QString &propertyName, DomProperty *property)
1934	{
1935	if (!property)
1936	return nullptr;
1937
1938	QExtensionManager *mgr = core()->extensionManager();
1939	if (const QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(manager: mgr, object)) {
1940	const QDesignerDynamicPropertySheetExtension *dynamicSheet = qt_extension<QDesignerDynamicPropertySheetExtension*>(manager: mgr, object);
1941	const QDesignerPropertySheet *designerSheet = qobject_cast<QDesignerPropertySheet*>(object: core()->extensionManager()->extension(object, Q_TYPEID(QDesignerPropertySheetExtension)));
1942	const int index = sheet->indexOf(name: propertyName);
1943	if ((dynamicSheet && dynamicSheet->isDynamicProperty(index)) || (designerSheet && designerSheet->isDefaultDynamicProperty(index)))
1944	property->setAttributeStdset(0);
1945	}
1946	return property;
1947	}
1948
1949	// Optimistic check for a standard setter function
1950	static inline bool hasSetter(QDesignerFormEditorInterface *core, QObject *object, const QString &propertyName)
1951	{
1952	const QDesignerMetaObjectInterface *meta = core->introspection()->metaObject(object);
1953	const int pindex = meta->indexOfProperty(name: propertyName);
1954	if (pindex == -1)
1955	return true;
1956	return meta->property(index: pindex)->hasSetter();
1957	}
1958
1959	DomProperty *QDesignerResource::createProperty(QObject *object, const QString &propertyName, const QVariant &value)
1960	{
1961	if (!checkProperty(obj: object, prop: propertyName)) {
1962	return nullptr;
1963	}
1964
1965	if (value.canConvert<PropertySheetFlagValue>()) {
1966	const PropertySheetFlagValue f = qvariant_cast<PropertySheetFlagValue>(v: value);
1967	const QString flagString = f.metaFlags.toString(value: f.value, sm: DesignerMetaFlags::FullyQualified);
1968	if (flagString.isEmpty())
1969	return nullptr;
1970
1971	DomProperty *p = new DomProperty;
1972	// check if we have a standard cpp set function
1973	if (!hasSetter(core: core(), object, propertyName))
1974	p->setAttributeStdset(0);
1975	p->setAttributeName(propertyName);
1976	p->setElementSet(flagString);
1977	return applyProperStdSetAttribute(object, propertyName, property: p);
1978	}
1979	if (value.canConvert<PropertySheetEnumValue>()) {
1980	const PropertySheetEnumValue e = qvariant_cast<PropertySheetEnumValue>(v: value);
1981	bool ok;
1982	const QString id = e.metaEnum.toString(value: e.value, sm: DesignerMetaEnum::FullyQualified, ok: &ok);
1983	if (!ok)
1984	designerWarning(message: e.metaEnum.messageToStringFailed(value: e.value));
1985	if (id.isEmpty())
1986	return nullptr;
1987
1988	DomProperty *p = new DomProperty;
1989	// check if we have a standard cpp set function
1990	if (!hasSetter(core: core(), object, propertyName))
1991	p->setAttributeStdset(0);
1992	p->setAttributeName(propertyName);
1993	p->setElementEnum(id);
1994	return applyProperStdSetAttribute(object, propertyName, property: p);
1995	}
1996	if (value.canConvert<PropertySheetStringValue>()) {
1997	const PropertySheetStringValue strVal = qvariant_cast<PropertySheetStringValue>(v: value);
1998	DomProperty *p = stringToDomProperty(value: strVal.value(), translatableData: strVal);
1999	if (!hasSetter(core: core(), object, propertyName))
2000	p->setAttributeStdset(0);
2001
2002	p->setAttributeName(propertyName);
2003
2004	return applyProperStdSetAttribute(object, propertyName, property: p);
2005	}
2006	if (value.canConvert<PropertySheetStringListValue>()) {
2007	const PropertySheetStringListValue listValue = qvariant_cast<PropertySheetStringListValue>(v: value);
2008	DomProperty *p = new DomProperty;
2009	if (!hasSetter(core: core(), object, propertyName))
2010	p->setAttributeStdset(0);
2011
2012	p->setAttributeName(propertyName);
2013
2014	DomStringList *domStringList = new DomStringList();
2015	domStringList->setElementString(listValue.value());
2016	translationParametersToDom(data: listValue, e: domStringList);
2017	p->setElementStringList(domStringList);
2018	return applyProperStdSetAttribute(object, propertyName, property: p);
2019	}
2020	if (value.canConvert<PropertySheetKeySequenceValue>()) {
2021	const PropertySheetKeySequenceValue keyVal = qvariant_cast<PropertySheetKeySequenceValue>(v: value);
2022	DomProperty *p = stringToDomProperty(value: keyVal.value().toString(), translatableData: keyVal);
2023	if (!hasSetter(core: core(), object, propertyName))
2024	p->setAttributeStdset(0);
2025
2026	p->setAttributeName(propertyName);
2027
2028	return applyProperStdSetAttribute(object, propertyName, property: p);
2029	}
2030
2031	return applyProperStdSetAttribute(object, propertyName, property: QAbstractFormBuilder::createProperty(object, propertyName, value));
2032	}
2033
2034	QStringList QDesignerResource::mergeWithLoadedPaths(const QStringList &paths) const
2035	{
2036	QStringList newPaths = paths;
2037	#ifdef OLD_RESOURCE_FORMAT
2038	const QStringList loadedPaths = m_resourceBuilder->loadedQrcFiles();
2039	std::remove_copy_if(first: loadedPaths.cbegin(), last: loadedPaths.cend(),
2040	result: std::back_inserter(x&: newPaths),
2041	pred: [&newPaths] (const QString &path) { return newPaths.contains(str: path); });
2042	#endif
2043	return newPaths;
2044	}
2045
2046
2047	void QDesignerResource::createResources(DomResources *resources)
2048	{
2049	QStringList paths;
2050	if (resources != nullptr) {
2051	const auto &dom_include = resources->elementInclude();
2052	for (DomResource *res : dom_include) {
2053	QString path = QDir::cleanPath(path: m_formWindow->absoluteDir().absoluteFilePath(fileName: res->attributeLocation()));
2054	while (!QFile::exists(fileName: path)) {
2055	QWidget *dialogParent = m_formWindow->core()->topLevel();
2056	const QString promptTitle = QCoreApplication::translate(context: "qdesigner_internal::QDesignerResource", key: "Loading qrc file");
2057	const QString prompt = QCoreApplication::translate(context: "qdesigner_internal::QDesignerResource", key: "The specified qrc file <p><b>%1</b></p><p>could not be found. Do you want to update the file location?</p>").arg(a: path);
2058
2059	const QMessageBox::StandardButton answer = core()->dialogGui()->message(parent: dialogParent, context: QDesignerDialogGuiInterface::ResourceLoadFailureMessage,
2060	icon: QMessageBox::Warning, title: promptTitle, text: prompt, buttons: QMessageBox::Yes|QMessageBox::No, defaultButton: QMessageBox::Yes);
2061	if (answer == QMessageBox::Yes) {
2062	const QFileInfo fi(path);
2063	const QString fileDialogTitle = QCoreApplication::translate(context: "qdesigner_internal::QDesignerResource", key: "New location for %1").arg(a: fi.fileName());
2064	const QString fileDialogPattern = QCoreApplication::translate(context: "qdesigner_internal::QDesignerResource", key: "Resource files (*.qrc)");
2065	path = core()->dialogGui()->getOpenFileName(parent: dialogParent, caption: fileDialogTitle, dir: fi.absolutePath(), filter: fileDialogPattern);
2066	if (path.isEmpty())
2067	break;
2068	m_formWindow->setProperty(name: "_q_resourcepathchanged", value: QVariant(true));
2069	} else {
2070	break;
2071	}
2072	}
2073	if (!path.isEmpty()) {
2074	paths << path;
2075	m_formWindow->addResourceFile(path);
2076	}
2077	}
2078	}
2079
2080	#ifdef OLD_RESOURCE_FORMAT
2081	paths = mergeWithLoadedPaths(paths);
2082	#endif
2083
2084	QtResourceSet *resourceSet = m_formWindow->resourceSet();
2085	if (resourceSet) {
2086	QStringList newPaths = resourceSet->activeResourceFilePaths();
2087	std::remove_copy_if(first: paths.cbegin(), last: paths.cend(),
2088	result: std::back_inserter(x&: newPaths),
2089	pred: [&newPaths] (const QString &path) { return newPaths.contains(str: path); });
2090	resourceSet->activateResourceFilePaths(paths: newPaths);
2091	} else {
2092	resourceSet = m_formWindow->core()->resourceModel()->addResourceSet(paths);
2093	m_formWindow->setResourceSet(resourceSet);
2094	QObject::connect(sender: m_formWindow->core()->resourceModel(), signal: &QtResourceModel::resourceSetActivated,
2095	receiver: m_formWindow, slot: &FormWindowBase::resourceSetActivated);
2096	}
2097	}
2098
2099	DomResources *QDesignerResource::saveResources()
2100	{
2101	QStringList paths;
2102	switch (m_formWindow->resourceFileSaveMode()) {
2103	case QDesignerFormWindowInterface::SaveAllResourceFiles:
2104	paths = m_formWindow->activeResourceFilePaths();
2105	break;
2106	case QDesignerFormWindowInterface::SaveOnlyUsedResourceFiles:
2107	paths = m_resourceBuilder->usedQrcFiles();
2108	break;
2109	case QDesignerFormWindowInterface::DontSaveResourceFiles:
2110	break;
2111	}
2112	return saveResources(qrcPaths: paths);
2113	}
2114
2115	DomResources *QDesignerResource::saveResources(const QStringList &qrcPaths)
2116	{
2117	QtResourceSet *resourceSet = m_formWindow->resourceSet();
2118	QVector<DomResource *> dom_include;
2119	if (resourceSet) {
2120	const QStringList activePaths = resourceSet->activeResourceFilePaths();
2121	for (const QString &path : activePaths) {
2122	if (qrcPaths.contains(str: path)) {
2123	DomResource *dom_res = new DomResource;
2124	QString conv_path = path;
2125	if (m_resourceBuilder->isSaveRelative())
2126	conv_path = m_formWindow->absoluteDir().relativeFilePath(fileName: path);
2127	dom_res->setAttributeLocation(conv_path.replace(before: QDir::separator(), after: QLatin1Char('/')));
2128	dom_include.append(t: dom_res);
2129	}
2130	}
2131	}
2132
2133	DomResources *dom_resources = new DomResources;
2134	dom_resources->setElementInclude(dom_include);
2135
2136	return dom_resources;
2137	}
2138
2139	DomAction *QDesignerResource::createDom(QAction *action)
2140	{
2141	if (!core()->metaDataBase()->item(object: action) || action->menu())
2142	return nullptr;
2143
2144	return QAbstractFormBuilder::createDom(action);
2145	}
2146
2147	DomActionGroup *QDesignerResource::createDom(QActionGroup *actionGroup)
2148	{
2149	if (core()->metaDataBase()->item(object: actionGroup) != nullptr) {
2150	return QAbstractFormBuilder::createDom(actionGroup);
2151	}
2152
2153	return nullptr;
2154	}
2155
2156	QAction *QDesignerResource::create(DomAction *ui_action, QObject *parent)
2157	{
2158	if (QAction *action = QAbstractFormBuilder::create(ui_action, parent)) {
2159	core()->metaDataBase()->add(object: action);
2160	return action;
2161	}
2162
2163	return nullptr;
2164	}
2165
2166	QActionGroup *QDesignerResource::create(DomActionGroup *ui_action_group, QObject *parent)
2167	{
2168	if (QActionGroup *actionGroup = QAbstractFormBuilder::create(ui_action_group, parent)) {
2169	core()->metaDataBase()->add(object: actionGroup);
2170	return actionGroup;
2171	}
2172
2173	return nullptr;
2174	}
2175
2176	DomActionRef *QDesignerResource::createActionRefDom(QAction *action)
2177	{
2178	if (!core()->metaDataBase()->item(object: action)
2179	|| (!action->isSeparator() && !action->menu() && action->objectName().isEmpty()))
2180	return nullptr;
2181
2182	return QAbstractFormBuilder::createActionRefDom(action);
2183	}
2184
2185	void QDesignerResource::addMenuAction(QAction *action)
2186	{
2187	core()->metaDataBase()->add(object: action);
2188	}
2189
2190	QAction *QDesignerResource::createAction(QObject *parent, const QString &name)
2191	{
2192	if (QAction *action = QAbstractFormBuilder::createAction(parent, name)) {
2193	core()->metaDataBase()->add(object: action);
2194	return action;
2195	}
2196
2197	return nullptr;
2198	}
2199
2200	QActionGroup *QDesignerResource::createActionGroup(QObject *parent, const QString &name)
2201	{
2202	if (QActionGroup *actionGroup = QAbstractFormBuilder::createActionGroup(parent, name)) {
2203	core()->metaDataBase()->add(object: actionGroup);
2204	return actionGroup;
2205	}
2206
2207	return nullptr;
2208	}
2209
2210	/* Apply the attributes to a widget via property sheet where appropriate,
2211	* that is, the sheet handles attributive fake properties */
2212	void QDesignerResource::applyAttributesToPropertySheet(const DomWidget *ui_widget, QWidget *widget)
2213	{
2214	const DomPropertyList attributes = ui_widget->elementAttribute();
2215	if (attributes.isEmpty())
2216	return;
2217	QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(manager: m_formWindow->core()->extensionManager(), object: widget);
2218	const DomPropertyList::const_iterator acend = attributes.constEnd();
2219	for (DomPropertyList::const_iterator it = attributes.constBegin(); it != acend; ++it) {
2220	const QString name = (*it)->attributeName();
2221	const int index = sheet->indexOf(name);
2222	if (index == -1) {
2223	const QString msg = QString::fromUtf8(str: "Unable to apply attributive property '%1' to '%2'. It does not exist.").arg(args: name, args: widget->objectName());
2224	designerWarning(message: msg);
2225	} else {
2226	sheet->setProperty(index, value: domPropertyToVariant(abstractFormBuilder: this, meta: widget->metaObject(), property: *it));
2227	sheet->setChanged(index, changed: true);
2228	}
2229	}
2230	}
2231
2232	void QDesignerResource::loadExtraInfo(DomWidget *ui_widget, QWidget *widget, QWidget *parentWidget)
2233	{
2234	QAbstractFormBuilder::loadExtraInfo(ui_widget, widget, parentWidget);
2235	// Apply the page id attribute of a QWizardPage (which is an attributive fake property)
2236	if (qobject_cast<const QWizardPage*>(object: widget))
2237	applyAttributesToPropertySheet(ui_widget, widget);
2238	}
2239
2240	}
2241
2242	QT_END_NAMESPACE
2243