diff options
Diffstat (limited to 'tools/designer/src/lib/uilib')
22 files changed, 21371 insertions, 0 deletions
diff --git a/tools/designer/src/lib/uilib/abstractformbuilder.cpp b/tools/designer/src/lib/uilib/abstractformbuilder.cpp new file mode 100644 index 0000000..4dae28e --- /dev/null +++ b/tools/designer/src/lib/uilib/abstractformbuilder.cpp @@ -0,0 +1,2920 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +**sw +****************************************************************************/ + +#include "abstractformbuilder.h" +#include "formbuilderextra_p.h" +#include "resourcebuilder_p.h" +#include "textbuilder_p.h" +#include "ui4_p.h" +#include "properties_p.h" + +#include <QtCore/QVariant> +#include <QtCore/QMetaProperty> +#include <QtCore/QFileInfo> +#include <QtCore/QDir> +#include <QtCore/QQueue> +#include <QtCore/QHash> +#include <QtCore/qdebug.h> +#include <QtCore/QCoreApplication> + +#include <QtGui/QAction> +#include <QtGui/QActionGroup> +#include <QtGui/QButtonGroup> +#include <QtGui/QComboBox> +#include <QtGui/QFontComboBox> +#include <QtGui/QGridLayout> +#ifndef QT_NO_FORMLAYOUT +# include <QtGui/QFormLayout> +#endif +#include <QtGui/QIcon> +#include <QtGui/QListWidget> +#include <QtGui/QMainWindow> +#include <QtGui/QPixmap> +#include <QtGui/QStatusBar> +#include <QtGui/QTreeWidget> +#include <QtGui/QTableWidget> +#include <QtGui/QWidget> +#include <QtGui/QSplitter> +#include <QtGui/QScrollArea> +#include <QtGui/QAbstractButton> +#include <QtGui/QAbstractItemView> +#include <QtGui/QHeaderView> +#ifndef QFORMINTERNAL_NAMESPACE +# include <private/qlayout_p.h> // Compiling within Designer +#endif + +#include <QtXml/QXmlStreamReader> + +#include <QtGui/QDialog> + +// containers +#include <QtGui/QToolBox> +#include <QtGui/QStackedWidget> +#include <QtGui/QTabWidget> +#include <QtGui/QToolBar> +#include <QtGui/QMenuBar> +#include <QtGui/QDockWidget> +#include <QtGui/QMdiArea> +#include <QtGui/QWorkspace> +#include <QtGui/QWizard> +#include <QtGui/QWizardPage> + +#include <QtCore/qdebug.h> + +#include <limits.h> + +Q_DECLARE_METATYPE(QWidgetList) + +static const char *buttonGroupPropertyC = "buttonGroup"; + +QT_BEGIN_NAMESPACE + +#ifdef QFORMINTERNAL_NAMESPACE +using namespace QFormInternal; +#endif + +class QFriendlyLayout: public QLayout +{ +public: + inline QFriendlyLayout() { Q_ASSERT(0); } + +#ifdef QFORMINTERNAL_NAMESPACE + friend class QFormInternal::QAbstractFormBuilder; +#else + friend class QAbstractFormBuilder; +#endif +}; + +/*! + \class QAbstractFormBuilder + + \brief The QAbstractFormBuilder class provides a default + implementation for classes that create user interfaces at + run-time. + + \inmodule QtDesigner + + QAbstractFormBuilder provides a standard interface and a default + implementation for constructing forms from user interface + files. It is not intended to be instantiated directly. Use the + QFormBuilder class to create user interfaces from \c{.ui} files at + run-time. For example: + + \snippet doc/src/snippets/code/tools_designer_src_lib_uilib_abstractformbuilder.cpp 0 + + To override certain aspects of the form builder's behavior, + subclass QAbstractFormBuilder and reimplement the relevant virtual + functions: + + \list + \o load() handles reading of \c{.ui} format files from arbitrary + QIODevices, and construction of widgets from the XML data + that they contain. + \o save() handles saving of widget details in \c{.ui} format to + arbitrary QIODevices. + \o workingDirectory() and setWorkingDirectory() control the + directory in which forms are held. The form builder looks for + other resources on paths relative to this directory. + \endlist + + The QFormBuilder class is typically used by custom components and + applications that embed \QD. Standalone applications that need to + dynamically generate user interfaces at run-time use the + QUiLoader, found in the QtUiTools module. + + \sa {QtUiTools Module} +*/ + +/*! + Constructs a new form builder.*/ +QAbstractFormBuilder::QAbstractFormBuilder() : + m_defaultMargin(INT_MIN), + m_defaultSpacing(INT_MIN) +{ + setResourceBuilder(new QResourceBuilder()); + setTextBuilder(new QTextBuilder()); +} + +/*! + Destroys the form builder.*/ +QAbstractFormBuilder::~QAbstractFormBuilder() +{ + QFormBuilderExtra::removeInstance(this); +} + + +/*! + \fn QWidget *QAbstractFormBuilder::load(QIODevice *device, QWidget *parent) + + Loads an XML representation of a widget from the given \a device, + and constructs a new widget with the specified \a parent. + + \sa save() +*/ +QWidget *QAbstractFormBuilder::load(QIODevice *dev, QWidget *parentWidget) +{ + QXmlStreamReader reader; + reader.setDevice(dev); + DomUI ui; + bool initialized = false; + + const QString uiElement = QLatin1String("ui"); + while (!reader.atEnd()) { + if (reader.readNext() == QXmlStreamReader::StartElement) { + if (reader.name().compare(uiElement, Qt::CaseInsensitive) == 0) { + ui.read(reader); + initialized = true; + } else { + reader.raiseError(QCoreApplication::translate("QAbstractFormBuilder", "Unexpected element <%1>").arg(reader.name().toString())); + } + } + } + if (reader.hasError()) { + uiLibWarning(QCoreApplication::translate("QAbstractFormBuilder", "An error has occurred while reading the ui file at line %1, column %2: %3") + .arg(reader.lineNumber()).arg(reader.columnNumber()) + .arg(reader.errorString())); + return 0; + } + if (!initialized) { + uiLibWarning(QCoreApplication::translate("QAbstractFormBuilder", "Invalid ui file: The root element <ui> is missing.")); + return 0; + } + + QWidget *widget = create(&ui, parentWidget); + return widget; +} + +/*! + \internal +*/ +QWidget *QAbstractFormBuilder::create(DomUI *ui, QWidget *parentWidget) +{ + typedef QFormBuilderExtra::ButtonGroupHash ButtonGroupHash; + + QFormBuilderExtra *formBuilderPrivate = QFormBuilderExtra::instance(this); + formBuilderPrivate->clear(); + if (const DomLayoutDefault *def = ui->elementLayoutDefault()) { + m_defaultMargin = def->hasAttributeMargin() ? def->attributeMargin() : INT_MIN; + m_defaultSpacing = def->hasAttributeSpacing() ? def->attributeSpacing() : INT_MIN; + } + + DomWidget *ui_widget = ui->elementWidget(); + if (!ui_widget) + return 0; + + initialize(ui); + + if (const DomButtonGroups *domButtonGroups = ui->elementButtonGroups()) + formBuilderPrivate->registerButtonGroups(domButtonGroups); + + if (QWidget *widget = create(ui_widget, parentWidget)) { + // Reparent button groups that were actually created to main container for them to be found in the signal/slot part + const ButtonGroupHash &buttonGroups = formBuilderPrivate->buttonGroups(); + if (!buttonGroups.empty()) { + const ButtonGroupHash::const_iterator cend = buttonGroups.constEnd(); + for (ButtonGroupHash::const_iterator it = buttonGroups.constBegin(); it != cend; ++it) + if (it.value().second) + it.value().second->setParent(widget); + } + createConnections(ui->elementConnections(), widget); + createResources(ui->elementResources()); // maybe this should go first, before create()... + applyTabStops(widget, ui->elementTabStops()); + formBuilderPrivate->applyInternalProperties(); + reset(); + formBuilderPrivate->clear(); + return widget; + } + formBuilderPrivate->clear(); + return 0; +} + +/*! + \internal + Retrieve relevant information from the custom widgets section. + Called by create(DomUI *, QWidget *); call manually if you + just use create(DomWidget *, QWidget *) on some child widget of DomUI. + */ + +void QAbstractFormBuilder::initialize(const DomUI *ui) +{ + typedef QList<DomCustomWidget*> DomCustomWidgetList; + + DomCustomWidgets *domCustomWidgets = ui->elementCustomWidgets(); + createCustomWidgets(domCustomWidgets); + + if (domCustomWidgets) { + const DomCustomWidgetList customWidgets = domCustomWidgets->elementCustomWidget(); + if (!customWidgets.empty()) { + QFormBuilderExtra *formBuilderPrivate = QFormBuilderExtra::instance(this); + const DomCustomWidgetList::const_iterator cend = customWidgets.constEnd(); + for (DomCustomWidgetList::const_iterator it = customWidgets.constBegin(); it != cend; ++it) { + const DomCustomWidget *cw = *it; +#ifndef QT_FORMBUILDER_NO_SCRIPT + if (const DomScript *domScript = cw->elementScript()) { + const QString script = domScript->text(); + if (!script.isEmpty()) + formBuilderPrivate->storeCustomWidgetScript(cw->elementClass(), script); + } +#endif + const QString addPageMethod = cw->elementAddPageMethod(); + if (!addPageMethod.isEmpty()) + formBuilderPrivate->storeCustomWidgetAddPageMethod(cw->elementClass(), addPageMethod); + + const QString extends = cw->elementExtends(); + if (!extends.isEmpty()) + formBuilderPrivate->storeCustomWidgetBaseClass(cw->elementClass(), extends); + } + } + } +} + +/*! + \internal +*/ +QWidget *QAbstractFormBuilder::create(DomWidget *ui_widget, QWidget *parentWidget) +{ + QWidget *w = createWidget(ui_widget->attributeClass(), parentWidget, ui_widget->attributeName()); + if (!w) + return 0; + + applyProperties(w, ui_widget->elementProperty()); + + foreach (DomAction *ui_action, ui_widget->elementAction()) { + QAction *child_action = create(ui_action, w); + Q_UNUSED( child_action ); + } + + foreach (DomActionGroup *ui_action_group, ui_widget->elementActionGroup()) { + QActionGroup *child_action_group = create(ui_action_group, w); + Q_UNUSED( child_action_group ); + } + + QWidgetList children; + foreach (DomWidget *ui_child, ui_widget->elementWidget()) { + if (QWidget *child = create(ui_child, w)) { + children += child; + } else { + const QString className = ui_child->elementClass().empty() ? QString() : ui_child->elementClass().front(); + uiLibWarning(QCoreApplication::translate("QAbstractFormBuilder", "The creation of a widget of the class '%1' failed.").arg(className)); + } + } + + foreach (DomLayout *ui_lay, ui_widget->elementLayout()) { + QLayout *child_lay = create(ui_lay, 0, w); + Q_UNUSED( child_lay ); + } + + const QList<DomActionRef *> addActions = ui_widget->elementAddAction(); + if (!addActions.empty()) { + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + foreach (DomActionRef *ui_action_ref, addActions) { + const QString name = ui_action_ref->attributeName(); + if (name == strings.separator) { + QAction *sep = new QAction(w); + sep->setSeparator(true); + w->addAction(sep); + addMenuAction(sep); + } else if (QAction *a = m_actions.value(name)) { + w->addAction(a); + } else if (QActionGroup *g = m_actionGroups.value(name)) { + w->addActions(g->actions()); + } else if (QMenu *menu = qFindChild<QMenu*>(w, name)) { + w->addAction(menu->menuAction()); + addMenuAction(menu->menuAction()); + } + } + } + + loadExtraInfo(ui_widget, w, parentWidget); +#ifndef QT_FORMBUILDER_NO_SCRIPT + QString scriptErrorMessage; + QFormBuilderExtra *extra = QFormBuilderExtra::instance(this); + extra->formScriptRunner().run(ui_widget, + extra->customWidgetScript(ui_widget->attributeClass()), + w, children, &scriptErrorMessage); +#endif + addItem(ui_widget, w, parentWidget); + + if (qobject_cast<QDialog *>(w) && parentWidget) + w->setAttribute(Qt::WA_Moved, false); // So that QDialog::setVisible(true) will center it + + const QStringList zOrderNames = ui_widget->elementZOrder(); + if (!zOrderNames.isEmpty()) { + QList<QWidget *> zOrder = qVariantValue<QWidgetList>(w->property("_q_zOrder")); + foreach (QString widgetName, zOrderNames) { + if (QWidget *child = qFindChild<QWidget*>(w, widgetName)) { + if (child->parentWidget() == w) { + zOrder.removeAll(child); + zOrder.append(child); + child->raise(); + } + } + } + w->setProperty("_q_zOrder", qVariantFromValue(zOrder)); + } + + return w; +} + +/*! + \internal +*/ +QAction *QAbstractFormBuilder::create(DomAction *ui_action, QObject *parent) +{ + QAction *a = createAction(parent, ui_action->attributeName()); + if (!a) + return 0; + + applyProperties(a, ui_action->elementProperty()); + return a; +} + +/*! + \internal +*/ +QActionGroup *QAbstractFormBuilder::create(DomActionGroup *ui_action_group, QObject *parent) +{ + QActionGroup *a = createActionGroup(parent, ui_action_group->attributeName()); + if (!a) + return 0; + + applyProperties(a, ui_action_group->elementProperty()); + + foreach (DomAction *ui_action, ui_action_group->elementAction()) { + QAction *child_action = create(ui_action, a); + Q_UNUSED( child_action ); + } + + foreach (DomActionGroup *g, ui_action_group->elementActionGroup()) { + QActionGroup *child_action_group = create(g, parent); + Q_UNUSED( child_action_group ); + } + + return a; +} + +// figure out the toolbar area of a DOM attrib list. +// By legacy, it is stored as an integer. As of 4.3.0, it is the enumeration value. +Qt::ToolBarArea QAbstractFormBuilder::toolbarAreaFromDOMAttributes(const DomPropertyHash &attributes) { + const DomProperty *attr = attributes.value(QFormBuilderStrings::instance().toolBarAreaAttribute); + if (!attr) + return Qt::TopToolBarArea; + switch(attr->kind()) { + case DomProperty::Number: + return static_cast<Qt::ToolBarArea>(attr->elementNumber()); + case DomProperty::Enum: + return enumKeyOfObjectToValue<QAbstractFormBuilderGadget, Qt::ToolBarArea>("toolBarArea", attr->elementEnum().toLatin1()); + default: + break; + } + return Qt::TopToolBarArea; +} + +/*! + \internal +*/ +bool QAbstractFormBuilder::addItem(DomWidget *ui_widget, QWidget *widget, QWidget *parentWidget) +{ + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + const DomPropertyHash attributes = propertyMap(ui_widget->elementAttribute()); + + if (parentWidget == 0) + return true; + // Check special cases. First: Custom container + const QString className = QLatin1String(parentWidget->metaObject()->className()); + const QString addPageMethod = QFormBuilderExtra::instance(this)->customWidgetAddPageMethod(className); + if (!addPageMethod.isEmpty()) { + // If this fails ( non-existent or non-slot), use ContainerExtension in Designer, else it can't be helped + return QMetaObject::invokeMethod(parentWidget, addPageMethod.toUtf8().constData(), Qt::DirectConnection, Q_ARG(QWidget*, widget)); + } + + if (QMainWindow *mw = qobject_cast<QMainWindow*>(parentWidget)) { + +#ifndef QT_NO_MENUBAR + // the menubar + if (QMenuBar *menuBar = qobject_cast<QMenuBar*>(widget)) { + mw->setMenuBar(menuBar); + return true; + } +#endif + +#ifndef QT_NO_TOOLBAR + // apply the toolbar's attributes + else if (QToolBar *toolBar = qobject_cast<QToolBar*>(widget)) { + mw->addToolBar(toolbarAreaFromDOMAttributes(attributes), toolBar); + // check break + if (const DomProperty *attr = attributes.value(strings.toolBarBreakAttribute)) + if (attr->elementBool() == strings.trueValue) + mw->insertToolBarBreak (toolBar); + + return true; + } +#endif + +#ifndef QT_NO_STATUSBAR + // statusBar + else if (QStatusBar *statusBar = qobject_cast<QStatusBar*>(widget)) { + mw->setStatusBar(statusBar); + return true; + } +#endif + +#ifndef QT_NO_DOCKWIDGET + // apply the dockwidget's attributes + else if (QDockWidget *dockWidget = qobject_cast<QDockWidget*>(widget)) { + if (const DomProperty *attr = attributes.value(strings.dockWidgetAreaAttribute)) { + Qt::DockWidgetArea area = static_cast<Qt::DockWidgetArea>(attr->elementNumber()); + if (!dockWidget->isAreaAllowed(area)) { + if (dockWidget->isAreaAllowed(Qt::LeftDockWidgetArea)) + area = Qt::LeftDockWidgetArea; + else if (dockWidget->isAreaAllowed(Qt::RightDockWidgetArea)) + area = Qt::RightDockWidgetArea; + else if (dockWidget->isAreaAllowed(Qt::TopDockWidgetArea)) + area = Qt::TopDockWidgetArea; + else if (dockWidget->isAreaAllowed(Qt::BottomDockWidgetArea)) + area = Qt::BottomDockWidgetArea; + } + mw->addDockWidget(area, dockWidget); + } else { + mw->addDockWidget(Qt::LeftDockWidgetArea, dockWidget); + } + return true; + } +#endif + + else if (! mw->centralWidget()) { + mw->setCentralWidget(widget); + return true; + } + } + +#ifndef QT_NO_TABWIDGET + else if (QTabWidget *tabWidget = qobject_cast<QTabWidget*>(parentWidget)) { + widget->setParent(0); + + const int tabIndex = tabWidget->count(); + if (const DomProperty *titleP = attributes.value(strings.titleAttribute, 0)) + tabWidget->addTab(widget, toString(titleP->elementString())); + else + tabWidget->addTab(widget, strings.defaultTitle); + + if (DomProperty *picon = attributes.value(strings.iconAttribute)) { + QVariant v = resourceBuilder()->loadResource(workingDirectory(), picon); + QVariant nativeValue = resourceBuilder()->toNativeValue(v); + tabWidget->setTabIcon(tabIndex, qvariant_cast<QIcon>(nativeValue)); + } + +#ifndef QT_NO_TOOLTIP + if (const DomProperty *ptoolTip = attributes.value(strings.toolTipAttribute)) { + tabWidget->setTabToolTip(tabIndex, toString(ptoolTip->elementString())); + } +#endif + +#ifndef QT_NO_WHATSTHIS + if (const DomProperty *pwhatsThis = attributes.value(strings.whatsThisAttribute)) { + tabWidget->setTabWhatsThis(tabIndex, toString(pwhatsThis->elementString())); + } +#endif + + return true; + } +#endif + +#ifndef QT_NO_TOOLBOX + else if (QToolBox *toolBox = qobject_cast<QToolBox*>(parentWidget)) { + const int tabIndex = toolBox->count(); + if (const DomProperty *labelP = attributes.value(strings.labelAttribute, 0)) + toolBox->addItem(widget, toString(labelP->elementString())); + else + toolBox->addItem(widget, strings.defaultTitle); + + if (DomProperty *picon = attributes.value(strings.iconAttribute)) { + QVariant v = resourceBuilder()->loadResource(workingDirectory(), picon); + QVariant nativeValue = resourceBuilder()->toNativeValue(v); + toolBox->setItemIcon(tabIndex, qvariant_cast<QIcon>(nativeValue)); + } + +#ifndef QT_NO_TOOLTIP + if (const DomProperty *ptoolTip = attributes.value(strings.toolTipAttribute)) { + toolBox->setItemToolTip(tabIndex, toString(ptoolTip->elementString())); + } +#endif + + return true; + } +#endif + +#ifndef QT_NO_STACKEDWIDGET + else if (QStackedWidget *stackedWidget = qobject_cast<QStackedWidget*>(parentWidget)) { + stackedWidget->addWidget(widget); + return true; + } +#endif + +#ifndef QT_NO_SPLITTER + else if (QSplitter *splitter = qobject_cast<QSplitter*>(parentWidget)) { + splitter->addWidget(widget); + return true; + } +#endif + +#ifndef QT_NO_MDIAREA + else if (QMdiArea *mdiArea = qobject_cast<QMdiArea*>(parentWidget)) { + mdiArea->addSubWindow(widget); + return true; + } +#endif + +#ifndef QT_NO_WORKSPACE + else if (QWorkspace *ws = qobject_cast<QWorkspace*>(parentWidget)) { + ws->addWindow(widget); + return true; + } +#endif + +#ifndef QT_NO_DOCKWIDGET + else if (QDockWidget *dockWidget = qobject_cast<QDockWidget*>(parentWidget)) { + dockWidget->setWidget(widget); + return true; + } +#endif + +#ifndef QT_NO_SCROLLAREA + else if (QScrollArea *scrollArea = qobject_cast<QScrollArea*>(parentWidget)) { + scrollArea->setWidget(widget); + return true; + } +#endif + +#ifndef QT_NO_WIZARD + else if (QWizard *wizard = qobject_cast<QWizard *>(parentWidget)) { + QWizardPage *page = qobject_cast<QWizardPage*>(widget); + if (!page) { + uiLibWarning(QCoreApplication::translate("QAbstractFormBuilder", "Attempt to add child that is not of class QWizardPage to QWizard.")); + return false; + } + wizard->addPage(page); + return true; + } +#endif + return false; +} + +/*! + \internal +*/ +void QAbstractFormBuilder::layoutInfo(DomLayout *ui_layout, QObject *parent, int *margin, int *spacing) +{ + Q_UNUSED(parent) + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + const DomPropertyHash properties = propertyMap(ui_layout->elementProperty()); + + int mar = INT_MIN; + int spac = INT_MIN; + if (const DomProperty *p = properties.value(strings.marginProperty, 0)) + mar = p->elementNumber(); + + if (const DomProperty *p = properties.value(strings.spacingProperty, 0)) + spac = p->elementNumber(); + +#ifdef Q_OS_MAC + // here we recognize ui file < 4.3 (no we don't store margin property) + if (mar != INT_MIN) { + const int defaultMargin = parent->inherits("QLayoutWidget") ? 0 : 9; + if (mar == defaultMargin) + mar = INT_MIN; + if (spac == 6) + spac = INT_MIN; + + if (mar == INT_MIN || spac == INT_MIN) { + QList<DomProperty *> properties = ui_layout->elementProperty(); + QMutableListIterator<DomProperty *> it(properties); + while (it.hasNext()) { + DomProperty *prop = it.next(); + if ((mar == INT_MIN && prop->attributeName() == strings.marginProperty) || + (spac == INT_MIN && prop->attributeName() == strings.spacingProperty)) { + it.remove(); + delete prop; + } + } + ui_layout->setElementProperty(properties); + } + } +#endif + if (margin) + *margin = mar; + if (spacing) + *spacing = spac; +} + +/*! + \internal +*/ +QLayout *QAbstractFormBuilder::create(DomLayout *ui_layout, QLayout *parentLayout, QWidget *parentWidget) +{ + QObject *p = parentLayout; + + if (p == 0) + p = parentWidget; + + Q_ASSERT(p != 0); + + bool tracking = false; + + if (p == parentWidget && parentWidget->layout()) { + tracking = true; + p = parentWidget->layout(); + } + + QLayout *layout = createLayout(ui_layout->attributeClass(), p, ui_layout->hasAttributeName() ? ui_layout->attributeName() : QString()); + + if (layout == 0) + return 0; + + if (tracking && layout->parent() == 0) { + QBoxLayout *box = qobject_cast<QBoxLayout*>(parentWidget->layout()); + if (!box) { // only QBoxLayout is supported + const QString widgetClass = QString::fromUtf8(parentWidget->metaObject()->className()); + const QString layoutClass = QString::fromUtf8(parentWidget->layout()->metaObject()->className()); + const QString msg = QCoreApplication::translate("QAbstractFormBuilder", "Attempt to add a layout to a widget '%1' (%2) which already has a layout of non-box type %3.\n" + "This indicates an inconsistency in the ui-file."). + arg(parentWidget->objectName(), widgetClass, layoutClass); + uiLibWarning(msg); + return 0; + } + box->addLayout(layout); + } + + int margin = INT_MIN, spacing = INT_MIN; + layoutInfo(ui_layout, p, &margin, &spacing); + + if (margin != INT_MIN) { + layout->setMargin(margin); + } else { + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + int left, top, right, bottom; + left = top = right = bottom = -1; + layout->getContentsMargins(&left, &top, &right, &bottom); + + const DomPropertyHash properties = propertyMap(ui_layout->elementProperty()); + + if (const DomProperty *p = properties.value(strings.leftMarginProperty, 0)) + left = p->elementNumber(); + + if (const DomProperty *p = properties.value(strings.topMarginProperty, 0)) + top = p->elementNumber(); + + if (const DomProperty *p = properties.value(strings.rightMarginProperty, 0)) + right = p->elementNumber(); + + if (const DomProperty *p = properties.value(strings.bottomMarginProperty, 0)) + bottom = p->elementNumber(); + + layout->setContentsMargins(left, top, right, bottom); + } + + if (spacing != INT_MIN) { + layout->setSpacing(spacing); + } else { + QGridLayout *grid = qobject_cast<QGridLayout *>(layout); + if (grid) { + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + const DomPropertyHash properties = propertyMap(ui_layout->elementProperty()); + + if (const DomProperty *p = properties.value(strings.horizontalSpacingProperty, 0)) + grid->setHorizontalSpacing(p->elementNumber()); + if (const DomProperty *p = properties.value(strings.verticalSpacingProperty, 0)) + grid->setVerticalSpacing(p->elementNumber()); + } + } + + applyProperties(layout, ui_layout->elementProperty()); + + foreach (DomLayoutItem *ui_item, ui_layout->elementItem()) { + if (QLayoutItem *item = create(ui_item, layout, parentWidget)) { + addItem(ui_item, item, layout); + } + } + // Check the box stretch attributes + if (QBoxLayout *box = qobject_cast<QBoxLayout*>(layout)) { + const QString boxStretch = ui_layout->attributeStretch(); + if (!boxStretch.isEmpty()) + QFormBuilderExtra::setBoxLayoutStretch(boxStretch, box); + } + // Check the grid stretch/minimum size attributes + if (QGridLayout *grid = qobject_cast<QGridLayout*>(layout)) { + // Stretch + const QString gridRowStretch = ui_layout->attributeRowStretch(); + if (!gridRowStretch.isEmpty()) + QFormBuilderExtra::setGridLayoutRowStretch(gridRowStretch, grid); + const QString gridColumnStretch = ui_layout->attributeColumnStretch(); + if (!gridColumnStretch.isEmpty()) + QFormBuilderExtra::setGridLayoutColumnStretch(gridColumnStretch, grid); + // Minimum size + const QString gridColumnMinimumWidth = ui_layout->attributeColumnMinimumWidth(); + if (!gridColumnMinimumWidth.isEmpty()) + QFormBuilderExtra::setGridLayoutColumnMinimumWidth(gridColumnMinimumWidth, grid); + const QString gridRowMinimumHeight = ui_layout->attributeRowMinimumHeight(); + if (!gridRowMinimumHeight.isEmpty()) + QFormBuilderExtra::setGridLayoutRowMinimumHeight(gridRowMinimumHeight, grid); + } + return layout; +} + +#ifndef QT_NO_FORMLAYOUT +static inline QFormLayout::ItemRole formLayoutRole(int column, int colspan) +{ + if (colspan > 1) + return QFormLayout::SpanningRole; + return column == 0 ? QFormLayout::LabelRole : QFormLayout::FieldRole; +} +#endif + +/*! + \internal +*/ +bool QAbstractFormBuilder::addItem(DomLayoutItem *ui_item, QLayoutItem *item, QLayout *layout) +{ + // Calling addChildWidget(), etc. is required to maintain consistency of the layouts, + // see documentation of addItem(), which should ideally not be used. + if (item->widget()) { + static_cast<QFriendlyLayout*>(layout)->addChildWidget(item->widget()); + } else if (item->layout()) { + static_cast<QFriendlyLayout*>(layout)->addChildLayout(item->layout()); + } else if (item->spacerItem()) { + // nothing to do + } else { + return false; + } + + if (QGridLayout *grid = qobject_cast<QGridLayout*>(layout)) { + const int rowSpan = ui_item->hasAttributeRowSpan() ? ui_item->attributeRowSpan() : 1; + const int colSpan = ui_item->hasAttributeColSpan() ? ui_item->attributeColSpan() : 1; + grid->addItem(item, ui_item->attributeRow(), ui_item->attributeColumn(), + rowSpan, colSpan, item->alignment()); + return true; + } +#ifndef QT_NO_FORMLAYOUT + if (QFormLayout *form = qobject_cast<QFormLayout *>(layout)) { + const int row = ui_item->attributeRow(); + const int colSpan = ui_item->hasAttributeColSpan() ? ui_item->attributeColSpan() : 1; + form->setItem(row, formLayoutRole(ui_item->attributeColumn(), colSpan), item); + return true; + } + +#endif + layout->addItem(item); + return true; +} + +/*! + \internal +*/ +QLayoutItem *QAbstractFormBuilder::create(DomLayoutItem *ui_layoutItem, QLayout *layout, QWidget *parentWidget) +{ + switch (ui_layoutItem->kind()) { + case DomLayoutItem::Widget: { + if (QWidget *w = create(ui_layoutItem->elementWidget(), parentWidget)) +#ifdef QFORMINTERNAL_NAMESPACE // uilib + return new QWidgetItemV2(w); +#else // Within Designer: Use factory method that returns special items that refuse to shrink to 0,0 + return QLayoutPrivate::createWidgetItem(layout, w); +#endif + qWarning() << QCoreApplication::translate("QAbstractFormBuilder", "Empty widget item in %1 '%2'.").arg(QString::fromUtf8(layout->metaObject()->className()), layout->objectName()); + return 0; + } + case DomLayoutItem::Spacer: { + QSize size(0, 0); + QSizePolicy::Policy sizeType = QSizePolicy::Expanding; + bool isVspacer = false; + + const DomSpacer *ui_spacer = ui_layoutItem->elementSpacer(); + + const QMetaEnum sizePolicy_enum = metaEnum<QAbstractFormBuilderGadget>("sizeType"); + const QMetaEnum orientation_enum = metaEnum<QAbstractFormBuilderGadget>("orientation"); + + const QList<DomProperty *> spacerProperties = ui_spacer->elementProperty(); + if (!spacerProperties.empty()) { + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + foreach (DomProperty *p, spacerProperties) { + const QVariant v = toVariant(&QAbstractFormBuilderGadget::staticMetaObject, p); // ### remove me + if (v.isNull()) + continue; + if (p->attributeName() == strings.sizeHintProperty && p->kind() == DomProperty::Size) { + size = v.toSize(); // ### remove me + } else if (p->attributeName() == strings.sizeTypeProperty && p->kind() == DomProperty::Enum) { + sizeType = static_cast<QSizePolicy::Policy>(v.toInt()); + } else if (p->attributeName() == strings.orientationProperty && p->kind() == DomProperty::Enum) { + const Qt::Orientation o = static_cast<Qt::Orientation>(v.toInt()); + isVspacer = (o == Qt::Vertical); + } + } + } + + QSpacerItem *spacer = 0; + if (isVspacer) + spacer = new QSpacerItem(size.width(), size.height(), QSizePolicy::Minimum, sizeType); + else + spacer = new QSpacerItem(size.width(), size.height(), sizeType, QSizePolicy::Minimum); + return spacer; } + + case DomLayoutItem::Layout: + return create(ui_layoutItem->elementLayout(), layout, parentWidget); + + default: + break; + } + + return 0; +} + +/*! + \internal +*/ +void QAbstractFormBuilder::applyProperties(QObject *o, const QList<DomProperty*> &properties) +{ + typedef QList<DomProperty*> DomPropertyList; + + if (properties.empty()) + return; + + QFormBuilderExtra *fb = QFormBuilderExtra::instance(this); + + const DomPropertyList::const_iterator cend = properties.constEnd(); + for (DomPropertyList::const_iterator it = properties.constBegin(); it != cend; ++it) { + const QVariant v = toVariant(o->metaObject(), *it); + if (!v.isNull()) { + const QString attributeName = (*it)->attributeName(); + if (!fb->applyPropertyInternally(o, attributeName, v)) + o->setProperty(attributeName.toUtf8(), v); + } + } +} + + +/*! + \internal + Check whether a property is applied internally by QAbstractFormBuilder. Call this + from overwritten applyProperties(). +*/ + +bool QAbstractFormBuilder::applyPropertyInternally(QObject *o, const QString &propertyName, const QVariant &value) +{ + return QFormBuilderExtra::instance(this)->applyPropertyInternally(o,propertyName, value); +} + +/*! + \internal +*/ + +QVariant QAbstractFormBuilder::toVariant(const QMetaObject *meta, DomProperty *p) +{ + return domPropertyToVariant(this, meta, p); +} + +/*! + \internal +*/ +void QAbstractFormBuilder::setupColorGroup(QPalette &palette, QPalette::ColorGroup colorGroup, + DomColorGroup *group) +{ + // old format + const QList<DomColor*> colors = group->elementColor(); + for (int role = 0; role < colors.size(); ++role) { + const DomColor *color = colors.at(role); + const QColor c(color->elementRed(), color->elementGreen(), color->elementBlue()); + palette.setColor(colorGroup, QPalette::ColorRole(role), c); + } + + // new format + const QMetaEnum colorRole_enum = metaEnum<QAbstractFormBuilderGadget>("colorRole"); + + const QList<DomColorRole*> colorRoles = group->elementColorRole(); + for (int role = 0; role < colorRoles.size(); ++role) { + const DomColorRole *colorRole = colorRoles.at(role); + + if (colorRole->hasAttributeRole()) { + const int r = colorRole_enum.keyToValue(colorRole->attributeRole().toLatin1()); + if (r != -1) { + const QBrush br = setupBrush(colorRole->elementBrush()); + palette.setBrush(colorGroup, static_cast<QPalette::ColorRole>(r), br); + } + } + } +} + +/*! + \internal +*/ +DomColorGroup *QAbstractFormBuilder::saveColorGroup(const QPalette &palette) +{ + + const QMetaEnum colorRole_enum = metaEnum<QAbstractFormBuilderGadget>("colorRole"); + + DomColorGroup *group = new DomColorGroup(); + QList<DomColorRole*> colorRoles; + + const uint mask = palette.resolve(); + for (int role = QPalette::WindowText; role < QPalette::NColorRoles; ++role) { + if (mask & (1 << role)) { + QBrush br = palette.brush(QPalette::ColorRole(role)); + + DomColorRole *colorRole = new DomColorRole(); + colorRole->setElementBrush(saveBrush(br)); + colorRole->setAttributeRole(QLatin1String(colorRole_enum.valueToKey(role))); + colorRoles.append(colorRole); + } + } + + group->setElementColorRole(colorRoles); + return group; +} + +/*! + \internal +*/ +QBrush QAbstractFormBuilder::setupBrush(DomBrush *brush) +{ + QBrush br; + if (!brush->hasAttributeBrushStyle()) + return br; + + const Qt::BrushStyle style = enumKeyOfObjectToValue<QAbstractFormBuilderGadget, Qt::BrushStyle>("brushStyle", brush->attributeBrushStyle().toLatin1()); + + if (style == Qt::LinearGradientPattern || + style == Qt::RadialGradientPattern || + style == Qt::ConicalGradientPattern) { + const QMetaEnum gradientType_enum = metaEnum<QAbstractFormBuilderGadget>("gradientType"); + const QMetaEnum gradientSpread_enum = metaEnum<QAbstractFormBuilderGadget>("gradientSpread"); + const QMetaEnum gradientCoordinate_enum = metaEnum<QAbstractFormBuilderGadget>("gradientCoordinate"); + + const DomGradient *gradient = brush->elementGradient(); + const QGradient::Type type = enumKeyToValue<QGradient::Type>(gradientType_enum, gradient->attributeType().toLatin1()); + + + QGradient *gr = 0; + + if (type == QGradient::LinearGradient) { + gr = new QLinearGradient(QPointF(gradient->attributeStartX(), gradient->attributeStartY()), + QPointF(gradient->attributeEndX(), gradient->attributeEndY())); + } else if (type == QGradient::RadialGradient) { + gr = new QRadialGradient(QPointF(gradient->attributeCentralX(), gradient->attributeCentralY()), + gradient->attributeRadius(), + QPointF(gradient->attributeFocalX(), gradient->attributeFocalY())); + } else if (type == QGradient::ConicalGradient) { + gr = new QConicalGradient(QPointF(gradient->attributeCentralX(), gradient->attributeCentralY()), + gradient->attributeAngle()); + } + if (!gr) + return br; + + const QGradient::Spread spread = enumKeyToValue<QGradient::Spread>(gradientSpread_enum, gradient->attributeSpread().toLatin1()); + gr->setSpread(spread); + + const QGradient::CoordinateMode coord = enumKeyToValue<QGradient::CoordinateMode>(gradientCoordinate_enum, gradient->attributeCoordinateMode().toLatin1()); + gr->setCoordinateMode(coord); + + const QList<DomGradientStop *> stops = gradient->elementGradientStop(); + QListIterator<DomGradientStop *> it(stops); + while (it.hasNext()) { + const DomGradientStop *stop = it.next(); + const DomColor *color = stop->elementColor(); + gr->setColorAt(stop->attributePosition(), QColor::fromRgb(color->elementRed(), + color->elementGreen(), color->elementBlue(), color->attributeAlpha())); + } + br = QBrush(*gr); + delete gr; + } else if (style == Qt::TexturePattern) { + const DomProperty *texture = brush->elementTexture(); + if (texture && texture->kind() == DomProperty::Pixmap) { + br.setTexture(domPropertyToPixmap(texture)); + } + } else { + const DomColor *color = brush->elementColor(); + br.setColor(QColor::fromRgb(color->elementRed(), + color->elementGreen(), color->elementBlue(), color->attributeAlpha())); + br.setStyle((Qt::BrushStyle)style); + } + return br; +} + +/*! + \internal +*/ +DomBrush *QAbstractFormBuilder::saveBrush(const QBrush &br) +{ + const QMetaEnum brushStyle_enum = metaEnum<QAbstractFormBuilderGadget>("brushStyle"); + + DomBrush *brush = new DomBrush(); + const Qt::BrushStyle style = br.style(); + brush->setAttributeBrushStyle(QLatin1String(brushStyle_enum.valueToKey(style))); + if (style == Qt::LinearGradientPattern || + style == Qt::RadialGradientPattern || + style == Qt::ConicalGradientPattern) { + const QMetaEnum gradientType_enum = metaEnum<QAbstractFormBuilderGadget>("gradientType"); + const QMetaEnum gradientSpread_enum = metaEnum<QAbstractFormBuilderGadget>("gradientSpread"); + const QMetaEnum gradientCoordinate_enum = metaEnum<QAbstractFormBuilderGadget>("gradientCoordinate"); + + DomGradient *gradient = new DomGradient(); + const QGradient *gr = br.gradient(); + const QGradient::Type type = gr->type(); + gradient->setAttributeType(QLatin1String(gradientType_enum.valueToKey(type))); + gradient->setAttributeSpread(QLatin1String(gradientSpread_enum.valueToKey(gr->spread()))); + gradient->setAttributeCoordinateMode(QLatin1String(gradientCoordinate_enum.valueToKey(gr->coordinateMode()))); + QList<DomGradientStop *> stops; + QGradientStops st = gr->stops(); + QVectorIterator<QPair<qreal, QColor> > it(st); + while (it.hasNext()) { + const QPair<qreal, QColor> pair = it.next(); + DomGradientStop *stop = new DomGradientStop(); + stop->setAttributePosition(pair.first); + DomColor *color = new DomColor(); + color->setElementRed(pair.second.red()); + color->setElementGreen(pair.second.green()); + color->setElementBlue(pair.second.blue()); + color->setAttributeAlpha(pair.second.alpha()); + stop->setElementColor(color); + stops.append(stop); + } + gradient->setElementGradientStop(stops); + if (type == QGradient::LinearGradient) { + QLinearGradient *lgr = (QLinearGradient *)(gr); + gradient->setAttributeStartX(lgr->start().x()); + gradient->setAttributeStartY(lgr->start().y()); + gradient->setAttributeEndX(lgr->finalStop().x()); + gradient->setAttributeEndY(lgr->finalStop().y()); + } else if (type == QGradient::RadialGradient) { + QRadialGradient *rgr = (QRadialGradient *)(gr); + gradient->setAttributeCentralX(rgr->center().x()); + gradient->setAttributeCentralY(rgr->center().y()); + gradient->setAttributeFocalX(rgr->focalPoint().x()); + gradient->setAttributeFocalY(rgr->focalPoint().y()); + gradient->setAttributeRadius(rgr->radius()); + } else if (type == QGradient::ConicalGradient) { + QConicalGradient *cgr = (QConicalGradient *)(gr); + gradient->setAttributeCentralX(cgr->center().x()); + gradient->setAttributeCentralY(cgr->center().y()); + gradient->setAttributeAngle(cgr->angle()); + } + + brush->setElementGradient(gradient); + } else if (style == Qt::TexturePattern) { + const QPixmap pixmap = br.texture(); + if (!pixmap.isNull()) { + DomProperty *p = new DomProperty; + setPixmapProperty(*p, pixmapPaths(pixmap)); + brush->setElementTexture(p); + } + } else { + QColor c = br.color(); + DomColor *color = new DomColor(); + color->setElementRed(c.red()); + color->setElementGreen(c.green()); + color->setElementBlue(c.blue()); + color->setAttributeAlpha(c.alpha()); + brush->setElementColor(color); + } + return brush; +} + +/*! + \internal +*/ +QWidget *QAbstractFormBuilder::createWidget(const QString &widgetName, QWidget *parentWidget, const QString &name) +{ + Q_UNUSED(widgetName); + Q_UNUSED(parentWidget); + Q_UNUSED(name); + return 0; +} + +/*! + \internal +*/ +QLayout *QAbstractFormBuilder::createLayout(const QString &layoutName, QObject *parent, const QString &name) +{ + Q_UNUSED(layoutName); + Q_UNUSED(parent); + Q_UNUSED(name); + return 0; +} + +/*! + \internal +*/ +QAction *QAbstractFormBuilder::createAction(QObject *parent, const QString &name) +{ + QAction *action = new QAction(parent); + action->setObjectName(name); + m_actions.insert(name, action); + + return action; +} + +/*! + \internal +*/ +QActionGroup *QAbstractFormBuilder::createActionGroup(QObject *parent, const QString &name) +{ + QActionGroup *g = new QActionGroup(parent); + g->setObjectName(name); + m_actionGroups.insert(name, g); + + return g; +} + +/*! + \fn void QAbstractFormBuilder::save(QIODevice *device, QWidget *widget) + + Saves an XML representation of the given \a widget to the + specified \a device in the standard \c{.ui} file format. + + \sa load()*/ +void QAbstractFormBuilder::save(QIODevice *dev, QWidget *widget) +{ + DomWidget *ui_widget = createDom(widget, 0); + Q_ASSERT( ui_widget != 0 ); + + DomUI *ui = new DomUI(); + ui->setAttributeVersion(QLatin1String("4.0")); + ui->setElementWidget(ui_widget); + + saveDom(ui, widget); + + QXmlStreamWriter writer(dev); + writer.setAutoFormatting(true); + writer.setAutoFormattingIndent(1); + writer.writeStartDocument(); + ui->write(writer); + writer.writeEndDocument(); + + m_laidout.clear(); + + delete ui; +} + +/*! + \internal +*/ +void QAbstractFormBuilder::saveDom(DomUI *ui, QWidget *widget) +{ + ui->setElementClass(widget->objectName()); + + if (DomConnections *ui_connections = saveConnections()) { + ui->setElementConnections(ui_connections); + } + + if (DomCustomWidgets *ui_customWidgets = saveCustomWidgets()) { + ui->setElementCustomWidgets(ui_customWidgets); + } + + if (DomTabStops *ui_tabStops = saveTabStops()) { + ui->setElementTabStops(ui_tabStops); + } + + if (DomResources *ui_resources = saveResources()) { + ui->setElementResources(ui_resources); + } + if (DomButtonGroups *ui_buttonGroups = saveButtonGroups(widget)) + ui->setElementButtonGroups(ui_buttonGroups); +} + +/*! + \internal +*/ +DomConnections *QAbstractFormBuilder::saveConnections() +{ + return new DomConnections; +} + +/*! + \internal +*/ + +DomWidget *QAbstractFormBuilder::createDom(QWidget *widget, DomWidget *ui_parentWidget, bool recursive) +{ + DomWidget *ui_widget = new DomWidget(); + ui_widget->setAttributeClass(QLatin1String(widget->metaObject()->className())); + ui_widget->setElementProperty(computeProperties(widget)); + + if (recursive) { + if (QLayout *layout = widget->layout()) { + if (DomLayout *ui_layout = createDom(layout, 0, ui_parentWidget)) { + QList<DomLayout*> ui_layouts; + ui_layouts.append(ui_layout); + + ui_widget->setElementLayout(ui_layouts); + } + } + } + + // widgets, actions and action groups + QList<DomWidget*> ui_widgets; + QList<DomAction*> ui_actions; + QList<DomActionGroup*> ui_action_groups; + + QList<QObject*> children; + + // splitters need to store their children in the order specified by child indexes, + // not the order of the child list. +#ifndef QT_NO_SPLITTER + if (const QSplitter *splitter = qobject_cast<const QSplitter*>(widget)) { + const int count = splitter->count(); + for (int i = 0; i < count; ++i) + children.append(splitter->widget(i)); + } else +#endif + { + QList<QObject *> childObjects = widget->children(); + + const QList<QWidget *> list = qVariantValue<QWidgetList>(widget->property("_q_widgetOrder")); + foreach (QWidget *w, list) { + if (childObjects.contains(w)) { + children.append(w); + childObjects.removeAll(w); + } + } + children += childObjects; + + const QList<QWidget *> zOrder = qVariantValue<QWidgetList>(widget->property("_q_zOrder")); + if (list != zOrder) { + QStringList zOrderList; + QListIterator<QWidget* > itZOrder(zOrder); + while (itZOrder.hasNext()) + zOrderList.append(itZOrder.next()->objectName()); + ui_widget->setElementZOrder(zOrderList); + } + } + + foreach (QObject *obj, children) { + if (QWidget *childWidget = qobject_cast<QWidget*>(obj)) { + if (m_laidout.contains(childWidget) || recursive == false) + continue; + + if (QMenu *menu = qobject_cast<QMenu *>(childWidget)) { + QList<QAction *> actions = menu->parentWidget()->actions(); + QListIterator<QAction *> it(actions); + bool found = false; + while (it.hasNext()) { + if (it.next()->menu() == menu) + found = true; + } + if (!found) + continue; + } + + if (DomWidget *ui_child = createDom(childWidget, ui_widget)) { + ui_widgets.append(ui_child); + } + } else if (QAction *childAction = qobject_cast<QAction*>(obj)) { + if (childAction->actionGroup() != 0) { + // it will be added later. + continue; + } + + if (DomAction *ui_action = createDom(childAction)) { + ui_actions.append(ui_action); + } + } else if (QActionGroup *childActionGroup = qobject_cast<QActionGroup*>(obj)) { + if (DomActionGroup *ui_action_group = createDom(childActionGroup)) { + ui_action_groups.append(ui_action_group); + } + } + } + + // add-action + QList<DomActionRef*> ui_action_refs; + foreach (QAction *action, widget->actions()) { + if (DomActionRef *ui_action_ref = createActionRefDom(action)) { + ui_action_refs.append(ui_action_ref); + } + } + + if (recursive) + ui_widget->setElementWidget(ui_widgets); + + ui_widget->setElementAction(ui_actions); + ui_widget->setElementActionGroup(ui_action_groups); + ui_widget->setElementAddAction(ui_action_refs); + + saveExtraInfo(widget, ui_widget, ui_parentWidget); + + return ui_widget; +} + +/*! + \internal +*/ +DomActionRef *QAbstractFormBuilder::createActionRefDom(QAction *action) +{ + QString name = action->objectName(); + + if (action->menu() != 0) + name = action->menu()->objectName(); + + DomActionRef *ui_action_ref = new DomActionRef(); + if (action->isSeparator()) + ui_action_ref->setAttributeName(QFormBuilderStrings::instance().separator); + else + ui_action_ref->setAttributeName(name); + + return ui_action_ref; +} + +/*! + \internal +*/ +DomLayout *QAbstractFormBuilder::createDom(QLayout *layout, DomLayout *ui_layout, DomWidget *ui_parentWidget) +{ + Q_UNUSED(ui_layout) + DomLayout *lay = new DomLayout(); + lay->setAttributeClass(QLatin1String(layout->metaObject()->className())); + const QString objectName = layout->objectName(); + if (!objectName.isEmpty()) + lay->setAttributeName(objectName); + lay->setElementProperty(computeProperties(layout)); + + QList<DomLayoutItem*> ui_items; + + QMap<QObject *, QLayoutItem *> objectToItem; + QList<QLayoutItem *> spacerItems; + QList<QLayoutItem *> newList; + + for (int idx=0; layout->itemAt(idx); ++idx) { + QLayoutItem *item = layout->itemAt(idx); + if (item->widget()) + objectToItem[item->widget()] = item; + else if (item->layout()) + objectToItem[item->layout()] = item; + else if (item->spacerItem()) + spacerItems.append(item); + newList.append(item); + } + + if (qobject_cast<QGridLayout *>(layout)) { + newList.clear(); + QList<QObject *> childrenList = layout->parentWidget()->children(); + foreach (QObject *o, childrenList) { + if (objectToItem.contains(o)) + newList.append(objectToItem[o]); + } + newList += spacerItems; + } + + foreach (QLayoutItem *item, newList) { + DomLayoutItem *ui_item = createDom(item, lay, ui_parentWidget); + if (ui_item) + ui_items.append(ui_item); + } + + lay->setElementItem(ui_items); + + return lay; +} + +/*! + \internal +*/ +DomLayoutItem *QAbstractFormBuilder::createDom(QLayoutItem *item, DomLayout *ui_layout, DomWidget *ui_parentWidget) +{ + DomLayoutItem *ui_item = new DomLayoutItem(); + + if (item->widget()) { + ui_item->setElementWidget(createDom(item->widget(), ui_parentWidget)); + m_laidout.insert(item->widget(), true); + } else if (item->layout()) { + ui_item->setElementLayout(createDom(item->layout(), ui_layout, ui_parentWidget)); + } else if (item->spacerItem()) { + ui_item->setElementSpacer(createDom(item->spacerItem(), ui_layout, ui_parentWidget)); + } + + return ui_item; +} + +/*! + \internal +*/ +DomSpacer *QAbstractFormBuilder::createDom(QSpacerItem *spacer, DomLayout *ui_layout, DomWidget *ui_parentWidget) +{ + Q_UNUSED(ui_layout); + Q_UNUSED(ui_parentWidget); + + DomSpacer *ui_spacer = new DomSpacer(); + QList<DomProperty*> properties; + + DomProperty *prop = 0; + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + // sizeHint property + prop = new DomProperty(); + prop->setAttributeName(strings.sizeHintProperty); + prop->setElementSize(new DomSize()); + prop->elementSize()->setElementWidth(spacer->sizeHint().width()); + prop->elementSize()->setElementHeight(spacer->sizeHint().height()); + properties.append(prop); + + // orientation property + prop = new DomProperty(); // ### we don't implemented the case where expandingDirections() is both Vertical and Horizontal + prop->setAttributeName(strings.orientationProperty); + prop->setElementEnum((spacer->expandingDirections() & Qt::Horizontal) ? strings.qtHorizontal : strings.qtVertical); + properties.append(prop); + + ui_spacer->setElementProperty(properties); + return ui_spacer; +} + +/*! + \internal +*/ +DomProperty *QAbstractFormBuilder::createProperty(QObject *obj, const QString &pname, const QVariant &v) +{ + if (!checkProperty(obj, pname)) { + return 0; + } + return variantToDomProperty(this, obj->metaObject(), pname, v); +} + +/*! + \internal +*/ +QList<DomProperty*> QAbstractFormBuilder::computeProperties(QObject *obj) +{ + QList<DomProperty*> lst; + + const QMetaObject *meta = obj->metaObject(); + + QHash<QByteArray, bool> properties; + const int propertyCount = meta->propertyCount(); + for(int i=0; i < propertyCount; ++i) + properties.insert(meta->property(i).name(), true); + + const QList<QByteArray> propertyNames = properties.keys(); + + const int propertyNamesCount = propertyNames.size(); + for(int i=0; i<propertyNamesCount ; ++i) { + const QString pname = QString::fromUtf8(propertyNames.at(i)); + const QMetaProperty prop = meta->property(meta->indexOfProperty(pname.toUtf8())); + + if (!prop.isWritable() || !checkProperty(obj, QLatin1String(prop.name()))) + continue; + + const QVariant v = prop.read(obj); + + DomProperty *dom_prop = 0; + if (v.type() == QVariant::Int) { + dom_prop = new DomProperty(); + + if (prop.isFlagType()) + uiLibWarning(QCoreApplication::translate("QAbstractFormBuilder", "Flags property are not supported yet.")); + + if (prop.isEnumType()) { + QString scope = QString::fromUtf8(prop.enumerator().scope()); + if (scope.size()) + scope += QString::fromUtf8("::"); + const QString e = QString::fromUtf8(prop.enumerator().valueToKey(v.toInt())); + if (e.size()) + dom_prop->setElementEnum(scope + e); + } else + dom_prop->setElementNumber(v.toInt()); + dom_prop->setAttributeName(pname); + } else { + dom_prop = createProperty(obj, pname, v); + } + + if (!dom_prop || dom_prop->kind() == DomProperty::Unknown) + delete dom_prop; + else + lst.append(dom_prop); + } + + return lst; +} + + +/*! + \internal + \typedef QAbstractFormBuilder::DomPropertyHash + \typedef QAbstractFormBuilder::IconPaths +*/ + + +/*! + \internal +*/ +QAbstractFormBuilder::DomPropertyHash QAbstractFormBuilder::propertyMap(const QList<DomProperty*> &properties) +{ + DomPropertyHash map; + + foreach (DomProperty *p, properties) + map.insert(p->attributeName(), p); + + return map; +} + +/*! + \internal +*/ +bool QAbstractFormBuilder::checkProperty(QObject *obj, const QString &prop) const +{ + Q_UNUSED(obj); + Q_UNUSED(prop); + + return true; +} + +/*! + \internal +*/ +QString QAbstractFormBuilder::toString(const DomString *str) +{ + return str ? str->text() : QString(); +} + +/*! + \internal +*/ +void QAbstractFormBuilder::applyTabStops(QWidget *widget, DomTabStops *tabStops) +{ + if (!tabStops) + return; + + QWidget *lastWidget = 0; + + const QStringList l = tabStops->elementTabStop(); + for (int i=0; i<l.size(); ++i) { + const QString name = l.at(i); + + QWidget *child = qFindChild<QWidget*>(widget, name); + if (!child) { + uiLibWarning(QCoreApplication::translate("QAbstractFormBuilder", "While applying tab stops: The widget '%1' could not be found.").arg(name)); + continue; + } + + if (i == 0) { + lastWidget = qFindChild<QWidget*>(widget, name); + continue; + } else if (!child || !lastWidget) { + continue; + } + + QWidget::setTabOrder(lastWidget, child); + + lastWidget = qFindChild<QWidget*>(widget, name); + } +} + +/*! + \internal +*/ +DomCustomWidgets *QAbstractFormBuilder::saveCustomWidgets() +{ + return 0; +} + +/*! + \internal +*/ +DomTabStops *QAbstractFormBuilder::saveTabStops() +{ + return 0; +} + +/*! + \internal +*/ +DomResources *QAbstractFormBuilder::saveResources() +{ + return 0; +} + +/*! + \internal + \since 4.5 +*/ + +DomButtonGroups *QAbstractFormBuilder::saveButtonGroups(const QWidget *mainContainer) +{ + // Save fst order buttongroup children of maincontainer + typedef QList<QButtonGroup*> ButtonGroupList; + const QObjectList mchildren = mainContainer->children(); + if (mchildren.empty()) + return 0; + QList<DomButtonGroup*> domGroups; + const QObjectList::const_iterator cend = mchildren.constEnd(); + for (QObjectList::const_iterator it = mchildren.constBegin(); it != cend; ++it) + if (QButtonGroup *bg = qobject_cast<QButtonGroup *>(*it)) + if (DomButtonGroup* dg = createDom(bg)) + domGroups.push_back(dg); + + if (domGroups.empty()) + return 0; + DomButtonGroups *rc = new DomButtonGroups; + rc->setElementButtonGroup(domGroups); + return rc; +} + +// VC6 would not find templated members, so we use statics and this utter hack. +class FriendlyFB : public QAbstractFormBuilder { +public: + using QAbstractFormBuilder::saveResource; + using QAbstractFormBuilder::saveText; + using QAbstractFormBuilder::resourceBuilder; + using QAbstractFormBuilder::textBuilder; + using QAbstractFormBuilder::toVariant; +}; + +template<class T> +static void storeItemProps(QAbstractFormBuilder *abstractFormBuilder, const T *item, + QList<DomProperty*> *properties) +{ + static const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + FriendlyFB * const formBuilder = static_cast<FriendlyFB *>(abstractFormBuilder); + + DomProperty *p; + QVariant v; + + foreach (const QFormBuilderStrings::TextRoleNName &it, strings.itemTextRoles) + if ((p = formBuilder->saveText(it.second, item->data(it.first.second)))) + properties->append(p); + + foreach (const QFormBuilderStrings::RoleNName &it, strings.itemRoles) + if ((v = item->data(it.first)).isValid() && + (p = variantToDomProperty(abstractFormBuilder, + static_cast<const QMetaObject *>(&QAbstractFormBuilderGadget::staticMetaObject), + it.second, v))) + properties->append(p); + + if ((p = formBuilder->saveResource(item->data(Qt::DecorationPropertyRole)))) + properties->append(p); +} + +template<class T> +static void storeItemFlags(const T *item, QList<DomProperty*> *properties) +{ + static const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + static const Qt::ItemFlags defaultFlags = T().flags(); + static const QMetaEnum itemFlags_enum = metaEnum<QAbstractFormBuilderGadget>("itemFlags"); + + if (item->flags() != defaultFlags) { + DomProperty *p = new DomProperty; + p->setAttributeName(strings.flagsAttribute); + p->setElementSet(QString::fromAscii(itemFlags_enum.valueToKeys(item->flags()))); + properties->append(p); + } +} + +template<class T> +static void storeItemPropsNFlags(QAbstractFormBuilder *abstractFormBuilder, const T *item, + QList<DomProperty*> *properties) +{ + storeItemProps<T>(abstractFormBuilder, item, properties); + storeItemFlags<T>(item, properties); +} + +template<class T> +static void loadItemProps(QAbstractFormBuilder *abstractFormBuilder, T *item, + const QHash<QString, DomProperty*> &properties) +{ + static const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + FriendlyFB * const formBuilder = static_cast<FriendlyFB *>(abstractFormBuilder); + + DomProperty *p; + QVariant v; + + foreach (const QFormBuilderStrings::TextRoleNName &it, strings.itemTextRoles) + if ((p = properties.value(it.second))) { + v = formBuilder->textBuilder()->loadText(p); + QVariant nativeValue = formBuilder->textBuilder()->toNativeValue(v); + item->setData(it.first.first, qVariantValue<QString>(nativeValue)); + item->setData(it.first.second, v); + } + + foreach (const QFormBuilderStrings::RoleNName &it, strings.itemRoles) + if ((p = properties.value(it.second)) && + (v = formBuilder->toVariant(&QAbstractFormBuilderGadget::staticMetaObject, p)).isValid()) + item->setData(it.first, v); + + if ((p = properties.value(strings.iconAttribute))) { + v = formBuilder->resourceBuilder()->loadResource(formBuilder->workingDirectory(), p); + QVariant nativeValue = formBuilder->resourceBuilder()->toNativeValue(v); + item->setIcon(qVariantValue<QIcon>(nativeValue)); + item->setData(Qt::DecorationPropertyRole, v); + } +} + +template<class T> +static void loadItemPropsNFlags(QAbstractFormBuilder *abstractFormBuilder, T *item, + const QHash<QString, DomProperty*> &properties) +{ + static const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + static const QMetaEnum itemFlags_enum = metaEnum<QAbstractFormBuilderGadget>("itemFlags"); + + loadItemProps<T>(abstractFormBuilder, item, properties); + + DomProperty *p; + if ((p = properties.value(strings.flagsAttribute)) && p->kind() == DomProperty::Set) + item->setFlags(enumKeysToValue<Qt::ItemFlags>(itemFlags_enum, p->elementSet().toAscii())); +} + +/*! + \internal +*/ +void QAbstractFormBuilder::saveTreeWidgetExtraInfo(QTreeWidget *treeWidget, DomWidget *ui_widget, DomWidget *ui_parentWidget) +{ + Q_UNUSED(ui_parentWidget); + + QList<DomColumn*> columns; + DomProperty *p; + QVariant v; + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + // save the header + for (int c = 0; c<treeWidget->columnCount(); ++c) { + DomColumn *column = new DomColumn; + + QList<DomProperty*> properties; + + foreach (const QFormBuilderStrings::TextRoleNName &it, strings.itemTextRoles) { + p = saveText(it.second, treeWidget->headerItem()->data(c, it.first.second)); + // Prevent uic 4.4.X from crashing if it cannot find a column text + if (!p && it.first.first == Qt::EditRole && it.second == QLatin1String("text")) { + DomString *defaultHeader = new DomString; + defaultHeader->setText(QString::number(c + 1)); + defaultHeader->setAttributeNotr(QLatin1String("true")); + p = new DomProperty; + p->setAttributeName(it.second); + p->setElementString(defaultHeader); + } + if (p) + properties.append(p); + } + + foreach (const QFormBuilderStrings::RoleNName &it, strings.itemRoles) + if ((v = treeWidget->headerItem()->data(c, it.first)).isValid() && + (p = variantToDomProperty(this, &QAbstractFormBuilderGadget::staticMetaObject, it.second, v))) + properties.append(p); + + if ((p = saveResource(treeWidget->headerItem()->data(c, Qt::DecorationPropertyRole)))) + properties.append(p); + + column->setElementProperty(properties); + columns.append(column); + } + + ui_widget->setElementColumn(columns); + + QList<DomItem *> items = ui_widget->elementItem(); + + QQueue<QPair<QTreeWidgetItem *, DomItem *> > pendingQueue; + for (int i = 0; i < treeWidget->topLevelItemCount(); i++) + pendingQueue.enqueue(qMakePair(treeWidget->topLevelItem(i), (DomItem *)0)); + + while (!pendingQueue.isEmpty()) { + const QPair<QTreeWidgetItem *, DomItem *> pair = pendingQueue.dequeue(); + QTreeWidgetItem *item = pair.first; + DomItem *parentDomItem = pair.second; + + DomItem *currentDomItem = new DomItem; + + QList<DomProperty*> properties; + for (int c = 0; c < treeWidget->columnCount(); c++) { + foreach (const QFormBuilderStrings::TextRoleNName &it, strings.itemTextRoles) + if ((p = saveText(it.second, item->data(c, it.first.second)))) + properties.append(p); + + foreach (const QFormBuilderStrings::RoleNName &it, strings.itemRoles) + if ((v = item->data(c, it.first)).isValid() && + (p = variantToDomProperty(this, &QAbstractFormBuilderGadget::staticMetaObject, it.second, v))) + properties.append(p); + + if ((p = saveResource(item->data(c, Qt::DecorationPropertyRole)))) + properties.append(p); + } + storeItemFlags(item, &properties); + currentDomItem->setElementProperty(properties); + + if (parentDomItem) { + QList<DomItem *> childrenItems = parentDomItem->elementItem(); + childrenItems.append(currentDomItem); + parentDomItem->setElementItem(childrenItems); + } else + items.append(currentDomItem); + + for (int i = 0; i < item->childCount(); i++) + pendingQueue.enqueue(qMakePair(item->child(i), currentDomItem)); + } + + ui_widget->setElementItem(items); +} + +/*! + \internal +*/ +void QAbstractFormBuilder::saveTableWidgetExtraInfo(QTableWidget *tableWidget, DomWidget *ui_widget, DomWidget *ui_parentWidget) +{ + Q_UNUSED(ui_parentWidget); + + // save the horizontal header + QList<DomColumn*> columns; + for (int c = 0; c < tableWidget->columnCount(); c++) { + QList<DomProperty*> properties; + QTableWidgetItem *item = tableWidget->horizontalHeaderItem(c); + if (item) + storeItemProps(this, item, &properties); + + DomColumn *column = new DomColumn; + column->setElementProperty(properties); + columns.append(column); + } + ui_widget->setElementColumn(columns); + + // save the vertical header + QList<DomRow*> rows; + for (int r = 0; r < tableWidget->rowCount(); r++) { + QList<DomProperty*> properties; + QTableWidgetItem *item = tableWidget->verticalHeaderItem(r); + if (item) + storeItemProps(this, item, &properties); + + DomRow *row = new DomRow; + row->setElementProperty(properties); + rows.append(row); + } + ui_widget->setElementRow(rows); + + QList<DomItem *> items = ui_widget->elementItem(); + for (int r = 0; r < tableWidget->rowCount(); r++) + for (int c = 0; c < tableWidget->columnCount(); c++) { + QTableWidgetItem *item = tableWidget->item(r, c); + if (item) { + QList<DomProperty*> properties; + storeItemPropsNFlags(this, item, &properties); + + DomItem *domItem = new DomItem; + domItem->setAttributeRow(r); + domItem->setAttributeColumn(c); + domItem->setElementProperty(properties); + items.append(domItem); + } + } + + ui_widget->setElementItem(items); +} + +/*! + \internal +*/ +void QAbstractFormBuilder::saveListWidgetExtraInfo(QListWidget *listWidget, DomWidget *ui_widget, DomWidget *ui_parentWidget) +{ + Q_UNUSED(ui_parentWidget); + + QList<DomItem*> ui_items = ui_widget->elementItem(); + for (int i=0; i<listWidget->count(); ++i) { + QList<DomProperty*> properties; + storeItemPropsNFlags(this, listWidget->item(i), &properties); + + DomItem *ui_item = new DomItem(); + ui_item->setElementProperty(properties); + ui_items.append(ui_item); + } + + ui_widget->setElementItem(ui_items); +} + +/*! + \internal +*/ +void QAbstractFormBuilder::saveComboBoxExtraInfo(QComboBox *comboBox, DomWidget *ui_widget, DomWidget *ui_parentWidget) +{ + Q_UNUSED(ui_parentWidget); + QList<DomItem*> ui_items = ui_widget->elementItem(); + + const int count = comboBox->count(); + for (int i=0; i < count; ++i) { + // We might encounter items for which both builders return 0 in Designer + // (indicating a custom combo adding items in the constructor). Ignore those. + DomProperty *textProperty = saveText(QFormBuilderStrings::instance().textAttribute, + comboBox->itemData(i, Qt::DisplayPropertyRole)); + DomProperty *iconProperty = saveResource(comboBox->itemData(i, Qt::DecorationPropertyRole)); + if (textProperty || iconProperty) { + QList<DomProperty*> properties; + if (textProperty) + properties.push_back(textProperty); + if (iconProperty) + properties.push_back(iconProperty); + + DomItem *ui_item = new DomItem(); + ui_item->setElementProperty(properties); + ui_items.push_back(ui_item); + } + } + + ui_widget->setElementItem(ui_items); +} + +/*! + \internal + \since 4.5 +*/ + +void QAbstractFormBuilder::saveButtonExtraInfo(const QAbstractButton *widget, DomWidget *ui_widget, DomWidget *) +{ + typedef QList<DomProperty*> DomPropertyList; + if (const QButtonGroup *buttonGroup = widget->group()) { + DomPropertyList attributes = ui_widget->elementAttribute(); + DomString *domString = new DomString(); + domString->setText(buttonGroup->objectName()); + DomProperty *domProperty = new DomProperty(); + domProperty->setAttributeName(QLatin1String(buttonGroupPropertyC)); + domProperty->setElementString(domString); + attributes += domProperty; + ui_widget->setElementAttribute(attributes); + } +} + +/*! + \internal + \since 4.5 +*/ +void QAbstractFormBuilder::saveItemViewExtraInfo(const QAbstractItemView *itemView, + DomWidget *ui_widget, DomWidget *) +{ + // + // Special handling for qtableview/qtreeview fake header attributes + // + static QStringList realPropertyNames = + (QStringList() << QLatin1String("visible") + << QLatin1String("cascadingSectionResizes") + << QLatin1String("defaultSectionSize") + << QLatin1String("highlightSections") + << QLatin1String("minimumSectionSize") + << QLatin1String("showSortIndicator") + << QLatin1String("stretchLastSection")); + + if (const QTreeView *treeView = qobject_cast<const QTreeView*>(itemView)) { + QList<DomProperty*> viewProperties = ui_widget->elementAttribute(); + QList<DomProperty*> headerProperties = computeProperties(treeView->header()); + foreach (const QString &realPropertyName, realPropertyNames) { + const QString upperPropertyName = realPropertyName.at(0).toUpper() + + realPropertyName.mid(1); + const QString fakePropertyName = QLatin1String("header") + upperPropertyName; + foreach (DomProperty *property, headerProperties) { + if (property->attributeName() == realPropertyName) { + property->setAttributeName(fakePropertyName); + viewProperties << property; + } + } + } + ui_widget->setElementAttribute(viewProperties); + } else if (const QTableView *tableView = qobject_cast<const QTableView*>(itemView)) { + static QStringList headerPrefixes = + (QStringList() << QLatin1String("horizontalHeader") + << QLatin1String("verticalHeader")); + + QList<DomProperty*> viewProperties = ui_widget->elementAttribute(); + foreach (const QString &headerPrefix, headerPrefixes) { + QList<DomProperty*> headerProperties; + if (headerPrefix == QLatin1String("horizontalHeader")) + headerProperties = computeProperties(tableView->horizontalHeader()); + else + headerProperties = computeProperties(tableView->verticalHeader()); + foreach (const QString &realPropertyName, realPropertyNames) { + const QString upperPropertyName = realPropertyName.at(0).toUpper() + + realPropertyName.mid(1); + const QString fakePropertyName = headerPrefix + upperPropertyName; + foreach (DomProperty *property, headerProperties) { + if (property->attributeName() == realPropertyName) { + property->setAttributeName(fakePropertyName); + viewProperties << property; + } + } + } + } + ui_widget->setElementAttribute(viewProperties); + } +} + +/*! + \internal + \since 4.4 +*/ + +void QAbstractFormBuilder::setResourceBuilder(QResourceBuilder *builder) +{ + QFormBuilderExtra::instance(this)->setResourceBuilder(builder); +} + +/*! + \internal + \since 4.4 +*/ + +QResourceBuilder *QAbstractFormBuilder::resourceBuilder() const +{ + return QFormBuilderExtra::instance(this)->resourceBuilder(); +} + +/*! + \internal + \since 4.5 +*/ + +void QAbstractFormBuilder::setTextBuilder(QTextBuilder *builder) +{ + QFormBuilderExtra::instance(this)->setTextBuilder(builder); +} + +/*! + \internal + \since 4.5 +*/ + +QTextBuilder *QAbstractFormBuilder::textBuilder() const +{ + return QFormBuilderExtra::instance(this)->textBuilder(); +} + +/*! + \internal +*/ +void QAbstractFormBuilder::saveExtraInfo(QWidget *widget, DomWidget *ui_widget, + DomWidget *ui_parentWidget) +{ + if (QListWidget *listWidget = qobject_cast<QListWidget*>(widget)) { + saveListWidgetExtraInfo(listWidget, ui_widget, ui_parentWidget); + } else if (QTreeWidget *treeWidget = qobject_cast<QTreeWidget*>(widget)) { + saveTreeWidgetExtraInfo(treeWidget, ui_widget, ui_parentWidget); + } else if (QTableWidget *tableWidget = qobject_cast<QTableWidget*>(widget)) { + saveTableWidgetExtraInfo(tableWidget, ui_widget, ui_parentWidget); + } else if (QComboBox *comboBox = qobject_cast<QComboBox*>(widget)) { + if (!qobject_cast<QFontComboBox*>(widget)) + saveComboBoxExtraInfo(comboBox, ui_widget, ui_parentWidget); + } else if(QAbstractButton *ab = qobject_cast<QAbstractButton *>(widget)) { + saveButtonExtraInfo(ab, ui_widget, ui_parentWidget); + } + if (QAbstractItemView *itemView = qobject_cast<QAbstractItemView *>(widget)) { + saveItemViewExtraInfo(itemView, ui_widget, ui_parentWidget); + } +} + +/*! + \internal +*/ +void QAbstractFormBuilder::loadListWidgetExtraInfo(DomWidget *ui_widget, QListWidget *listWidget, QWidget *parentWidget) +{ + Q_UNUSED(parentWidget); + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + const QMetaEnum itemFlags_enum = metaEnum<QAbstractFormBuilderGadget>("itemFlags"); + + foreach (DomItem *ui_item, ui_widget->elementItem()) { + const DomPropertyHash properties = propertyMap(ui_item->elementProperty()); + QListWidgetItem *item = new QListWidgetItem(listWidget); + loadItemPropsNFlags<QListWidgetItem>(this, item, properties); + } + + DomProperty *currentRow = propertyMap(ui_widget->elementProperty()).value(strings.currentRowProperty); + if (currentRow) + listWidget->setCurrentRow(currentRow->elementNumber()); +} + +/*! + \internal +*/ +void QAbstractFormBuilder::loadTreeWidgetExtraInfo(DomWidget *ui_widget, QTreeWidget *treeWidget, QWidget *parentWidget) +{ + Q_UNUSED(parentWidget); + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + const QMetaEnum itemFlags_enum = metaEnum<QAbstractFormBuilderGadget>("itemFlags"); + const QList<DomColumn*> columns = ui_widget->elementColumn(); + if (columns.count() > 0) + treeWidget->setColumnCount(columns.count()); + + for (int i = 0; i<columns.count(); ++i) { + const DomColumn *c = columns.at(i); + const DomPropertyHash properties = propertyMap(c->elementProperty()); + + DomProperty *p; + QVariant v; + + foreach (const QFormBuilderStrings::RoleNName &it, strings.itemRoles) + if ((p = properties.value(it.second)) && + (v = toVariant(&QAbstractFormBuilderGadget::staticMetaObject, p)).isValid()) + treeWidget->headerItem()->setData(i, it.first, v); + + foreach (const QFormBuilderStrings::TextRoleNName &it, strings.itemTextRoles) + if ((p = properties.value(it.second))) { + v = textBuilder()->loadText(p); + QVariant nativeValue = textBuilder()->toNativeValue(v); + treeWidget->headerItem()->setData(i, it.first.first, qVariantValue<QString>(nativeValue)); + treeWidget->headerItem()->setData(i, it.first.second, v); + } + + if ((p = properties.value(strings.iconAttribute))) { + v = resourceBuilder()->loadResource(workingDirectory(), p); + QVariant nativeValue = resourceBuilder()->toNativeValue(v); + treeWidget->headerItem()->setIcon(i, qVariantValue<QIcon>(nativeValue)); + treeWidget->headerItem()->setData(i, Qt::DecorationPropertyRole, v); + } + } + + QQueue<QPair<DomItem *, QTreeWidgetItem *> > pendingQueue; + foreach (DomItem *ui_item, ui_widget->elementItem()) + pendingQueue.enqueue(qMakePair(ui_item, (QTreeWidgetItem *)0)); + + while (!pendingQueue.isEmpty()) { + const QPair<DomItem *, QTreeWidgetItem *> pair = pendingQueue.dequeue(); + const DomItem *domItem = pair.first; + QTreeWidgetItem *parentItem = pair.second; + + QTreeWidgetItem *currentItem = 0; + + if (parentItem) + currentItem = new QTreeWidgetItem(parentItem); + else + currentItem = new QTreeWidgetItem(treeWidget); + + const QList<DomProperty *> properties = domItem->elementProperty(); + int col = -1; + foreach (DomProperty *property, properties) { + if (property->attributeName() == strings.flagsAttribute && !property->elementSet().isEmpty()) { + currentItem->setFlags(enumKeysToValue<Qt::ItemFlags>(itemFlags_enum, property->elementSet().toAscii())); + } else if (property->attributeName() == strings.textAttribute && property->elementString()) { + col++; + QVariant textV = textBuilder()->loadText(property); + QVariant nativeValue = textBuilder()->toNativeValue(textV); + currentItem->setText(col, qVariantValue<QString>(nativeValue)); + currentItem->setData(col, Qt::DisplayPropertyRole, textV); + } else if (col >= 0) { + if (property->attributeName() == strings.iconAttribute) { + QVariant v = resourceBuilder()->loadResource(workingDirectory(), property); + if (v.isValid()) { + QVariant nativeValue = resourceBuilder()->toNativeValue(v); + currentItem->setIcon(col, qVariantValue<QIcon>(nativeValue)); + currentItem->setData(col, Qt::DecorationPropertyRole, v); + } + } else { + QVariant v; + int role = strings.treeItemRoleHash.value(property->attributeName(), (Qt::ItemDataRole)-1); + if (role >= 0) { + if ((v = toVariant(&QAbstractFormBuilderGadget::staticMetaObject, property)).isValid()) + currentItem->setData(col, role, v); + } else { + QPair<Qt::ItemDataRole, Qt::ItemDataRole> rolePair = + strings.treeItemTextRoleHash.value(property->attributeName(), + qMakePair((Qt::ItemDataRole)-1, (Qt::ItemDataRole)-1)); + if (rolePair.first >= 0) { + QVariant textV = textBuilder()->loadText(property); + QVariant nativeValue = textBuilder()->toNativeValue(textV); + currentItem->setData(col, rolePair.first, qVariantValue<QString>(nativeValue)); + currentItem->setData(col, rolePair.second, textV); + } + } + } + } + } + + foreach (DomItem *childItem, domItem->elementItem()) + pendingQueue.enqueue(qMakePair(childItem, currentItem)); + + } +} + +/*! + \internal +*/ +void QAbstractFormBuilder::loadTableWidgetExtraInfo(DomWidget *ui_widget, QTableWidget *tableWidget, QWidget *parentWidget) +{ + Q_UNUSED(parentWidget); + + const QList<DomColumn*> columns = ui_widget->elementColumn(); + if (columns.count() > 0) + tableWidget->setColumnCount(columns.count()); + for (int i = 0; i< columns.count(); i++) { + DomColumn *c = columns.at(i); + const DomPropertyHash properties = propertyMap(c->elementProperty()); + + if (!properties.isEmpty()) { + QTableWidgetItem *item = new QTableWidgetItem; + loadItemProps(this, item, properties); + tableWidget->setHorizontalHeaderItem(i, item); + } + } + + const QList<DomRow*> rows = ui_widget->elementRow(); + if (rows.count() > 0) + tableWidget->setRowCount(rows.count()); + for (int i = 0; i< rows.count(); i++) { + const DomRow *r = rows.at(i); + const DomPropertyHash properties = propertyMap(r->elementProperty()); + + if (!properties.isEmpty()) { + QTableWidgetItem *item = new QTableWidgetItem; + loadItemProps(this, item, properties); + tableWidget->setVerticalHeaderItem(i, item); + } + } + + foreach (DomItem *ui_item, ui_widget->elementItem()) { + if (ui_item->hasAttributeRow() && ui_item->hasAttributeColumn()) { + const DomPropertyHash properties = propertyMap(ui_item->elementProperty()); + QTableWidgetItem *item = new QTableWidgetItem; + loadItemPropsNFlags(this, item, properties); + tableWidget->setItem(ui_item->attributeRow(), ui_item->attributeColumn(), item); + } + } +} + +/*! + \internal +*/ +void QAbstractFormBuilder::loadComboBoxExtraInfo(DomWidget *ui_widget, QComboBox *comboBox, QWidget *parentWidget) +{ + Q_UNUSED(parentWidget); + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + foreach (DomItem *ui_item, ui_widget->elementItem()) { + const DomPropertyHash properties = propertyMap(ui_item->elementProperty()); + QString text; + QIcon icon; + QVariant textData; + QVariant iconData; + + DomProperty *p = 0; + + p = properties.value(strings.textAttribute); + if (p && p->elementString()) { + textData = textBuilder()->loadText(p); + text = qVariantValue<QString>(textBuilder()->toNativeValue(textData)); + } + + p = properties.value(strings.iconAttribute); + if (p) { + iconData = resourceBuilder()->loadResource(workingDirectory(), p); + icon = qVariantValue<QIcon>(resourceBuilder()->toNativeValue(iconData)); + } + + comboBox->addItem(icon, text); + comboBox->setItemData((comboBox->count()-1), iconData, Qt::DecorationPropertyRole); + comboBox->setItemData((comboBox->count()-1), textData, Qt::DisplayPropertyRole); + } + + DomProperty *currentIndex = propertyMap(ui_widget->elementProperty()).value(strings.currentIndexProperty); + if (currentIndex) + comboBox->setCurrentIndex(currentIndex->elementNumber()); +} + +// Get the button group name out of a widget's attribute list +static QString buttonGroupName(const DomWidget *ui_widget) +{ + typedef QList<DomProperty*> DomPropertyList; + const DomPropertyList attributes = ui_widget->elementAttribute(); + if (attributes.empty()) + return QString(); + const QString buttonGroupProperty = QLatin1String(buttonGroupPropertyC); + const DomPropertyList::const_iterator cend = attributes.constEnd(); + for (DomPropertyList::const_iterator it = attributes.constBegin(); it != cend; ++it) + if ( (*it)->attributeName() == buttonGroupProperty) + return (*it)->elementString()->text(); + return QString(); +} + +/*! + \internal + \since 4.5 +*/ + +void QAbstractFormBuilder::loadButtonExtraInfo(const DomWidget *ui_widget, QAbstractButton *button, QWidget *) +{ + typedef QFormBuilderExtra::ButtonGroupEntry ButtonGroupEntry; + typedef QFormBuilderExtra::ButtonGroupHash ButtonGroupHash; + + const QString groupName = buttonGroupName(ui_widget); + if (groupName.isEmpty()) + return; + // Find entry + QFormBuilderExtra *extra = QFormBuilderExtra::instance(this); + ButtonGroupHash &buttonGroups = extra->buttonGroups(); + ButtonGroupHash::iterator it = buttonGroups.find(groupName); + if (it == buttonGroups.end()) { +#ifdef QFORMINTERNAL_NAMESPACE // Suppress the warning when copying in Designer + uiLibWarning(QCoreApplication::translate("QAbstractFormBuilder", "Invalid QButtonGroup reference '%1' referenced by '%2'.").arg(groupName, button->objectName())); +#endif + return; + } + // Create button group on demand? + QButtonGroup *&group = it.value().second; + if (group == 0) { + group = new QButtonGroup; + group->setObjectName(groupName); + applyProperties(group, it.value().first->elementProperty()); + } + group->addButton(button); +} + +/*! + \internal + \since 4.5 +*/ +void QAbstractFormBuilder::loadItemViewExtraInfo(DomWidget *ui_widget, QAbstractItemView *itemView, + QWidget *) +{ + // + // Special handling for qtableview/qtreeview fake header attributes + // + static QStringList realPropertyNames = + (QStringList() << QLatin1String("visible") + << QLatin1String("cascadingSectionResizes") + << QLatin1String("defaultSectionSize") + << QLatin1String("highlightSections") + << QLatin1String("minimumSectionSize") + << QLatin1String("showSortIndicator") + << QLatin1String("stretchLastSection")); + + if (QTreeView *treeView = qobject_cast<QTreeView*>(itemView)) { + QList<DomProperty*> allAttributes = ui_widget->elementAttribute(); + QList<DomProperty*> headerProperties; + foreach (const QString &realPropertyName, realPropertyNames) { + const QString upperPropertyName = realPropertyName.at(0).toUpper() + + realPropertyName.mid(1); + const QString fakePropertyName = QLatin1String("header") + upperPropertyName; + foreach (DomProperty *attr, allAttributes) { + if (attr->attributeName() == fakePropertyName) { + attr->setAttributeName(realPropertyName); + headerProperties << attr; + } + } + } + applyProperties(treeView->header(), headerProperties); + } else if (QTableView *tableView = qobject_cast<QTableView*>(itemView)) { + static QStringList headerPrefixes = + (QStringList() << QLatin1String("horizontalHeader") + << QLatin1String("verticalHeader")); + + QList<DomProperty*> allAttributes = ui_widget->elementAttribute(); + foreach (const QString &headerPrefix, headerPrefixes) { + QList<DomProperty*> headerProperties; + foreach (const QString &realPropertyName, realPropertyNames) { + const QString upperPropertyName = realPropertyName.at(0).toUpper() + + realPropertyName.mid(1); + const QString fakePropertyName = headerPrefix + upperPropertyName; + foreach (DomProperty *attr, allAttributes) { + if (attr->attributeName() == fakePropertyName) { + attr->setAttributeName(realPropertyName); + headerProperties << attr; + } + } + } + if (headerPrefix == QLatin1String("horizontalHeader")) + applyProperties(tableView->horizontalHeader(), headerProperties); + else + applyProperties(tableView->verticalHeader(), headerProperties); + } + } +} + +/*! + \internal +*/ +void QAbstractFormBuilder::loadExtraInfo(DomWidget *ui_widget, QWidget *widget, QWidget *parentWidget) +{ + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + if (0) { +#ifndef QT_NO_LISTWIDGET + } else if (QListWidget *listWidget = qobject_cast<QListWidget*>(widget)) { + loadListWidgetExtraInfo(ui_widget, listWidget, parentWidget); +#endif +#ifndef QT_NO_TREEWIDGET + } else if (QTreeWidget *treeWidget = qobject_cast<QTreeWidget*>(widget)) { + loadTreeWidgetExtraInfo(ui_widget, treeWidget, parentWidget); +#endif +#ifndef QT_NO_TABLEWIDGET + } else if (QTableWidget *tableWidget = qobject_cast<QTableWidget*>(widget)) { + loadTableWidgetExtraInfo(ui_widget, tableWidget, parentWidget); +#endif +#ifndef QT_NO_COMBOBOX + } else if (QComboBox *comboBox = qobject_cast<QComboBox*>(widget)) { + if (!qobject_cast<QFontComboBox *>(widget)) + loadComboBoxExtraInfo(ui_widget, comboBox, parentWidget); +#endif +#ifndef QT_NO_TABWIDGET + } else if (QTabWidget *tabWidget = qobject_cast<QTabWidget*>(widget)) { + const DomProperty *currentIndex = propertyMap(ui_widget->elementProperty()).value(strings.currentIndexProperty); + if (currentIndex) + tabWidget->setCurrentIndex(currentIndex->elementNumber()); +#endif +#ifndef QT_NO_STACKEDWIDGET + } else if (QStackedWidget *stackedWidget = qobject_cast<QStackedWidget*>(widget)) { + const DomProperty *currentIndex = propertyMap(ui_widget->elementProperty()).value(strings.currentIndexProperty); + if (currentIndex) + stackedWidget->setCurrentIndex(currentIndex->elementNumber()); +#endif +#ifndef QT_NO_TOOLBOX + } else if (QToolBox *toolBox = qobject_cast<QToolBox*>(widget)) { + const DomProperty *currentIndex = propertyMap(ui_widget->elementProperty()).value(strings.currentIndexProperty); + if (currentIndex) + toolBox->setCurrentIndex(currentIndex->elementNumber()); + const DomProperty *tabSpacing = propertyMap(ui_widget->elementProperty()).value(strings.tabSpacingProperty); + if (tabSpacing) + toolBox->layout()->setSpacing(tabSpacing->elementNumber()); +#endif + } else if (QAbstractButton *ab = qobject_cast<QAbstractButton *>(widget)) { + loadButtonExtraInfo(ui_widget, ab, parentWidget); + } + if (QAbstractItemView *itemView = qobject_cast<QAbstractItemView *>(widget)) { + loadItemViewExtraInfo(ui_widget, itemView, parentWidget); + } +} + +/*! + \internal +*/ +QIcon QAbstractFormBuilder::nameToIcon(const QString &filePath, const QString &qrcPath) +{ + Q_UNUSED(filePath) + Q_UNUSED(qrcPath) + qWarning() << "QAbstractFormBuilder::nameToIcon() is obsoleted"; + return QIcon(); +} + +/*! + \internal +*/ +QString QAbstractFormBuilder::iconToFilePath(const QIcon &pm) const +{ + Q_UNUSED(pm) + qWarning() << "QAbstractFormBuilder::iconToFilePath() is obsoleted"; + return QString(); +} + +/*! + \internal +*/ +QString QAbstractFormBuilder::iconToQrcPath(const QIcon &pm) const +{ + Q_UNUSED(pm) + qWarning() << "QAbstractFormBuilder::iconToQrcPath() is obsoleted"; + return QString(); +} + +/*! + \internal +*/ +QPixmap QAbstractFormBuilder::nameToPixmap(const QString &filePath, const QString &qrcPath) +{ + Q_UNUSED(filePath) + Q_UNUSED(qrcPath) + qWarning() << "QAbstractFormBuilder::nameToPixmap() is obsoleted"; + return QPixmap(); +} + +/*! + \internal +*/ +QString QAbstractFormBuilder::pixmapToFilePath(const QPixmap &pm) const +{ + Q_UNUSED(pm) + qWarning() << "QAbstractFormBuilder::pixmapToFilePath() is obsoleted"; + return QString(); +} + +/*! + \internal +*/ +QString QAbstractFormBuilder::pixmapToQrcPath(const QPixmap &pm) const +{ + Q_UNUSED(pm) + qWarning() << "QAbstractFormBuilder::pixmapToQrcPath() is obsoleted"; + return QString(); +} + +/*! + Returns the current working directory of the form builder. + + \sa setWorkingDirectory() */ +QDir QAbstractFormBuilder::workingDirectory() const +{ + return m_workingDirectory; +} + +/*! + Sets the current working directory of the form builder to the + specified \a directory. + + \sa workingDirectory()*/ +void QAbstractFormBuilder::setWorkingDirectory(const QDir &directory) +{ + m_workingDirectory = directory; +} + +/*! + \internal +*/ +DomAction *QAbstractFormBuilder::createDom(QAction *action) +{ + if (action->parentWidget() == action->menu() || action->isSeparator()) + return 0; + + DomAction *ui_action = new DomAction; + ui_action->setAttributeName(action->objectName()); + + const QList<DomProperty*> properties = computeProperties(action); + ui_action->setElementProperty(properties); + + return ui_action; +} + +/*! + \internal + \since 4.5 +*/ + +DomButtonGroup *QAbstractFormBuilder::createDom(QButtonGroup *buttonGroup) +{ + if (buttonGroup->buttons().count() == 0) // Empty group left over on form? + return 0; + DomButtonGroup *domButtonGroup = new DomButtonGroup; + domButtonGroup->setAttributeName(buttonGroup->objectName()); + + QList<DomProperty*> properties = computeProperties(buttonGroup); + domButtonGroup->setElementProperty(properties); + return domButtonGroup; +} + +/*! + \internal +*/ +DomActionGroup *QAbstractFormBuilder::createDom(QActionGroup *actionGroup) +{ + DomActionGroup *ui_action_group = new DomActionGroup; + ui_action_group->setAttributeName(actionGroup->objectName()); + + QList<DomProperty*> properties = computeProperties(actionGroup); + ui_action_group->setElementProperty(properties); + + QList<DomAction*> ui_actions; + + foreach (QAction *action, actionGroup->actions()) { + if (DomAction *ui_action = createDom(action)) { + ui_actions.append(ui_action); + } + } + + ui_action_group->setElementAction(ui_actions); + + return ui_action_group; +} + +/*! + \internal +*/ +void QAbstractFormBuilder::addMenuAction(QAction *action) +{ + Q_UNUSED(action); +} + +/*! + \internal +*/ +void QAbstractFormBuilder::reset() +{ + m_laidout.clear(); + m_actions.clear(); + m_actionGroups.clear(); + m_defaultMargin = INT_MIN; + m_defaultSpacing = INT_MIN; +} + +/*! + \internal + Access meta enumeration for Qt::ToolBarArea +*/ + +QMetaEnum QAbstractFormBuilder::toolBarAreaMetaEnum() +{ + return metaEnum<QAbstractFormBuilderGadget>("toolBarArea"); +} + +namespace { + // set forward slashes in image path. + inline void fixImagePath(QString &p) { + p.replace(QLatin1Char('\\'), QLatin1Char('/')); + } +} + +/*! + \internal + Return paths of an icon. +*/ + +QAbstractFormBuilder::IconPaths QAbstractFormBuilder::iconPaths(const QIcon &icon) const +{ + Q_UNUSED(icon); + qWarning() << "QAbstractFormBuilder::iconPaths() is obsoleted"; + return IconPaths(); +} + +/*! + \internal + Return paths of a pixmap. +*/ + +QAbstractFormBuilder::IconPaths QAbstractFormBuilder::pixmapPaths(const QPixmap &pixmap) const +{ + Q_UNUSED(pixmap); + qWarning() << "QAbstractFormBuilder::pixmapPaths() is obsoleted"; + return IconPaths(); +} + +/*! + \internal + Set up a DOM property with icon. +*/ + +void QAbstractFormBuilder::setIconProperty(DomProperty &p, const IconPaths &ip) const +{ + DomResourceIcon *dpi = new DomResourceIcon; + + /* TODO + if (!ip.second.isEmpty()) + pix->setAttributeResource(ip.second); +*/ + dpi->setText(ip.first); + + p.setAttributeName(QFormBuilderStrings::instance().iconAttribute); + p.setElementIconSet(dpi); +} + +/*! + \internal + Set up a DOM property with pixmap. +*/ + +void QAbstractFormBuilder::setPixmapProperty(DomProperty &p, const IconPaths &ip) const +{ + DomResourcePixmap *pix = new DomResourcePixmap; + if (!ip.second.isEmpty()) + pix->setAttributeResource(ip.second); + + pix->setText(ip.first); + + p.setAttributeName(QFormBuilderStrings::instance().pixmapAttribute); + p.setElementPixmap(pix); +} + +/*! + \internal + Convenience. Return DOM property for icon; 0 if icon.isNull(). +*/ + +DomProperty* QAbstractFormBuilder::iconToDomProperty(const QIcon &icon) const +{ + Q_UNUSED(icon); + qWarning() << "QAbstractFormBuilder::iconToDomProperty() is obsoleted"; + return 0; +} + +/*! + \internal + \since 4.4 +*/ + +DomProperty *QAbstractFormBuilder::saveResource(const QVariant &v) const +{ + if (v.isNull()) + return 0; + + DomProperty *p = resourceBuilder()->saveResource(workingDirectory(), v); + if (p) + p->setAttributeName(QFormBuilderStrings::instance().iconAttribute); + return p; +} + +/*! + \internal + \since 4.5 +*/ + +DomProperty *QAbstractFormBuilder::saveText(const QString &attributeName, const QVariant &v) const +{ + if (v.isNull()) + return 0; + + DomProperty *p = textBuilder()->saveText(v); + if (p) + p->setAttributeName(attributeName); + return p; +} + +/*! + \internal + Return the appropriate DOM pixmap for an image dom property. + From 4.4 - unused +*/ + +const DomResourcePixmap *QAbstractFormBuilder::domPixmap(const DomProperty* p) { + switch (p->kind()) { + case DomProperty::IconSet: + qDebug() << "** WARNING QAbstractFormBuilder::domPixmap() called for icon set!"; + break; + case DomProperty::Pixmap: + return p->elementPixmap(); + default: + break; + } + return 0; +} + +/*! + \internal + Create icon from DOM. + From 4.4 - unused +*/ + +QIcon QAbstractFormBuilder::domPropertyToIcon(const DomResourcePixmap *icon) +{ + Q_UNUSED(icon); + qWarning() << "QAbstractFormBuilder::domPropertyToIcon() is obsoleted"; + return QIcon(); +} + +/*! + \internal + Create icon from DOM. Assert if !domPixmap + From 4.4 - unused +*/ + +QIcon QAbstractFormBuilder::domPropertyToIcon(const DomProperty* p) +{ + Q_UNUSED(p); + qWarning() << "QAbstractFormBuilder::domPropertyToIcon() is obsoleted"; + return QIcon(); +} + + +/*! + \internal + Create pixmap from DOM. + From 4.4 - unused +*/ + +QPixmap QAbstractFormBuilder::domPropertyToPixmap(const DomResourcePixmap* pixmap) +{ + Q_UNUSED(pixmap); + qWarning() << "QAbstractFormBuilder::domPropertyToPixmap() is obsoleted"; + return QPixmap(); +} + + +/*! + \internal + Create pixmap from DOM. Assert if !domPixmap + From 4.4 - unused +*/ + +QPixmap QAbstractFormBuilder::domPropertyToPixmap(const DomProperty* p) +{ + Q_UNUSED(p); + qWarning() << "QAbstractFormBuilder::domPropertyToPixmap() is obsoleted"; + return QPixmap(); +} + +/*! + \fn void QAbstractFormBuilder::createConnections ( DomConnections *, QWidget * ) + \internal +*/ + +/*! + \fn void QAbstractFormBuilder::createCustomWidgets ( DomCustomWidgets * ) + \internal +*/ + +/*! + \fn void QAbstractFormBuilder::createResources ( DomResources * ) + \internal +*/ + +/*! + \fn QFormScriptRunner *QAbstractFormBuilder::formScriptRunner() const + \internal + \since 4.3 +*/ +#ifndef QT_FORMBUILDER_NO_SCRIPT +QFormScriptRunner *QAbstractFormBuilder::formScriptRunner() const +{ + return &(QFormBuilderExtra::instance(this)->formScriptRunner()); +} +#endif + +/*! + Sets whether the execution of scripts is enabled to \a enabled. + \since 4.3 + \internal +*/ + +void QAbstractFormBuilder::setScriptingEnabled(bool enabled) +{ +#ifdef QT_FORMBUILDER_NO_SCRIPT + if (enabled) + uiLibWarning(QCoreApplication::translate("QAbstractFormBuilder", "This version of the uitools library is linked without script support.")); +#else + QFormScriptRunner::Options options = formScriptRunner()->options(); + if (enabled) + options &= ~QFormScriptRunner::DisableScripts; + else + options |= QFormScriptRunner::DisableScripts; + formScriptRunner()->setOptions(options); +#endif +} + +/*! + Returns whether the execution of scripts is enabled. + \sa setScriptingEnabled() + \since 4.3 + \internal +*/ + +bool QAbstractFormBuilder::isScriptingEnabled() const +{ +#ifdef QT_FORMBUILDER_NO_SCRIPT + return false; +#else + return !(formScriptRunner()->options() & QFormScriptRunner::DisableScripts); +#endif +} + +QT_END_NAMESPACE diff --git a/tools/designer/src/lib/uilib/abstractformbuilder.h b/tools/designer/src/lib/uilib/abstractformbuilder.h new file mode 100644 index 0000000..94429f8 --- /dev/null +++ b/tools/designer/src/lib/uilib/abstractformbuilder.h @@ -0,0 +1,290 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef ABSTRACTFORMBUILDER_H +#define ABSTRACTFORMBUILDER_H + +#include <QtDesigner/uilib_global.h> + +#include <QtCore/QList> +#include <QtCore/QHash> +#include <QtCore/QDir> + +#include <QtGui/QSizePolicy> +#include <QtGui/QPalette> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE +#if 0 +// pragma for syncqt, don't remove. + +#pragma qt_class(QAbstractFormBuilder) +#endif + +class QAction; +class QButtonGroup; +class QActionGroup; +class QComboBox; +class QIODevice; +class QIcon; +class QLayout; +class QLayoutItem; +class QListWidget; +class QObject; +class QSpacerItem; +class QTreeWidget; +class QTableWidget; +class QVariant; +class QWidget; +class QAbstractButton; +class QAbstractItemView; + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal +{ +#endif + +class DomAction; +class DomActionGroup; +class DomButtonGroup; +class DomButtonGroups; +class DomActionRef; +class DomBrush; +class DomColorGroup; +class DomConnections; +class DomCustomWidgets; +class DomLayout; +class DomLayoutItem; +class DomProperty; +class DomResources; +class DomSpacer; +class DomString; +class DomTabStops; +class DomUI; +class DomWidget; +class DomResourcePixmap; + +class QResourceBuilder; +class QTextBuilder; + +#ifndef QT_FORMBUILDER_NO_SCRIPT +class QFormScriptRunner; +#endif + +class QDESIGNER_UILIB_EXPORT QAbstractFormBuilder +{ +public: + QAbstractFormBuilder(); + virtual ~QAbstractFormBuilder(); + + QDir workingDirectory() const; + void setWorkingDirectory(const QDir &directory); + + virtual QWidget *load(QIODevice *dev, QWidget *parentWidget=0); + virtual void save(QIODevice *dev, QWidget *widget); + + void setScriptingEnabled(bool enabled); + bool isScriptingEnabled() const; + +protected: +// +// load +// + virtual void loadExtraInfo(DomWidget *ui_widget, QWidget *widget, QWidget *parentWidget); + + virtual QWidget *create(DomUI *ui, QWidget *parentWidget); + virtual QWidget *create(DomWidget *ui_widget, QWidget *parentWidget); + virtual QLayout *create(DomLayout *ui_layout, QLayout *layout, QWidget *parentWidget); + virtual QLayoutItem *create(DomLayoutItem *ui_layoutItem, QLayout *layout, QWidget *parentWidget); + + virtual QAction *create(DomAction *ui_action, QObject *parent); + virtual QActionGroup *create(DomActionGroup *ui_action_group, QObject *parent); + virtual void addMenuAction(QAction *action); + + virtual void applyProperties(QObject *o, const QList<DomProperty*> &properties); + bool applyPropertyInternally(QObject *o, const QString &propertyName, const QVariant &value); + + virtual void applyTabStops(QWidget *widget, DomTabStops *tabStops); + + virtual QWidget *createWidget(const QString &widgetName, QWidget *parentWidget, const QString &name); + virtual QLayout *createLayout(const QString &layoutName, QObject *parent, const QString &name); + virtual QAction *createAction(QObject *parent, const QString &name); + virtual QActionGroup *createActionGroup(QObject *parent, const QString &name); + + virtual void createCustomWidgets(DomCustomWidgets *) {} + virtual void createConnections(DomConnections *, QWidget *) {} + virtual void createResources(DomResources*) {} + + virtual bool addItem(DomLayoutItem *ui_item, QLayoutItem *item, QLayout *layout); + virtual bool addItem(DomWidget *ui_widget, QWidget *widget, QWidget *parentWidget); + +// +// save +// + virtual void saveExtraInfo(QWidget *widget, DomWidget *ui_widget, DomWidget *ui_parentWidget); + + virtual void saveDom(DomUI *ui, QWidget *widget); + + virtual DomActionRef *createActionRefDom(QAction *action); + + virtual DomWidget *createDom(QWidget *widget, DomWidget *ui_parentWidget, bool recursive = true); + virtual DomLayout *createDom(QLayout *layout, DomLayout *ui_layout, DomWidget *ui_parentWidget); + virtual DomLayoutItem *createDom(QLayoutItem *item, DomLayout *ui_parentLayout, DomWidget *ui_parentWidget); + virtual DomSpacer *createDom(QSpacerItem *spacer, DomLayout *ui_parentLayout, DomWidget *ui_parentWidget); + + virtual DomAction *createDom(QAction *action); + virtual DomActionGroup *createDom(QActionGroup *actionGroup); + DomButtonGroup *createDom(QButtonGroup *buttonGroup); + + virtual DomConnections *saveConnections(); + virtual DomCustomWidgets *saveCustomWidgets(); + virtual DomTabStops *saveTabStops(); + virtual DomResources *saveResources(); + DomButtonGroups *saveButtonGroups(const QWidget *mainContainer); + virtual QList<DomProperty*> computeProperties(QObject *obj); + virtual bool checkProperty(QObject *obj, const QString &prop) const; + virtual DomProperty *createProperty(QObject *object, const QString &propertyName, const QVariant &value); + + virtual void layoutInfo(DomLayout *layout, QObject *parent, int *margin, int *spacing); + + virtual QIcon nameToIcon(const QString &filePath, const QString &qrcPath); + virtual QString iconToFilePath(const QIcon &pm) const; + virtual QString iconToQrcPath(const QIcon &pm) const; + virtual QPixmap nameToPixmap(const QString &filePath, const QString &qrcPath); + virtual QString pixmapToFilePath(const QPixmap &pm) const; + virtual QString pixmapToQrcPath(const QPixmap &pm) const; + + void loadListWidgetExtraInfo(DomWidget *ui_widget, QListWidget *listWidget, QWidget *parentWidget); + void loadTreeWidgetExtraInfo(DomWidget *ui_widget, QTreeWidget *treeWidget, QWidget *parentWidget); + void loadTableWidgetExtraInfo(DomWidget *ui_widget, QTableWidget *tableWidget, QWidget *parentWidget); + void loadComboBoxExtraInfo(DomWidget *ui_widget, QComboBox *comboBox, QWidget *parentWidget); + void loadButtonExtraInfo(const DomWidget *ui_widget, QAbstractButton *button, QWidget *parentWidget); + void loadItemViewExtraInfo(DomWidget *ui_widget, QAbstractItemView *itemView, QWidget *parentWidget); + + void saveListWidgetExtraInfo(QListWidget *widget, DomWidget *ui_widget, DomWidget *ui_parentWidget); + void saveTreeWidgetExtraInfo(QTreeWidget *treeWidget, DomWidget *ui_widget, DomWidget *ui_parentWidget); + void saveTableWidgetExtraInfo(QTableWidget *tablWidget, DomWidget *ui_widget, DomWidget *ui_parentWidget); + void saveComboBoxExtraInfo(QComboBox *widget, DomWidget *ui_widget, DomWidget *ui_parentWidget); + void saveButtonExtraInfo(const QAbstractButton *widget, DomWidget *ui_widget, DomWidget *ui_parentWidget); + void saveItemViewExtraInfo(const QAbstractItemView *itemView, DomWidget *ui_widget, DomWidget *ui_parentWidget); + + void setResourceBuilder(QResourceBuilder *builder); + QResourceBuilder *resourceBuilder() const; + DomProperty *saveResource(const QVariant &v) const; + + void setTextBuilder(QTextBuilder *builder); + QTextBuilder *textBuilder() const; + DomProperty *saveText(const QString &attributeName, const QVariant &v) const; +// +// utils +// + + QVariant toVariant(const QMetaObject *meta, DomProperty *property); + static QString toString(const DomString *str); + + typedef QHash<QString, DomProperty*> DomPropertyHash; + static DomPropertyHash propertyMap(const QList<DomProperty*> &properties); + + void setupColorGroup(QPalette &palette, QPalette::ColorGroup colorGroup, DomColorGroup *group); + DomColorGroup *saveColorGroup(const QPalette &palette); + QBrush setupBrush(DomBrush *brush); + DomBrush *saveBrush(const QBrush &brush); + + void reset(); + void initialize(const DomUI *ui); + +#ifndef QT_FORMBUILDER_NO_SCRIPT + QFormScriptRunner *formScriptRunner() const; +#endif +// +// utils +// + + static QMetaEnum toolBarAreaMetaEnum(); + +// +// Icon/pixmap stuff +// + // A Pair of icon path/qrc path. + typedef QPair<QString, QString> IconPaths; + + IconPaths iconPaths(const QIcon &) const; + IconPaths pixmapPaths(const QPixmap &) const; + void setIconProperty(DomProperty &, const IconPaths &) const; + void setPixmapProperty(DomProperty &, const IconPaths &) const; + DomProperty* iconToDomProperty(const QIcon &) const; + + static const DomResourcePixmap *domPixmap(const DomProperty* p); + QIcon domPropertyToIcon(const DomResourcePixmap *); + QIcon domPropertyToIcon(const DomProperty* p); + QPixmap domPropertyToPixmap(const DomResourcePixmap* p); + QPixmap domPropertyToPixmap(const DomProperty* p); + + QHash<QObject*, bool> m_laidout; + QHash<QString, QAction*> m_actions; + QHash<QString, QActionGroup*> m_actionGroups; + int m_defaultMargin; + int m_defaultSpacing; + QDir m_workingDirectory; + +private: +// +// utils +// + static Qt::ToolBarArea toolbarAreaFromDOMAttributes(const DomPropertyHash &attributeMap); + + QAbstractFormBuilder(const QAbstractFormBuilder &other); + void operator = (const QAbstractFormBuilder &other); + + friend QDESIGNER_UILIB_EXPORT DomProperty *variantToDomProperty(QAbstractFormBuilder *abstractFormBuilder, const QMetaObject *meta, const QString &propertyName, const QVariant &value); + friend QDESIGNER_UILIB_EXPORT QVariant domPropertyToVariant(QAbstractFormBuilder *abstractFormBuilder,const QMetaObject *meta, const DomProperty *property); +}; + +#ifdef QFORMINTERNAL_NAMESPACE +} +#endif + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // ABSTRACTFORMBUILDER_H diff --git a/tools/designer/src/lib/uilib/container.h b/tools/designer/src/lib/uilib/container.h new file mode 100644 index 0000000..e107ad7 --- /dev/null +++ b/tools/designer/src/lib/uilib/container.h @@ -0,0 +1,75 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef CONTAINER_H +#define CONTAINER_H + +#include <QtDesigner/extension.h> +#include <QtCore/QObject> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +class QWidget; + +class QDesignerContainerExtension +{ +public: + virtual ~QDesignerContainerExtension() {} + + virtual int count() const = 0; + virtual QWidget *widget(int index) const = 0; + + virtual int currentIndex() const = 0; + virtual void setCurrentIndex(int index) = 0; + + virtual void addWidget(QWidget *widget) = 0; + virtual void insertWidget(int index, QWidget *widget) = 0; + virtual void remove(int index) = 0; +}; +Q_DECLARE_EXTENSION_INTERFACE(QDesignerContainerExtension, "com.trolltech.Qt.Designer.Container") + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // CONTAINER_H diff --git a/tools/designer/src/lib/uilib/customwidget.h b/tools/designer/src/lib/uilib/customwidget.h new file mode 100644 index 0000000..0da4c05 --- /dev/null +++ b/tools/designer/src/lib/uilib/customwidget.h @@ -0,0 +1,101 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef CUSTOMWIDGET_H +#define CUSTOMWIDGET_H + +#include <QtDesigner/extension.h> +#include <QtCore/QObject> +#include <QtCore/QString> +#include <QtGui/QIcon> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +class QWidget; +class QDesignerFormEditorInterface; + +class QDesignerCustomWidgetInterface +{ +public: + virtual ~QDesignerCustomWidgetInterface() {} + + virtual QString name() const = 0; + virtual QString group() const = 0; + virtual QString toolTip() const = 0; + virtual QString whatsThis() const = 0; + virtual QString includeFile() const = 0; + virtual QIcon icon() const = 0; + + virtual bool isContainer() const = 0; + + virtual QWidget *createWidget(QWidget *parent) = 0; + + virtual bool isInitialized() const { return false; } + virtual void initialize(QDesignerFormEditorInterface *core) { Q_UNUSED(core); } + + virtual QString domXml() const + { + return QString::fromUtf8("<widget class=\"%1\" name=\"%2\"/>") + .arg(name()).arg(name().toLower()); + } + + virtual QString codeTemplate() const { return QString(); } +}; +Q_DECLARE_INTERFACE(QDesignerCustomWidgetInterface, "com.trolltech.Qt.Designer.CustomWidget") + + +class QDesignerCustomWidgetCollectionInterface +{ +public: + virtual ~QDesignerCustomWidgetCollectionInterface() {} + + virtual QList<QDesignerCustomWidgetInterface*> customWidgets() const = 0; +}; +Q_DECLARE_INTERFACE(QDesignerCustomWidgetCollectionInterface, + "com.trolltech.Qt.Designer.CustomWidgetCollection") + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // CUSTOMWIDGET_H diff --git a/tools/designer/src/lib/uilib/formbuilder.cpp b/tools/designer/src/lib/uilib/formbuilder.cpp new file mode 100644 index 0000000..414eb14 --- /dev/null +++ b/tools/designer/src/lib/uilib/formbuilder.cpp @@ -0,0 +1,562 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "customwidget.h" +#include "formbuilder.h" +#include "formbuilderextra_p.h" +#include "ui4_p.h" + +#include <QtGui/QtGui> +#include <QtCore/QCoreApplication> + +QT_BEGIN_NAMESPACE + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal { +#endif + +/*! + \class QFormBuilder + + \brief The QFormBuilder class is used to dynamically construct + user interfaces from .ui files at run-time. + + \inmodule QtDesigner + + The QFormBuilder class provides a mechanism for dynamically + creating user interfaces at run-time, based on \c{.ui} files + created with \QD. For example: + + \snippet doc/src/snippets/code/tools_designer_src_lib_uilib_formbuilder.cpp 0 + + By including the user interface in the example's resources (\c + myForm.qrc), we ensure that it will be present when the example is + run: + + \snippet doc/src/snippets/code/tools_designer_src_lib_uilib_formbuilder.cpp 1 + + QFormBuilder extends the QAbstractFormBuilder base class with a + number of functions that are used to support custom widget + plugins: + + \list + \o pluginPaths() returns the list of paths that the form builder + searches when loading custom widget plugins. + \o addPluginPath() allows additional paths to be registered with + the form builder. + \o setPluginPath() is used to replace the existing list of paths + with a list obtained from some other source. + \o clearPluginPaths() removes all paths registered with the form + builder. + \o customWidgets() returns a list of interfaces to plugins that + can be used to create new instances of registered custom widgets. + \endlist + + The QFormBuilder class is typically used by custom components and + applications that embed \QD. Standalone applications that need to + dynamically generate user interfaces at run-time use the + QUiLoader class, found in the QtUiTools module. + + \sa QAbstractFormBuilder, {QtUiTools Module} +*/ + +/*! + \fn QFormBuilder::QFormBuilder() + + Constructs a new form builder. +*/ + +QFormBuilder::QFormBuilder() : QAbstractFormBuilder() +{ +} + +/*! + Destroys the form builder. +*/ +QFormBuilder::~QFormBuilder() +{ +} + +/*! + \internal +*/ +QWidget *QFormBuilder::create(DomWidget *ui_widget, QWidget *parentWidget) +{ + QFormBuilderExtra::instance(this)->setProcessingLayoutWidget(false); + if (ui_widget->attributeClass() == QFormBuilderStrings::instance().qWidgetClass && !ui_widget->hasAttributeNative() + && parentWidget +#ifndef QT_NO_MAINWINDOW + && !qobject_cast<QMainWindow *>(parentWidget) +#endif +#ifndef QT_NO_TOOLBOX + && !qobject_cast<QToolBox *>(parentWidget) +#endif +#ifndef QT_NO_STACKEDWIDGET + && !qobject_cast<QStackedWidget *>(parentWidget) +#endif +#ifndef QT_NO_STACKEDWIDGET + && !qobject_cast<QTabWidget *>(parentWidget) +#endif +#ifndef QT_NO_SCROLLAREA + && !qobject_cast<QScrollArea *>(parentWidget) +#endif +#ifndef QT_NO_MDIAREA + && !qobject_cast<QMdiArea *>(parentWidget) +#endif +#ifndef QT_NO_DOCKWIDGET + && !qobject_cast<QDockWidget *>(parentWidget) +#endif + ) + QFormBuilderExtra::instance(this)->setProcessingLayoutWidget(true); + return QAbstractFormBuilder::create(ui_widget, parentWidget); +} + + +/*! + \internal +*/ +QWidget *QFormBuilder::createWidget(const QString &widgetName, QWidget *parentWidget, const QString &name) +{ + if (widgetName.isEmpty()) { + //: Empty class name passed to widget factory method + qWarning() << QCoreApplication::translate("QFormBuilder", "An empty class name was passed on to %1 (object name: '%2').").arg(QString::fromUtf8(Q_FUNC_INFO), name); + return 0; + } + + QWidget *w = 0; + +#ifndef QT_NO_TABWIDGET + if (qobject_cast<QTabWidget*>(parentWidget)) + parentWidget = 0; +#endif +#ifndef QT_NO_STACKEDWIDGET + if (qobject_cast<QStackedWidget*>(parentWidget)) + parentWidget = 0; +#endif +#ifndef QT_NO_TOOLBOX + if (qobject_cast<QToolBox*>(parentWidget)) + parentWidget = 0; +#endif + + // ### special-casing for Line (QFrame) -- fix for 4.2 + do { + if (widgetName == QFormBuilderStrings::instance().lineClass) { + w = new QFrame(parentWidget); + static_cast<QFrame*>(w)->setFrameStyle(QFrame::HLine | QFrame::Sunken); + break; + } + const QByteArray widgetNameBA = widgetName.toUtf8(); + const char *widgetNameC = widgetNameBA.constData(); + if (w) { // symmetry for macro + } + +#define DECLARE_LAYOUT(L, C) +#define DECLARE_COMPAT_WIDGET(W, C) +#define DECLARE_WIDGET(W, C) else if (!qstrcmp(widgetNameC, #W)) { Q_ASSERT(w == 0); w = new W(parentWidget); } +#define DECLARE_WIDGET_1(W, C) else if (!qstrcmp(widgetNameC, #W)) { Q_ASSERT(w == 0); w = new W(0, parentWidget); } + +#include "widgets.table" + +#undef DECLARE_COMPAT_WIDGET +#undef DECLARE_LAYOUT +#undef DECLARE_WIDGET +#undef DECLARE_WIDGET_1 + + if (w) + break; + + // try with a registered custom widget + QDesignerCustomWidgetInterface *factory = m_customWidgets.value(widgetName); + if (factory != 0) + w = factory->createWidget(parentWidget); + } while(false); + + QFormBuilderExtra *fb = QFormBuilderExtra::instance(this); + if (w == 0) { // Attempt to instantiate base class of promoted/custom widgets + const QString baseClassName = fb->customWidgetBaseClass(widgetName); + if (!baseClassName.isEmpty()) { + qWarning() << QCoreApplication::translate("QFormBuilder", "QFormBuilder was unable to create a custom widget of the class '%1'; defaulting to base class '%2'.").arg(widgetName, baseClassName); + return createWidget(baseClassName, parentWidget, name); + } + } + + if (w == 0) { // nothing to do + qWarning() << QCoreApplication::translate("QFormBuilder", "QFormBuilder was unable to create a widget of the class '%1'.").arg(widgetName); + return 0; + } + + w->setObjectName(name); + + if (qobject_cast<QDialog *>(w)) + w->setParent(parentWidget); + + if (!fb->rootWidget()) + fb->setRootWidget(w); + + return w; +} + +/*! + \internal +*/ +QLayout *QFormBuilder::createLayout(const QString &layoutName, QObject *parent, const QString &name) +{ + QLayout *l = 0; + + QWidget *parentWidget = qobject_cast<QWidget*>(parent); + QLayout *parentLayout = qobject_cast<QLayout*>(parent); + + Q_ASSERT(parentWidget || parentLayout); + +#define DECLARE_WIDGET(W, C) +#define DECLARE_COMPAT_WIDGET(W, C) + +#define DECLARE_LAYOUT(L, C) \ + if (layoutName == QLatin1String(#L)) { \ + Q_ASSERT(l == 0); \ + l = parentLayout \ + ? new L() \ + : new L(parentWidget); \ + } + +#include "widgets.table" + +#undef DECLARE_LAYOUT +#undef DECLARE_COMPAT_WIDGET +#undef DECLARE_WIDGET + + if (l) { + l->setObjectName(name); + if (parentLayout) { + QWidget *w = qobject_cast<QWidget *>(parentLayout->parent()); + if (w && w->inherits("Q3GroupBox")) { + l->setContentsMargins(w->style()->pixelMetric(QStyle::PM_LayoutLeftMargin), + w->style()->pixelMetric(QStyle::PM_LayoutTopMargin), + w->style()->pixelMetric(QStyle::PM_LayoutRightMargin), + w->style()->pixelMetric(QStyle::PM_LayoutBottomMargin)); + QGridLayout *grid = qobject_cast<QGridLayout *>(l); + if (grid) { + grid->setHorizontalSpacing(-1); + grid->setVerticalSpacing(-1); + } else { + l->setSpacing(-1); + } + l->setAlignment(Qt::AlignTop); + } + } + } else { + qWarning() << QCoreApplication::translate("QFormBuilder", "The layout type `%1' is not supported.").arg(layoutName); + } + + return l; +} + +/*! + \internal +*/ +bool QFormBuilder::addItem(DomLayoutItem *ui_item, QLayoutItem *item, QLayout *layout) +{ + return QAbstractFormBuilder::addItem(ui_item, item, layout); +} + +/*! + \internal +*/ +bool QFormBuilder::addItem(DomWidget *ui_widget, QWidget *widget, QWidget *parentWidget) +{ + return QAbstractFormBuilder::addItem(ui_widget, widget, parentWidget); +} + +/*! + \internal +*/ +QWidget *QFormBuilder::widgetByName(QWidget *topLevel, const QString &name) +{ + Q_ASSERT(topLevel); + if (topLevel->objectName() == name) + return topLevel; + + return qFindChild<QWidget*>(topLevel, name); +} + +static QObject *objectByName(QWidget *topLevel, const QString &name) +{ + Q_ASSERT(topLevel); + if (topLevel->objectName() == name) + return topLevel; + + return qFindChild<QObject*>(topLevel, name); +} + +/*! + \internal +*/ +void QFormBuilder::createConnections(DomConnections *ui_connections, QWidget *widget) +{ + typedef QList<DomConnection*> DomConnectionList; + Q_ASSERT(widget != 0); + + if (ui_connections == 0) + return; + + const DomConnectionList connections = ui_connections->elementConnection(); + if (!connections.empty()) { + const DomConnectionList::const_iterator cend = connections.constEnd(); + for (DomConnectionList::const_iterator it = connections.constBegin(); it != cend; ++it) { + + QObject *sender = objectByName(widget, (*it)->elementSender()); + QObject *receiver = objectByName(widget, (*it)->elementReceiver()); + if (!sender || !receiver) + continue; + + QByteArray sig = (*it)->elementSignal().toUtf8(); + sig.prepend("2"); + QByteArray sl = (*it)->elementSlot().toUtf8(); + sl.prepend("1"); + QObject::connect(sender, sig, receiver, sl); + } + } +} + +/*! + \internal +*/ +QWidget *QFormBuilder::create(DomUI *ui, QWidget *parentWidget) +{ + return QAbstractFormBuilder::create(ui, parentWidget); +} + +/*! + \internal +*/ +QLayout *QFormBuilder::create(DomLayout *ui_layout, QLayout *layout, QWidget *parentWidget) +{ + // Is this a temporary layout widget used to represent QLayout hierarchies in Designer? + // Set its margins to 0. + bool layoutWidget = QFormBuilderExtra::instance(this)->processingLayoutWidget(); + QLayout *l = QAbstractFormBuilder::create(ui_layout, layout, parentWidget); + if (layoutWidget) { + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + int left, top, right, bottom; + left = top = right = bottom = 0; + const DomPropertyHash properties = propertyMap(ui_layout->elementProperty()); + + if (DomProperty *prop = properties.value(strings.leftMarginProperty)) + left = prop->elementNumber(); + + if (DomProperty *prop = properties.value(strings.topMarginProperty)) + top = prop->elementNumber(); + + if (DomProperty *prop = properties.value(strings.rightMarginProperty)) + right = prop->elementNumber(); + + if (DomProperty *prop = properties.value(strings.bottomMarginProperty)) + bottom = prop->elementNumber(); + + l->setContentsMargins(left, top, right, bottom); + QFormBuilderExtra::instance(this)->setProcessingLayoutWidget(false); + } + return l; +} + +/*! + \internal +*/ +QLayoutItem *QFormBuilder::create(DomLayoutItem *ui_layoutItem, QLayout *layout, QWidget *parentWidget) +{ + return QAbstractFormBuilder::create(ui_layoutItem, layout, parentWidget); +} + +/*! + \internal +*/ +QAction *QFormBuilder::create(DomAction *ui_action, QObject *parent) +{ + return QAbstractFormBuilder::create(ui_action, parent); +} + +/*! + \internal +*/ +QActionGroup *QFormBuilder::create(DomActionGroup *ui_action_group, QObject *parent) +{ + return QAbstractFormBuilder::create(ui_action_group, parent); +} + +/*! + Returns the list of paths the form builder searches for plugins. + + \sa addPluginPath() +*/ +QStringList QFormBuilder::pluginPaths() const +{ + return m_pluginPaths; +} + +/*! + Clears the list of paths that the form builder uses to search for + custom widget plugins. + + \sa pluginPaths() +*/ +void QFormBuilder::clearPluginPaths() +{ + m_pluginPaths.clear(); + updateCustomWidgets(); +} + +/*! + Adds a new plugin path specified by \a pluginPath to the list of + paths that will be searched by the form builder when loading a + custom widget plugin. + + \sa setPluginPath(), clearPluginPaths() +*/ +void QFormBuilder::addPluginPath(const QString &pluginPath) +{ + m_pluginPaths.append(pluginPath); + updateCustomWidgets(); +} + +/*! + Sets the list of plugin paths to the list specified by \a pluginPaths. + + \sa addPluginPath() +*/ +void QFormBuilder::setPluginPath(const QStringList &pluginPaths) +{ + m_pluginPaths = pluginPaths; + updateCustomWidgets(); +} + +static void insertPlugins(QObject *o, QMap<QString, QDesignerCustomWidgetInterface*> *customWidgets) +{ + // step 1) try with a normal plugin + if (QDesignerCustomWidgetInterface *iface = qobject_cast<QDesignerCustomWidgetInterface *>(o)) { + customWidgets->insert(iface->name(), iface); + return; + } + // step 2) try with a collection of plugins + if (QDesignerCustomWidgetCollectionInterface *c = qobject_cast<QDesignerCustomWidgetCollectionInterface *>(o)) { + foreach (QDesignerCustomWidgetInterface *iface, c->customWidgets()) + customWidgets->insert(iface->name(), iface); + } +} + +/*! + \internal +*/ +void QFormBuilder::updateCustomWidgets() +{ + m_customWidgets.clear(); + + foreach (QString path, m_pluginPaths) { + const QDir dir(path); + const QStringList candidates = dir.entryList(QDir::Files); + + foreach (const QString &plugin, candidates) { + if (!QLibrary::isLibrary(plugin)) + continue; + + QString loaderPath = path; + loaderPath += QLatin1Char('/'); + loaderPath += plugin; + + QPluginLoader loader(loaderPath); + if (loader.load()) + insertPlugins(loader.instance(), &m_customWidgets); + } + } + // Check statically linked plugins + const QObjectList staticPlugins = QPluginLoader::staticInstances(); + if (!staticPlugins.empty()) + foreach (QObject *o, staticPlugins) + insertPlugins(o, &m_customWidgets); +} + +/*! + \fn QList<QDesignerCustomWidgetInterface*> QFormBuilder::customWidgets() const + + Returns a list of the available plugins. +*/ +QList<QDesignerCustomWidgetInterface*> QFormBuilder::customWidgets() const +{ + return m_customWidgets.values(); +} + +/*! + \internal +*/ +void QFormBuilder::applyProperties(QObject *o, const QList<DomProperty*> &properties) +{ + typedef QList<DomProperty*> DomPropertyList; + + if (properties.empty()) + return; + + QFormBuilderExtra *fb = QFormBuilderExtra::instance(this); + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + + const DomPropertyList::const_iterator cend = properties.constEnd(); + for (DomPropertyList::const_iterator it = properties.constBegin(); it != cend; ++it) { + const QVariant v = toVariant(o->metaObject(), *it); + if (v.isNull()) + continue; + + const QString attributeName = (*it)->attributeName(); + if (o == fb->rootWidget() && attributeName == strings.geometryProperty) { + // apply only the size for the rootWidget + fb->rootWidget()->resize(qvariant_cast<QRect>(v).size()); + } else if (fb->applyPropertyInternally(o, attributeName, v)) { + } else if (!qstrcmp("QFrame", o->metaObject()->className ()) && attributeName == strings.orientationProperty) { + // ### special-casing for Line (QFrame) -- try to fix me + o->setProperty("frameShape", v); // v is of QFrame::Shape enum + } else { + o->setProperty(attributeName.toUtf8(), v); + } + } +} + +#ifdef QFORMINTERNAL_NAMESPACE +} // namespace QFormInternal +#endif + +QT_END_NAMESPACE diff --git a/tools/designer/src/lib/uilib/formbuilder.h b/tools/designer/src/lib/uilib/formbuilder.h new file mode 100644 index 0000000..a9fe900 --- /dev/null +++ b/tools/designer/src/lib/uilib/formbuilder.h @@ -0,0 +1,115 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef FORMBUILDER_H +#define FORMBUILDER_H + +#include <QtDesigner/uilib_global.h> +#include <QtDesigner/QAbstractFormBuilder> + +#include <QtCore/QStringList> +#include <QtCore/QMap> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE +#if 0 +// pragma for syncqt, don't remove. + +#pragma qt_class(QFormBuilder) +#endif + +class QDesignerCustomWidgetInterface; + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal +{ +#endif + +class QDESIGNER_UILIB_EXPORT QFormBuilder: public QAbstractFormBuilder +{ +public: + QFormBuilder(); + virtual ~QFormBuilder(); + + QStringList pluginPaths() const; + + void clearPluginPaths(); + void addPluginPath(const QString &pluginPath); + void setPluginPath(const QStringList &pluginPaths); + + QList<QDesignerCustomWidgetInterface*> customWidgets() const; + +protected: + virtual QWidget *create(DomUI *ui, QWidget *parentWidget); + virtual QWidget *create(DomWidget *ui_widget, QWidget *parentWidget); + virtual QLayout *create(DomLayout *ui_layout, QLayout *layout, QWidget *parentWidget); + virtual QLayoutItem *create(DomLayoutItem *ui_layoutItem, QLayout *layout, QWidget *parentWidget); + virtual QAction *create(DomAction *ui_action, QObject *parent); + virtual QActionGroup *create(DomActionGroup *ui_action_group, QObject *parent); + + virtual QWidget *createWidget(const QString &widgetName, QWidget *parentWidget, const QString &name); + virtual QLayout *createLayout(const QString &layoutName, QObject *parent, const QString &name); + + virtual void createConnections(DomConnections *connections, QWidget *widget); + + virtual bool addItem(DomLayoutItem *ui_item, QLayoutItem *item, QLayout *layout); + virtual bool addItem(DomWidget *ui_widget, QWidget *widget, QWidget *parentWidget); + + virtual void updateCustomWidgets(); + virtual void applyProperties(QObject *o, const QList<DomProperty*> &properties); + + static QWidget *widgetByName(QWidget *topLevel, const QString &name); + +private: + QStringList m_pluginPaths; + QMap<QString, QDesignerCustomWidgetInterface*> m_customWidgets; +}; + +#ifdef QFORMINTERNAL_NAMESPACE +} +#endif + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // FORMBUILDER_H diff --git a/tools/designer/src/lib/uilib/formbuilderextra.cpp b/tools/designer/src/lib/uilib/formbuilderextra.cpp new file mode 100644 index 0000000..cb82967 --- /dev/null +++ b/tools/designer/src/lib/uilib/formbuilderextra.cpp @@ -0,0 +1,531 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "formbuilderextra_p.h" +#include "abstractformbuilder.h" +#include "resourcebuilder_p.h" +#include "textbuilder_p.h" +#include "ui4_p.h" + +#include <QtGui/QLabel> +#include <QtGui/QBoxLayout> +#include <QtGui/QGridLayout> + +#include <QtCore/QVariant> +#include <QtCore/qdebug.h> +#include <QtCore/QTextStream> +#include <QtCore/QStringList> +#include <QtCore/QCoreApplication> + +QT_BEGIN_NAMESPACE + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal { +#endif + +void uiLibWarning(const QString &message) { + qWarning("Designer: %s", qPrintable(message)); +} + +QFormBuilderExtra::QFormBuilderExtra() : + m_layoutWidget(false), + m_resourceBuilder(0), + m_textBuilder(0) +{ +} + +QFormBuilderExtra::~QFormBuilderExtra() +{ + clearResourceBuilder(); + clearTextBuilder(); +} + +void QFormBuilderExtra::clear() +{ + m_buddies.clear(); + m_rootWidget = 0; +#ifndef QT_FORMBUILDER_NO_SCRIPT + m_FormScriptRunner.clearErrors(); + m_customWidgetScriptHash.clear(); +#endif + m_buttonGroups.clear(); +} + + +bool QFormBuilderExtra::applyPropertyInternally(QObject *o, const QString &propertyName, const QVariant &value) +{ + // Store buddies and apply them later on as the widgets might not exist yet. + QLabel *label = qobject_cast<QLabel*>(o); + if (!label || propertyName != QFormBuilderStrings::instance().buddyProperty) + return false; + + m_buddies.insert(label, value.toString()); + return true; +} + +void QFormBuilderExtra::applyInternalProperties() const +{ + if (m_buddies.empty()) + return; + + const BuddyHash::const_iterator cend = m_buddies.constEnd(); + for (BuddyHash::const_iterator it = m_buddies.constBegin(); it != cend; ++it ) + applyBuddy(it.value(), BuddyApplyAll, it.key()); +} + +bool QFormBuilderExtra::applyBuddy(const QString &buddyName, BuddyMode applyMode, QLabel *label) +{ + if (buddyName.isEmpty()) { + label->setBuddy(0); + return false; + } + + const QWidgetList widgets = qFindChildren<QWidget*>(label->topLevelWidget(), buddyName); + if (widgets.empty()) { + label->setBuddy(0); + return false; + } + + const QWidgetList::const_iterator cend = widgets.constEnd(); + for ( QWidgetList::const_iterator it = widgets.constBegin(); it != cend; ++it) { + if (applyMode == BuddyApplyAll || !(*it)->isHidden()) { + label->setBuddy(*it); + return true; + } + } + + label->setBuddy(0); + return false; +} + +const QPointer<QWidget> &QFormBuilderExtra::rootWidget() const +{ + return m_rootWidget; +} + +void QFormBuilderExtra::setRootWidget(const QPointer<QWidget> &w) +{ + m_rootWidget = w; +} + +#ifndef QT_FORMBUILDER_NO_SCRIPT +QFormScriptRunner &QFormBuilderExtra::formScriptRunner() +{ + return m_FormScriptRunner; +} + +void QFormBuilderExtra::storeCustomWidgetScript(const QString &className, const QString &script) +{ + m_customWidgetScriptHash.insert(className, script); +} + +QString QFormBuilderExtra::customWidgetScript(const QString &className) const +{ + const CustomWidgetScriptHash::const_iterator it = m_customWidgetScriptHash.constFind(className); + if ( it == m_customWidgetScriptHash.constEnd()) + return QString(); + return it.value(); +} + +#endif + +void QFormBuilderExtra::storeCustomWidgetBaseClass(const QString &className, const QString &baseClassName) +{ + m_customWidgetBaseClassHash.insert(className, baseClassName); +} + +QString QFormBuilderExtra::customWidgetBaseClass(const QString &className) const +{ + const QHash<QString, QString>::const_iterator it = m_customWidgetBaseClassHash.constFind(className); + if (it == m_customWidgetBaseClassHash.constEnd()) + return QString(); + return it.value(); +} + +void QFormBuilderExtra::storeCustomWidgetAddPageMethod(const QString &className, const QString &ct) +{ + m_customWidgetAddPageMethodHash.insert(className, ct); +} + +QString QFormBuilderExtra::customWidgetAddPageMethod(const QString &className) const +{ + const QHash<QString, QString>::const_iterator it = m_customWidgetAddPageMethodHash.constFind(className); + if (it == m_customWidgetAddPageMethodHash.constEnd()) + return QString(); + return it.value(); +} + +namespace { + typedef QHash<const QAbstractFormBuilder *, QFormBuilderExtra *> FormBuilderPrivateHash; +} + +Q_GLOBAL_STATIC(FormBuilderPrivateHash, g_FormBuilderPrivateHash) + +QFormBuilderExtra *QFormBuilderExtra::instance(const QAbstractFormBuilder *afb) +{ + FormBuilderPrivateHash &fbHash = *g_FormBuilderPrivateHash(); + + FormBuilderPrivateHash::iterator it = fbHash.find(afb); + if (it == fbHash.end()) + it = fbHash.insert(afb, new QFormBuilderExtra); + return it.value(); +} + +void QFormBuilderExtra::removeInstance(const QAbstractFormBuilder *afb) +{ + FormBuilderPrivateHash &fbHash = *g_FormBuilderPrivateHash(); + + FormBuilderPrivateHash::iterator it = fbHash.find(afb); + if (it != fbHash.end()) { + delete it.value(); + fbHash.erase(it); + } +} + +void QFormBuilderExtra::setProcessingLayoutWidget(bool processing) +{ + m_layoutWidget = processing; +} + + bool QFormBuilderExtra::processingLayoutWidget() const +{ + return m_layoutWidget; +} +void QFormBuilderExtra::setResourceBuilder(QResourceBuilder *builder) +{ + if (m_resourceBuilder == builder) + return; + clearResourceBuilder(); + m_resourceBuilder = builder; +} + +QResourceBuilder *QFormBuilderExtra::resourceBuilder() const +{ + return m_resourceBuilder; +} + +void QFormBuilderExtra::clearResourceBuilder() +{ + if (m_resourceBuilder) { + delete m_resourceBuilder; + m_resourceBuilder = 0; + } +} + +void QFormBuilderExtra::setTextBuilder(QTextBuilder *builder) +{ + if (m_textBuilder == builder) + return; + clearTextBuilder(); + m_textBuilder = builder; +} + +QTextBuilder *QFormBuilderExtra::textBuilder() const +{ + return m_textBuilder; +} + +void QFormBuilderExtra::clearTextBuilder() +{ + if (m_textBuilder) { + delete m_textBuilder; + m_textBuilder = 0; + } +} + +void QFormBuilderExtra::registerButtonGroups(const DomButtonGroups *domGroups) +{ + typedef QList<DomButtonGroup*> DomButtonGroupList; + const DomButtonGroupList domGroupList = domGroups->elementButtonGroup(); + const DomButtonGroupList::const_iterator cend = domGroupList.constEnd(); + for (DomButtonGroupList::const_iterator it = domGroupList.constBegin(); it != cend; ++it) { + DomButtonGroup *domGroup = *it; + m_buttonGroups.insert(domGroup->attributeName(), ButtonGroupEntry(domGroup, 0)); + } +} + +// Utilities for parsing per-cell integer properties that have setters and +// getters of the form 'setX(int idx, int value)' and 'x(int index)' +// (converting them to comma-separated string lists and back). +// Used for layout stretch and grid per-row/column properties. + +// Format a list of cell-properties of one dimension as a ','-separated list +template <class Layout> +inline QString perCellPropertyToString(const Layout *l, int count, int (Layout::*getter)(int) const) +{ + if (count == 0) + return QString(); + QString rc; + { + QTextStream str(&rc); + for (int i = 0; i < count; i++) { + if (i) + str << QLatin1Char(','); + str << (l->*getter)(i); + } + } + return rc; +} + +// Clear the property, set all cells to 0 + +template <class Layout> +inline void clearPerCellValue(Layout *l, int count, void (Layout::*setter)(int,int), int value = 0) +{ + for (int i = 0; i < count; i++) + (l->*setter)(i, value); +} + +// Parse and set the property from a comma-separated list + +template <class Layout> +inline bool parsePerCellProperty(Layout *l, int count, void (Layout::*setter)(int,int), const QString &s, int defaultValue = 0) +{ + if (s.isEmpty()) { + clearPerCellValue(l, count, setter, defaultValue); + return true; + } + const QStringList list = s.split(QLatin1Char(',')); + if (list.empty()) { + clearPerCellValue(l, count, setter, defaultValue); + return true; + } + // Apply all values contained in list + const int ac = qMin(count, list.size()); + bool ok; + int i = 0; + for ( ; i < ac; i++) { + const int value = list.at(i).toInt(&ok); + if (!ok || value < 0) + return false; + (l->*setter)(i, value); + } + // Clear rest + for ( ; i < count; i++) + (l->*setter)(i, defaultValue); + return true; +} + +// Read and write stretch +static QString msgInvalidStretch(const QString &objectName, const QString &stretch) +{ + //: Parsing layout stretch values + return QCoreApplication::translate("FormBuilder", "Invalid stretch value for '%1': '%2'").arg(objectName, stretch); +} + +QString QFormBuilderExtra::boxLayoutStretch(const QBoxLayout *box) +{ + return perCellPropertyToString(box, box->count(), &QBoxLayout::stretch); +} + +bool QFormBuilderExtra::setBoxLayoutStretch(const QString &s, QBoxLayout *box) +{ + const bool rc = parsePerCellProperty(box, box->count(), &QBoxLayout::setStretch, s); + if (!rc) + uiLibWarning(msgInvalidStretch(box->objectName(), s)); + return rc; +} + +void QFormBuilderExtra::clearBoxLayoutStretch(QBoxLayout *box) +{ + clearPerCellValue(box, box->count(), &QBoxLayout::setStretch); +} + +QString QFormBuilderExtra::gridLayoutRowStretch(const QGridLayout *grid) +{ + return perCellPropertyToString(grid, grid->rowCount(), &QGridLayout::rowStretch); +} + +bool QFormBuilderExtra::setGridLayoutRowStretch(const QString &s, QGridLayout *grid) +{ + const bool rc = parsePerCellProperty(grid, grid->rowCount(), &QGridLayout::setRowStretch, s); + if (!rc) + uiLibWarning(msgInvalidStretch(grid->objectName(), s)); + return rc; +} + +void QFormBuilderExtra::clearGridLayoutRowStretch(QGridLayout *grid) +{ + clearPerCellValue(grid, grid->rowCount(), &QGridLayout::setRowStretch); +} + +QString QFormBuilderExtra::gridLayoutColumnStretch(const QGridLayout *grid) +{ + return perCellPropertyToString(grid, grid->columnCount(), &QGridLayout::columnStretch); +} + +bool QFormBuilderExtra::setGridLayoutColumnStretch(const QString &s, QGridLayout *grid) +{ + const bool rc = parsePerCellProperty(grid, grid->columnCount(), &QGridLayout::setColumnStretch, s); + if (!rc) + uiLibWarning(msgInvalidStretch(grid->objectName(), s)); + return rc; +} + +void QFormBuilderExtra::clearGridLayoutColumnStretch(QGridLayout *grid) +{ + clearPerCellValue(grid, grid->columnCount(), &QGridLayout::setColumnStretch); +} + +// Read and write grid layout row/column size limits + +static QString msgInvalidMinimumSize(const QString &objectName, const QString &ms) +{ + //: Parsing grid layout minimum size values + return QCoreApplication::translate("FormBuilder", "Invalid minimum size for '%1': '%2'").arg(objectName, ms); +} + +QString QFormBuilderExtra::gridLayoutRowMinimumHeight(const QGridLayout *grid) +{ + return perCellPropertyToString(grid, grid->rowCount(), &QGridLayout::rowMinimumHeight); +} + +bool QFormBuilderExtra::setGridLayoutRowMinimumHeight(const QString &s, QGridLayout *grid) +{ + const bool rc = parsePerCellProperty(grid, grid->rowCount(), &QGridLayout::setRowMinimumHeight, s); + if (!rc) + uiLibWarning(msgInvalidMinimumSize(grid->objectName(), s)); + return rc; +} + +void QFormBuilderExtra::clearGridLayoutRowMinimumHeight(QGridLayout *grid) +{ + clearPerCellValue(grid, grid->rowCount(), &QGridLayout::setRowMinimumHeight); +} + +QString QFormBuilderExtra::gridLayoutColumnMinimumWidth(const QGridLayout *grid) +{ + return perCellPropertyToString(grid, grid->columnCount(), &QGridLayout::columnMinimumWidth); +} + +bool QFormBuilderExtra::setGridLayoutColumnMinimumWidth(const QString &s, QGridLayout *grid) +{ + const bool rc = parsePerCellProperty(grid, grid->columnCount(), &QGridLayout::setColumnMinimumWidth, s); + if (!rc) + uiLibWarning(msgInvalidMinimumSize(grid->objectName(), s)); + return rc; +} + +void QFormBuilderExtra::clearGridLayoutColumnMinimumWidth(QGridLayout *grid) +{ + clearPerCellValue(grid, grid->columnCount(), &QGridLayout::setColumnMinimumWidth); +} + +// ------------ QFormBuilderStrings + +QFormBuilderStrings::QFormBuilderStrings() : + buddyProperty(QLatin1String("buddy")), + cursorProperty(QLatin1String("cursor")), + objectNameProperty(QLatin1String("objectName")), + trueValue(QLatin1String("true")), + falseValue(QLatin1String("false")), + horizontalPostFix(QLatin1String("Horizontal")), + separator(QLatin1String("separator")), + defaultTitle(QLatin1String("Page")), + titleAttribute(QLatin1String("title")), + labelAttribute(QLatin1String("label")), + toolTipAttribute(QLatin1String("toolTip")), + whatsThisAttribute(QLatin1String("whatsThis")), + flagsAttribute(QLatin1String("flags")), + iconAttribute(QLatin1String("icon")), + pixmapAttribute(QLatin1String("pixmap")), + textAttribute(QLatin1String("text")), + currentIndexProperty(QLatin1String("currentIndex")), + toolBarAreaAttribute(QLatin1String("toolBarArea")), + toolBarBreakAttribute(QLatin1String("toolBarBreak")), + dockWidgetAreaAttribute(QLatin1String("dockWidgetArea")), + marginProperty(QLatin1String("margin")), + spacingProperty(QLatin1String("spacing")), + leftMarginProperty(QLatin1String("leftMargin")), + topMarginProperty(QLatin1String("topMargin")), + rightMarginProperty(QLatin1String("rightMargin")), + bottomMarginProperty(QLatin1String("bottomMargin")), + horizontalSpacingProperty(QLatin1String("horizontalSpacing")), + verticalSpacingProperty(QLatin1String("verticalSpacing")), + sizeHintProperty(QLatin1String("sizeHint")), + sizeTypeProperty(QLatin1String("sizeType")), + orientationProperty(QLatin1String("orientation")), + styleSheetProperty(QLatin1String("styleSheet")), + qtHorizontal(QLatin1String("Qt::Horizontal")), + qtVertical(QLatin1String("Qt::Vertical")), + currentRowProperty(QLatin1String("currentRow")), + tabSpacingProperty(QLatin1String("tabSpacing")), + qWidgetClass(QLatin1String("QWidget")), + lineClass(QLatin1String("Line")), + geometryProperty(QLatin1String("geometry")), + scriptWidgetVariable(QLatin1String("widget")), + scriptChildWidgetsVariable(QLatin1String("childWidgets")) +{ + itemRoles.append(qMakePair(Qt::FontRole, QString::fromLatin1("font"))); + itemRoles.append(qMakePair(Qt::TextAlignmentRole, QString::fromLatin1("textAlignment"))); + itemRoles.append(qMakePair(Qt::BackgroundRole, QString::fromLatin1("background"))); + itemRoles.append(qMakePair(Qt::ForegroundRole, QString::fromLatin1("foreground"))); + itemRoles.append(qMakePair(Qt::CheckStateRole, QString::fromLatin1("checkState"))); + + foreach (const RoleNName &it, itemRoles) + treeItemRoleHash.insert(it.second, it.first); + + itemTextRoles.append(qMakePair(qMakePair(Qt::EditRole, Qt::DisplayPropertyRole), + textAttribute)); // This must be first for the loop below + itemTextRoles.append(qMakePair(qMakePair(Qt::ToolTipRole, Qt::ToolTipPropertyRole), + toolTipAttribute)); + itemTextRoles.append(qMakePair(qMakePair(Qt::StatusTipRole, Qt::StatusTipPropertyRole), + QString::fromLatin1("statusTip"))); + itemTextRoles.append(qMakePair(qMakePair(Qt::WhatsThisRole, Qt::WhatsThisPropertyRole), + whatsThisAttribute)); + + // Note: this skips the first item! + QList<TextRoleNName>::const_iterator it = itemTextRoles.constBegin(), end = itemTextRoles.constEnd(); + while (++it != end) + treeItemTextRoleHash.insert(it->second, it->first); +} + +const QFormBuilderStrings &QFormBuilderStrings::instance() +{ + static const QFormBuilderStrings rc; + return rc; +} + +#ifdef QFORMINTERNAL_NAMESPACE +} // namespace QFormInternal +#endif + +QT_END_NAMESPACE diff --git a/tools/designer/src/lib/uilib/formbuilderextra_p.h b/tools/designer/src/lib/uilib/formbuilderextra_p.h new file mode 100644 index 0000000..f357239 --- /dev/null +++ b/tools/designer/src/lib/uilib/formbuilderextra_p.h @@ -0,0 +1,255 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef ABSTRACTFORMBUILDERPRIVATE_H +#define ABSTRACTFORMBUILDERPRIVATE_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include "uilib_global.h" + +#ifndef QT_FORMBUILDER_NO_SCRIPT +# include "formscriptrunner_p.h" +#endif + +#include <QtCore/QHash> +#include <QtCore/QPointer> +#include <QtCore/QString> + +QT_BEGIN_NAMESPACE + +class QObject; +class QVariant; +class QWidget; +class QObject; +class QLabel; +class QButtonGroup; + +class QBoxLayout; +class QGridLayout; + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal +{ +#endif + +class DomButtonGroups; +class DomButtonGroup; + +class QAbstractFormBuilder; +class QResourceBuilder; +class QTextBuilder; + +class QDESIGNER_UILIB_EXPORT QFormBuilderExtra +{ + QFormBuilderExtra(); + ~QFormBuilderExtra(); +public: + void clear(); + + bool applyPropertyInternally(QObject *o, const QString &propertyName, const QVariant &value); + + enum BuddyMode { BuddyApplyAll, BuddyApplyVisibleOnly }; + + void applyInternalProperties() const; + static bool applyBuddy(const QString &buddyName, BuddyMode applyMode, QLabel *label); + + const QPointer<QWidget> &rootWidget() const; + void setRootWidget(const QPointer<QWidget> &w); + +#ifndef QT_FORMBUILDER_NO_SCRIPT + QFormScriptRunner &formScriptRunner(); + void storeCustomWidgetScript(const QString &className, const QString &script); + QString customWidgetScript(const QString &className) const; +#endif + + void setProcessingLayoutWidget(bool processing); + bool processingLayoutWidget() const; + + void setResourceBuilder(QResourceBuilder *builder); + QResourceBuilder *resourceBuilder() const; + + void setTextBuilder(QTextBuilder *builder); + QTextBuilder *textBuilder() const; + + static QFormBuilderExtra *instance(const QAbstractFormBuilder *afb); + static void removeInstance(const QAbstractFormBuilder *afb); + + void storeCustomWidgetAddPageMethod(const QString &className, const QString &ct); + QString customWidgetAddPageMethod(const QString &className) const; + + void storeCustomWidgetBaseClass(const QString &className, const QString &baseClassName); + QString customWidgetBaseClass(const QString &className) const; + + // --- Hash used in creating button groups on demand. Store a map of name and pair of dom group and real group + void registerButtonGroups(const DomButtonGroups *groups); + + typedef QPair<DomButtonGroup *, QButtonGroup*> ButtonGroupEntry; + typedef QHash<QString, ButtonGroupEntry> ButtonGroupHash; + const ButtonGroupHash &buttonGroups() const { return m_buttonGroups; } + ButtonGroupHash &buttonGroups() { return m_buttonGroups; } + + // return stretch as a comma-separated list + static QString boxLayoutStretch(const QBoxLayout*); + // apply stretch + static bool setBoxLayoutStretch(const QString &, QBoxLayout*); + static void clearBoxLayoutStretch(QBoxLayout*); + + static QString gridLayoutRowStretch(const QGridLayout *); + static bool setGridLayoutRowStretch(const QString &, QGridLayout *); + static void clearGridLayoutRowStretch(QGridLayout *); + + static QString gridLayoutColumnStretch(const QGridLayout *); + static bool setGridLayoutColumnStretch(const QString &, QGridLayout *); + static void clearGridLayoutColumnStretch(QGridLayout *); + + // return the row/column sizes as comma-separated lists + static QString gridLayoutRowMinimumHeight(const QGridLayout *); + static bool setGridLayoutRowMinimumHeight(const QString &, QGridLayout *); + static void clearGridLayoutRowMinimumHeight(QGridLayout *); + + static QString gridLayoutColumnMinimumWidth(const QGridLayout *); + static bool setGridLayoutColumnMinimumWidth(const QString &, QGridLayout *); + static void clearGridLayoutColumnMinimumWidth(QGridLayout *); + +private: + void clearResourceBuilder(); + void clearTextBuilder(); + + typedef QHash<QLabel*, QString> BuddyHash; + BuddyHash m_buddies; + +#ifndef QT_FORMBUILDER_NO_SCRIPT + QFormScriptRunner m_FormScriptRunner; + + typedef QHash<QString, QString> CustomWidgetScriptHash; + CustomWidgetScriptHash m_customWidgetScriptHash; +#endif + + QHash<QString, QString> m_customWidgetAddPageMethodHash; + QHash<QString, QString> m_customWidgetBaseClassHash; + + ButtonGroupHash m_buttonGroups; + + bool m_layoutWidget; + QResourceBuilder *m_resourceBuilder; + QTextBuilder *m_textBuilder; + + QPointer<QWidget> m_rootWidget; +}; + +void uiLibWarning(const QString &message); + +// Struct with static accessor that provides most strings used in the form builder. +struct QDESIGNER_UILIB_EXPORT QFormBuilderStrings { + QFormBuilderStrings(); + + static const QFormBuilderStrings &instance(); + + const QString buddyProperty; + const QString cursorProperty; + const QString objectNameProperty; + const QString trueValue; + const QString falseValue; + const QString horizontalPostFix; + const QString separator; + const QString defaultTitle; + const QString titleAttribute; + const QString labelAttribute; + const QString toolTipAttribute; + const QString whatsThisAttribute; + const QString flagsAttribute; + const QString iconAttribute; + const QString pixmapAttribute; + const QString textAttribute; + const QString currentIndexProperty; + const QString toolBarAreaAttribute; + const QString toolBarBreakAttribute; + const QString dockWidgetAreaAttribute; + const QString marginProperty; + const QString spacingProperty; + const QString leftMarginProperty; + const QString topMarginProperty; + const QString rightMarginProperty; + const QString bottomMarginProperty; + const QString horizontalSpacingProperty; + const QString verticalSpacingProperty; + const QString sizeHintProperty; + const QString sizeTypeProperty; + const QString orientationProperty; + const QString styleSheetProperty; + const QString qtHorizontal; + const QString qtVertical; + const QString currentRowProperty; + const QString tabSpacingProperty; + const QString qWidgetClass; + const QString lineClass; + const QString geometryProperty; + const QString scriptWidgetVariable; + const QString scriptChildWidgetsVariable; + + typedef QPair<Qt::ItemDataRole, QString> RoleNName; + QList<RoleNName> itemRoles; + QHash<QString, Qt::ItemDataRole> treeItemRoleHash; + + // first.first is primary role, first.second is shadow role. + // Shadow is used for either the translation source or the designer + // representation of the string value. + typedef QPair<QPair<Qt::ItemDataRole, Qt::ItemDataRole>, QString> TextRoleNName; + QList<TextRoleNName> itemTextRoles; + QHash<QString, QPair<Qt::ItemDataRole, Qt::ItemDataRole> > treeItemTextRoleHash; +}; +#ifdef QFORMINTERNAL_NAMESPACE +} +#endif + +QT_END_NAMESPACE + +#endif // ABSTRACTFORMBUILDERPRIVATE_H diff --git a/tools/designer/src/lib/uilib/formscriptrunner.cpp b/tools/designer/src/lib/uilib/formscriptrunner.cpp new file mode 100644 index 0000000..d07673a --- /dev/null +++ b/tools/designer/src/lib/uilib/formscriptrunner.cpp @@ -0,0 +1,208 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "formscriptrunner_p.h" +#include "formbuilderextra_p.h" +#include "ui4_p.h" + +#include <QtScript/QScriptEngine> +#include <QtGui/QWidget> +#include <QtCore/QDebug> +#include <QtCore/QCoreApplication> + +QT_BEGIN_NAMESPACE + +namespace { + enum { debugFormScriptRunner = 0 }; +} + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal { +#endif + +class QFormScriptRunner::QFormScriptRunnerPrivate { +public: + QFormScriptRunnerPrivate() : m_options(DisableScripts) {} + void clearErrors() { m_errors.clear(); } + + bool run(const QString &script, QWidget *widget, const WidgetList &children, QString *errorMessage); + + static void initializeEngine(QWidget *w, const WidgetList &children, QScriptEngine &scriptEngine); + static QString engineError(QScriptEngine &scriptEngine); + + Options options() const { return m_options; } + void setOptions(Options options) { m_options = options; } + + Errors errors() const { return m_errors; } +private: + QScriptEngine m_scriptEngine; + Options m_options; + Errors m_errors; +}; + +bool QFormScriptRunner::QFormScriptRunnerPrivate::run(const QString &script, QWidget *widget, const WidgetList &children, QString *errorMessage) { + bool rc = false; + initializeEngine(widget, children, m_scriptEngine); + + do { + m_scriptEngine.evaluate(script); + if (m_scriptEngine.hasUncaughtException ()) { + *errorMessage = QCoreApplication::tr("Exception at line %1: %2").arg(m_scriptEngine.uncaughtExceptionLineNumber()).arg(engineError(m_scriptEngine)); + break; + } + rc = true; + } while (false); + m_scriptEngine.popContext(); + + if (!rc) { + Error error; + error.objectName = widget->objectName(); + error.script = script; + error.errorMessage = *errorMessage; + m_errors.push_back(error); + } + return rc; +} + +void QFormScriptRunner::QFormScriptRunnerPrivate::initializeEngine(QWidget *w, const WidgetList &children, QScriptEngine &scriptEngine) { + // Populate the script variables. This pushes a context which must be popped. + QScriptContext *ctx = scriptEngine.pushContext(); + QScriptValue widgetObject = scriptEngine.newQObject(w); + QScriptValue childrenArray = scriptEngine.newArray (children.size()); + + for(int i = 0; i < children.size(); i++) { + childrenArray.setProperty(i, scriptEngine.newQObject(children[i])); + } + + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + ctx ->activationObject().setProperty(strings.scriptWidgetVariable, widgetObject); + ctx ->activationObject().setProperty(strings.scriptChildWidgetsVariable, childrenArray); +} + +QString QFormScriptRunner::QFormScriptRunnerPrivate::engineError(QScriptEngine &scriptEngine) { + QScriptValue error = scriptEngine.evaluate(QLatin1String("Error")); + if (error.isValid()) + return error.toString(); + return QCoreApplication::tr("Unknown error"); +} +// -- QFormScriptRunner + +QFormScriptRunner::QFormScriptRunner() : m_impl(new QFormScriptRunnerPrivate) +{ +} + +QFormScriptRunner::~QFormScriptRunner() +{ + delete m_impl; +} + +bool QFormScriptRunner::run(const DomWidget *domWidget, + const QString &customWidgetScript, + QWidget *widget, const WidgetList &children, + QString *errorMessage) +{ + typedef QList<DomScript*> DomScripts; + + const Options scriptOptions = m_impl->options(); + if (scriptOptions & DisableScripts) + return true; + // get list + const DomScripts domScripts = domWidget->elementScript(); + // Concatenate snippets, starting with custom widget script + QString script = customWidgetScript; + if (script.isEmpty() && domScripts.empty()) + return true; + + foreach (const DomScript *scriptSnippet, domScripts) { + // Ensure new line + if (!script.isEmpty() && !script.endsWith(QLatin1Char('\n'))) + script += QLatin1Char('\n'); + script += scriptSnippet->text(); + } + + if (script.isEmpty()) + return true; + + const bool rc = m_impl->run(script, widget, children, errorMessage); + + if (debugFormScriptRunner) { + qDebug() << "For " << widget << " with " << children.size() << " children, ran: " << script; + if (!rc) + qDebug() << *errorMessage; + } + + if (!rc) { + if (!(scriptOptions & DisableWarnings)) { + const QString message = QCoreApplication::tr("An error occurred while running the script for %1: %2\nScript: %3"). + arg(widget->objectName()).arg(*errorMessage).arg(script); + qWarning() << message; + } + } + return rc; +} + +QFormScriptRunner::Options QFormScriptRunner::options() const +{ + return m_impl->options(); +} + +void QFormScriptRunner::setOptions(Options options) +{ + m_impl->setOptions(options); +} + + +QFormScriptRunner::Errors QFormScriptRunner::errors() const +{ + return m_impl->errors(); +} + +void QFormScriptRunner::clearErrors() +{ + m_impl->clearErrors(); +} + + +#ifdef QFORMINTERNAL_NAMESPACE +} // namespace QFormInternal +#endif + +QT_END_NAMESPACE diff --git a/tools/designer/src/lib/uilib/formscriptrunner_p.h b/tools/designer/src/lib/uilib/formscriptrunner_p.h new file mode 100644 index 0000000..f53120c --- /dev/null +++ b/tools/designer/src/lib/uilib/formscriptrunner_p.h @@ -0,0 +1,120 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef FORMSCRIPTRUNNER_H +#define FORMSCRIPTRUNNER_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtDesigner/uilib_global.h> +#include <QtCore/QList> +#include <QtCore/QFlags> +#include <QtCore/QString> + +QT_BEGIN_NAMESPACE + +class QWidget; + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal +{ +#endif + +class DomWidget; + +class QDESIGNER_UILIB_EXPORT QFormScriptRunner +{ +public: + QFormScriptRunner(); + ~QFormScriptRunner(); + + typedef QList<QWidget*> WidgetList; + + bool run(const DomWidget *domWidget, + const QString &customWidgetScript, + QWidget *widget, const WidgetList &children, + QString *errorMessage); + + struct Error { + QString objectName; + QString script; + QString errorMessage; + }; + typedef QList<Error> Errors; + Errors errors() const; + void clearErrors(); + + enum Option { + NoOptions = 0x0, + DisableWarnings = 0x1, + DisableScripts = 02 + }; + Q_DECLARE_FLAGS(Options, Option) + + Options options() const; + void setOptions(Options options); + +private: + class QFormScriptRunnerPrivate; + QFormScriptRunnerPrivate *m_impl; + + QFormScriptRunner(const QFormScriptRunner &); + void operator = (const QFormScriptRunner &); +}; + +Q_DECLARE_OPERATORS_FOR_FLAGS(QFormScriptRunner::Options) + +#ifdef QFORMINTERNAL_NAMESPACE +} +#endif + +QT_END_NAMESPACE + +#endif // FORMSCRIPTRUNNER_H diff --git a/tools/designer/src/lib/uilib/properties.cpp b/tools/designer/src/lib/uilib/properties.cpp new file mode 100644 index 0000000..2cf9bf9 --- /dev/null +++ b/tools/designer/src/lib/uilib/properties.cpp @@ -0,0 +1,676 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "properties_p.h" +#include "ui4_p.h" +#include "abstractformbuilder.h" +#include "formbuilderextra_p.h" +#include "resourcebuilder_p.h" + +#include <QtCore/QDateTime> +#include <QtCore/QUrl> +#include <QtCore/qdebug.h> + +#include <QtGui/QIcon> +#include <QtGui/QPixmap> +#include <QtGui/QFont> +#include <QtGui/QFrame> +#include <QtGui/QAbstractScrollArea> + +QT_BEGIN_NAMESPACE + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal +{ +#endif + +static inline void fixEnum(QString &s) +{ + int qualifierIndex = s.lastIndexOf(QLatin1Char(':')); + if (qualifierIndex == -1) + qualifierIndex = s.lastIndexOf(QLatin1Char('.')); + if (qualifierIndex != -1) + s.remove(0, qualifierIndex + 1); +} +// Convert complex DOM types with the help of QAbstractFormBuilder +QVariant domPropertyToVariant(QAbstractFormBuilder *afb,const QMetaObject *meta,const DomProperty *p) +{ + // Complex types that need functions from QAbstractFormBuilder + switch(p->kind()) { + case DomProperty::String: { + const int index = meta->indexOfProperty(p->attributeName().toUtf8()); + if (index != -1 && meta->property(index).type() == QVariant::KeySequence) + return qVariantFromValue(QKeySequence(p->elementString()->text())); + } + break; + + case DomProperty::Palette: { + const DomPalette *dom = p->elementPalette(); + QPalette palette; + + if (dom->elementActive()) + afb->setupColorGroup(palette, QPalette::Active, dom->elementActive()); + + if (dom->elementInactive()) + afb->setupColorGroup(palette, QPalette::Inactive, dom->elementInactive()); + + if (dom->elementDisabled()) + afb->setupColorGroup(palette, QPalette::Disabled, dom->elementDisabled()); + + palette.setCurrentColorGroup(QPalette::Active); + return qVariantFromValue(palette); + } + + case DomProperty::Set: { + const QByteArray pname = p->attributeName().toUtf8(); + const int index = meta->indexOfProperty(pname); + if (index == -1) { + uiLibWarning(QCoreApplication::translate("QFormBuilder", "The set-type property %1 could not be read.").arg(p->attributeName())); + return QVariant(); + } + + const QMetaEnum e = meta->property(index).enumerator(); + Q_ASSERT(e.isFlag() == true); + return QVariant(e.keysToValue(p->elementSet().toUtf8())); + } + + case DomProperty::Enum: { + const QByteArray pname = p->attributeName().toUtf8(); + const int index = meta->indexOfProperty(pname); + QString enumValue = p->elementEnum(); + // Triggers in case of objects in Designer like Spacer/Line for which properties + // are serialized using language introspection. On preview, however, these objects are + // emulated by hacks in the formbuilder (size policy/orientation) + fixEnum(enumValue); + if (index == -1) { + // ### special-casing for Line (QFrame) -- fix for 4.2. Jambi hack for enumerations + if (!qstrcmp(meta->className(), "QFrame") + && (pname == QByteArray("orientation"))) { + return QVariant(enumValue == QFormBuilderStrings::instance().horizontalPostFix ? QFrame::HLine : QFrame::VLine); + } else { + uiLibWarning(QCoreApplication::translate("QFormBuilder", "The enumeration-type property %1 could not be read.").arg(p->attributeName())); + return QVariant(); + } + } + + const QMetaEnum e = meta->property(index).enumerator(); + return QVariant(e.keyToValue(enumValue.toUtf8())); + } + case DomProperty::Brush: + return qVariantFromValue(afb->setupBrush(p->elementBrush())); + default: + if (afb->resourceBuilder()->isResourceProperty(p)) { + return afb->resourceBuilder()->loadResource(afb->workingDirectory(), p); + } + + break; + } + + // simple type + return domPropertyToVariant(p); +} + +// Convert simple DOM types +QVariant domPropertyToVariant(const DomProperty *p) +{ + // requires non-const virtual nameToIcon, etc. + switch(p->kind()) { + case DomProperty::Bool: + return QVariant(p->elementBool() == QFormBuilderStrings::instance().trueValue); + + case DomProperty::Cstring: + return QVariant(p->elementCstring().toUtf8()); + + case DomProperty::Point: { + const DomPoint *point = p->elementPoint(); + return QVariant(QPoint(point->elementX(), point->elementY())); + } + + case DomProperty::PointF: { + const DomPointF *pointf = p->elementPointF(); + return QVariant(QPointF(pointf->elementX(), pointf->elementY())); + } + + case DomProperty::Size: { + const DomSize *size = p->elementSize(); + return QVariant(QSize(size->elementWidth(), size->elementHeight())); + } + + case DomProperty::SizeF: { + const DomSizeF *sizef = p->elementSizeF(); + return QVariant(QSizeF(sizef->elementWidth(), sizef->elementHeight())); + } + + case DomProperty::Rect: { + const DomRect *rc = p->elementRect(); + const QRect g(rc->elementX(), rc->elementY(), rc->elementWidth(), rc->elementHeight()); + return QVariant(g); + } + + case DomProperty::RectF: { + const DomRectF *rcf = p->elementRectF(); + const QRectF g(rcf->elementX(), rcf->elementY(), rcf->elementWidth(), rcf->elementHeight()); + return QVariant(g); + } + + case DomProperty::String: + return QVariant(p->elementString()->text()); + + case DomProperty::Number: + return QVariant(p->elementNumber()); + + case DomProperty::UInt: + return QVariant(p->elementUInt()); + + case DomProperty::LongLong: + return QVariant(p->elementLongLong()); + + case DomProperty::ULongLong: + return QVariant(p->elementULongLong()); + + case DomProperty::Double: + return QVariant(p->elementDouble()); + + case DomProperty::Char: { + const DomChar *character = p->elementChar(); + const QChar c(character->elementUnicode()); + return qVariantFromValue(c); + } + + case DomProperty::Color: { + const DomColor *color = p->elementColor(); + QColor c(color->elementRed(), color->elementGreen(), color->elementBlue()); + if (color->hasAttributeAlpha()) + c.setAlpha(color->attributeAlpha()); + return qVariantFromValue(c); + } + + case DomProperty::Font: { + const DomFont *font = p->elementFont(); + + QFont f; + if (font->hasElementFamily() && !font->elementFamily().isEmpty()) + f.setFamily(font->elementFamily()); + if (font->hasElementPointSize() && font->elementPointSize() > 0) + f.setPointSize(font->elementPointSize()); + if (font->hasElementWeight() && font->elementWeight() > 0) + f.setWeight(font->elementWeight()); + if (font->hasElementItalic()) + f.setItalic(font->elementItalic()); + if (font->hasElementBold()) + f.setBold(font->elementBold()); + if (font->hasElementUnderline()) + f.setUnderline(font->elementUnderline()); + if (font->hasElementStrikeOut()) + f.setStrikeOut(font->elementStrikeOut()); + if (font->hasElementKerning()) + f.setKerning(font->elementKerning()); + if (font->hasElementAntialiasing()) + f.setStyleStrategy(font->elementAntialiasing() ? QFont::PreferDefault : QFont::NoAntialias); + if (font->hasElementStyleStrategy()) { + f.setStyleStrategy(enumKeyOfObjectToValue<QAbstractFormBuilderGadget, QFont::StyleStrategy>("styleStrategy", font->elementStyleStrategy().toLatin1())); + } + return qVariantFromValue(f); + } + + case DomProperty::Date: { + const DomDate *date = p->elementDate(); + return QVariant(QDate(date->elementYear(), date->elementMonth(), date->elementDay())); + } + + case DomProperty::Time: { + const DomTime *t = p->elementTime(); + return QVariant(QTime(t->elementHour(), t->elementMinute(), t->elementSecond())); + } + + case DomProperty::DateTime: { + const DomDateTime *dateTime = p->elementDateTime(); + const QDate d(dateTime->elementYear(), dateTime->elementMonth(), dateTime->elementDay()); + const QTime tm(dateTime->elementHour(), dateTime->elementMinute(), dateTime->elementSecond()); + return QVariant(QDateTime(d, tm)); + } + + case DomProperty::Url: { + const DomUrl *url = p->elementUrl(); + return QVariant(QUrl(url->elementString()->text())); + } + +#ifndef QT_NO_CURSOR + case DomProperty::Cursor: + return qVariantFromValue(QCursor(static_cast<Qt::CursorShape>(p->elementCursor()))); + + case DomProperty::CursorShape: + return qVariantFromValue(QCursor(enumKeyOfObjectToValue<QAbstractFormBuilderGadget, Qt::CursorShape>("cursorShape", p->elementCursorShape().toLatin1()))); +#endif + + case DomProperty::Locale: { + const DomLocale *locale = p->elementLocale(); + return qVariantFromValue(QLocale(enumKeyOfObjectToValue<QAbstractFormBuilderGadget, QLocale::Language>("language", locale->attributeLanguage().toLatin1()), + enumKeyOfObjectToValue<QAbstractFormBuilderGadget, QLocale::Country>("country", locale->attributeCountry().toLatin1()))); + } + case DomProperty::SizePolicy: { + const DomSizePolicy *sizep = p->elementSizePolicy(); + + QSizePolicy sizePolicy; + sizePolicy.setHorizontalStretch(sizep->elementHorStretch()); + sizePolicy.setVerticalStretch(sizep->elementVerStretch()); + + const QMetaEnum sizeType_enum = metaEnum<QAbstractFormBuilderGadget>("sizeType"); + + if (sizep->hasElementHSizeType()) { + sizePolicy.setHorizontalPolicy((QSizePolicy::Policy) sizep->elementHSizeType()); + } else if (sizep->hasAttributeHSizeType()) { + const QSizePolicy::Policy sp = enumKeyToValue<QSizePolicy::Policy>(sizeType_enum, sizep->attributeHSizeType().toLatin1()); + sizePolicy.setHorizontalPolicy(sp); + } + + if (sizep->hasElementVSizeType()) { + sizePolicy.setVerticalPolicy((QSizePolicy::Policy) sizep->elementVSizeType()); + } else if (sizep->hasAttributeVSizeType()) { + const QSizePolicy::Policy sp = enumKeyToValue<QSizePolicy::Policy>(sizeType_enum, sizep->attributeVSizeType().toLatin1()); + sizePolicy.setVerticalPolicy(sp); + } + + return qVariantFromValue(sizePolicy); + } + + case DomProperty::StringList: + return QVariant(p->elementStringList()->elementString()); + + default: + uiLibWarning(QCoreApplication::translate("QFormBuilder", "Reading properties of the type %1 is not supported yet.").arg(p->kind())); + break; + } + + return QVariant(); +} + +// Apply a simple variant type to a DOM property +static bool applySimpleProperty(const QVariant &v, bool translateString, DomProperty *dom_prop) +{ + switch (v.type()) { + case QVariant::String: { + DomString *str = new DomString(); + str->setText(v.toString()); + if (!translateString) + str->setAttributeNotr(QLatin1String("true")); + dom_prop->setElementString(str); + } + return true; + + case QVariant::ByteArray: + dom_prop->setElementCstring(QString::fromUtf8(v.toByteArray())); + return true; + + case QVariant::Int: + dom_prop->setElementNumber(v.toInt()); + return true; + + case QVariant::UInt: + dom_prop->setElementUInt(v.toUInt()); + return true; + + case QVariant::LongLong: + dom_prop->setElementLongLong(v.toLongLong()); + return true; + + case QVariant::ULongLong: + dom_prop->setElementULongLong(v.toULongLong()); + return true; + + case QVariant::Double: + dom_prop->setElementDouble(v.toDouble()); + return true; + + case QVariant::Bool: + dom_prop->setElementBool(v.toBool() ? QFormBuilderStrings::instance().trueValue : QFormBuilderStrings::instance().falseValue); + return true; + + case QVariant::Char: { + DomChar *ch = new DomChar(); + const QChar character = v.toChar(); + ch->setElementUnicode(character.unicode()); + dom_prop->setElementChar(ch); + } + return true; + + case QVariant::Point: { + DomPoint *pt = new DomPoint(); + const QPoint point = v.toPoint(); + pt->setElementX(point.x()); + pt->setElementY(point.y()); + dom_prop->setElementPoint(pt); + } + return true; + + case QVariant::PointF: { + DomPointF *ptf = new DomPointF(); + const QPointF pointf = v.toPointF(); + ptf->setElementX(pointf.x()); + ptf->setElementY(pointf.y()); + dom_prop->setElementPointF(ptf); + } + return true; + + case QVariant::Color: { + DomColor *clr = new DomColor(); + const QColor color = qvariant_cast<QColor>(v); + clr->setElementRed(color.red()); + clr->setElementGreen(color.green()); + clr->setElementBlue(color.blue()); + const int alphaChannel = color.alpha(); + if (alphaChannel != 255) + clr->setAttributeAlpha(alphaChannel); + dom_prop->setElementColor(clr); + } + return true; + + case QVariant::Size: { + DomSize *sz = new DomSize(); + const QSize size = v.toSize(); + sz->setElementWidth(size.width()); + sz->setElementHeight(size.height()); + dom_prop->setElementSize(sz); + } + return true; + + case QVariant::SizeF: { + DomSizeF *szf = new DomSizeF(); + const QSizeF sizef = v.toSizeF(); + szf->setElementWidth(sizef.width()); + szf->setElementHeight(sizef.height()); + dom_prop->setElementSizeF(szf); + } + return true; + + case QVariant::Rect: { + DomRect *rc = new DomRect(); + const QRect rect = v.toRect(); + rc->setElementX(rect.x()); + rc->setElementY(rect.y()); + rc->setElementWidth(rect.width()); + rc->setElementHeight(rect.height()); + dom_prop->setElementRect(rc); + } + return true; + + case QVariant::RectF: { + DomRectF *rcf = new DomRectF(); + const QRectF rectf = v.toRectF(); + rcf->setElementX(rectf.x()); + rcf->setElementY(rectf.y()); + rcf->setElementWidth(rectf.width()); + rcf->setElementHeight(rectf.height()); + dom_prop->setElementRectF(rcf); + } + return true; + + case QVariant::Font: { + DomFont *fnt = new DomFont(); + const QFont font = qvariant_cast<QFont>(v); + const uint mask = font.resolve(); + if (mask & QFont::WeightResolved) { + fnt->setElementBold(font.bold()); + fnt->setElementWeight(font.weight()); + } + if (mask & QFont::FamilyResolved) + fnt->setElementFamily(font.family()); + if (mask & QFont::StyleResolved) + fnt->setElementItalic(font.italic()); + if (mask & QFont::SizeResolved) + fnt->setElementPointSize(font.pointSize()); + if (mask & QFont::StrikeOutResolved) + fnt->setElementStrikeOut(font.strikeOut()); + if (mask & QFont::UnderlineResolved) + fnt->setElementUnderline(font.underline()); + if (mask & QFont::KerningResolved) + fnt->setElementKerning(font.kerning()); + if (mask & QFont::StyleStrategyResolved) { + const QMetaEnum styleStrategy_enum = metaEnum<QAbstractFormBuilderGadget>("styleStrategy"); + fnt->setElementStyleStrategy(QLatin1String(styleStrategy_enum.valueToKey(font.styleStrategy()))); + } + dom_prop->setElementFont(fnt); + } + return true; + +#ifndef QT_NO_CURSOR + case QVariant::Cursor: { + const QMetaEnum cursorShape_enum = metaEnum<QAbstractFormBuilderGadget>("cursorShape"); + dom_prop->setElementCursorShape(QLatin1String(cursorShape_enum.valueToKey(qvariant_cast<QCursor>(v).shape()))); + } + return true; +#endif + + case QVariant::KeySequence: { + DomString *s = new DomString(); + s->setText(qvariant_cast<QKeySequence>(v).toString(QKeySequence::PortableText)); + dom_prop->setElementString(s); + } + return true; + + case QVariant::Locale: { + DomLocale *dom = new DomLocale(); + const QLocale locale = qvariant_cast<QLocale>(v); + + const QMetaEnum language_enum = metaEnum<QAbstractFormBuilderGadget>("language"); + const QMetaEnum country_enum = metaEnum<QAbstractFormBuilderGadget>("country"); + + dom->setAttributeLanguage(QLatin1String(language_enum.valueToKey(locale.language()))); + dom->setAttributeCountry(QLatin1String(country_enum.valueToKey(locale.country()))); + + dom_prop->setElementLocale(dom); + } + return true; + + case QVariant::SizePolicy: { + DomSizePolicy *dom = new DomSizePolicy(); + const QSizePolicy sizePolicy = qvariant_cast<QSizePolicy>(v); + + dom->setElementHorStretch(sizePolicy.horizontalStretch()); + dom->setElementVerStretch(sizePolicy.verticalStretch()); + + const QMetaEnum sizeType_enum = metaEnum<QAbstractFormBuilderGadget>("sizeType"); + + dom->setAttributeHSizeType(QLatin1String(sizeType_enum.valueToKey(sizePolicy.horizontalPolicy()))); + dom->setAttributeVSizeType(QLatin1String(sizeType_enum.valueToKey(sizePolicy.verticalPolicy()))); + + dom_prop->setElementSizePolicy(dom); + } + return true; + + case QVariant::Date: { + DomDate *dom = new DomDate(); + const QDate date = qvariant_cast<QDate>(v); + + dom->setElementYear(date.year()); + dom->setElementMonth(date.month()); + dom->setElementDay(date.day()); + + dom_prop->setElementDate(dom); + } + return true; + + case QVariant::Time: { + DomTime *dom = new DomTime(); + const QTime time = qvariant_cast<QTime>(v); + + dom->setElementHour(time.hour()); + dom->setElementMinute(time.minute()); + dom->setElementSecond(time.second()); + + dom_prop->setElementTime(dom); + } + return true; + + case QVariant::DateTime: { + DomDateTime *dom = new DomDateTime(); + const QDateTime dateTime = qvariant_cast<QDateTime>(v); + + dom->setElementHour(dateTime.time().hour()); + dom->setElementMinute(dateTime.time().minute()); + dom->setElementSecond(dateTime.time().second()); + dom->setElementYear(dateTime.date().year()); + dom->setElementMonth(dateTime.date().month()); + dom->setElementDay(dateTime.date().day()); + + dom_prop->setElementDateTime(dom); + } + return true; + + case QVariant::Url: { + DomUrl *dom = new DomUrl(); + const QUrl url = v.toUrl(); + + DomString *str = new DomString(); + str->setText(url.toString()); + dom->setElementString(str); + + dom_prop->setElementUrl(dom); + } + return true; + + case QVariant::StringList: { + DomStringList *sl = new DomStringList; + sl->setElementString(qvariant_cast<QStringList>(v)); + dom_prop->setElementStringList(sl); + } + return true; + + default: + break; + } + + return false; +} +static QString msgCannotWriteProperty(const QString &pname, const QVariant &v) +{ + return QCoreApplication::translate("QFormBuilder", "The property %1 could not be written. The type %2 is not supported yet."). + arg(pname).arg(QLatin1String(v.typeName())); + +} + +static bool isOfType(const QMetaObject *what, const QMetaObject *type) +{ + do { + if (what == type) + return true; + } while ((what = what->superClass())); + return false; +} + +static bool isTranslatable(const QString &pname, const QVariant &v, const QMetaObject *meta) +{ + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + if (pname == strings.objectNameProperty) + return false; + if (pname == strings.styleSheetProperty && v.type() == QVariant::String && isOfType(meta, &QWidget::staticMetaObject)) + return false; + return true; +} + +// Convert complex variant types to DOM properties with the help of QAbstractFormBuilder +// Does not perform a check using QAbstractFormBuilder::checkProperty(). +DomProperty *variantToDomProperty(QAbstractFormBuilder *afb, const QMetaObject *meta, + const QString &pname, const QVariant &v) +{ + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + + DomProperty *dom_prop = new DomProperty(); + dom_prop->setAttributeName(pname); + + const int pindex = meta->indexOfProperty(pname.toLatin1()); + if (pindex != -1) { + QMetaProperty meta_property = meta->property(pindex); + if ((v.type() == QVariant::Int || v.type() == QVariant::UInt) && meta_property.isEnumType()) { + const QMetaEnum e = meta_property.enumerator(); + if (e.isFlag()) + dom_prop->setElementSet(QString::fromAscii(e.valueToKeys(v.toInt()))); + else + dom_prop->setElementEnum(QString::fromAscii(e.valueToKey(v.toInt()))); + return dom_prop; + } + if (!meta_property.hasStdCppSet() || (isOfType(meta, &QAbstractScrollArea::staticMetaObject) && pname == strings.cursorProperty)) + dom_prop->setAttributeStdset(0); + } + + // Try simple properties + if (applySimpleProperty(v, isTranslatable(pname, v, meta), dom_prop)) + return dom_prop; + + // Complex properties + switch (v.type()) { + case QVariant::Palette: { + DomPalette *dom = new DomPalette(); + QPalette palette = qvariant_cast<QPalette>(v); + + palette.setCurrentColorGroup(QPalette::Active); + dom->setElementActive(afb->saveColorGroup(palette)); + + palette.setCurrentColorGroup(QPalette::Inactive); + dom->setElementInactive(afb->saveColorGroup(palette)); + + palette.setCurrentColorGroup(QPalette::Disabled); + dom->setElementDisabled(afb->saveColorGroup(palette)); + + dom_prop->setElementPalette(dom); + } break; + case QVariant::Brush: + dom_prop->setElementBrush(afb->saveBrush(qvariant_cast<QBrush>(v))); + break; + default: + delete dom_prop; + if (afb->resourceBuilder()->isResourceType(v)) { + dom_prop = afb->resourceBuilder()->saveResource(afb->workingDirectory(), v); + if (dom_prop) + dom_prop->setAttributeName(pname); + break; + } + uiLibWarning(msgCannotWriteProperty(pname, v)); + return 0; + } + return dom_prop; +} + +#ifdef QFORMINTERNAL_NAMESPACE +} +#endif + +QT_END_NAMESPACE diff --git a/tools/designer/src/lib/uilib/properties_p.h b/tools/designer/src/lib/uilib/properties_p.h new file mode 100644 index 0000000..bc02ad5 --- /dev/null +++ b/tools/designer/src/lib/uilib/properties_p.h @@ -0,0 +1,176 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience +// of Qt Designer. This header +// file may change from version to version without notice, or even be removed. +// +// We mean it. +// + +#ifndef UILIBPROPERTIES_H +#define UILIBPROPERTIES_H + +#include <QtDesigner/uilib_global.h> + +#include <QtCore/QObject> +#include <QtCore/QMetaProperty> +#include <QtCore/QLocale> +#include <QtCore/QCoreApplication> + +#include <QtGui/QWidget> + +#include "formbuilderextra_p.h" + +QT_BEGIN_NAMESPACE + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal +{ +#endif + +class QAbstractFormBuilder; +class DomProperty; + +QDESIGNER_UILIB_EXPORT DomProperty *variantToDomProperty(QAbstractFormBuilder *abstractFormBuilder, const QMetaObject *meta, const QString &propertyName, const QVariant &value); + + +QDESIGNER_UILIB_EXPORT QVariant domPropertyToVariant(const DomProperty *property); +QDESIGNER_UILIB_EXPORT QVariant domPropertyToVariant(QAbstractFormBuilder *abstractFormBuilder, const QMetaObject *meta, const DomProperty *property); + +// This class exists to provide meta information +// for enumerations only. +class QAbstractFormBuilderGadget: public QWidget +{ + Q_OBJECT + Q_PROPERTY(Qt::ItemFlags itemFlags READ fakeItemFlags) + Q_PROPERTY(Qt::CheckState checkState READ fakeCheckState) + Q_PROPERTY(Qt::Alignment textAlignment READ fakeAlignment) + Q_PROPERTY(Qt::Orientation orientation READ fakeOrientation) + Q_PROPERTY(QSizePolicy::Policy sizeType READ fakeSizeType) + Q_PROPERTY(QPalette::ColorRole colorRole READ fakeColorRole) + Q_PROPERTY(QPalette::ColorGroup colorGroup READ fakeColorGroup) + Q_PROPERTY(QFont::StyleStrategy styleStrategy READ fakeStyleStrategy) + Q_PROPERTY(Qt::CursorShape cursorShape READ fakeCursorShape) + Q_PROPERTY(Qt::BrushStyle brushStyle READ fakeBrushStyle) + Q_PROPERTY(Qt::ToolBarArea toolBarArea READ fakeToolBarArea) + Q_PROPERTY(QGradient::Type gradientType READ fakeGradientType) + Q_PROPERTY(QGradient::Spread gradientSpread READ fakeGradientSpread) + Q_PROPERTY(QGradient::CoordinateMode gradientCoordinate READ fakeGradientCoordinate) + Q_PROPERTY(QLocale::Language language READ fakeLanguage) + Q_PROPERTY(QLocale::Country country READ fakeCountry) +public: + QAbstractFormBuilderGadget() { Q_ASSERT(0); } + + Qt::Orientation fakeOrientation() const { Q_ASSERT(0); return Qt::Horizontal; } + QSizePolicy::Policy fakeSizeType() const { Q_ASSERT(0); return QSizePolicy::Expanding; } + QPalette::ColorGroup fakeColorGroup() const { Q_ASSERT(0); return static_cast<QPalette::ColorGroup>(0); } + QPalette::ColorRole fakeColorRole() const { Q_ASSERT(0); return static_cast<QPalette::ColorRole>(0); } + QFont::StyleStrategy fakeStyleStrategy() const { Q_ASSERT(0); return QFont::PreferDefault; } + Qt::CursorShape fakeCursorShape() const { Q_ASSERT(0); return Qt::ArrowCursor; } + Qt::BrushStyle fakeBrushStyle() const { Q_ASSERT(0); return Qt::NoBrush; } + Qt::ToolBarArea fakeToolBarArea() const { Q_ASSERT(0); return Qt::NoToolBarArea; } + QGradient::Type fakeGradientType() const { Q_ASSERT(0); return QGradient::NoGradient; } + QGradient::Spread fakeGradientSpread() const { Q_ASSERT(0); return QGradient::PadSpread; } + QGradient::CoordinateMode fakeGradientCoordinate() const { Q_ASSERT(0); return QGradient::LogicalMode; } + QLocale::Language fakeLanguage() const { Q_ASSERT(0); return QLocale::C; } + QLocale::Country fakeCountry() const { Q_ASSERT(0); return QLocale::AnyCountry; } + Qt::ItemFlags fakeItemFlags() const { Q_ASSERT(0); return Qt::NoItemFlags; } + Qt::CheckState fakeCheckState() const { Q_ASSERT(0); return Qt::Unchecked; } + Qt::Alignment fakeAlignment() const { Q_ASSERT(0); return Qt::AlignLeft; } +}; + +// Convert key to value for a given QMetaEnum +template <class EnumType> +inline EnumType enumKeyToValue(const QMetaEnum &metaEnum,const char *key, const EnumType* = 0) +{ + int val = metaEnum.keyToValue(key); + if (val == -1) { + + uiLibWarning(QCoreApplication::translate("QFormBuilder", "The enumeration-value '%1' is invalid. The default value '%2' will be used instead.") + .arg(QString::fromUtf8(key)).arg(QString::fromUtf8(metaEnum.key(0)))); + val = metaEnum.value(0); + } + return static_cast<EnumType>(val); +} + +// Convert keys to value for a given QMetaEnum +template <class EnumType> +inline EnumType enumKeysToValue(const QMetaEnum &metaEnum,const char *keys, const EnumType* = 0) +{ + int val = metaEnum.keysToValue(keys); + if (val == -1) { + + uiLibWarning(QCoreApplication::translate("QFormBuilder", "The flag-value '%1' is invalid. Zero will be used instead.") + .arg(QString::fromUtf8(keys))); + val = 0; + } + return static_cast<EnumType>(QFlag(val)); +} + +// Access meta enumeration object of a qobject +template <class QObjectType> +inline QMetaEnum metaEnum(const char *name, const QObjectType* = 0) +{ + const int e_index = QObjectType::staticMetaObject.indexOfProperty(name); + Q_ASSERT(e_index != -1); + return QObjectType::staticMetaObject.property(e_index).enumerator(); +} + +// Convert key to value for enumeration by name +template <class QObjectType, class EnumType> +inline EnumType enumKeyOfObjectToValue(const char *enumName, const char *key, const QObjectType* = 0, const EnumType* = 0) +{ + const QMetaEnum me = metaEnum<QObjectType>(enumName); + return enumKeyToValue<EnumType>(me, key); +} + +#ifdef QFORMINTERNAL_NAMESPACE +} +#endif + +QT_END_NAMESPACE + +#endif // UILIBPROPERTIES_H diff --git a/tools/designer/src/lib/uilib/qdesignerexportwidget.h b/tools/designer/src/lib/uilib/qdesignerexportwidget.h new file mode 100644 index 0000000..c50f34c --- /dev/null +++ b/tools/designer/src/lib/uilib/qdesignerexportwidget.h @@ -0,0 +1,66 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDESIGNEREXPORTWIDGET_H +#define QDESIGNEREXPORTWIDGET_H + +#include <QtCore/QtGlobal> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +#if 0 +// pragma for syncqt, don't remove. +#pragma qt_class(QDesignerExportWidget) +#endif + +#if defined(QDESIGNER_EXPORT_WIDGETS) +# define QDESIGNER_WIDGET_EXPORT Q_DECL_EXPORT +#else +# define QDESIGNER_WIDGET_EXPORT Q_DECL_IMPORT +#endif + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif //QDESIGNEREXPORTWIDGET_H diff --git a/tools/designer/src/lib/uilib/resourcebuilder.cpp b/tools/designer/src/lib/uilib/resourcebuilder.cpp new file mode 100644 index 0000000..3679f92 --- /dev/null +++ b/tools/designer/src/lib/uilib/resourcebuilder.cpp @@ -0,0 +1,169 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "resourcebuilder_p.h" +#include "ui4_p.h" +#include <QtCore/QVariant> +#include <QtCore/QFileInfo> +#include <QtCore/QDir> +#include <QtGui/QPixmap> +#include <QtGui/QIcon> + +QT_BEGIN_NAMESPACE + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal { +#endif + +QResourceBuilder::QResourceBuilder() +{ + +} + +QResourceBuilder::~QResourceBuilder() +{ + +} + +int QResourceBuilder::iconStateFlags(const DomResourceIcon *dpi) +{ + int rc = 0; + if (dpi->hasElementNormalOff()) + rc |= NormalOff; + if (dpi->hasElementNormalOn()) + rc |= NormalOn; + if (dpi->hasElementDisabledOff()) + rc |= DisabledOff; + if (dpi->hasElementDisabledOn()) + rc |= DisabledOn; + if (dpi->hasElementActiveOff()) + rc |= ActiveOff; + if (dpi->hasElementActiveOn()) + rc |= ActiveOn; + if (dpi->hasElementSelectedOff()) + rc |= SelectedOff; + if (dpi->hasElementSelectedOn()) + rc |= SelectedOn; + return rc; +} + +QVariant QResourceBuilder::loadResource(const QDir &workingDirectory, const DomProperty *property) const +{ + switch (property->kind()) { + case DomProperty::Pixmap: { + const DomResourcePixmap *dpx = property->elementPixmap(); + QPixmap pixmap(QFileInfo(workingDirectory, dpx->text()).absoluteFilePath()); + return qVariantFromValue(pixmap); + } + case DomProperty::IconSet: { + const DomResourceIcon *dpi = property->elementIconSet(); + if (const int flags = iconStateFlags(dpi)) { // new, post 4.4 format + QIcon icon; + if (flags & NormalOff) + icon.addPixmap(QFileInfo(workingDirectory, dpi->elementNormalOff()->text()).absoluteFilePath(), QIcon::Normal, QIcon::Off); + if (flags & NormalOn) + icon.addPixmap(QFileInfo(workingDirectory, dpi->elementNormalOn()->text()).absoluteFilePath(), QIcon::Normal, QIcon::On); + if (flags & DisabledOff) + icon.addPixmap(QFileInfo(workingDirectory, dpi->elementDisabledOff()->text()).absoluteFilePath(), QIcon::Disabled, QIcon::Off); + if (flags & DisabledOn) + icon.addPixmap(QFileInfo(workingDirectory, dpi->elementDisabledOn()->text()).absoluteFilePath(), QIcon::Disabled, QIcon::On); + if (flags & ActiveOff) + icon.addPixmap(QFileInfo(workingDirectory, dpi->elementActiveOff()->text()).absoluteFilePath(), QIcon::Active, QIcon::Off); + if (flags & ActiveOn) + icon.addPixmap(QFileInfo(workingDirectory, dpi->elementActiveOn()->text()).absoluteFilePath(), QIcon::Active, QIcon::On); + if (flags & SelectedOff) + icon.addPixmap(QFileInfo(workingDirectory, dpi->elementSelectedOff()->text()).absoluteFilePath(), QIcon::Selected, QIcon::Off); + if (flags & SelectedOn) + icon.addPixmap(QFileInfo(workingDirectory, dpi->elementSelectedOn()->text()).absoluteFilePath(), QIcon::Selected, QIcon::On); + return qVariantFromValue(icon); + } else { // 4.3 legacy + const QIcon icon(QFileInfo(workingDirectory, dpi->text()).absoluteFilePath()); + return qVariantFromValue(icon); + } + } + break; + default: + break; + } + return QVariant(); +} + +QVariant QResourceBuilder::toNativeValue(const QVariant &value) const +{ + return value; +} + +DomProperty *QResourceBuilder::saveResource(const QDir &workingDirectory, const QVariant &value) const +{ + Q_UNUSED(workingDirectory) + Q_UNUSED(value) + return 0; +} + +bool QResourceBuilder::isResourceProperty(const DomProperty *p) const +{ + switch (p->kind()) { + case DomProperty::Pixmap: + case DomProperty::IconSet: + return true; + default: + break; + } + return false; +} + +bool QResourceBuilder::isResourceType(const QVariant &value) const +{ + switch (value.type()) { + case QVariant::Pixmap: + case QVariant::Icon: + return true; + default: + break; + } + return false; +} + +#ifdef QFORMINTERNAL_NAMESPACE +} // namespace QFormInternal +#endif + +QT_END_NAMESPACE diff --git a/tools/designer/src/lib/uilib/resourcebuilder_p.h b/tools/designer/src/lib/uilib/resourcebuilder_p.h new file mode 100644 index 0000000..5274b2d --- /dev/null +++ b/tools/designer/src/lib/uilib/resourcebuilder_p.h @@ -0,0 +1,104 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef RESOURCEBUILDER_H +#define RESOURCEBUILDER_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtDesigner/uilib_global.h> +#include <QtCore/QList> +#include <QtCore/QString> + +QT_BEGIN_NAMESPACE + +class QDir; +class QVariant; + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal +{ +#endif + +class DomProperty; +class DomResourceIcon; + +class QDESIGNER_UILIB_EXPORT QResourceBuilder +{ +public: + enum IconStateFlags { + NormalOff = 0x1, NormalOn = 0x2, DisabledOff = 0x4, DisabledOn = 0x8, + ActiveOff = 0x10, ActiveOn = 0x20, SelectedOff = 0x40, SelectedOn = 0x80 + }; + + QResourceBuilder(); + virtual ~QResourceBuilder(); + + virtual QVariant loadResource(const QDir &workingDirectory, const DomProperty *property) const; + + virtual QVariant toNativeValue(const QVariant &value) const; + + virtual DomProperty *saveResource(const QDir &workingDirectory, const QVariant &value) const; + + virtual bool isResourceProperty(const DomProperty *p) const; + + virtual bool isResourceType(const QVariant &value) const; + + static int iconStateFlags(const DomResourceIcon *resIcon); +}; + + +#ifdef QFORMINTERNAL_NAMESPACE +} +#endif + +QT_END_NAMESPACE + +#endif // RESOURCEBUILDER_H diff --git a/tools/designer/src/lib/uilib/textbuilder.cpp b/tools/designer/src/lib/uilib/textbuilder.cpp new file mode 100644 index 0000000..4219d14 --- /dev/null +++ b/tools/designer/src/lib/uilib/textbuilder.cpp @@ -0,0 +1,84 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "textbuilder_p.h" +#include "ui4_p.h" +#include <QtCore/QVariant> + +QT_BEGIN_NAMESPACE + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal { +#endif + +QTextBuilder::QTextBuilder() +{ + +} + +QTextBuilder::~QTextBuilder() +{ + +} + +QVariant QTextBuilder::loadText(const DomProperty *property) const +{ + if (property->kind() == DomProperty::String) + return property->elementString()->text(); + return QVariant(); +} + +QVariant QTextBuilder::toNativeValue(const QVariant &value) const +{ + return value; +} + +DomProperty *QTextBuilder::saveText(const QVariant &value) const +{ + Q_UNUSED(value) + return 0; +} + +#ifdef QFORMINTERNAL_NAMESPACE +} // namespace QFormInternal +#endif + +QT_END_NAMESPACE diff --git a/tools/designer/src/lib/uilib/textbuilder_p.h b/tools/designer/src/lib/uilib/textbuilder_p.h new file mode 100644 index 0000000..fb0b981 --- /dev/null +++ b/tools/designer/src/lib/uilib/textbuilder_p.h @@ -0,0 +1,93 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef TEXTBUILDER_H +#define TEXTBUILDER_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtDesigner/uilib_global.h> +#include <QtCore/QList> +#include <QtCore/QString> + +QT_BEGIN_NAMESPACE + +class QDir; +class QVariant; + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal +{ +#endif + +class DomProperty; +class DomString; + +class QDESIGNER_UILIB_EXPORT QTextBuilder +{ +public: + QTextBuilder(); + virtual ~QTextBuilder(); + + virtual QVariant loadText(const DomProperty *property) const; + + virtual QVariant toNativeValue(const QVariant &value) const; + + virtual DomProperty *saveText(const QVariant &value) const; +}; + + +#ifdef QFORMINTERNAL_NAMESPACE +} +#endif + +QT_END_NAMESPACE + +#endif // TEXTBUILDER_H diff --git a/tools/designer/src/lib/uilib/ui4.cpp b/tools/designer/src/lib/uilib/ui4.cpp new file mode 100644 index 0000000..2047739 --- /dev/null +++ b/tools/designer/src/lib/uilib/ui4.cpp @@ -0,0 +1,10887 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the tools applications of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ +#include "ui4_p.h" + +#ifdef QUILOADER_QDOM_READ +#include <QtXml/QDomElement> +#endif + +QT_BEGIN_NAMESPACE +#ifdef QFORMINTERNAL_NAMESPACE +using namespace QFormInternal; +#endif + +/******************************************************************************* +** Implementations +*/ + +void DomUI::clear(bool clear_all) +{ + delete m_widget; + delete m_layoutDefault; + delete m_layoutFunction; + delete m_customWidgets; + delete m_tabStops; + delete m_images; + delete m_includes; + delete m_resources; + delete m_connections; + delete m_designerdata; + delete m_slots; + delete m_buttonGroups; + + if (clear_all) { + m_text.clear(); + m_has_attr_version = false; + m_has_attr_language = false; + m_has_attr_displayname = false; + m_has_attr_stdsetdef = false; + m_attr_stdsetdef = 0; + m_has_attr_stdSetDef = false; + m_attr_stdSetDef = 0; + } + + m_children = 0; + m_widget = 0; + m_layoutDefault = 0; + m_layoutFunction = 0; + m_customWidgets = 0; + m_tabStops = 0; + m_images = 0; + m_includes = 0; + m_resources = 0; + m_connections = 0; + m_designerdata = 0; + m_slots = 0; + m_buttonGroups = 0; +} + +DomUI::DomUI() +{ + m_children = 0; + m_has_attr_version = false; + m_has_attr_language = false; + m_has_attr_displayname = false; + m_has_attr_stdsetdef = false; + m_attr_stdsetdef = 0; + m_has_attr_stdSetDef = false; + m_attr_stdSetDef = 0; + m_widget = 0; + m_layoutDefault = 0; + m_layoutFunction = 0; + m_customWidgets = 0; + m_tabStops = 0; + m_images = 0; + m_includes = 0; + m_resources = 0; + m_connections = 0; + m_designerdata = 0; + m_slots = 0; + m_buttonGroups = 0; +} + +DomUI::~DomUI() +{ + delete m_widget; + delete m_layoutDefault; + delete m_layoutFunction; + delete m_customWidgets; + delete m_tabStops; + delete m_images; + delete m_includes; + delete m_resources; + delete m_connections; + delete m_designerdata; + delete m_slots; + delete m_buttonGroups; +} + +void DomUI::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("version")) { + setAttributeVersion(attribute.value().toString()); + continue; + } + if (name == QLatin1String("language")) { + setAttributeLanguage(attribute.value().toString()); + continue; + } + if (name == QLatin1String("displayname")) { + setAttributeDisplayname(attribute.value().toString()); + continue; + } + if (name == QLatin1String("stdsetdef")) { + setAttributeStdsetdef(attribute.value().toString().toInt()); + continue; + } + if (name == QLatin1String("stdSetDef")) { + setAttributeStdSetDef(attribute.value().toString().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("author")) { + setElementAuthor(reader.readElementText()); + continue; + } + if (tag == QLatin1String("comment")) { + setElementComment(reader.readElementText()); + continue; + } + if (tag == QLatin1String("exportmacro")) { + setElementExportMacro(reader.readElementText()); + continue; + } + if (tag == QLatin1String("class")) { + setElementClass(reader.readElementText()); + continue; + } + if (tag == QLatin1String("widget")) { + DomWidget *v = new DomWidget(); + v->read(reader); + setElementWidget(v); + continue; + } + if (tag == QLatin1String("layoutdefault")) { + DomLayoutDefault *v = new DomLayoutDefault(); + v->read(reader); + setElementLayoutDefault(v); + continue; + } + if (tag == QLatin1String("layoutfunction")) { + DomLayoutFunction *v = new DomLayoutFunction(); + v->read(reader); + setElementLayoutFunction(v); + continue; + } + if (tag == QLatin1String("pixmapfunction")) { + setElementPixmapFunction(reader.readElementText()); + continue; + } + if (tag == QLatin1String("customwidgets")) { + DomCustomWidgets *v = new DomCustomWidgets(); + v->read(reader); + setElementCustomWidgets(v); + continue; + } + if (tag == QLatin1String("tabstops")) { + DomTabStops *v = new DomTabStops(); + v->read(reader); + setElementTabStops(v); + continue; + } + if (tag == QLatin1String("images")) { + DomImages *v = new DomImages(); + v->read(reader); + setElementImages(v); + continue; + } + if (tag == QLatin1String("includes")) { + DomIncludes *v = new DomIncludes(); + v->read(reader); + setElementIncludes(v); + continue; + } + if (tag == QLatin1String("resources")) { + DomResources *v = new DomResources(); + v->read(reader); + setElementResources(v); + continue; + } + if (tag == QLatin1String("connections")) { + DomConnections *v = new DomConnections(); + v->read(reader); + setElementConnections(v); + continue; + } + if (tag == QLatin1String("designerdata")) { + DomDesignerData *v = new DomDesignerData(); + v->read(reader); + setElementDesignerdata(v); + continue; + } + if (tag == QLatin1String("slots")) { + DomSlots *v = new DomSlots(); + v->read(reader); + setElementSlots(v); + continue; + } + if (tag == QLatin1String("buttongroups")) { + DomButtonGroups *v = new DomButtonGroups(); + v->read(reader); + setElementButtonGroups(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomUI::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("version"))) + setAttributeVersion(node.attribute(QLatin1String("version"))); + if (node.hasAttribute(QLatin1String("language"))) + setAttributeLanguage(node.attribute(QLatin1String("language"))); + if (node.hasAttribute(QLatin1String("displayname"))) + setAttributeDisplayname(node.attribute(QLatin1String("displayname"))); + if (node.hasAttribute(QLatin1String("stdsetdef"))) + setAttributeStdsetdef(node.attribute(QLatin1String("stdsetdef")).toInt()); + if (node.hasAttribute(QLatin1String("stdSetDef"))) + setAttributeStdSetDef(node.attribute(QLatin1String("stdSetDef")).toInt()); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("author")) { + setElementAuthor(e.text()); + continue; + } + if (tag == QLatin1String("comment")) { + setElementComment(e.text()); + continue; + } + if (tag == QLatin1String("exportmacro")) { + setElementExportMacro(e.text()); + continue; + } + if (tag == QLatin1String("class")) { + setElementClass(e.text()); + continue; + } + if (tag == QLatin1String("widget")) { + DomWidget *v = new DomWidget(); + v->read(e); + setElementWidget(v); + continue; + } + if (tag == QLatin1String("layoutdefault")) { + DomLayoutDefault *v = new DomLayoutDefault(); + v->read(e); + setElementLayoutDefault(v); + continue; + } + if (tag == QLatin1String("layoutfunction")) { + DomLayoutFunction *v = new DomLayoutFunction(); + v->read(e); + setElementLayoutFunction(v); + continue; + } + if (tag == QLatin1String("pixmapfunction")) { + setElementPixmapFunction(e.text()); + continue; + } + if (tag == QLatin1String("customwidgets")) { + DomCustomWidgets *v = new DomCustomWidgets(); + v->read(e); + setElementCustomWidgets(v); + continue; + } + if (tag == QLatin1String("tabstops")) { + DomTabStops *v = new DomTabStops(); + v->read(e); + setElementTabStops(v); + continue; + } + if (tag == QLatin1String("images")) { + DomImages *v = new DomImages(); + v->read(e); + setElementImages(v); + continue; + } + if (tag == QLatin1String("includes")) { + DomIncludes *v = new DomIncludes(); + v->read(e); + setElementIncludes(v); + continue; + } + if (tag == QLatin1String("resources")) { + DomResources *v = new DomResources(); + v->read(e); + setElementResources(v); + continue; + } + if (tag == QLatin1String("connections")) { + DomConnections *v = new DomConnections(); + v->read(e); + setElementConnections(v); + continue; + } + if (tag == QLatin1String("designerdata")) { + DomDesignerData *v = new DomDesignerData(); + v->read(e); + setElementDesignerdata(v); + continue; + } + if (tag == QLatin1String("slots")) { + DomSlots *v = new DomSlots(); + v->read(e); + setElementSlots(v); + continue; + } + if (tag == QLatin1String("buttongroups")) { + DomButtonGroups *v = new DomButtonGroups(); + v->read(e); + setElementButtonGroups(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomUI::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("ui") : tagName.toLower()); + + if (hasAttributeVersion()) + writer.writeAttribute(QLatin1String("version"), attributeVersion()); + + if (hasAttributeLanguage()) + writer.writeAttribute(QLatin1String("language"), attributeLanguage()); + + if (hasAttributeDisplayname()) + writer.writeAttribute(QLatin1String("displayname"), attributeDisplayname()); + + if (hasAttributeStdsetdef()) + writer.writeAttribute(QLatin1String("stdsetdef"), QString::number(attributeStdsetdef())); + + if (hasAttributeStdSetDef()) + writer.writeAttribute(QLatin1String("stdsetdef"), QString::number(attributeStdSetDef())); + + if (m_children & Author) { + writer.writeTextElement(QLatin1String("author"), m_author); + } + + if (m_children & Comment) { + writer.writeTextElement(QLatin1String("comment"), m_comment); + } + + if (m_children & ExportMacro) { + writer.writeTextElement(QLatin1String("exportmacro"), m_exportMacro); + } + + if (m_children & Class) { + writer.writeTextElement(QLatin1String("class"), m_class); + } + + if (m_children & Widget) { + m_widget->write(writer, QLatin1String("widget")); + } + + if (m_children & LayoutDefault) { + m_layoutDefault->write(writer, QLatin1String("layoutdefault")); + } + + if (m_children & LayoutFunction) { + m_layoutFunction->write(writer, QLatin1String("layoutfunction")); + } + + if (m_children & PixmapFunction) { + writer.writeTextElement(QLatin1String("pixmapfunction"), m_pixmapFunction); + } + + if (m_children & CustomWidgets) { + m_customWidgets->write(writer, QLatin1String("customwidgets")); + } + + if (m_children & TabStops) { + m_tabStops->write(writer, QLatin1String("tabstops")); + } + + if (m_children & Images) { + m_images->write(writer, QLatin1String("images")); + } + + if (m_children & Includes) { + m_includes->write(writer, QLatin1String("includes")); + } + + if (m_children & Resources) { + m_resources->write(writer, QLatin1String("resources")); + } + + if (m_children & Connections) { + m_connections->write(writer, QLatin1String("connections")); + } + + if (m_children & Designerdata) { + m_designerdata->write(writer, QLatin1String("designerdata")); + } + + if (m_children & Slots) { + m_slots->write(writer, QLatin1String("slots")); + } + + if (m_children & ButtonGroups) { + m_buttonGroups->write(writer, QLatin1String("buttongroups")); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomUI::setElementAuthor(const QString& a) +{ + m_children |= Author; + m_author = a; +} + +void DomUI::setElementComment(const QString& a) +{ + m_children |= Comment; + m_comment = a; +} + +void DomUI::setElementExportMacro(const QString& a) +{ + m_children |= ExportMacro; + m_exportMacro = a; +} + +void DomUI::setElementClass(const QString& a) +{ + m_children |= Class; + m_class = a; +} + +DomWidget* DomUI::takeElementWidget() +{ + DomWidget* a = m_widget; + m_widget = 0; + m_children ^= Widget; + return a; +} + +void DomUI::setElementWidget(DomWidget* a) +{ + delete m_widget; + m_children |= Widget; + m_widget = a; +} + +DomLayoutDefault* DomUI::takeElementLayoutDefault() +{ + DomLayoutDefault* a = m_layoutDefault; + m_layoutDefault = 0; + m_children ^= LayoutDefault; + return a; +} + +void DomUI::setElementLayoutDefault(DomLayoutDefault* a) +{ + delete m_layoutDefault; + m_children |= LayoutDefault; + m_layoutDefault = a; +} + +DomLayoutFunction* DomUI::takeElementLayoutFunction() +{ + DomLayoutFunction* a = m_layoutFunction; + m_layoutFunction = 0; + m_children ^= LayoutFunction; + return a; +} + +void DomUI::setElementLayoutFunction(DomLayoutFunction* a) +{ + delete m_layoutFunction; + m_children |= LayoutFunction; + m_layoutFunction = a; +} + +void DomUI::setElementPixmapFunction(const QString& a) +{ + m_children |= PixmapFunction; + m_pixmapFunction = a; +} + +DomCustomWidgets* DomUI::takeElementCustomWidgets() +{ + DomCustomWidgets* a = m_customWidgets; + m_customWidgets = 0; + m_children ^= CustomWidgets; + return a; +} + +void DomUI::setElementCustomWidgets(DomCustomWidgets* a) +{ + delete m_customWidgets; + m_children |= CustomWidgets; + m_customWidgets = a; +} + +DomTabStops* DomUI::takeElementTabStops() +{ + DomTabStops* a = m_tabStops; + m_tabStops = 0; + m_children ^= TabStops; + return a; +} + +void DomUI::setElementTabStops(DomTabStops* a) +{ + delete m_tabStops; + m_children |= TabStops; + m_tabStops = a; +} + +DomImages* DomUI::takeElementImages() +{ + DomImages* a = m_images; + m_images = 0; + m_children ^= Images; + return a; +} + +void DomUI::setElementImages(DomImages* a) +{ + delete m_images; + m_children |= Images; + m_images = a; +} + +DomIncludes* DomUI::takeElementIncludes() +{ + DomIncludes* a = m_includes; + m_includes = 0; + m_children ^= Includes; + return a; +} + +void DomUI::setElementIncludes(DomIncludes* a) +{ + delete m_includes; + m_children |= Includes; + m_includes = a; +} + +DomResources* DomUI::takeElementResources() +{ + DomResources* a = m_resources; + m_resources = 0; + m_children ^= Resources; + return a; +} + +void DomUI::setElementResources(DomResources* a) +{ + delete m_resources; + m_children |= Resources; + m_resources = a; +} + +DomConnections* DomUI::takeElementConnections() +{ + DomConnections* a = m_connections; + m_connections = 0; + m_children ^= Connections; + return a; +} + +void DomUI::setElementConnections(DomConnections* a) +{ + delete m_connections; + m_children |= Connections; + m_connections = a; +} + +DomDesignerData* DomUI::takeElementDesignerdata() +{ + DomDesignerData* a = m_designerdata; + m_designerdata = 0; + m_children ^= Designerdata; + return a; +} + +void DomUI::setElementDesignerdata(DomDesignerData* a) +{ + delete m_designerdata; + m_children |= Designerdata; + m_designerdata = a; +} + +DomSlots* DomUI::takeElementSlots() +{ + DomSlots* a = m_slots; + m_slots = 0; + m_children ^= Slots; + return a; +} + +void DomUI::setElementSlots(DomSlots* a) +{ + delete m_slots; + m_children |= Slots; + m_slots = a; +} + +DomButtonGroups* DomUI::takeElementButtonGroups() +{ + DomButtonGroups* a = m_buttonGroups; + m_buttonGroups = 0; + m_children ^= ButtonGroups; + return a; +} + +void DomUI::setElementButtonGroups(DomButtonGroups* a) +{ + delete m_buttonGroups; + m_children |= ButtonGroups; + m_buttonGroups = a; +} + +void DomUI::clearElementAuthor() +{ + m_children &= ~Author; +} + +void DomUI::clearElementComment() +{ + m_children &= ~Comment; +} + +void DomUI::clearElementExportMacro() +{ + m_children &= ~ExportMacro; +} + +void DomUI::clearElementClass() +{ + m_children &= ~Class; +} + +void DomUI::clearElementWidget() +{ + delete m_widget; + m_widget = 0; + m_children &= ~Widget; +} + +void DomUI::clearElementLayoutDefault() +{ + delete m_layoutDefault; + m_layoutDefault = 0; + m_children &= ~LayoutDefault; +} + +void DomUI::clearElementLayoutFunction() +{ + delete m_layoutFunction; + m_layoutFunction = 0; + m_children &= ~LayoutFunction; +} + +void DomUI::clearElementPixmapFunction() +{ + m_children &= ~PixmapFunction; +} + +void DomUI::clearElementCustomWidgets() +{ + delete m_customWidgets; + m_customWidgets = 0; + m_children &= ~CustomWidgets; +} + +void DomUI::clearElementTabStops() +{ + delete m_tabStops; + m_tabStops = 0; + m_children &= ~TabStops; +} + +void DomUI::clearElementImages() +{ + delete m_images; + m_images = 0; + m_children &= ~Images; +} + +void DomUI::clearElementIncludes() +{ + delete m_includes; + m_includes = 0; + m_children &= ~Includes; +} + +void DomUI::clearElementResources() +{ + delete m_resources; + m_resources = 0; + m_children &= ~Resources; +} + +void DomUI::clearElementConnections() +{ + delete m_connections; + m_connections = 0; + m_children &= ~Connections; +} + +void DomUI::clearElementDesignerdata() +{ + delete m_designerdata; + m_designerdata = 0; + m_children &= ~Designerdata; +} + +void DomUI::clearElementSlots() +{ + delete m_slots; + m_slots = 0; + m_children &= ~Slots; +} + +void DomUI::clearElementButtonGroups() +{ + delete m_buttonGroups; + m_buttonGroups = 0; + m_children &= ~ButtonGroups; +} + +void DomIncludes::clear(bool clear_all) +{ + qDeleteAll(m_include); + m_include.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomIncludes::DomIncludes() +{ + m_children = 0; +} + +DomIncludes::~DomIncludes() +{ + qDeleteAll(m_include); + m_include.clear(); +} + +void DomIncludes::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("include")) { + DomInclude *v = new DomInclude(); + v->read(reader); + m_include.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomIncludes::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("include")) { + DomInclude *v = new DomInclude(); + v->read(e); + m_include.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomIncludes::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("includes") : tagName.toLower()); + + for (int i = 0; i < m_include.size(); ++i) { + DomInclude* v = m_include[i]; + v->write(writer, QLatin1String("include")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomIncludes::setElementInclude(const QList<DomInclude*>& a) +{ + m_children |= Include; + m_include = a; +} + +void DomInclude::clear(bool clear_all) +{ + + if (clear_all) { + m_text = QLatin1String(""); + m_has_attr_location = false; + m_has_attr_impldecl = false; + } + + m_children = 0; +} + +DomInclude::DomInclude() +{ + m_children = 0; + m_has_attr_location = false; + m_has_attr_impldecl = false; + m_text = QLatin1String(""); +} + +DomInclude::~DomInclude() +{ +} + +void DomInclude::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("location")) { + setAttributeLocation(attribute.value().toString()); + continue; + } + if (name == QLatin1String("impldecl")) { + setAttributeImpldecl(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomInclude::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("location"))) + setAttributeLocation(node.attribute(QLatin1String("location"))); + if (node.hasAttribute(QLatin1String("impldecl"))) + setAttributeImpldecl(node.attribute(QLatin1String("impldecl"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + } + m_text = QLatin1String(""); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomInclude::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("include") : tagName.toLower()); + + if (hasAttributeLocation()) + writer.writeAttribute(QLatin1String("location"), attributeLocation()); + + if (hasAttributeImpldecl()) + writer.writeAttribute(QLatin1String("impldecl"), attributeImpldecl()); + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomResources::clear(bool clear_all) +{ + qDeleteAll(m_include); + m_include.clear(); + + if (clear_all) { + m_text.clear(); + m_has_attr_name = false; + } + + m_children = 0; +} + +DomResources::DomResources() +{ + m_children = 0; + m_has_attr_name = false; +} + +DomResources::~DomResources() +{ + qDeleteAll(m_include); + m_include.clear(); +} + +void DomResources::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("name")) { + setAttributeName(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("include")) { + DomResource *v = new DomResource(); + v->read(reader); + m_include.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomResources::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("name"))) + setAttributeName(node.attribute(QLatin1String("name"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("include")) { + DomResource *v = new DomResource(); + v->read(e); + m_include.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomResources::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("resources") : tagName.toLower()); + + if (hasAttributeName()) + writer.writeAttribute(QLatin1String("name"), attributeName()); + + for (int i = 0; i < m_include.size(); ++i) { + DomResource* v = m_include[i]; + v->write(writer, QLatin1String("include")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomResources::setElementInclude(const QList<DomResource*>& a) +{ + m_children |= Include; + m_include = a; +} + +void DomResource::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + m_has_attr_location = false; + } + + m_children = 0; +} + +DomResource::DomResource() +{ + m_children = 0; + m_has_attr_location = false; +} + +DomResource::~DomResource() +{ +} + +void DomResource::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("location")) { + setAttributeLocation(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomResource::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("location"))) + setAttributeLocation(node.attribute(QLatin1String("location"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomResource::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("resource") : tagName.toLower()); + + if (hasAttributeLocation()) + writer.writeAttribute(QLatin1String("location"), attributeLocation()); + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomActionGroup::clear(bool clear_all) +{ + qDeleteAll(m_action); + m_action.clear(); + qDeleteAll(m_actionGroup); + m_actionGroup.clear(); + qDeleteAll(m_property); + m_property.clear(); + qDeleteAll(m_attribute); + m_attribute.clear(); + + if (clear_all) { + m_text.clear(); + m_has_attr_name = false; + } + + m_children = 0; +} + +DomActionGroup::DomActionGroup() +{ + m_children = 0; + m_has_attr_name = false; +} + +DomActionGroup::~DomActionGroup() +{ + qDeleteAll(m_action); + m_action.clear(); + qDeleteAll(m_actionGroup); + m_actionGroup.clear(); + qDeleteAll(m_property); + m_property.clear(); + qDeleteAll(m_attribute); + m_attribute.clear(); +} + +void DomActionGroup::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("name")) { + setAttributeName(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("action")) { + DomAction *v = new DomAction(); + v->read(reader); + m_action.append(v); + continue; + } + if (tag == QLatin1String("actiongroup")) { + DomActionGroup *v = new DomActionGroup(); + v->read(reader); + m_actionGroup.append(v); + continue; + } + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_property.append(v); + continue; + } + if (tag == QLatin1String("attribute")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_attribute.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomActionGroup::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("name"))) + setAttributeName(node.attribute(QLatin1String("name"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("action")) { + DomAction *v = new DomAction(); + v->read(e); + m_action.append(v); + continue; + } + if (tag == QLatin1String("actiongroup")) { + DomActionGroup *v = new DomActionGroup(); + v->read(e); + m_actionGroup.append(v); + continue; + } + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_property.append(v); + continue; + } + if (tag == QLatin1String("attribute")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_attribute.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomActionGroup::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("actiongroup") : tagName.toLower()); + + if (hasAttributeName()) + writer.writeAttribute(QLatin1String("name"), attributeName()); + + for (int i = 0; i < m_action.size(); ++i) { + DomAction* v = m_action[i]; + v->write(writer, QLatin1String("action")); + } + for (int i = 0; i < m_actionGroup.size(); ++i) { + DomActionGroup* v = m_actionGroup[i]; + v->write(writer, QLatin1String("actiongroup")); + } + for (int i = 0; i < m_property.size(); ++i) { + DomProperty* v = m_property[i]; + v->write(writer, QLatin1String("property")); + } + for (int i = 0; i < m_attribute.size(); ++i) { + DomProperty* v = m_attribute[i]; + v->write(writer, QLatin1String("attribute")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomActionGroup::setElementAction(const QList<DomAction*>& a) +{ + m_children |= Action; + m_action = a; +} + +void DomActionGroup::setElementActionGroup(const QList<DomActionGroup*>& a) +{ + m_children |= ActionGroup; + m_actionGroup = a; +} + +void DomActionGroup::setElementProperty(const QList<DomProperty*>& a) +{ + m_children |= Property; + m_property = a; +} + +void DomActionGroup::setElementAttribute(const QList<DomProperty*>& a) +{ + m_children |= Attribute; + m_attribute = a; +} + +void DomAction::clear(bool clear_all) +{ + qDeleteAll(m_property); + m_property.clear(); + qDeleteAll(m_attribute); + m_attribute.clear(); + + if (clear_all) { + m_text.clear(); + m_has_attr_name = false; + m_has_attr_menu = false; + } + + m_children = 0; +} + +DomAction::DomAction() +{ + m_children = 0; + m_has_attr_name = false; + m_has_attr_menu = false; +} + +DomAction::~DomAction() +{ + qDeleteAll(m_property); + m_property.clear(); + qDeleteAll(m_attribute); + m_attribute.clear(); +} + +void DomAction::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("name")) { + setAttributeName(attribute.value().toString()); + continue; + } + if (name == QLatin1String("menu")) { + setAttributeMenu(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_property.append(v); + continue; + } + if (tag == QLatin1String("attribute")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_attribute.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomAction::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("name"))) + setAttributeName(node.attribute(QLatin1String("name"))); + if (node.hasAttribute(QLatin1String("menu"))) + setAttributeMenu(node.attribute(QLatin1String("menu"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_property.append(v); + continue; + } + if (tag == QLatin1String("attribute")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_attribute.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomAction::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("action") : tagName.toLower()); + + if (hasAttributeName()) + writer.writeAttribute(QLatin1String("name"), attributeName()); + + if (hasAttributeMenu()) + writer.writeAttribute(QLatin1String("menu"), attributeMenu()); + + for (int i = 0; i < m_property.size(); ++i) { + DomProperty* v = m_property[i]; + v->write(writer, QLatin1String("property")); + } + for (int i = 0; i < m_attribute.size(); ++i) { + DomProperty* v = m_attribute[i]; + v->write(writer, QLatin1String("attribute")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomAction::setElementProperty(const QList<DomProperty*>& a) +{ + m_children |= Property; + m_property = a; +} + +void DomAction::setElementAttribute(const QList<DomProperty*>& a) +{ + m_children |= Attribute; + m_attribute = a; +} + +void DomActionRef::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + m_has_attr_name = false; + } + + m_children = 0; +} + +DomActionRef::DomActionRef() +{ + m_children = 0; + m_has_attr_name = false; +} + +DomActionRef::~DomActionRef() +{ +} + +void DomActionRef::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("name")) { + setAttributeName(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomActionRef::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("name"))) + setAttributeName(node.attribute(QLatin1String("name"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomActionRef::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("actionref") : tagName.toLower()); + + if (hasAttributeName()) + writer.writeAttribute(QLatin1String("name"), attributeName()); + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomButtonGroup::clear(bool clear_all) +{ + qDeleteAll(m_property); + m_property.clear(); + qDeleteAll(m_attribute); + m_attribute.clear(); + + if (clear_all) { + m_text.clear(); + m_has_attr_name = false; + } + + m_children = 0; +} + +DomButtonGroup::DomButtonGroup() +{ + m_children = 0; + m_has_attr_name = false; +} + +DomButtonGroup::~DomButtonGroup() +{ + qDeleteAll(m_property); + m_property.clear(); + qDeleteAll(m_attribute); + m_attribute.clear(); +} + +void DomButtonGroup::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("name")) { + setAttributeName(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_property.append(v); + continue; + } + if (tag == QLatin1String("attribute")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_attribute.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomButtonGroup::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("name"))) + setAttributeName(node.attribute(QLatin1String("name"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_property.append(v); + continue; + } + if (tag == QLatin1String("attribute")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_attribute.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomButtonGroup::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("buttongroup") : tagName.toLower()); + + if (hasAttributeName()) + writer.writeAttribute(QLatin1String("name"), attributeName()); + + for (int i = 0; i < m_property.size(); ++i) { + DomProperty* v = m_property[i]; + v->write(writer, QLatin1String("property")); + } + for (int i = 0; i < m_attribute.size(); ++i) { + DomProperty* v = m_attribute[i]; + v->write(writer, QLatin1String("attribute")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomButtonGroup::setElementProperty(const QList<DomProperty*>& a) +{ + m_children |= Property; + m_property = a; +} + +void DomButtonGroup::setElementAttribute(const QList<DomProperty*>& a) +{ + m_children |= Attribute; + m_attribute = a; +} + +void DomButtonGroups::clear(bool clear_all) +{ + qDeleteAll(m_buttonGroup); + m_buttonGroup.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomButtonGroups::DomButtonGroups() +{ + m_children = 0; +} + +DomButtonGroups::~DomButtonGroups() +{ + qDeleteAll(m_buttonGroup); + m_buttonGroup.clear(); +} + +void DomButtonGroups::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("buttongroup")) { + DomButtonGroup *v = new DomButtonGroup(); + v->read(reader); + m_buttonGroup.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomButtonGroups::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("buttongroup")) { + DomButtonGroup *v = new DomButtonGroup(); + v->read(e); + m_buttonGroup.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomButtonGroups::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("buttongroups") : tagName.toLower()); + + for (int i = 0; i < m_buttonGroup.size(); ++i) { + DomButtonGroup* v = m_buttonGroup[i]; + v->write(writer, QLatin1String("buttongroup")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomButtonGroups::setElementButtonGroup(const QList<DomButtonGroup*>& a) +{ + m_children |= ButtonGroup; + m_buttonGroup = a; +} + +void DomImages::clear(bool clear_all) +{ + qDeleteAll(m_image); + m_image.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomImages::DomImages() +{ + m_children = 0; +} + +DomImages::~DomImages() +{ + qDeleteAll(m_image); + m_image.clear(); +} + +void DomImages::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("image")) { + DomImage *v = new DomImage(); + v->read(reader); + m_image.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomImages::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("image")) { + DomImage *v = new DomImage(); + v->read(e); + m_image.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomImages::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("images") : tagName.toLower()); + + for (int i = 0; i < m_image.size(); ++i) { + DomImage* v = m_image[i]; + v->write(writer, QLatin1String("image")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomImages::setElementImage(const QList<DomImage*>& a) +{ + m_children |= Image; + m_image = a; +} + +void DomImage::clear(bool clear_all) +{ + delete m_data; + + if (clear_all) { + m_text.clear(); + m_has_attr_name = false; + } + + m_children = 0; + m_data = 0; +} + +DomImage::DomImage() +{ + m_children = 0; + m_has_attr_name = false; + m_data = 0; +} + +DomImage::~DomImage() +{ + delete m_data; +} + +void DomImage::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("name")) { + setAttributeName(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("data")) { + DomImageData *v = new DomImageData(); + v->read(reader); + setElementData(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomImage::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("name"))) + setAttributeName(node.attribute(QLatin1String("name"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("data")) { + DomImageData *v = new DomImageData(); + v->read(e); + setElementData(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomImage::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("image") : tagName.toLower()); + + if (hasAttributeName()) + writer.writeAttribute(QLatin1String("name"), attributeName()); + + if (m_children & Data) { + m_data->write(writer, QLatin1String("data")); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +DomImageData* DomImage::takeElementData() +{ + DomImageData* a = m_data; + m_data = 0; + m_children ^= Data; + return a; +} + +void DomImage::setElementData(DomImageData* a) +{ + delete m_data; + m_children |= Data; + m_data = a; +} + +void DomImage::clearElementData() +{ + delete m_data; + m_data = 0; + m_children &= ~Data; +} + +void DomImageData::clear(bool clear_all) +{ + + if (clear_all) { + m_text = QLatin1String(""); + m_has_attr_format = false; + m_has_attr_length = false; + m_attr_length = 0; + } + + m_children = 0; +} + +DomImageData::DomImageData() +{ + m_children = 0; + m_has_attr_format = false; + m_has_attr_length = false; + m_attr_length = 0; + m_text = QLatin1String(""); +} + +DomImageData::~DomImageData() +{ +} + +void DomImageData::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("format")) { + setAttributeFormat(attribute.value().toString()); + continue; + } + if (name == QLatin1String("length")) { + setAttributeLength(attribute.value().toString().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomImageData::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("format"))) + setAttributeFormat(node.attribute(QLatin1String("format"))); + if (node.hasAttribute(QLatin1String("length"))) + setAttributeLength(node.attribute(QLatin1String("length")).toInt()); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + } + m_text = QLatin1String(""); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomImageData::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("imagedata") : tagName.toLower()); + + if (hasAttributeFormat()) + writer.writeAttribute(QLatin1String("format"), attributeFormat()); + + if (hasAttributeLength()) + writer.writeAttribute(QLatin1String("length"), QString::number(attributeLength())); + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomCustomWidgets::clear(bool clear_all) +{ + qDeleteAll(m_customWidget); + m_customWidget.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomCustomWidgets::DomCustomWidgets() +{ + m_children = 0; +} + +DomCustomWidgets::~DomCustomWidgets() +{ + qDeleteAll(m_customWidget); + m_customWidget.clear(); +} + +void DomCustomWidgets::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("customwidget")) { + DomCustomWidget *v = new DomCustomWidget(); + v->read(reader); + m_customWidget.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomCustomWidgets::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("customwidget")) { + DomCustomWidget *v = new DomCustomWidget(); + v->read(e); + m_customWidget.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomCustomWidgets::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("customwidgets") : tagName.toLower()); + + for (int i = 0; i < m_customWidget.size(); ++i) { + DomCustomWidget* v = m_customWidget[i]; + v->write(writer, QLatin1String("customwidget")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomCustomWidgets::setElementCustomWidget(const QList<DomCustomWidget*>& a) +{ + m_children |= CustomWidget; + m_customWidget = a; +} + +void DomHeader::clear(bool clear_all) +{ + + if (clear_all) { + m_text = QLatin1String(""); + m_has_attr_location = false; + } + + m_children = 0; +} + +DomHeader::DomHeader() +{ + m_children = 0; + m_has_attr_location = false; + m_text = QLatin1String(""); +} + +DomHeader::~DomHeader() +{ +} + +void DomHeader::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("location")) { + setAttributeLocation(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomHeader::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("location"))) + setAttributeLocation(node.attribute(QLatin1String("location"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + } + m_text = QLatin1String(""); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomHeader::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("header") : tagName.toLower()); + + if (hasAttributeLocation()) + writer.writeAttribute(QLatin1String("location"), attributeLocation()); + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomCustomWidget::clear(bool clear_all) +{ + delete m_header; + delete m_sizeHint; + delete m_sizePolicy; + delete m_script; + delete m_properties; + delete m_slots; + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_header = 0; + m_sizeHint = 0; + m_container = 0; + m_sizePolicy = 0; + m_script = 0; + m_properties = 0; + m_slots = 0; +} + +DomCustomWidget::DomCustomWidget() +{ + m_children = 0; + m_header = 0; + m_sizeHint = 0; + m_container = 0; + m_sizePolicy = 0; + m_script = 0; + m_properties = 0; + m_slots = 0; +} + +DomCustomWidget::~DomCustomWidget() +{ + delete m_header; + delete m_sizeHint; + delete m_sizePolicy; + delete m_script; + delete m_properties; + delete m_slots; +} + +void DomCustomWidget::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("class")) { + setElementClass(reader.readElementText()); + continue; + } + if (tag == QLatin1String("extends")) { + setElementExtends(reader.readElementText()); + continue; + } + if (tag == QLatin1String("header")) { + DomHeader *v = new DomHeader(); + v->read(reader); + setElementHeader(v); + continue; + } + if (tag == QLatin1String("sizehint")) { + DomSize *v = new DomSize(); + v->read(reader); + setElementSizeHint(v); + continue; + } + if (tag == QLatin1String("addpagemethod")) { + setElementAddPageMethod(reader.readElementText()); + continue; + } + if (tag == QLatin1String("container")) { + setElementContainer(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("sizepolicy")) { + DomSizePolicyData *v = new DomSizePolicyData(); + v->read(reader); + setElementSizePolicy(v); + continue; + } + if (tag == QLatin1String("pixmap")) { + setElementPixmap(reader.readElementText()); + continue; + } + if (tag == QLatin1String("script")) { + DomScript *v = new DomScript(); + v->read(reader); + setElementScript(v); + continue; + } + if (tag == QLatin1String("properties")) { + DomProperties *v = new DomProperties(); + v->read(reader); + setElementProperties(v); + continue; + } + if (tag == QLatin1String("slots")) { + DomSlots *v = new DomSlots(); + v->read(reader); + setElementSlots(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomCustomWidget::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("class")) { + setElementClass(e.text()); + continue; + } + if (tag == QLatin1String("extends")) { + setElementExtends(e.text()); + continue; + } + if (tag == QLatin1String("header")) { + DomHeader *v = new DomHeader(); + v->read(e); + setElementHeader(v); + continue; + } + if (tag == QLatin1String("sizehint")) { + DomSize *v = new DomSize(); + v->read(e); + setElementSizeHint(v); + continue; + } + if (tag == QLatin1String("addpagemethod")) { + setElementAddPageMethod(e.text()); + continue; + } + if (tag == QLatin1String("container")) { + setElementContainer(e.text().toInt()); + continue; + } + if (tag == QLatin1String("sizepolicy")) { + DomSizePolicyData *v = new DomSizePolicyData(); + v->read(e); + setElementSizePolicy(v); + continue; + } + if (tag == QLatin1String("pixmap")) { + setElementPixmap(e.text()); + continue; + } + if (tag == QLatin1String("script")) { + DomScript *v = new DomScript(); + v->read(e); + setElementScript(v); + continue; + } + if (tag == QLatin1String("properties")) { + DomProperties *v = new DomProperties(); + v->read(e); + setElementProperties(v); + continue; + } + if (tag == QLatin1String("slots")) { + DomSlots *v = new DomSlots(); + v->read(e); + setElementSlots(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomCustomWidget::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("customwidget") : tagName.toLower()); + + if (m_children & Class) { + writer.writeTextElement(QLatin1String("class"), m_class); + } + + if (m_children & Extends) { + writer.writeTextElement(QLatin1String("extends"), m_extends); + } + + if (m_children & Header) { + m_header->write(writer, QLatin1String("header")); + } + + if (m_children & SizeHint) { + m_sizeHint->write(writer, QLatin1String("sizehint")); + } + + if (m_children & AddPageMethod) { + writer.writeTextElement(QLatin1String("addpagemethod"), m_addPageMethod); + } + + if (m_children & Container) { + writer.writeTextElement(QLatin1String("container"), QString::number(m_container)); + } + + if (m_children & SizePolicy) { + m_sizePolicy->write(writer, QLatin1String("sizepolicy")); + } + + if (m_children & Pixmap) { + writer.writeTextElement(QLatin1String("pixmap"), m_pixmap); + } + + if (m_children & Script) { + m_script->write(writer, QLatin1String("script")); + } + + if (m_children & Properties) { + m_properties->write(writer, QLatin1String("properties")); + } + + if (m_children & Slots) { + m_slots->write(writer, QLatin1String("slots")); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomCustomWidget::setElementClass(const QString& a) +{ + m_children |= Class; + m_class = a; +} + +void DomCustomWidget::setElementExtends(const QString& a) +{ + m_children |= Extends; + m_extends = a; +} + +DomHeader* DomCustomWidget::takeElementHeader() +{ + DomHeader* a = m_header; + m_header = 0; + m_children ^= Header; + return a; +} + +void DomCustomWidget::setElementHeader(DomHeader* a) +{ + delete m_header; + m_children |= Header; + m_header = a; +} + +DomSize* DomCustomWidget::takeElementSizeHint() +{ + DomSize* a = m_sizeHint; + m_sizeHint = 0; + m_children ^= SizeHint; + return a; +} + +void DomCustomWidget::setElementSizeHint(DomSize* a) +{ + delete m_sizeHint; + m_children |= SizeHint; + m_sizeHint = a; +} + +void DomCustomWidget::setElementAddPageMethod(const QString& a) +{ + m_children |= AddPageMethod; + m_addPageMethod = a; +} + +void DomCustomWidget::setElementContainer(int a) +{ + m_children |= Container; + m_container = a; +} + +DomSizePolicyData* DomCustomWidget::takeElementSizePolicy() +{ + DomSizePolicyData* a = m_sizePolicy; + m_sizePolicy = 0; + m_children ^= SizePolicy; + return a; +} + +void DomCustomWidget::setElementSizePolicy(DomSizePolicyData* a) +{ + delete m_sizePolicy; + m_children |= SizePolicy; + m_sizePolicy = a; +} + +void DomCustomWidget::setElementPixmap(const QString& a) +{ + m_children |= Pixmap; + m_pixmap = a; +} + +DomScript* DomCustomWidget::takeElementScript() +{ + DomScript* a = m_script; + m_script = 0; + m_children ^= Script; + return a; +} + +void DomCustomWidget::setElementScript(DomScript* a) +{ + delete m_script; + m_children |= Script; + m_script = a; +} + +DomProperties* DomCustomWidget::takeElementProperties() +{ + DomProperties* a = m_properties; + m_properties = 0; + m_children ^= Properties; + return a; +} + +void DomCustomWidget::setElementProperties(DomProperties* a) +{ + delete m_properties; + m_children |= Properties; + m_properties = a; +} + +DomSlots* DomCustomWidget::takeElementSlots() +{ + DomSlots* a = m_slots; + m_slots = 0; + m_children ^= Slots; + return a; +} + +void DomCustomWidget::setElementSlots(DomSlots* a) +{ + delete m_slots; + m_children |= Slots; + m_slots = a; +} + +void DomCustomWidget::clearElementClass() +{ + m_children &= ~Class; +} + +void DomCustomWidget::clearElementExtends() +{ + m_children &= ~Extends; +} + +void DomCustomWidget::clearElementHeader() +{ + delete m_header; + m_header = 0; + m_children &= ~Header; +} + +void DomCustomWidget::clearElementSizeHint() +{ + delete m_sizeHint; + m_sizeHint = 0; + m_children &= ~SizeHint; +} + +void DomCustomWidget::clearElementAddPageMethod() +{ + m_children &= ~AddPageMethod; +} + +void DomCustomWidget::clearElementContainer() +{ + m_children &= ~Container; +} + +void DomCustomWidget::clearElementSizePolicy() +{ + delete m_sizePolicy; + m_sizePolicy = 0; + m_children &= ~SizePolicy; +} + +void DomCustomWidget::clearElementPixmap() +{ + m_children &= ~Pixmap; +} + +void DomCustomWidget::clearElementScript() +{ + delete m_script; + m_script = 0; + m_children &= ~Script; +} + +void DomCustomWidget::clearElementProperties() +{ + delete m_properties; + m_properties = 0; + m_children &= ~Properties; +} + +void DomCustomWidget::clearElementSlots() +{ + delete m_slots; + m_slots = 0; + m_children &= ~Slots; +} + +void DomProperties::clear(bool clear_all) +{ + qDeleteAll(m_property); + m_property.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomProperties::DomProperties() +{ + m_children = 0; +} + +DomProperties::~DomProperties() +{ + qDeleteAll(m_property); + m_property.clear(); +} + +void DomProperties::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("property")) { + DomPropertyData *v = new DomPropertyData(); + v->read(reader); + m_property.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomProperties::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("property")) { + DomPropertyData *v = new DomPropertyData(); + v->read(e); + m_property.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomProperties::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("properties") : tagName.toLower()); + + for (int i = 0; i < m_property.size(); ++i) { + DomPropertyData* v = m_property[i]; + v->write(writer, QLatin1String("property")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomProperties::setElementProperty(const QList<DomPropertyData*>& a) +{ + m_children |= Property; + m_property = a; +} + +void DomPropertyData::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + m_has_attr_type = false; + } + + m_children = 0; +} + +DomPropertyData::DomPropertyData() +{ + m_children = 0; + m_has_attr_type = false; +} + +DomPropertyData::~DomPropertyData() +{ +} + +void DomPropertyData::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("type")) { + setAttributeType(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomPropertyData::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("type"))) + setAttributeType(node.attribute(QLatin1String("type"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomPropertyData::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("propertydata") : tagName.toLower()); + + if (hasAttributeType()) + writer.writeAttribute(QLatin1String("type"), attributeType()); + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomSizePolicyData::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_horData = 0; + m_verData = 0; +} + +DomSizePolicyData::DomSizePolicyData() +{ + m_children = 0; + m_horData = 0; + m_verData = 0; +} + +DomSizePolicyData::~DomSizePolicyData() +{ +} + +void DomSizePolicyData::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("hordata")) { + setElementHorData(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("verdata")) { + setElementVerData(reader.readElementText().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomSizePolicyData::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("hordata")) { + setElementHorData(e.text().toInt()); + continue; + } + if (tag == QLatin1String("verdata")) { + setElementVerData(e.text().toInt()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomSizePolicyData::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("sizepolicydata") : tagName.toLower()); + + if (m_children & HorData) { + writer.writeTextElement(QLatin1String("hordata"), QString::number(m_horData)); + } + + if (m_children & VerData) { + writer.writeTextElement(QLatin1String("verdata"), QString::number(m_verData)); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomSizePolicyData::setElementHorData(int a) +{ + m_children |= HorData; + m_horData = a; +} + +void DomSizePolicyData::setElementVerData(int a) +{ + m_children |= VerData; + m_verData = a; +} + +void DomSizePolicyData::clearElementHorData() +{ + m_children &= ~HorData; +} + +void DomSizePolicyData::clearElementVerData() +{ + m_children &= ~VerData; +} + +void DomLayoutDefault::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + m_has_attr_spacing = false; + m_attr_spacing = 0; + m_has_attr_margin = false; + m_attr_margin = 0; + } + + m_children = 0; +} + +DomLayoutDefault::DomLayoutDefault() +{ + m_children = 0; + m_has_attr_spacing = false; + m_attr_spacing = 0; + m_has_attr_margin = false; + m_attr_margin = 0; +} + +DomLayoutDefault::~DomLayoutDefault() +{ +} + +void DomLayoutDefault::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("spacing")) { + setAttributeSpacing(attribute.value().toString().toInt()); + continue; + } + if (name == QLatin1String("margin")) { + setAttributeMargin(attribute.value().toString().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomLayoutDefault::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("spacing"))) + setAttributeSpacing(node.attribute(QLatin1String("spacing")).toInt()); + if (node.hasAttribute(QLatin1String("margin"))) + setAttributeMargin(node.attribute(QLatin1String("margin")).toInt()); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomLayoutDefault::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("layoutdefault") : tagName.toLower()); + + if (hasAttributeSpacing()) + writer.writeAttribute(QLatin1String("spacing"), QString::number(attributeSpacing())); + + if (hasAttributeMargin()) + writer.writeAttribute(QLatin1String("margin"), QString::number(attributeMargin())); + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomLayoutFunction::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + m_has_attr_spacing = false; + m_has_attr_margin = false; + } + + m_children = 0; +} + +DomLayoutFunction::DomLayoutFunction() +{ + m_children = 0; + m_has_attr_spacing = false; + m_has_attr_margin = false; +} + +DomLayoutFunction::~DomLayoutFunction() +{ +} + +void DomLayoutFunction::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("spacing")) { + setAttributeSpacing(attribute.value().toString()); + continue; + } + if (name == QLatin1String("margin")) { + setAttributeMargin(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomLayoutFunction::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("spacing"))) + setAttributeSpacing(node.attribute(QLatin1String("spacing"))); + if (node.hasAttribute(QLatin1String("margin"))) + setAttributeMargin(node.attribute(QLatin1String("margin"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomLayoutFunction::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("layoutfunction") : tagName.toLower()); + + if (hasAttributeSpacing()) + writer.writeAttribute(QLatin1String("spacing"), attributeSpacing()); + + if (hasAttributeMargin()) + writer.writeAttribute(QLatin1String("margin"), attributeMargin()); + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomTabStops::clear(bool clear_all) +{ + m_tabStop.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomTabStops::DomTabStops() +{ + m_children = 0; +} + +DomTabStops::~DomTabStops() +{ + m_tabStop.clear(); +} + +void DomTabStops::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("tabstop")) { + m_tabStop.append(reader.readElementText()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomTabStops::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("tabstop")) { + m_tabStop.append(e.text()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomTabStops::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("tabstops") : tagName.toLower()); + + for (int i = 0; i < m_tabStop.size(); ++i) { + QString v = m_tabStop[i]; + writer.writeTextElement(QLatin1String("tabstop"), v); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomTabStops::setElementTabStop(const QStringList& a) +{ + m_children |= TabStop; + m_tabStop = a; +} + +void DomLayout::clear(bool clear_all) +{ + qDeleteAll(m_property); + m_property.clear(); + qDeleteAll(m_attribute); + m_attribute.clear(); + qDeleteAll(m_item); + m_item.clear(); + + if (clear_all) { + m_text.clear(); + m_has_attr_class = false; + m_has_attr_name = false; + m_has_attr_stretch = false; + m_has_attr_rowStretch = false; + m_has_attr_columnStretch = false; + m_has_attr_rowMinimumHeight = false; + m_has_attr_columnMinimumWidth = false; + } + + m_children = 0; +} + +DomLayout::DomLayout() +{ + m_children = 0; + m_has_attr_class = false; + m_has_attr_name = false; + m_has_attr_stretch = false; + m_has_attr_rowStretch = false; + m_has_attr_columnStretch = false; + m_has_attr_rowMinimumHeight = false; + m_has_attr_columnMinimumWidth = false; +} + +DomLayout::~DomLayout() +{ + qDeleteAll(m_property); + m_property.clear(); + qDeleteAll(m_attribute); + m_attribute.clear(); + qDeleteAll(m_item); + m_item.clear(); +} + +void DomLayout::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("class")) { + setAttributeClass(attribute.value().toString()); + continue; + } + if (name == QLatin1String("name")) { + setAttributeName(attribute.value().toString()); + continue; + } + if (name == QLatin1String("stretch")) { + setAttributeStretch(attribute.value().toString()); + continue; + } + if (name == QLatin1String("rowstretch")) { + setAttributeRowStretch(attribute.value().toString()); + continue; + } + if (name == QLatin1String("columnstretch")) { + setAttributeColumnStretch(attribute.value().toString()); + continue; + } + if (name == QLatin1String("rowminimumheight")) { + setAttributeRowMinimumHeight(attribute.value().toString()); + continue; + } + if (name == QLatin1String("columnminimumwidth")) { + setAttributeColumnMinimumWidth(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_property.append(v); + continue; + } + if (tag == QLatin1String("attribute")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_attribute.append(v); + continue; + } + if (tag == QLatin1String("item")) { + DomLayoutItem *v = new DomLayoutItem(); + v->read(reader); + m_item.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomLayout::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("class"))) + setAttributeClass(node.attribute(QLatin1String("class"))); + if (node.hasAttribute(QLatin1String("name"))) + setAttributeName(node.attribute(QLatin1String("name"))); + if (node.hasAttribute(QLatin1String("stretch"))) + setAttributeStretch(node.attribute(QLatin1String("stretch"))); + if (node.hasAttribute(QLatin1String("rowstretch"))) + setAttributeRowStretch(node.attribute(QLatin1String("rowstretch"))); + if (node.hasAttribute(QLatin1String("columnstretch"))) + setAttributeColumnStretch(node.attribute(QLatin1String("columnstretch"))); + if (node.hasAttribute(QLatin1String("rowminimumheight"))) + setAttributeRowMinimumHeight(node.attribute(QLatin1String("rowminimumheight"))); + if (node.hasAttribute(QLatin1String("columnminimumwidth"))) + setAttributeColumnMinimumWidth(node.attribute(QLatin1String("columnminimumwidth"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_property.append(v); + continue; + } + if (tag == QLatin1String("attribute")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_attribute.append(v); + continue; + } + if (tag == QLatin1String("item")) { + DomLayoutItem *v = new DomLayoutItem(); + v->read(e); + m_item.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomLayout::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("layout") : tagName.toLower()); + + if (hasAttributeClass()) + writer.writeAttribute(QLatin1String("class"), attributeClass()); + + if (hasAttributeName()) + writer.writeAttribute(QLatin1String("name"), attributeName()); + + if (hasAttributeStretch()) + writer.writeAttribute(QLatin1String("stretch"), attributeStretch()); + + if (hasAttributeRowStretch()) + writer.writeAttribute(QLatin1String("rowstretch"), attributeRowStretch()); + + if (hasAttributeColumnStretch()) + writer.writeAttribute(QLatin1String("columnstretch"), attributeColumnStretch()); + + if (hasAttributeRowMinimumHeight()) + writer.writeAttribute(QLatin1String("rowminimumheight"), attributeRowMinimumHeight()); + + if (hasAttributeColumnMinimumWidth()) + writer.writeAttribute(QLatin1String("columnminimumwidth"), attributeColumnMinimumWidth()); + + for (int i = 0; i < m_property.size(); ++i) { + DomProperty* v = m_property[i]; + v->write(writer, QLatin1String("property")); + } + for (int i = 0; i < m_attribute.size(); ++i) { + DomProperty* v = m_attribute[i]; + v->write(writer, QLatin1String("attribute")); + } + for (int i = 0; i < m_item.size(); ++i) { + DomLayoutItem* v = m_item[i]; + v->write(writer, QLatin1String("item")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomLayout::setElementProperty(const QList<DomProperty*>& a) +{ + m_children |= Property; + m_property = a; +} + +void DomLayout::setElementAttribute(const QList<DomProperty*>& a) +{ + m_children |= Attribute; + m_attribute = a; +} + +void DomLayout::setElementItem(const QList<DomLayoutItem*>& a) +{ + m_children |= Item; + m_item = a; +} + +void DomLayoutItem::clear(bool clear_all) +{ + delete m_widget; + delete m_layout; + delete m_spacer; + + if (clear_all) { + m_text.clear(); + m_has_attr_row = false; + m_attr_row = 0; + m_has_attr_column = false; + m_attr_column = 0; + m_has_attr_rowSpan = false; + m_attr_rowSpan = 0; + m_has_attr_colSpan = false; + m_attr_colSpan = 0; + } + + m_kind = Unknown; + + m_widget = 0; + m_layout = 0; + m_spacer = 0; +} + +DomLayoutItem::DomLayoutItem() +{ + m_kind = Unknown; + + m_has_attr_row = false; + m_attr_row = 0; + m_has_attr_column = false; + m_attr_column = 0; + m_has_attr_rowSpan = false; + m_attr_rowSpan = 0; + m_has_attr_colSpan = false; + m_attr_colSpan = 0; + m_widget = 0; + m_layout = 0; + m_spacer = 0; +} + +DomLayoutItem::~DomLayoutItem() +{ + delete m_widget; + delete m_layout; + delete m_spacer; +} + +void DomLayoutItem::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("row")) { + setAttributeRow(attribute.value().toString().toInt()); + continue; + } + if (name == QLatin1String("column")) { + setAttributeColumn(attribute.value().toString().toInt()); + continue; + } + if (name == QLatin1String("rowspan")) { + setAttributeRowSpan(attribute.value().toString().toInt()); + continue; + } + if (name == QLatin1String("colspan")) { + setAttributeColSpan(attribute.value().toString().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("widget")) { + DomWidget *v = new DomWidget(); + v->read(reader); + setElementWidget(v); + continue; + } + if (tag == QLatin1String("layout")) { + DomLayout *v = new DomLayout(); + v->read(reader); + setElementLayout(v); + continue; + } + if (tag == QLatin1String("spacer")) { + DomSpacer *v = new DomSpacer(); + v->read(reader); + setElementSpacer(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomLayoutItem::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("row"))) + setAttributeRow(node.attribute(QLatin1String("row")).toInt()); + if (node.hasAttribute(QLatin1String("column"))) + setAttributeColumn(node.attribute(QLatin1String("column")).toInt()); + if (node.hasAttribute(QLatin1String("rowspan"))) + setAttributeRowSpan(node.attribute(QLatin1String("rowspan")).toInt()); + if (node.hasAttribute(QLatin1String("colspan"))) + setAttributeColSpan(node.attribute(QLatin1String("colspan")).toInt()); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("widget")) { + DomWidget *v = new DomWidget(); + v->read(e); + setElementWidget(v); + continue; + } + if (tag == QLatin1String("layout")) { + DomLayout *v = new DomLayout(); + v->read(e); + setElementLayout(v); + continue; + } + if (tag == QLatin1String("spacer")) { + DomSpacer *v = new DomSpacer(); + v->read(e); + setElementSpacer(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomLayoutItem::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("layoutitem") : tagName.toLower()); + + if (hasAttributeRow()) + writer.writeAttribute(QLatin1String("row"), QString::number(attributeRow())); + + if (hasAttributeColumn()) + writer.writeAttribute(QLatin1String("column"), QString::number(attributeColumn())); + + if (hasAttributeRowSpan()) + writer.writeAttribute(QLatin1String("rowspan"), QString::number(attributeRowSpan())); + + if (hasAttributeColSpan()) + writer.writeAttribute(QLatin1String("colspan"), QString::number(attributeColSpan())); + + switch (kind()) { + case Widget: { + DomWidget* v = elementWidget(); + if (v != 0) { + v->write(writer, QLatin1String("widget")); + } + break; + } + case Layout: { + DomLayout* v = elementLayout(); + if (v != 0) { + v->write(writer, QLatin1String("layout")); + } + break; + } + case Spacer: { + DomSpacer* v = elementSpacer(); + if (v != 0) { + v->write(writer, QLatin1String("spacer")); + } + break; + } + default: + break; + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +DomWidget* DomLayoutItem::takeElementWidget() +{ + DomWidget* a = m_widget; + m_widget = 0; + return a; +} + +void DomLayoutItem::setElementWidget(DomWidget* a) +{ + clear(false); + m_kind = Widget; + m_widget = a; +} + +DomLayout* DomLayoutItem::takeElementLayout() +{ + DomLayout* a = m_layout; + m_layout = 0; + return a; +} + +void DomLayoutItem::setElementLayout(DomLayout* a) +{ + clear(false); + m_kind = Layout; + m_layout = a; +} + +DomSpacer* DomLayoutItem::takeElementSpacer() +{ + DomSpacer* a = m_spacer; + m_spacer = 0; + return a; +} + +void DomLayoutItem::setElementSpacer(DomSpacer* a) +{ + clear(false); + m_kind = Spacer; + m_spacer = a; +} + +void DomRow::clear(bool clear_all) +{ + qDeleteAll(m_property); + m_property.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomRow::DomRow() +{ + m_children = 0; +} + +DomRow::~DomRow() +{ + qDeleteAll(m_property); + m_property.clear(); +} + +void DomRow::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_property.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomRow::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_property.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomRow::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("row") : tagName.toLower()); + + for (int i = 0; i < m_property.size(); ++i) { + DomProperty* v = m_property[i]; + v->write(writer, QLatin1String("property")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomRow::setElementProperty(const QList<DomProperty*>& a) +{ + m_children |= Property; + m_property = a; +} + +void DomColumn::clear(bool clear_all) +{ + qDeleteAll(m_property); + m_property.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomColumn::DomColumn() +{ + m_children = 0; +} + +DomColumn::~DomColumn() +{ + qDeleteAll(m_property); + m_property.clear(); +} + +void DomColumn::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_property.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomColumn::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_property.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomColumn::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("column") : tagName.toLower()); + + for (int i = 0; i < m_property.size(); ++i) { + DomProperty* v = m_property[i]; + v->write(writer, QLatin1String("property")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomColumn::setElementProperty(const QList<DomProperty*>& a) +{ + m_children |= Property; + m_property = a; +} + +void DomItem::clear(bool clear_all) +{ + qDeleteAll(m_property); + m_property.clear(); + qDeleteAll(m_item); + m_item.clear(); + + if (clear_all) { + m_text.clear(); + m_has_attr_row = false; + m_attr_row = 0; + m_has_attr_column = false; + m_attr_column = 0; + } + + m_children = 0; +} + +DomItem::DomItem() +{ + m_children = 0; + m_has_attr_row = false; + m_attr_row = 0; + m_has_attr_column = false; + m_attr_column = 0; +} + +DomItem::~DomItem() +{ + qDeleteAll(m_property); + m_property.clear(); + qDeleteAll(m_item); + m_item.clear(); +} + +void DomItem::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("row")) { + setAttributeRow(attribute.value().toString().toInt()); + continue; + } + if (name == QLatin1String("column")) { + setAttributeColumn(attribute.value().toString().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_property.append(v); + continue; + } + if (tag == QLatin1String("item")) { + DomItem *v = new DomItem(); + v->read(reader); + m_item.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomItem::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("row"))) + setAttributeRow(node.attribute(QLatin1String("row")).toInt()); + if (node.hasAttribute(QLatin1String("column"))) + setAttributeColumn(node.attribute(QLatin1String("column")).toInt()); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_property.append(v); + continue; + } + if (tag == QLatin1String("item")) { + DomItem *v = new DomItem(); + v->read(e); + m_item.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomItem::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("item") : tagName.toLower()); + + if (hasAttributeRow()) + writer.writeAttribute(QLatin1String("row"), QString::number(attributeRow())); + + if (hasAttributeColumn()) + writer.writeAttribute(QLatin1String("column"), QString::number(attributeColumn())); + + for (int i = 0; i < m_property.size(); ++i) { + DomProperty* v = m_property[i]; + v->write(writer, QLatin1String("property")); + } + for (int i = 0; i < m_item.size(); ++i) { + DomItem* v = m_item[i]; + v->write(writer, QLatin1String("item")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomItem::setElementProperty(const QList<DomProperty*>& a) +{ + m_children |= Property; + m_property = a; +} + +void DomItem::setElementItem(const QList<DomItem*>& a) +{ + m_children |= Item; + m_item = a; +} + +void DomWidget::clear(bool clear_all) +{ + m_class.clear(); + qDeleteAll(m_property); + m_property.clear(); + qDeleteAll(m_script); + m_script.clear(); + qDeleteAll(m_widgetData); + m_widgetData.clear(); + qDeleteAll(m_attribute); + m_attribute.clear(); + qDeleteAll(m_row); + m_row.clear(); + qDeleteAll(m_column); + m_column.clear(); + qDeleteAll(m_item); + m_item.clear(); + qDeleteAll(m_layout); + m_layout.clear(); + qDeleteAll(m_widget); + m_widget.clear(); + qDeleteAll(m_action); + m_action.clear(); + qDeleteAll(m_actionGroup); + m_actionGroup.clear(); + qDeleteAll(m_addAction); + m_addAction.clear(); + m_zOrder.clear(); + + if (clear_all) { + m_text.clear(); + m_has_attr_class = false; + m_has_attr_name = false; + m_has_attr_native = false; + m_attr_native = false; + } + + m_children = 0; +} + +DomWidget::DomWidget() +{ + m_children = 0; + m_has_attr_class = false; + m_has_attr_name = false; + m_has_attr_native = false; + m_attr_native = false; +} + +DomWidget::~DomWidget() +{ + m_class.clear(); + qDeleteAll(m_property); + m_property.clear(); + qDeleteAll(m_script); + m_script.clear(); + qDeleteAll(m_widgetData); + m_widgetData.clear(); + qDeleteAll(m_attribute); + m_attribute.clear(); + qDeleteAll(m_row); + m_row.clear(); + qDeleteAll(m_column); + m_column.clear(); + qDeleteAll(m_item); + m_item.clear(); + qDeleteAll(m_layout); + m_layout.clear(); + qDeleteAll(m_widget); + m_widget.clear(); + qDeleteAll(m_action); + m_action.clear(); + qDeleteAll(m_actionGroup); + m_actionGroup.clear(); + qDeleteAll(m_addAction); + m_addAction.clear(); + m_zOrder.clear(); +} + +void DomWidget::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("class")) { + setAttributeClass(attribute.value().toString()); + continue; + } + if (name == QLatin1String("name")) { + setAttributeName(attribute.value().toString()); + continue; + } + if (name == QLatin1String("native")) { + setAttributeNative((attribute.value().toString() == QLatin1String("true") ? true : false)); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("class")) { + m_class.append(reader.readElementText()); + continue; + } + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_property.append(v); + continue; + } + if (tag == QLatin1String("script")) { + DomScript *v = new DomScript(); + v->read(reader); + m_script.append(v); + continue; + } + if (tag == QLatin1String("widgetdata")) { + DomWidgetData *v = new DomWidgetData(); + v->read(reader); + m_widgetData.append(v); + continue; + } + if (tag == QLatin1String("attribute")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_attribute.append(v); + continue; + } + if (tag == QLatin1String("row")) { + DomRow *v = new DomRow(); + v->read(reader); + m_row.append(v); + continue; + } + if (tag == QLatin1String("column")) { + DomColumn *v = new DomColumn(); + v->read(reader); + m_column.append(v); + continue; + } + if (tag == QLatin1String("item")) { + DomItem *v = new DomItem(); + v->read(reader); + m_item.append(v); + continue; + } + if (tag == QLatin1String("layout")) { + DomLayout *v = new DomLayout(); + v->read(reader); + m_layout.append(v); + continue; + } + if (tag == QLatin1String("widget")) { + DomWidget *v = new DomWidget(); + v->read(reader); + m_widget.append(v); + continue; + } + if (tag == QLatin1String("action")) { + DomAction *v = new DomAction(); + v->read(reader); + m_action.append(v); + continue; + } + if (tag == QLatin1String("actiongroup")) { + DomActionGroup *v = new DomActionGroup(); + v->read(reader); + m_actionGroup.append(v); + continue; + } + if (tag == QLatin1String("addaction")) { + DomActionRef *v = new DomActionRef(); + v->read(reader); + m_addAction.append(v); + continue; + } + if (tag == QLatin1String("zorder")) { + m_zOrder.append(reader.readElementText()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomWidget::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("class"))) + setAttributeClass(node.attribute(QLatin1String("class"))); + if (node.hasAttribute(QLatin1String("name"))) + setAttributeName(node.attribute(QLatin1String("name"))); + if (node.hasAttribute(QLatin1String("native"))) + setAttributeNative((node.attribute(QLatin1String("native")) == QLatin1String("true") ? true : false)); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("class")) { + m_class.append(e.text()); + continue; + } + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_property.append(v); + continue; + } + if (tag == QLatin1String("script")) { + DomScript *v = new DomScript(); + v->read(e); + m_script.append(v); + continue; + } + if (tag == QLatin1String("widgetdata")) { + DomWidgetData *v = new DomWidgetData(); + v->read(e); + m_widgetData.append(v); + continue; + } + if (tag == QLatin1String("attribute")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_attribute.append(v); + continue; + } + if (tag == QLatin1String("row")) { + DomRow *v = new DomRow(); + v->read(e); + m_row.append(v); + continue; + } + if (tag == QLatin1String("column")) { + DomColumn *v = new DomColumn(); + v->read(e); + m_column.append(v); + continue; + } + if (tag == QLatin1String("item")) { + DomItem *v = new DomItem(); + v->read(e); + m_item.append(v); + continue; + } + if (tag == QLatin1String("layout")) { + DomLayout *v = new DomLayout(); + v->read(e); + m_layout.append(v); + continue; + } + if (tag == QLatin1String("widget")) { + DomWidget *v = new DomWidget(); + v->read(e); + m_widget.append(v); + continue; + } + if (tag == QLatin1String("action")) { + DomAction *v = new DomAction(); + v->read(e); + m_action.append(v); + continue; + } + if (tag == QLatin1String("actiongroup")) { + DomActionGroup *v = new DomActionGroup(); + v->read(e); + m_actionGroup.append(v); + continue; + } + if (tag == QLatin1String("addaction")) { + DomActionRef *v = new DomActionRef(); + v->read(e); + m_addAction.append(v); + continue; + } + if (tag == QLatin1String("zorder")) { + m_zOrder.append(e.text()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomWidget::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("widget") : tagName.toLower()); + + if (hasAttributeClass()) + writer.writeAttribute(QLatin1String("class"), attributeClass()); + + if (hasAttributeName()) + writer.writeAttribute(QLatin1String("name"), attributeName()); + + if (hasAttributeNative()) + writer.writeAttribute(QLatin1String("native"), (attributeNative() ? QLatin1String("true") : QLatin1String("false"))); + + for (int i = 0; i < m_class.size(); ++i) { + QString v = m_class[i]; + writer.writeTextElement(QLatin1String("class"), v); + } + for (int i = 0; i < m_property.size(); ++i) { + DomProperty* v = m_property[i]; + v->write(writer, QLatin1String("property")); + } + for (int i = 0; i < m_script.size(); ++i) { + DomScript* v = m_script[i]; + v->write(writer, QLatin1String("script")); + } + for (int i = 0; i < m_widgetData.size(); ++i) { + DomWidgetData* v = m_widgetData[i]; + v->write(writer, QLatin1String("widgetdata")); + } + for (int i = 0; i < m_attribute.size(); ++i) { + DomProperty* v = m_attribute[i]; + v->write(writer, QLatin1String("attribute")); + } + for (int i = 0; i < m_row.size(); ++i) { + DomRow* v = m_row[i]; + v->write(writer, QLatin1String("row")); + } + for (int i = 0; i < m_column.size(); ++i) { + DomColumn* v = m_column[i]; + v->write(writer, QLatin1String("column")); + } + for (int i = 0; i < m_item.size(); ++i) { + DomItem* v = m_item[i]; + v->write(writer, QLatin1String("item")); + } + for (int i = 0; i < m_layout.size(); ++i) { + DomLayout* v = m_layout[i]; + v->write(writer, QLatin1String("layout")); + } + for (int i = 0; i < m_widget.size(); ++i) { + DomWidget* v = m_widget[i]; + v->write(writer, QLatin1String("widget")); + } + for (int i = 0; i < m_action.size(); ++i) { + DomAction* v = m_action[i]; + v->write(writer, QLatin1String("action")); + } + for (int i = 0; i < m_actionGroup.size(); ++i) { + DomActionGroup* v = m_actionGroup[i]; + v->write(writer, QLatin1String("actiongroup")); + } + for (int i = 0; i < m_addAction.size(); ++i) { + DomActionRef* v = m_addAction[i]; + v->write(writer, QLatin1String("addaction")); + } + for (int i = 0; i < m_zOrder.size(); ++i) { + QString v = m_zOrder[i]; + writer.writeTextElement(QLatin1String("zorder"), v); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomWidget::setElementClass(const QStringList& a) +{ + m_children |= Class; + m_class = a; +} + +void DomWidget::setElementProperty(const QList<DomProperty*>& a) +{ + m_children |= Property; + m_property = a; +} + +void DomWidget::setElementScript(const QList<DomScript*>& a) +{ + m_children |= Script; + m_script = a; +} + +void DomWidget::setElementWidgetData(const QList<DomWidgetData*>& a) +{ + m_children |= WidgetData; + m_widgetData = a; +} + +void DomWidget::setElementAttribute(const QList<DomProperty*>& a) +{ + m_children |= Attribute; + m_attribute = a; +} + +void DomWidget::setElementRow(const QList<DomRow*>& a) +{ + m_children |= Row; + m_row = a; +} + +void DomWidget::setElementColumn(const QList<DomColumn*>& a) +{ + m_children |= Column; + m_column = a; +} + +void DomWidget::setElementItem(const QList<DomItem*>& a) +{ + m_children |= Item; + m_item = a; +} + +void DomWidget::setElementLayout(const QList<DomLayout*>& a) +{ + m_children |= Layout; + m_layout = a; +} + +void DomWidget::setElementWidget(const QList<DomWidget*>& a) +{ + m_children |= Widget; + m_widget = a; +} + +void DomWidget::setElementAction(const QList<DomAction*>& a) +{ + m_children |= Action; + m_action = a; +} + +void DomWidget::setElementActionGroup(const QList<DomActionGroup*>& a) +{ + m_children |= ActionGroup; + m_actionGroup = a; +} + +void DomWidget::setElementAddAction(const QList<DomActionRef*>& a) +{ + m_children |= AddAction; + m_addAction = a; +} + +void DomWidget::setElementZOrder(const QStringList& a) +{ + m_children |= ZOrder; + m_zOrder = a; +} + +void DomSpacer::clear(bool clear_all) +{ + qDeleteAll(m_property); + m_property.clear(); + + if (clear_all) { + m_text.clear(); + m_has_attr_name = false; + } + + m_children = 0; +} + +DomSpacer::DomSpacer() +{ + m_children = 0; + m_has_attr_name = false; +} + +DomSpacer::~DomSpacer() +{ + qDeleteAll(m_property); + m_property.clear(); +} + +void DomSpacer::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("name")) { + setAttributeName(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_property.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomSpacer::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("name"))) + setAttributeName(node.attribute(QLatin1String("name"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_property.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomSpacer::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("spacer") : tagName.toLower()); + + if (hasAttributeName()) + writer.writeAttribute(QLatin1String("name"), attributeName()); + + for (int i = 0; i < m_property.size(); ++i) { + DomProperty* v = m_property[i]; + v->write(writer, QLatin1String("property")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomSpacer::setElementProperty(const QList<DomProperty*>& a) +{ + m_children |= Property; + m_property = a; +} + +void DomColor::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + m_has_attr_alpha = false; + m_attr_alpha = 0; + } + + m_children = 0; + m_red = 0; + m_green = 0; + m_blue = 0; +} + +DomColor::DomColor() +{ + m_children = 0; + m_has_attr_alpha = false; + m_attr_alpha = 0; + m_red = 0; + m_green = 0; + m_blue = 0; +} + +DomColor::~DomColor() +{ +} + +void DomColor::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("alpha")) { + setAttributeAlpha(attribute.value().toString().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("red")) { + setElementRed(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("green")) { + setElementGreen(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("blue")) { + setElementBlue(reader.readElementText().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomColor::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("alpha"))) + setAttributeAlpha(node.attribute(QLatin1String("alpha")).toInt()); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("red")) { + setElementRed(e.text().toInt()); + continue; + } + if (tag == QLatin1String("green")) { + setElementGreen(e.text().toInt()); + continue; + } + if (tag == QLatin1String("blue")) { + setElementBlue(e.text().toInt()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomColor::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("color") : tagName.toLower()); + + if (hasAttributeAlpha()) + writer.writeAttribute(QLatin1String("alpha"), QString::number(attributeAlpha())); + + if (m_children & Red) { + writer.writeTextElement(QLatin1String("red"), QString::number(m_red)); + } + + if (m_children & Green) { + writer.writeTextElement(QLatin1String("green"), QString::number(m_green)); + } + + if (m_children & Blue) { + writer.writeTextElement(QLatin1String("blue"), QString::number(m_blue)); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomColor::setElementRed(int a) +{ + m_children |= Red; + m_red = a; +} + +void DomColor::setElementGreen(int a) +{ + m_children |= Green; + m_green = a; +} + +void DomColor::setElementBlue(int a) +{ + m_children |= Blue; + m_blue = a; +} + +void DomColor::clearElementRed() +{ + m_children &= ~Red; +} + +void DomColor::clearElementGreen() +{ + m_children &= ~Green; +} + +void DomColor::clearElementBlue() +{ + m_children &= ~Blue; +} + +void DomGradientStop::clear(bool clear_all) +{ + delete m_color; + + if (clear_all) { + m_text.clear(); + m_has_attr_position = false; + m_attr_position = 0.0; + } + + m_children = 0; + m_color = 0; +} + +DomGradientStop::DomGradientStop() +{ + m_children = 0; + m_has_attr_position = false; + m_attr_position = 0.0; + m_color = 0; +} + +DomGradientStop::~DomGradientStop() +{ + delete m_color; +} + +void DomGradientStop::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("position")) { + setAttributePosition(attribute.value().toString().toDouble()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("color")) { + DomColor *v = new DomColor(); + v->read(reader); + setElementColor(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomGradientStop::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("position"))) + setAttributePosition(node.attribute(QLatin1String("position")).toDouble()); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("color")) { + DomColor *v = new DomColor(); + v->read(e); + setElementColor(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomGradientStop::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("gradientstop") : tagName.toLower()); + + if (hasAttributePosition()) + writer.writeAttribute(QLatin1String("position"), QString::number(attributePosition(), 'f', 15)); + + if (m_children & Color) { + m_color->write(writer, QLatin1String("color")); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +DomColor* DomGradientStop::takeElementColor() +{ + DomColor* a = m_color; + m_color = 0; + m_children ^= Color; + return a; +} + +void DomGradientStop::setElementColor(DomColor* a) +{ + delete m_color; + m_children |= Color; + m_color = a; +} + +void DomGradientStop::clearElementColor() +{ + delete m_color; + m_color = 0; + m_children &= ~Color; +} + +void DomGradient::clear(bool clear_all) +{ + qDeleteAll(m_gradientStop); + m_gradientStop.clear(); + + if (clear_all) { + m_text.clear(); + m_has_attr_startX = false; + m_attr_startX = 0.0; + m_has_attr_startY = false; + m_attr_startY = 0.0; + m_has_attr_endX = false; + m_attr_endX = 0.0; + m_has_attr_endY = false; + m_attr_endY = 0.0; + m_has_attr_centralX = false; + m_attr_centralX = 0.0; + m_has_attr_centralY = false; + m_attr_centralY = 0.0; + m_has_attr_focalX = false; + m_attr_focalX = 0.0; + m_has_attr_focalY = false; + m_attr_focalY = 0.0; + m_has_attr_radius = false; + m_attr_radius = 0.0; + m_has_attr_angle = false; + m_attr_angle = 0.0; + m_has_attr_type = false; + m_has_attr_spread = false; + m_has_attr_coordinateMode = false; + } + + m_children = 0; +} + +DomGradient::DomGradient() +{ + m_children = 0; + m_has_attr_startX = false; + m_attr_startX = 0.0; + m_has_attr_startY = false; + m_attr_startY = 0.0; + m_has_attr_endX = false; + m_attr_endX = 0.0; + m_has_attr_endY = false; + m_attr_endY = 0.0; + m_has_attr_centralX = false; + m_attr_centralX = 0.0; + m_has_attr_centralY = false; + m_attr_centralY = 0.0; + m_has_attr_focalX = false; + m_attr_focalX = 0.0; + m_has_attr_focalY = false; + m_attr_focalY = 0.0; + m_has_attr_radius = false; + m_attr_radius = 0.0; + m_has_attr_angle = false; + m_attr_angle = 0.0; + m_has_attr_type = false; + m_has_attr_spread = false; + m_has_attr_coordinateMode = false; +} + +DomGradient::~DomGradient() +{ + qDeleteAll(m_gradientStop); + m_gradientStop.clear(); +} + +void DomGradient::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("startx")) { + setAttributeStartX(attribute.value().toString().toDouble()); + continue; + } + if (name == QLatin1String("starty")) { + setAttributeStartY(attribute.value().toString().toDouble()); + continue; + } + if (name == QLatin1String("endx")) { + setAttributeEndX(attribute.value().toString().toDouble()); + continue; + } + if (name == QLatin1String("endy")) { + setAttributeEndY(attribute.value().toString().toDouble()); + continue; + } + if (name == QLatin1String("centralx")) { + setAttributeCentralX(attribute.value().toString().toDouble()); + continue; + } + if (name == QLatin1String("centraly")) { + setAttributeCentralY(attribute.value().toString().toDouble()); + continue; + } + if (name == QLatin1String("focalx")) { + setAttributeFocalX(attribute.value().toString().toDouble()); + continue; + } + if (name == QLatin1String("focaly")) { + setAttributeFocalY(attribute.value().toString().toDouble()); + continue; + } + if (name == QLatin1String("radius")) { + setAttributeRadius(attribute.value().toString().toDouble()); + continue; + } + if (name == QLatin1String("angle")) { + setAttributeAngle(attribute.value().toString().toDouble()); + continue; + } + if (name == QLatin1String("type")) { + setAttributeType(attribute.value().toString()); + continue; + } + if (name == QLatin1String("spread")) { + setAttributeSpread(attribute.value().toString()); + continue; + } + if (name == QLatin1String("coordinatemode")) { + setAttributeCoordinateMode(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("gradientstop")) { + DomGradientStop *v = new DomGradientStop(); + v->read(reader); + m_gradientStop.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomGradient::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("startx"))) + setAttributeStartX(node.attribute(QLatin1String("startx")).toDouble()); + if (node.hasAttribute(QLatin1String("starty"))) + setAttributeStartY(node.attribute(QLatin1String("starty")).toDouble()); + if (node.hasAttribute(QLatin1String("endx"))) + setAttributeEndX(node.attribute(QLatin1String("endx")).toDouble()); + if (node.hasAttribute(QLatin1String("endy"))) + setAttributeEndY(node.attribute(QLatin1String("endy")).toDouble()); + if (node.hasAttribute(QLatin1String("centralx"))) + setAttributeCentralX(node.attribute(QLatin1String("centralx")).toDouble()); + if (node.hasAttribute(QLatin1String("centraly"))) + setAttributeCentralY(node.attribute(QLatin1String("centraly")).toDouble()); + if (node.hasAttribute(QLatin1String("focalx"))) + setAttributeFocalX(node.attribute(QLatin1String("focalx")).toDouble()); + if (node.hasAttribute(QLatin1String("focaly"))) + setAttributeFocalY(node.attribute(QLatin1String("focaly")).toDouble()); + if (node.hasAttribute(QLatin1String("radius"))) + setAttributeRadius(node.attribute(QLatin1String("radius")).toDouble()); + if (node.hasAttribute(QLatin1String("angle"))) + setAttributeAngle(node.attribute(QLatin1String("angle")).toDouble()); + if (node.hasAttribute(QLatin1String("type"))) + setAttributeType(node.attribute(QLatin1String("type"))); + if (node.hasAttribute(QLatin1String("spread"))) + setAttributeSpread(node.attribute(QLatin1String("spread"))); + if (node.hasAttribute(QLatin1String("coordinatemode"))) + setAttributeCoordinateMode(node.attribute(QLatin1String("coordinatemode"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("gradientstop")) { + DomGradientStop *v = new DomGradientStop(); + v->read(e); + m_gradientStop.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomGradient::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("gradient") : tagName.toLower()); + + if (hasAttributeStartX()) + writer.writeAttribute(QLatin1String("startx"), QString::number(attributeStartX(), 'f', 15)); + + if (hasAttributeStartY()) + writer.writeAttribute(QLatin1String("starty"), QString::number(attributeStartY(), 'f', 15)); + + if (hasAttributeEndX()) + writer.writeAttribute(QLatin1String("endx"), QString::number(attributeEndX(), 'f', 15)); + + if (hasAttributeEndY()) + writer.writeAttribute(QLatin1String("endy"), QString::number(attributeEndY(), 'f', 15)); + + if (hasAttributeCentralX()) + writer.writeAttribute(QLatin1String("centralx"), QString::number(attributeCentralX(), 'f', 15)); + + if (hasAttributeCentralY()) + writer.writeAttribute(QLatin1String("centraly"), QString::number(attributeCentralY(), 'f', 15)); + + if (hasAttributeFocalX()) + writer.writeAttribute(QLatin1String("focalx"), QString::number(attributeFocalX(), 'f', 15)); + + if (hasAttributeFocalY()) + writer.writeAttribute(QLatin1String("focaly"), QString::number(attributeFocalY(), 'f', 15)); + + if (hasAttributeRadius()) + writer.writeAttribute(QLatin1String("radius"), QString::number(attributeRadius(), 'f', 15)); + + if (hasAttributeAngle()) + writer.writeAttribute(QLatin1String("angle"), QString::number(attributeAngle(), 'f', 15)); + + if (hasAttributeType()) + writer.writeAttribute(QLatin1String("type"), attributeType()); + + if (hasAttributeSpread()) + writer.writeAttribute(QLatin1String("spread"), attributeSpread()); + + if (hasAttributeCoordinateMode()) + writer.writeAttribute(QLatin1String("coordinatemode"), attributeCoordinateMode()); + + for (int i = 0; i < m_gradientStop.size(); ++i) { + DomGradientStop* v = m_gradientStop[i]; + v->write(writer, QLatin1String("gradientstop")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomGradient::setElementGradientStop(const QList<DomGradientStop*>& a) +{ + m_children |= GradientStop; + m_gradientStop = a; +} + +void DomBrush::clear(bool clear_all) +{ + delete m_color; + delete m_texture; + delete m_gradient; + + if (clear_all) { + m_text.clear(); + m_has_attr_brushStyle = false; + } + + m_kind = Unknown; + + m_color = 0; + m_texture = 0; + m_gradient = 0; +} + +DomBrush::DomBrush() +{ + m_kind = Unknown; + + m_has_attr_brushStyle = false; + m_color = 0; + m_texture = 0; + m_gradient = 0; +} + +DomBrush::~DomBrush() +{ + delete m_color; + delete m_texture; + delete m_gradient; +} + +void DomBrush::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("brushstyle")) { + setAttributeBrushStyle(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("color")) { + DomColor *v = new DomColor(); + v->read(reader); + setElementColor(v); + continue; + } + if (tag == QLatin1String("texture")) { + DomProperty *v = new DomProperty(); + v->read(reader); + setElementTexture(v); + continue; + } + if (tag == QLatin1String("gradient")) { + DomGradient *v = new DomGradient(); + v->read(reader); + setElementGradient(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomBrush::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("brushstyle"))) + setAttributeBrushStyle(node.attribute(QLatin1String("brushstyle"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("color")) { + DomColor *v = new DomColor(); + v->read(e); + setElementColor(v); + continue; + } + if (tag == QLatin1String("texture")) { + DomProperty *v = new DomProperty(); + v->read(e); + setElementTexture(v); + continue; + } + if (tag == QLatin1String("gradient")) { + DomGradient *v = new DomGradient(); + v->read(e); + setElementGradient(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomBrush::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("brush") : tagName.toLower()); + + if (hasAttributeBrushStyle()) + writer.writeAttribute(QLatin1String("brushstyle"), attributeBrushStyle()); + + switch (kind()) { + case Color: { + DomColor* v = elementColor(); + if (v != 0) { + v->write(writer, QLatin1String("color")); + } + break; + } + case Texture: { + DomProperty* v = elementTexture(); + if (v != 0) { + v->write(writer, QLatin1String("texture")); + } + break; + } + case Gradient: { + DomGradient* v = elementGradient(); + if (v != 0) { + v->write(writer, QLatin1String("gradient")); + } + break; + } + default: + break; + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +DomColor* DomBrush::takeElementColor() +{ + DomColor* a = m_color; + m_color = 0; + return a; +} + +void DomBrush::setElementColor(DomColor* a) +{ + clear(false); + m_kind = Color; + m_color = a; +} + +DomProperty* DomBrush::takeElementTexture() +{ + DomProperty* a = m_texture; + m_texture = 0; + return a; +} + +void DomBrush::setElementTexture(DomProperty* a) +{ + clear(false); + m_kind = Texture; + m_texture = a; +} + +DomGradient* DomBrush::takeElementGradient() +{ + DomGradient* a = m_gradient; + m_gradient = 0; + return a; +} + +void DomBrush::setElementGradient(DomGradient* a) +{ + clear(false); + m_kind = Gradient; + m_gradient = a; +} + +void DomColorRole::clear(bool clear_all) +{ + delete m_brush; + + if (clear_all) { + m_text.clear(); + m_has_attr_role = false; + } + + m_children = 0; + m_brush = 0; +} + +DomColorRole::DomColorRole() +{ + m_children = 0; + m_has_attr_role = false; + m_brush = 0; +} + +DomColorRole::~DomColorRole() +{ + delete m_brush; +} + +void DomColorRole::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("role")) { + setAttributeRole(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("brush")) { + DomBrush *v = new DomBrush(); + v->read(reader); + setElementBrush(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomColorRole::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("role"))) + setAttributeRole(node.attribute(QLatin1String("role"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("brush")) { + DomBrush *v = new DomBrush(); + v->read(e); + setElementBrush(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomColorRole::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("colorrole") : tagName.toLower()); + + if (hasAttributeRole()) + writer.writeAttribute(QLatin1String("role"), attributeRole()); + + if (m_children & Brush) { + m_brush->write(writer, QLatin1String("brush")); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +DomBrush* DomColorRole::takeElementBrush() +{ + DomBrush* a = m_brush; + m_brush = 0; + m_children ^= Brush; + return a; +} + +void DomColorRole::setElementBrush(DomBrush* a) +{ + delete m_brush; + m_children |= Brush; + m_brush = a; +} + +void DomColorRole::clearElementBrush() +{ + delete m_brush; + m_brush = 0; + m_children &= ~Brush; +} + +void DomColorGroup::clear(bool clear_all) +{ + qDeleteAll(m_colorRole); + m_colorRole.clear(); + qDeleteAll(m_color); + m_color.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomColorGroup::DomColorGroup() +{ + m_children = 0; +} + +DomColorGroup::~DomColorGroup() +{ + qDeleteAll(m_colorRole); + m_colorRole.clear(); + qDeleteAll(m_color); + m_color.clear(); +} + +void DomColorGroup::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("colorrole")) { + DomColorRole *v = new DomColorRole(); + v->read(reader); + m_colorRole.append(v); + continue; + } + if (tag == QLatin1String("color")) { + DomColor *v = new DomColor(); + v->read(reader); + m_color.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomColorGroup::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("colorrole")) { + DomColorRole *v = new DomColorRole(); + v->read(e); + m_colorRole.append(v); + continue; + } + if (tag == QLatin1String("color")) { + DomColor *v = new DomColor(); + v->read(e); + m_color.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomColorGroup::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("colorgroup") : tagName.toLower()); + + for (int i = 0; i < m_colorRole.size(); ++i) { + DomColorRole* v = m_colorRole[i]; + v->write(writer, QLatin1String("colorrole")); + } + for (int i = 0; i < m_color.size(); ++i) { + DomColor* v = m_color[i]; + v->write(writer, QLatin1String("color")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomColorGroup::setElementColorRole(const QList<DomColorRole*>& a) +{ + m_children |= ColorRole; + m_colorRole = a; +} + +void DomColorGroup::setElementColor(const QList<DomColor*>& a) +{ + m_children |= Color; + m_color = a; +} + +void DomPalette::clear(bool clear_all) +{ + delete m_active; + delete m_inactive; + delete m_disabled; + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_active = 0; + m_inactive = 0; + m_disabled = 0; +} + +DomPalette::DomPalette() +{ + m_children = 0; + m_active = 0; + m_inactive = 0; + m_disabled = 0; +} + +DomPalette::~DomPalette() +{ + delete m_active; + delete m_inactive; + delete m_disabled; +} + +void DomPalette::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("active")) { + DomColorGroup *v = new DomColorGroup(); + v->read(reader); + setElementActive(v); + continue; + } + if (tag == QLatin1String("inactive")) { + DomColorGroup *v = new DomColorGroup(); + v->read(reader); + setElementInactive(v); + continue; + } + if (tag == QLatin1String("disabled")) { + DomColorGroup *v = new DomColorGroup(); + v->read(reader); + setElementDisabled(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomPalette::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("active")) { + DomColorGroup *v = new DomColorGroup(); + v->read(e); + setElementActive(v); + continue; + } + if (tag == QLatin1String("inactive")) { + DomColorGroup *v = new DomColorGroup(); + v->read(e); + setElementInactive(v); + continue; + } + if (tag == QLatin1String("disabled")) { + DomColorGroup *v = new DomColorGroup(); + v->read(e); + setElementDisabled(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomPalette::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("palette") : tagName.toLower()); + + if (m_children & Active) { + m_active->write(writer, QLatin1String("active")); + } + + if (m_children & Inactive) { + m_inactive->write(writer, QLatin1String("inactive")); + } + + if (m_children & Disabled) { + m_disabled->write(writer, QLatin1String("disabled")); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +DomColorGroup* DomPalette::takeElementActive() +{ + DomColorGroup* a = m_active; + m_active = 0; + m_children ^= Active; + return a; +} + +void DomPalette::setElementActive(DomColorGroup* a) +{ + delete m_active; + m_children |= Active; + m_active = a; +} + +DomColorGroup* DomPalette::takeElementInactive() +{ + DomColorGroup* a = m_inactive; + m_inactive = 0; + m_children ^= Inactive; + return a; +} + +void DomPalette::setElementInactive(DomColorGroup* a) +{ + delete m_inactive; + m_children |= Inactive; + m_inactive = a; +} + +DomColorGroup* DomPalette::takeElementDisabled() +{ + DomColorGroup* a = m_disabled; + m_disabled = 0; + m_children ^= Disabled; + return a; +} + +void DomPalette::setElementDisabled(DomColorGroup* a) +{ + delete m_disabled; + m_children |= Disabled; + m_disabled = a; +} + +void DomPalette::clearElementActive() +{ + delete m_active; + m_active = 0; + m_children &= ~Active; +} + +void DomPalette::clearElementInactive() +{ + delete m_inactive; + m_inactive = 0; + m_children &= ~Inactive; +} + +void DomPalette::clearElementDisabled() +{ + delete m_disabled; + m_disabled = 0; + m_children &= ~Disabled; +} + +void DomFont::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_pointSize = 0; + m_weight = 0; + m_italic = false; + m_bold = false; + m_underline = false; + m_strikeOut = false; + m_antialiasing = false; + m_kerning = false; +} + +DomFont::DomFont() +{ + m_children = 0; + m_pointSize = 0; + m_weight = 0; + m_italic = false; + m_bold = false; + m_underline = false; + m_strikeOut = false; + m_antialiasing = false; + m_kerning = false; +} + +DomFont::~DomFont() +{ +} + +void DomFont::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("family")) { + setElementFamily(reader.readElementText()); + continue; + } + if (tag == QLatin1String("pointsize")) { + setElementPointSize(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("weight")) { + setElementWeight(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("italic")) { + setElementItalic((reader.readElementText() == QLatin1String("true") ? true : false)); + continue; + } + if (tag == QLatin1String("bold")) { + setElementBold((reader.readElementText() == QLatin1String("true") ? true : false)); + continue; + } + if (tag == QLatin1String("underline")) { + setElementUnderline((reader.readElementText() == QLatin1String("true") ? true : false)); + continue; + } + if (tag == QLatin1String("strikeout")) { + setElementStrikeOut((reader.readElementText() == QLatin1String("true") ? true : false)); + continue; + } + if (tag == QLatin1String("antialiasing")) { + setElementAntialiasing((reader.readElementText() == QLatin1String("true") ? true : false)); + continue; + } + if (tag == QLatin1String("stylestrategy")) { + setElementStyleStrategy(reader.readElementText()); + continue; + } + if (tag == QLatin1String("kerning")) { + setElementKerning((reader.readElementText() == QLatin1String("true") ? true : false)); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomFont::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("family")) { + setElementFamily(e.text()); + continue; + } + if (tag == QLatin1String("pointsize")) { + setElementPointSize(e.text().toInt()); + continue; + } + if (tag == QLatin1String("weight")) { + setElementWeight(e.text().toInt()); + continue; + } + if (tag == QLatin1String("italic")) { + setElementItalic((e.text() == QLatin1String("true") ? true : false)); + continue; + } + if (tag == QLatin1String("bold")) { + setElementBold((e.text() == QLatin1String("true") ? true : false)); + continue; + } + if (tag == QLatin1String("underline")) { + setElementUnderline((e.text() == QLatin1String("true") ? true : false)); + continue; + } + if (tag == QLatin1String("strikeout")) { + setElementStrikeOut((e.text() == QLatin1String("true") ? true : false)); + continue; + } + if (tag == QLatin1String("antialiasing")) { + setElementAntialiasing((e.text() == QLatin1String("true") ? true : false)); + continue; + } + if (tag == QLatin1String("stylestrategy")) { + setElementStyleStrategy(e.text()); + continue; + } + if (tag == QLatin1String("kerning")) { + setElementKerning((e.text() == QLatin1String("true") ? true : false)); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomFont::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("font") : tagName.toLower()); + + if (m_children & Family) { + writer.writeTextElement(QLatin1String("family"), m_family); + } + + if (m_children & PointSize) { + writer.writeTextElement(QLatin1String("pointsize"), QString::number(m_pointSize)); + } + + if (m_children & Weight) { + writer.writeTextElement(QLatin1String("weight"), QString::number(m_weight)); + } + + if (m_children & Italic) { + writer.writeTextElement(QLatin1String("italic"), (m_italic ? QLatin1String("true") : QLatin1String("false"))); + } + + if (m_children & Bold) { + writer.writeTextElement(QLatin1String("bold"), (m_bold ? QLatin1String("true") : QLatin1String("false"))); + } + + if (m_children & Underline) { + writer.writeTextElement(QLatin1String("underline"), (m_underline ? QLatin1String("true") : QLatin1String("false"))); + } + + if (m_children & StrikeOut) { + writer.writeTextElement(QLatin1String("strikeout"), (m_strikeOut ? QLatin1String("true") : QLatin1String("false"))); + } + + if (m_children & Antialiasing) { + writer.writeTextElement(QLatin1String("antialiasing"), (m_antialiasing ? QLatin1String("true") : QLatin1String("false"))); + } + + if (m_children & StyleStrategy) { + writer.writeTextElement(QLatin1String("stylestrategy"), m_styleStrategy); + } + + if (m_children & Kerning) { + writer.writeTextElement(QLatin1String("kerning"), (m_kerning ? QLatin1String("true") : QLatin1String("false"))); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomFont::setElementFamily(const QString& a) +{ + m_children |= Family; + m_family = a; +} + +void DomFont::setElementPointSize(int a) +{ + m_children |= PointSize; + m_pointSize = a; +} + +void DomFont::setElementWeight(int a) +{ + m_children |= Weight; + m_weight = a; +} + +void DomFont::setElementItalic(bool a) +{ + m_children |= Italic; + m_italic = a; +} + +void DomFont::setElementBold(bool a) +{ + m_children |= Bold; + m_bold = a; +} + +void DomFont::setElementUnderline(bool a) +{ + m_children |= Underline; + m_underline = a; +} + +void DomFont::setElementStrikeOut(bool a) +{ + m_children |= StrikeOut; + m_strikeOut = a; +} + +void DomFont::setElementAntialiasing(bool a) +{ + m_children |= Antialiasing; + m_antialiasing = a; +} + +void DomFont::setElementStyleStrategy(const QString& a) +{ + m_children |= StyleStrategy; + m_styleStrategy = a; +} + +void DomFont::setElementKerning(bool a) +{ + m_children |= Kerning; + m_kerning = a; +} + +void DomFont::clearElementFamily() +{ + m_children &= ~Family; +} + +void DomFont::clearElementPointSize() +{ + m_children &= ~PointSize; +} + +void DomFont::clearElementWeight() +{ + m_children &= ~Weight; +} + +void DomFont::clearElementItalic() +{ + m_children &= ~Italic; +} + +void DomFont::clearElementBold() +{ + m_children &= ~Bold; +} + +void DomFont::clearElementUnderline() +{ + m_children &= ~Underline; +} + +void DomFont::clearElementStrikeOut() +{ + m_children &= ~StrikeOut; +} + +void DomFont::clearElementAntialiasing() +{ + m_children &= ~Antialiasing; +} + +void DomFont::clearElementStyleStrategy() +{ + m_children &= ~StyleStrategy; +} + +void DomFont::clearElementKerning() +{ + m_children &= ~Kerning; +} + +void DomPoint::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_x = 0; + m_y = 0; +} + +DomPoint::DomPoint() +{ + m_children = 0; + m_x = 0; + m_y = 0; +} + +DomPoint::~DomPoint() +{ +} + +void DomPoint::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QString(QLatin1Char('x'))) { + setElementX(reader.readElementText().toInt()); + continue; + } + if (tag == QString(QLatin1Char('y'))) { + setElementY(reader.readElementText().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomPoint::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QString(QLatin1Char('x'))) { + setElementX(e.text().toInt()); + continue; + } + if (tag == QString(QLatin1Char('y'))) { + setElementY(e.text().toInt()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomPoint::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("point") : tagName.toLower()); + + if (m_children & X) { + writer.writeTextElement(QString(QLatin1Char('x')), QString::number(m_x)); + } + + if (m_children & Y) { + writer.writeTextElement(QString(QLatin1Char('y')), QString::number(m_y)); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomPoint::setElementX(int a) +{ + m_children |= X; + m_x = a; +} + +void DomPoint::setElementY(int a) +{ + m_children |= Y; + m_y = a; +} + +void DomPoint::clearElementX() +{ + m_children &= ~X; +} + +void DomPoint::clearElementY() +{ + m_children &= ~Y; +} + +void DomRect::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_x = 0; + m_y = 0; + m_width = 0; + m_height = 0; +} + +DomRect::DomRect() +{ + m_children = 0; + m_x = 0; + m_y = 0; + m_width = 0; + m_height = 0; +} + +DomRect::~DomRect() +{ +} + +void DomRect::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QString(QLatin1Char('x'))) { + setElementX(reader.readElementText().toInt()); + continue; + } + if (tag == QString(QLatin1Char('y'))) { + setElementY(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("width")) { + setElementWidth(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("height")) { + setElementHeight(reader.readElementText().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomRect::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QString(QLatin1Char('x'))) { + setElementX(e.text().toInt()); + continue; + } + if (tag == QString(QLatin1Char('y'))) { + setElementY(e.text().toInt()); + continue; + } + if (tag == QLatin1String("width")) { + setElementWidth(e.text().toInt()); + continue; + } + if (tag == QLatin1String("height")) { + setElementHeight(e.text().toInt()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomRect::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("rect") : tagName.toLower()); + + if (m_children & X) { + writer.writeTextElement(QString(QLatin1Char('x')), QString::number(m_x)); + } + + if (m_children & Y) { + writer.writeTextElement(QString(QLatin1Char('y')), QString::number(m_y)); + } + + if (m_children & Width) { + writer.writeTextElement(QLatin1String("width"), QString::number(m_width)); + } + + if (m_children & Height) { + writer.writeTextElement(QLatin1String("height"), QString::number(m_height)); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomRect::setElementX(int a) +{ + m_children |= X; + m_x = a; +} + +void DomRect::setElementY(int a) +{ + m_children |= Y; + m_y = a; +} + +void DomRect::setElementWidth(int a) +{ + m_children |= Width; + m_width = a; +} + +void DomRect::setElementHeight(int a) +{ + m_children |= Height; + m_height = a; +} + +void DomRect::clearElementX() +{ + m_children &= ~X; +} + +void DomRect::clearElementY() +{ + m_children &= ~Y; +} + +void DomRect::clearElementWidth() +{ + m_children &= ~Width; +} + +void DomRect::clearElementHeight() +{ + m_children &= ~Height; +} + +void DomLocale::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + m_has_attr_language = false; + m_has_attr_country = false; + } + + m_children = 0; +} + +DomLocale::DomLocale() +{ + m_children = 0; + m_has_attr_language = false; + m_has_attr_country = false; +} + +DomLocale::~DomLocale() +{ +} + +void DomLocale::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("language")) { + setAttributeLanguage(attribute.value().toString()); + continue; + } + if (name == QLatin1String("country")) { + setAttributeCountry(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomLocale::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("language"))) + setAttributeLanguage(node.attribute(QLatin1String("language"))); + if (node.hasAttribute(QLatin1String("country"))) + setAttributeCountry(node.attribute(QLatin1String("country"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomLocale::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("locale") : tagName.toLower()); + + if (hasAttributeLanguage()) + writer.writeAttribute(QLatin1String("language"), attributeLanguage()); + + if (hasAttributeCountry()) + writer.writeAttribute(QLatin1String("country"), attributeCountry()); + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomSizePolicy::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + m_has_attr_hSizeType = false; + m_has_attr_vSizeType = false; + } + + m_children = 0; + m_hSizeType = 0; + m_vSizeType = 0; + m_horStretch = 0; + m_verStretch = 0; +} + +DomSizePolicy::DomSizePolicy() +{ + m_children = 0; + m_has_attr_hSizeType = false; + m_has_attr_vSizeType = false; + m_hSizeType = 0; + m_vSizeType = 0; + m_horStretch = 0; + m_verStretch = 0; +} + +DomSizePolicy::~DomSizePolicy() +{ +} + +void DomSizePolicy::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("hsizetype")) { + setAttributeHSizeType(attribute.value().toString()); + continue; + } + if (name == QLatin1String("vsizetype")) { + setAttributeVSizeType(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("hsizetype")) { + setElementHSizeType(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("vsizetype")) { + setElementVSizeType(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("horstretch")) { + setElementHorStretch(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("verstretch")) { + setElementVerStretch(reader.readElementText().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomSizePolicy::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("hsizetype"))) + setAttributeHSizeType(node.attribute(QLatin1String("hsizetype"))); + if (node.hasAttribute(QLatin1String("vsizetype"))) + setAttributeVSizeType(node.attribute(QLatin1String("vsizetype"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("hsizetype")) { + setElementHSizeType(e.text().toInt()); + continue; + } + if (tag == QLatin1String("vsizetype")) { + setElementVSizeType(e.text().toInt()); + continue; + } + if (tag == QLatin1String("horstretch")) { + setElementHorStretch(e.text().toInt()); + continue; + } + if (tag == QLatin1String("verstretch")) { + setElementVerStretch(e.text().toInt()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomSizePolicy::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("sizepolicy") : tagName.toLower()); + + if (hasAttributeHSizeType()) + writer.writeAttribute(QLatin1String("hsizetype"), attributeHSizeType()); + + if (hasAttributeVSizeType()) + writer.writeAttribute(QLatin1String("vsizetype"), attributeVSizeType()); + + if (m_children & HSizeType) { + writer.writeTextElement(QLatin1String("hsizetype"), QString::number(m_hSizeType)); + } + + if (m_children & VSizeType) { + writer.writeTextElement(QLatin1String("vsizetype"), QString::number(m_vSizeType)); + } + + if (m_children & HorStretch) { + writer.writeTextElement(QLatin1String("horstretch"), QString::number(m_horStretch)); + } + + if (m_children & VerStretch) { + writer.writeTextElement(QLatin1String("verstretch"), QString::number(m_verStretch)); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomSizePolicy::setElementHSizeType(int a) +{ + m_children |= HSizeType; + m_hSizeType = a; +} + +void DomSizePolicy::setElementVSizeType(int a) +{ + m_children |= VSizeType; + m_vSizeType = a; +} + +void DomSizePolicy::setElementHorStretch(int a) +{ + m_children |= HorStretch; + m_horStretch = a; +} + +void DomSizePolicy::setElementVerStretch(int a) +{ + m_children |= VerStretch; + m_verStretch = a; +} + +void DomSizePolicy::clearElementHSizeType() +{ + m_children &= ~HSizeType; +} + +void DomSizePolicy::clearElementVSizeType() +{ + m_children &= ~VSizeType; +} + +void DomSizePolicy::clearElementHorStretch() +{ + m_children &= ~HorStretch; +} + +void DomSizePolicy::clearElementVerStretch() +{ + m_children &= ~VerStretch; +} + +void DomSize::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_width = 0; + m_height = 0; +} + +DomSize::DomSize() +{ + m_children = 0; + m_width = 0; + m_height = 0; +} + +DomSize::~DomSize() +{ +} + +void DomSize::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("width")) { + setElementWidth(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("height")) { + setElementHeight(reader.readElementText().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomSize::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("width")) { + setElementWidth(e.text().toInt()); + continue; + } + if (tag == QLatin1String("height")) { + setElementHeight(e.text().toInt()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomSize::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("size") : tagName.toLower()); + + if (m_children & Width) { + writer.writeTextElement(QLatin1String("width"), QString::number(m_width)); + } + + if (m_children & Height) { + writer.writeTextElement(QLatin1String("height"), QString::number(m_height)); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomSize::setElementWidth(int a) +{ + m_children |= Width; + m_width = a; +} + +void DomSize::setElementHeight(int a) +{ + m_children |= Height; + m_height = a; +} + +void DomSize::clearElementWidth() +{ + m_children &= ~Width; +} + +void DomSize::clearElementHeight() +{ + m_children &= ~Height; +} + +void DomDate::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_year = 0; + m_month = 0; + m_day = 0; +} + +DomDate::DomDate() +{ + m_children = 0; + m_year = 0; + m_month = 0; + m_day = 0; +} + +DomDate::~DomDate() +{ +} + +void DomDate::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("year")) { + setElementYear(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("month")) { + setElementMonth(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("day")) { + setElementDay(reader.readElementText().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomDate::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("year")) { + setElementYear(e.text().toInt()); + continue; + } + if (tag == QLatin1String("month")) { + setElementMonth(e.text().toInt()); + continue; + } + if (tag == QLatin1String("day")) { + setElementDay(e.text().toInt()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomDate::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("date") : tagName.toLower()); + + if (m_children & Year) { + writer.writeTextElement(QLatin1String("year"), QString::number(m_year)); + } + + if (m_children & Month) { + writer.writeTextElement(QLatin1String("month"), QString::number(m_month)); + } + + if (m_children & Day) { + writer.writeTextElement(QLatin1String("day"), QString::number(m_day)); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomDate::setElementYear(int a) +{ + m_children |= Year; + m_year = a; +} + +void DomDate::setElementMonth(int a) +{ + m_children |= Month; + m_month = a; +} + +void DomDate::setElementDay(int a) +{ + m_children |= Day; + m_day = a; +} + +void DomDate::clearElementYear() +{ + m_children &= ~Year; +} + +void DomDate::clearElementMonth() +{ + m_children &= ~Month; +} + +void DomDate::clearElementDay() +{ + m_children &= ~Day; +} + +void DomTime::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_hour = 0; + m_minute = 0; + m_second = 0; +} + +DomTime::DomTime() +{ + m_children = 0; + m_hour = 0; + m_minute = 0; + m_second = 0; +} + +DomTime::~DomTime() +{ +} + +void DomTime::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("hour")) { + setElementHour(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("minute")) { + setElementMinute(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("second")) { + setElementSecond(reader.readElementText().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomTime::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("hour")) { + setElementHour(e.text().toInt()); + continue; + } + if (tag == QLatin1String("minute")) { + setElementMinute(e.text().toInt()); + continue; + } + if (tag == QLatin1String("second")) { + setElementSecond(e.text().toInt()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomTime::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("time") : tagName.toLower()); + + if (m_children & Hour) { + writer.writeTextElement(QLatin1String("hour"), QString::number(m_hour)); + } + + if (m_children & Minute) { + writer.writeTextElement(QLatin1String("minute"), QString::number(m_minute)); + } + + if (m_children & Second) { + writer.writeTextElement(QLatin1String("second"), QString::number(m_second)); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomTime::setElementHour(int a) +{ + m_children |= Hour; + m_hour = a; +} + +void DomTime::setElementMinute(int a) +{ + m_children |= Minute; + m_minute = a; +} + +void DomTime::setElementSecond(int a) +{ + m_children |= Second; + m_second = a; +} + +void DomTime::clearElementHour() +{ + m_children &= ~Hour; +} + +void DomTime::clearElementMinute() +{ + m_children &= ~Minute; +} + +void DomTime::clearElementSecond() +{ + m_children &= ~Second; +} + +void DomDateTime::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_hour = 0; + m_minute = 0; + m_second = 0; + m_year = 0; + m_month = 0; + m_day = 0; +} + +DomDateTime::DomDateTime() +{ + m_children = 0; + m_hour = 0; + m_minute = 0; + m_second = 0; + m_year = 0; + m_month = 0; + m_day = 0; +} + +DomDateTime::~DomDateTime() +{ +} + +void DomDateTime::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("hour")) { + setElementHour(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("minute")) { + setElementMinute(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("second")) { + setElementSecond(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("year")) { + setElementYear(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("month")) { + setElementMonth(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("day")) { + setElementDay(reader.readElementText().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomDateTime::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("hour")) { + setElementHour(e.text().toInt()); + continue; + } + if (tag == QLatin1String("minute")) { + setElementMinute(e.text().toInt()); + continue; + } + if (tag == QLatin1String("second")) { + setElementSecond(e.text().toInt()); + continue; + } + if (tag == QLatin1String("year")) { + setElementYear(e.text().toInt()); + continue; + } + if (tag == QLatin1String("month")) { + setElementMonth(e.text().toInt()); + continue; + } + if (tag == QLatin1String("day")) { + setElementDay(e.text().toInt()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomDateTime::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("datetime") : tagName.toLower()); + + if (m_children & Hour) { + writer.writeTextElement(QLatin1String("hour"), QString::number(m_hour)); + } + + if (m_children & Minute) { + writer.writeTextElement(QLatin1String("minute"), QString::number(m_minute)); + } + + if (m_children & Second) { + writer.writeTextElement(QLatin1String("second"), QString::number(m_second)); + } + + if (m_children & Year) { + writer.writeTextElement(QLatin1String("year"), QString::number(m_year)); + } + + if (m_children & Month) { + writer.writeTextElement(QLatin1String("month"), QString::number(m_month)); + } + + if (m_children & Day) { + writer.writeTextElement(QLatin1String("day"), QString::number(m_day)); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomDateTime::setElementHour(int a) +{ + m_children |= Hour; + m_hour = a; +} + +void DomDateTime::setElementMinute(int a) +{ + m_children |= Minute; + m_minute = a; +} + +void DomDateTime::setElementSecond(int a) +{ + m_children |= Second; + m_second = a; +} + +void DomDateTime::setElementYear(int a) +{ + m_children |= Year; + m_year = a; +} + +void DomDateTime::setElementMonth(int a) +{ + m_children |= Month; + m_month = a; +} + +void DomDateTime::setElementDay(int a) +{ + m_children |= Day; + m_day = a; +} + +void DomDateTime::clearElementHour() +{ + m_children &= ~Hour; +} + +void DomDateTime::clearElementMinute() +{ + m_children &= ~Minute; +} + +void DomDateTime::clearElementSecond() +{ + m_children &= ~Second; +} + +void DomDateTime::clearElementYear() +{ + m_children &= ~Year; +} + +void DomDateTime::clearElementMonth() +{ + m_children &= ~Month; +} + +void DomDateTime::clearElementDay() +{ + m_children &= ~Day; +} + +void DomStringList::clear(bool clear_all) +{ + m_string.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomStringList::DomStringList() +{ + m_children = 0; +} + +DomStringList::~DomStringList() +{ + m_string.clear(); +} + +void DomStringList::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("string")) { + m_string.append(reader.readElementText()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomStringList::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("string")) { + m_string.append(e.text()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomStringList::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("stringlist") : tagName.toLower()); + + for (int i = 0; i < m_string.size(); ++i) { + QString v = m_string[i]; + writer.writeTextElement(QLatin1String("string"), v); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomStringList::setElementString(const QStringList& a) +{ + m_children |= String; + m_string = a; +} + +void DomResourcePixmap::clear(bool clear_all) +{ + + if (clear_all) { + m_text = QLatin1String(""); + m_has_attr_resource = false; + m_has_attr_alias = false; + } + + m_children = 0; +} + +DomResourcePixmap::DomResourcePixmap() +{ + m_children = 0; + m_has_attr_resource = false; + m_has_attr_alias = false; + m_text = QLatin1String(""); +} + +DomResourcePixmap::~DomResourcePixmap() +{ +} + +void DomResourcePixmap::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("resource")) { + setAttributeResource(attribute.value().toString()); + continue; + } + if (name == QLatin1String("alias")) { + setAttributeAlias(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomResourcePixmap::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("resource"))) + setAttributeResource(node.attribute(QLatin1String("resource"))); + if (node.hasAttribute(QLatin1String("alias"))) + setAttributeAlias(node.attribute(QLatin1String("alias"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + } + m_text = QLatin1String(""); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomResourcePixmap::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("resourcepixmap") : tagName.toLower()); + + if (hasAttributeResource()) + writer.writeAttribute(QLatin1String("resource"), attributeResource()); + + if (hasAttributeAlias()) + writer.writeAttribute(QLatin1String("alias"), attributeAlias()); + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomResourceIcon::clear(bool clear_all) +{ + delete m_normalOff; + delete m_normalOn; + delete m_disabledOff; + delete m_disabledOn; + delete m_activeOff; + delete m_activeOn; + delete m_selectedOff; + delete m_selectedOn; + + if (clear_all) { + m_text = QLatin1String(""); + m_has_attr_resource = false; + } + + m_children = 0; + m_normalOff = 0; + m_normalOn = 0; + m_disabledOff = 0; + m_disabledOn = 0; + m_activeOff = 0; + m_activeOn = 0; + m_selectedOff = 0; + m_selectedOn = 0; +} + +DomResourceIcon::DomResourceIcon() +{ + m_children = 0; + m_has_attr_resource = false; + m_text = QLatin1String(""); + m_normalOff = 0; + m_normalOn = 0; + m_disabledOff = 0; + m_disabledOn = 0; + m_activeOff = 0; + m_activeOn = 0; + m_selectedOff = 0; + m_selectedOn = 0; +} + +DomResourceIcon::~DomResourceIcon() +{ + delete m_normalOff; + delete m_normalOn; + delete m_disabledOff; + delete m_disabledOn; + delete m_activeOff; + delete m_activeOn; + delete m_selectedOff; + delete m_selectedOn; +} + +void DomResourceIcon::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("resource")) { + setAttributeResource(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("normaloff")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(reader); + setElementNormalOff(v); + continue; + } + if (tag == QLatin1String("normalon")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(reader); + setElementNormalOn(v); + continue; + } + if (tag == QLatin1String("disabledoff")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(reader); + setElementDisabledOff(v); + continue; + } + if (tag == QLatin1String("disabledon")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(reader); + setElementDisabledOn(v); + continue; + } + if (tag == QLatin1String("activeoff")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(reader); + setElementActiveOff(v); + continue; + } + if (tag == QLatin1String("activeon")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(reader); + setElementActiveOn(v); + continue; + } + if (tag == QLatin1String("selectedoff")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(reader); + setElementSelectedOff(v); + continue; + } + if (tag == QLatin1String("selectedon")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(reader); + setElementSelectedOn(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomResourceIcon::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("resource"))) + setAttributeResource(node.attribute(QLatin1String("resource"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("normaloff")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(e); + setElementNormalOff(v); + continue; + } + if (tag == QLatin1String("normalon")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(e); + setElementNormalOn(v); + continue; + } + if (tag == QLatin1String("disabledoff")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(e); + setElementDisabledOff(v); + continue; + } + if (tag == QLatin1String("disabledon")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(e); + setElementDisabledOn(v); + continue; + } + if (tag == QLatin1String("activeoff")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(e); + setElementActiveOff(v); + continue; + } + if (tag == QLatin1String("activeon")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(e); + setElementActiveOn(v); + continue; + } + if (tag == QLatin1String("selectedoff")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(e); + setElementSelectedOff(v); + continue; + } + if (tag == QLatin1String("selectedon")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(e); + setElementSelectedOn(v); + continue; + } + } + m_text = QLatin1String(""); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomResourceIcon::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("resourceicon") : tagName.toLower()); + + if (hasAttributeResource()) + writer.writeAttribute(QLatin1String("resource"), attributeResource()); + + if (m_children & NormalOff) { + m_normalOff->write(writer, QLatin1String("normaloff")); + } + + if (m_children & NormalOn) { + m_normalOn->write(writer, QLatin1String("normalon")); + } + + if (m_children & DisabledOff) { + m_disabledOff->write(writer, QLatin1String("disabledoff")); + } + + if (m_children & DisabledOn) { + m_disabledOn->write(writer, QLatin1String("disabledon")); + } + + if (m_children & ActiveOff) { + m_activeOff->write(writer, QLatin1String("activeoff")); + } + + if (m_children & ActiveOn) { + m_activeOn->write(writer, QLatin1String("activeon")); + } + + if (m_children & SelectedOff) { + m_selectedOff->write(writer, QLatin1String("selectedoff")); + } + + if (m_children & SelectedOn) { + m_selectedOn->write(writer, QLatin1String("selectedon")); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +DomResourcePixmap* DomResourceIcon::takeElementNormalOff() +{ + DomResourcePixmap* a = m_normalOff; + m_normalOff = 0; + m_children ^= NormalOff; + return a; +} + +void DomResourceIcon::setElementNormalOff(DomResourcePixmap* a) +{ + delete m_normalOff; + m_children |= NormalOff; + m_normalOff = a; +} + +DomResourcePixmap* DomResourceIcon::takeElementNormalOn() +{ + DomResourcePixmap* a = m_normalOn; + m_normalOn = 0; + m_children ^= NormalOn; + return a; +} + +void DomResourceIcon::setElementNormalOn(DomResourcePixmap* a) +{ + delete m_normalOn; + m_children |= NormalOn; + m_normalOn = a; +} + +DomResourcePixmap* DomResourceIcon::takeElementDisabledOff() +{ + DomResourcePixmap* a = m_disabledOff; + m_disabledOff = 0; + m_children ^= DisabledOff; + return a; +} + +void DomResourceIcon::setElementDisabledOff(DomResourcePixmap* a) +{ + delete m_disabledOff; + m_children |= DisabledOff; + m_disabledOff = a; +} + +DomResourcePixmap* DomResourceIcon::takeElementDisabledOn() +{ + DomResourcePixmap* a = m_disabledOn; + m_disabledOn = 0; + m_children ^= DisabledOn; + return a; +} + +void DomResourceIcon::setElementDisabledOn(DomResourcePixmap* a) +{ + delete m_disabledOn; + m_children |= DisabledOn; + m_disabledOn = a; +} + +DomResourcePixmap* DomResourceIcon::takeElementActiveOff() +{ + DomResourcePixmap* a = m_activeOff; + m_activeOff = 0; + m_children ^= ActiveOff; + return a; +} + +void DomResourceIcon::setElementActiveOff(DomResourcePixmap* a) +{ + delete m_activeOff; + m_children |= ActiveOff; + m_activeOff = a; +} + +DomResourcePixmap* DomResourceIcon::takeElementActiveOn() +{ + DomResourcePixmap* a = m_activeOn; + m_activeOn = 0; + m_children ^= ActiveOn; + return a; +} + +void DomResourceIcon::setElementActiveOn(DomResourcePixmap* a) +{ + delete m_activeOn; + m_children |= ActiveOn; + m_activeOn = a; +} + +DomResourcePixmap* DomResourceIcon::takeElementSelectedOff() +{ + DomResourcePixmap* a = m_selectedOff; + m_selectedOff = 0; + m_children ^= SelectedOff; + return a; +} + +void DomResourceIcon::setElementSelectedOff(DomResourcePixmap* a) +{ + delete m_selectedOff; + m_children |= SelectedOff; + m_selectedOff = a; +} + +DomResourcePixmap* DomResourceIcon::takeElementSelectedOn() +{ + DomResourcePixmap* a = m_selectedOn; + m_selectedOn = 0; + m_children ^= SelectedOn; + return a; +} + +void DomResourceIcon::setElementSelectedOn(DomResourcePixmap* a) +{ + delete m_selectedOn; + m_children |= SelectedOn; + m_selectedOn = a; +} + +void DomResourceIcon::clearElementNormalOff() +{ + delete m_normalOff; + m_normalOff = 0; + m_children &= ~NormalOff; +} + +void DomResourceIcon::clearElementNormalOn() +{ + delete m_normalOn; + m_normalOn = 0; + m_children &= ~NormalOn; +} + +void DomResourceIcon::clearElementDisabledOff() +{ + delete m_disabledOff; + m_disabledOff = 0; + m_children &= ~DisabledOff; +} + +void DomResourceIcon::clearElementDisabledOn() +{ + delete m_disabledOn; + m_disabledOn = 0; + m_children &= ~DisabledOn; +} + +void DomResourceIcon::clearElementActiveOff() +{ + delete m_activeOff; + m_activeOff = 0; + m_children &= ~ActiveOff; +} + +void DomResourceIcon::clearElementActiveOn() +{ + delete m_activeOn; + m_activeOn = 0; + m_children &= ~ActiveOn; +} + +void DomResourceIcon::clearElementSelectedOff() +{ + delete m_selectedOff; + m_selectedOff = 0; + m_children &= ~SelectedOff; +} + +void DomResourceIcon::clearElementSelectedOn() +{ + delete m_selectedOn; + m_selectedOn = 0; + m_children &= ~SelectedOn; +} + +void DomString::clear(bool clear_all) +{ + + if (clear_all) { + m_text = QLatin1String(""); + m_has_attr_notr = false; + m_has_attr_comment = false; + m_has_attr_extraComment = false; + } + + m_children = 0; +} + +DomString::DomString() +{ + m_children = 0; + m_has_attr_notr = false; + m_has_attr_comment = false; + m_has_attr_extraComment = false; + m_text = QLatin1String(""); +} + +DomString::~DomString() +{ +} + +void DomString::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("notr")) { + setAttributeNotr(attribute.value().toString()); + continue; + } + if (name == QLatin1String("comment")) { + setAttributeComment(attribute.value().toString()); + continue; + } + if (name == QLatin1String("extracomment")) { + setAttributeExtraComment(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomString::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("notr"))) + setAttributeNotr(node.attribute(QLatin1String("notr"))); + if (node.hasAttribute(QLatin1String("comment"))) + setAttributeComment(node.attribute(QLatin1String("comment"))); + if (node.hasAttribute(QLatin1String("extracomment"))) + setAttributeExtraComment(node.attribute(QLatin1String("extracomment"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + } + m_text = QLatin1String(""); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomString::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("string") : tagName.toLower()); + + if (hasAttributeNotr()) + writer.writeAttribute(QLatin1String("notr"), attributeNotr()); + + if (hasAttributeComment()) + writer.writeAttribute(QLatin1String("comment"), attributeComment()); + + if (hasAttributeExtraComment()) + writer.writeAttribute(QLatin1String("extracomment"), attributeExtraComment()); + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomPointF::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_x = 0; + m_y = 0; +} + +DomPointF::DomPointF() +{ + m_children = 0; + m_x = 0; + m_y = 0; +} + +DomPointF::~DomPointF() +{ +} + +void DomPointF::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QString(QLatin1Char('x'))) { + setElementX(reader.readElementText().toDouble()); + continue; + } + if (tag == QString(QLatin1Char('y'))) { + setElementY(reader.readElementText().toDouble()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomPointF::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QString(QLatin1Char('x'))) { + setElementX(e.text().toDouble()); + continue; + } + if (tag == QString(QLatin1Char('y'))) { + setElementY(e.text().toDouble()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomPointF::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("pointf") : tagName.toLower()); + + if (m_children & X) { + writer.writeTextElement(QString(QLatin1Char('x')), QString::number(m_x, 'f', 15)); + } + + if (m_children & Y) { + writer.writeTextElement(QString(QLatin1Char('y')), QString::number(m_y, 'f', 15)); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomPointF::setElementX(double a) +{ + m_children |= X; + m_x = a; +} + +void DomPointF::setElementY(double a) +{ + m_children |= Y; + m_y = a; +} + +void DomPointF::clearElementX() +{ + m_children &= ~X; +} + +void DomPointF::clearElementY() +{ + m_children &= ~Y; +} + +void DomRectF::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_x = 0; + m_y = 0; + m_width = 0; + m_height = 0; +} + +DomRectF::DomRectF() +{ + m_children = 0; + m_x = 0; + m_y = 0; + m_width = 0; + m_height = 0; +} + +DomRectF::~DomRectF() +{ +} + +void DomRectF::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QString(QLatin1Char('x'))) { + setElementX(reader.readElementText().toDouble()); + continue; + } + if (tag == QString(QLatin1Char('y'))) { + setElementY(reader.readElementText().toDouble()); + continue; + } + if (tag == QLatin1String("width")) { + setElementWidth(reader.readElementText().toDouble()); + continue; + } + if (tag == QLatin1String("height")) { + setElementHeight(reader.readElementText().toDouble()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomRectF::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QString(QLatin1Char('x'))) { + setElementX(e.text().toDouble()); + continue; + } + if (tag == QString(QLatin1Char('y'))) { + setElementY(e.text().toDouble()); + continue; + } + if (tag == QLatin1String("width")) { + setElementWidth(e.text().toDouble()); + continue; + } + if (tag == QLatin1String("height")) { + setElementHeight(e.text().toDouble()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomRectF::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("rectf") : tagName.toLower()); + + if (m_children & X) { + writer.writeTextElement(QString(QLatin1Char('x')), QString::number(m_x, 'f', 15)); + } + + if (m_children & Y) { + writer.writeTextElement(QString(QLatin1Char('y')), QString::number(m_y, 'f', 15)); + } + + if (m_children & Width) { + writer.writeTextElement(QLatin1String("width"), QString::number(m_width, 'f', 15)); + } + + if (m_children & Height) { + writer.writeTextElement(QLatin1String("height"), QString::number(m_height, 'f', 15)); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomRectF::setElementX(double a) +{ + m_children |= X; + m_x = a; +} + +void DomRectF::setElementY(double a) +{ + m_children |= Y; + m_y = a; +} + +void DomRectF::setElementWidth(double a) +{ + m_children |= Width; + m_width = a; +} + +void DomRectF::setElementHeight(double a) +{ + m_children |= Height; + m_height = a; +} + +void DomRectF::clearElementX() +{ + m_children &= ~X; +} + +void DomRectF::clearElementY() +{ + m_children &= ~Y; +} + +void DomRectF::clearElementWidth() +{ + m_children &= ~Width; +} + +void DomRectF::clearElementHeight() +{ + m_children &= ~Height; +} + +void DomSizeF::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_width = 0; + m_height = 0; +} + +DomSizeF::DomSizeF() +{ + m_children = 0; + m_width = 0; + m_height = 0; +} + +DomSizeF::~DomSizeF() +{ +} + +void DomSizeF::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("width")) { + setElementWidth(reader.readElementText().toDouble()); + continue; + } + if (tag == QLatin1String("height")) { + setElementHeight(reader.readElementText().toDouble()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomSizeF::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("width")) { + setElementWidth(e.text().toDouble()); + continue; + } + if (tag == QLatin1String("height")) { + setElementHeight(e.text().toDouble()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomSizeF::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("sizef") : tagName.toLower()); + + if (m_children & Width) { + writer.writeTextElement(QLatin1String("width"), QString::number(m_width, 'f', 15)); + } + + if (m_children & Height) { + writer.writeTextElement(QLatin1String("height"), QString::number(m_height, 'f', 15)); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomSizeF::setElementWidth(double a) +{ + m_children |= Width; + m_width = a; +} + +void DomSizeF::setElementHeight(double a) +{ + m_children |= Height; + m_height = a; +} + +void DomSizeF::clearElementWidth() +{ + m_children &= ~Width; +} + +void DomSizeF::clearElementHeight() +{ + m_children &= ~Height; +} + +void DomChar::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_unicode = 0; +} + +DomChar::DomChar() +{ + m_children = 0; + m_unicode = 0; +} + +DomChar::~DomChar() +{ +} + +void DomChar::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("unicode")) { + setElementUnicode(reader.readElementText().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomChar::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("unicode")) { + setElementUnicode(e.text().toInt()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomChar::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("char") : tagName.toLower()); + + if (m_children & Unicode) { + writer.writeTextElement(QLatin1String("unicode"), QString::number(m_unicode)); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomChar::setElementUnicode(int a) +{ + m_children |= Unicode; + m_unicode = a; +} + +void DomChar::clearElementUnicode() +{ + m_children &= ~Unicode; +} + +void DomUrl::clear(bool clear_all) +{ + delete m_string; + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_string = 0; +} + +DomUrl::DomUrl() +{ + m_children = 0; + m_string = 0; +} + +DomUrl::~DomUrl() +{ + delete m_string; +} + +void DomUrl::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("string")) { + DomString *v = new DomString(); + v->read(reader); + setElementString(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomUrl::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("string")) { + DomString *v = new DomString(); + v->read(e); + setElementString(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomUrl::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("url") : tagName.toLower()); + + if (m_children & String) { + m_string->write(writer, QLatin1String("string")); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +DomString* DomUrl::takeElementString() +{ + DomString* a = m_string; + m_string = 0; + m_children ^= String; + return a; +} + +void DomUrl::setElementString(DomString* a) +{ + delete m_string; + m_children |= String; + m_string = a; +} + +void DomUrl::clearElementString() +{ + delete m_string; + m_string = 0; + m_children &= ~String; +} + +void DomProperty::clear(bool clear_all) +{ + delete m_color; + delete m_font; + delete m_iconSet; + delete m_pixmap; + delete m_palette; + delete m_point; + delete m_rect; + delete m_locale; + delete m_sizePolicy; + delete m_size; + delete m_string; + delete m_stringList; + delete m_date; + delete m_time; + delete m_dateTime; + delete m_pointF; + delete m_rectF; + delete m_sizeF; + delete m_char; + delete m_url; + delete m_brush; + + if (clear_all) { + m_text.clear(); + m_has_attr_name = false; + m_has_attr_stdset = false; + m_attr_stdset = 0; + } + + m_kind = Unknown; + + m_color = 0; + m_cursor = 0; + m_font = 0; + m_iconSet = 0; + m_pixmap = 0; + m_palette = 0; + m_point = 0; + m_rect = 0; + m_locale = 0; + m_sizePolicy = 0; + m_size = 0; + m_string = 0; + m_stringList = 0; + m_number = 0; + m_float = 0.0; + m_double = 0; + m_date = 0; + m_time = 0; + m_dateTime = 0; + m_pointF = 0; + m_rectF = 0; + m_sizeF = 0; + m_longLong = 0; + m_char = 0; + m_url = 0; + m_UInt = 0; + m_uLongLong = 0; + m_brush = 0; +} + +DomProperty::DomProperty() +{ + m_kind = Unknown; + + m_has_attr_name = false; + m_has_attr_stdset = false; + m_attr_stdset = 0; + m_color = 0; + m_cursor = 0; + m_font = 0; + m_iconSet = 0; + m_pixmap = 0; + m_palette = 0; + m_point = 0; + m_rect = 0; + m_locale = 0; + m_sizePolicy = 0; + m_size = 0; + m_string = 0; + m_stringList = 0; + m_number = 0; + m_float = 0.0; + m_double = 0; + m_date = 0; + m_time = 0; + m_dateTime = 0; + m_pointF = 0; + m_rectF = 0; + m_sizeF = 0; + m_longLong = 0; + m_char = 0; + m_url = 0; + m_UInt = 0; + m_uLongLong = 0; + m_brush = 0; +} + +DomProperty::~DomProperty() +{ + delete m_color; + delete m_font; + delete m_iconSet; + delete m_pixmap; + delete m_palette; + delete m_point; + delete m_rect; + delete m_locale; + delete m_sizePolicy; + delete m_size; + delete m_string; + delete m_stringList; + delete m_date; + delete m_time; + delete m_dateTime; + delete m_pointF; + delete m_rectF; + delete m_sizeF; + delete m_char; + delete m_url; + delete m_brush; +} + +void DomProperty::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("name")) { + setAttributeName(attribute.value().toString()); + continue; + } + if (name == QLatin1String("stdset")) { + setAttributeStdset(attribute.value().toString().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("bool")) { + setElementBool(reader.readElementText()); + continue; + } + if (tag == QLatin1String("color")) { + DomColor *v = new DomColor(); + v->read(reader); + setElementColor(v); + continue; + } + if (tag == QLatin1String("cstring")) { + setElementCstring(reader.readElementText()); + continue; + } + if (tag == QLatin1String("cursor")) { + setElementCursor(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("cursorshape")) { + setElementCursorShape(reader.readElementText()); + continue; + } + if (tag == QLatin1String("enum")) { + setElementEnum(reader.readElementText()); + continue; + } + if (tag == QLatin1String("font")) { + DomFont *v = new DomFont(); + v->read(reader); + setElementFont(v); + continue; + } + if (tag == QLatin1String("iconset")) { + DomResourceIcon *v = new DomResourceIcon(); + v->read(reader); + setElementIconSet(v); + continue; + } + if (tag == QLatin1String("pixmap")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(reader); + setElementPixmap(v); + continue; + } + if (tag == QLatin1String("palette")) { + DomPalette *v = new DomPalette(); + v->read(reader); + setElementPalette(v); + continue; + } + if (tag == QLatin1String("point")) { + DomPoint *v = new DomPoint(); + v->read(reader); + setElementPoint(v); + continue; + } + if (tag == QLatin1String("rect")) { + DomRect *v = new DomRect(); + v->read(reader); + setElementRect(v); + continue; + } + if (tag == QLatin1String("set")) { + setElementSet(reader.readElementText()); + continue; + } + if (tag == QLatin1String("locale")) { + DomLocale *v = new DomLocale(); + v->read(reader); + setElementLocale(v); + continue; + } + if (tag == QLatin1String("sizepolicy")) { + DomSizePolicy *v = new DomSizePolicy(); + v->read(reader); + setElementSizePolicy(v); + continue; + } + if (tag == QLatin1String("size")) { + DomSize *v = new DomSize(); + v->read(reader); + setElementSize(v); + continue; + } + if (tag == QLatin1String("string")) { + DomString *v = new DomString(); + v->read(reader); + setElementString(v); + continue; + } + if (tag == QLatin1String("stringlist")) { + DomStringList *v = new DomStringList(); + v->read(reader); + setElementStringList(v); + continue; + } + if (tag == QLatin1String("number")) { + setElementNumber(reader.readElementText().toInt()); + continue; + } + if (tag == QLatin1String("float")) { + setElementFloat(reader.readElementText().toFloat()); + continue; + } + if (tag == QLatin1String("double")) { + setElementDouble(reader.readElementText().toDouble()); + continue; + } + if (tag == QLatin1String("date")) { + DomDate *v = new DomDate(); + v->read(reader); + setElementDate(v); + continue; + } + if (tag == QLatin1String("time")) { + DomTime *v = new DomTime(); + v->read(reader); + setElementTime(v); + continue; + } + if (tag == QLatin1String("datetime")) { + DomDateTime *v = new DomDateTime(); + v->read(reader); + setElementDateTime(v); + continue; + } + if (tag == QLatin1String("pointf")) { + DomPointF *v = new DomPointF(); + v->read(reader); + setElementPointF(v); + continue; + } + if (tag == QLatin1String("rectf")) { + DomRectF *v = new DomRectF(); + v->read(reader); + setElementRectF(v); + continue; + } + if (tag == QLatin1String("sizef")) { + DomSizeF *v = new DomSizeF(); + v->read(reader); + setElementSizeF(v); + continue; + } + if (tag == QLatin1String("longlong")) { + setElementLongLong(reader.readElementText().toLongLong()); + continue; + } + if (tag == QLatin1String("char")) { + DomChar *v = new DomChar(); + v->read(reader); + setElementChar(v); + continue; + } + if (tag == QLatin1String("url")) { + DomUrl *v = new DomUrl(); + v->read(reader); + setElementUrl(v); + continue; + } + if (tag == QLatin1String("uint")) { + setElementUInt(reader.readElementText().toUInt()); + continue; + } + if (tag == QLatin1String("ulonglong")) { + setElementULongLong(reader.readElementText().toULongLong()); + continue; + } + if (tag == QLatin1String("brush")) { + DomBrush *v = new DomBrush(); + v->read(reader); + setElementBrush(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomProperty::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("name"))) + setAttributeName(node.attribute(QLatin1String("name"))); + if (node.hasAttribute(QLatin1String("stdset"))) + setAttributeStdset(node.attribute(QLatin1String("stdset")).toInt()); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("bool")) { + setElementBool(e.text()); + continue; + } + if (tag == QLatin1String("color")) { + DomColor *v = new DomColor(); + v->read(e); + setElementColor(v); + continue; + } + if (tag == QLatin1String("cstring")) { + setElementCstring(e.text()); + continue; + } + if (tag == QLatin1String("cursor")) { + setElementCursor(e.text().toInt()); + continue; + } + if (tag == QLatin1String("cursorshape")) { + setElementCursorShape(e.text()); + continue; + } + if (tag == QLatin1String("enum")) { + setElementEnum(e.text()); + continue; + } + if (tag == QLatin1String("font")) { + DomFont *v = new DomFont(); + v->read(e); + setElementFont(v); + continue; + } + if (tag == QLatin1String("iconset")) { + DomResourceIcon *v = new DomResourceIcon(); + v->read(e); + setElementIconSet(v); + continue; + } + if (tag == QLatin1String("pixmap")) { + DomResourcePixmap *v = new DomResourcePixmap(); + v->read(e); + setElementPixmap(v); + continue; + } + if (tag == QLatin1String("palette")) { + DomPalette *v = new DomPalette(); + v->read(e); + setElementPalette(v); + continue; + } + if (tag == QLatin1String("point")) { + DomPoint *v = new DomPoint(); + v->read(e); + setElementPoint(v); + continue; + } + if (tag == QLatin1String("rect")) { + DomRect *v = new DomRect(); + v->read(e); + setElementRect(v); + continue; + } + if (tag == QLatin1String("set")) { + setElementSet(e.text()); + continue; + } + if (tag == QLatin1String("locale")) { + DomLocale *v = new DomLocale(); + v->read(e); + setElementLocale(v); + continue; + } + if (tag == QLatin1String("sizepolicy")) { + DomSizePolicy *v = new DomSizePolicy(); + v->read(e); + setElementSizePolicy(v); + continue; + } + if (tag == QLatin1String("size")) { + DomSize *v = new DomSize(); + v->read(e); + setElementSize(v); + continue; + } + if (tag == QLatin1String("string")) { + DomString *v = new DomString(); + v->read(e); + setElementString(v); + continue; + } + if (tag == QLatin1String("stringlist")) { + DomStringList *v = new DomStringList(); + v->read(e); + setElementStringList(v); + continue; + } + if (tag == QLatin1String("number")) { + setElementNumber(e.text().toInt()); + continue; + } + if (tag == QLatin1String("float")) { + setElementFloat(e.text().toFloat()); + continue; + } + if (tag == QLatin1String("double")) { + setElementDouble(e.text().toDouble()); + continue; + } + if (tag == QLatin1String("date")) { + DomDate *v = new DomDate(); + v->read(e); + setElementDate(v); + continue; + } + if (tag == QLatin1String("time")) { + DomTime *v = new DomTime(); + v->read(e); + setElementTime(v); + continue; + } + if (tag == QLatin1String("datetime")) { + DomDateTime *v = new DomDateTime(); + v->read(e); + setElementDateTime(v); + continue; + } + if (tag == QLatin1String("pointf")) { + DomPointF *v = new DomPointF(); + v->read(e); + setElementPointF(v); + continue; + } + if (tag == QLatin1String("rectf")) { + DomRectF *v = new DomRectF(); + v->read(e); + setElementRectF(v); + continue; + } + if (tag == QLatin1String("sizef")) { + DomSizeF *v = new DomSizeF(); + v->read(e); + setElementSizeF(v); + continue; + } + if (tag == QLatin1String("longlong")) { + setElementLongLong(e.text().toLongLong()); + continue; + } + if (tag == QLatin1String("char")) { + DomChar *v = new DomChar(); + v->read(e); + setElementChar(v); + continue; + } + if (tag == QLatin1String("url")) { + DomUrl *v = new DomUrl(); + v->read(e); + setElementUrl(v); + continue; + } + if (tag == QLatin1String("uint")) { + setElementUInt(e.text().toUInt()); + continue; + } + if (tag == QLatin1String("ulonglong")) { + setElementULongLong(e.text().toULongLong()); + continue; + } + if (tag == QLatin1String("brush")) { + DomBrush *v = new DomBrush(); + v->read(e); + setElementBrush(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomProperty::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("property") : tagName.toLower()); + + if (hasAttributeName()) + writer.writeAttribute(QLatin1String("name"), attributeName()); + + if (hasAttributeStdset()) + writer.writeAttribute(QLatin1String("stdset"), QString::number(attributeStdset())); + + switch (kind()) { + case Bool: { + writer.writeTextElement(QLatin1String("bool"), elementBool()); + break; + } + case Color: { + DomColor* v = elementColor(); + if (v != 0) { + v->write(writer, QLatin1String("color")); + } + break; + } + case Cstring: { + writer.writeTextElement(QLatin1String("cstring"), elementCstring()); + break; + } + case Cursor: { + writer.writeTextElement(QLatin1String("cursor"), QString::number(elementCursor())); + break; + } + case CursorShape: { + writer.writeTextElement(QLatin1String("cursorShape"), elementCursorShape()); + break; + } + case Enum: { + writer.writeTextElement(QLatin1String("enum"), elementEnum()); + break; + } + case Font: { + DomFont* v = elementFont(); + if (v != 0) { + v->write(writer, QLatin1String("font")); + } + break; + } + case IconSet: { + DomResourceIcon* v = elementIconSet(); + if (v != 0) { + v->write(writer, QLatin1String("iconset")); + } + break; + } + case Pixmap: { + DomResourcePixmap* v = elementPixmap(); + if (v != 0) { + v->write(writer, QLatin1String("pixmap")); + } + break; + } + case Palette: { + DomPalette* v = elementPalette(); + if (v != 0) { + v->write(writer, QLatin1String("palette")); + } + break; + } + case Point: { + DomPoint* v = elementPoint(); + if (v != 0) { + v->write(writer, QLatin1String("point")); + } + break; + } + case Rect: { + DomRect* v = elementRect(); + if (v != 0) { + v->write(writer, QLatin1String("rect")); + } + break; + } + case Set: { + writer.writeTextElement(QLatin1String("set"), elementSet()); + break; + } + case Locale: { + DomLocale* v = elementLocale(); + if (v != 0) { + v->write(writer, QLatin1String("locale")); + } + break; + } + case SizePolicy: { + DomSizePolicy* v = elementSizePolicy(); + if (v != 0) { + v->write(writer, QLatin1String("sizepolicy")); + } + break; + } + case Size: { + DomSize* v = elementSize(); + if (v != 0) { + v->write(writer, QLatin1String("size")); + } + break; + } + case String: { + DomString* v = elementString(); + if (v != 0) { + v->write(writer, QLatin1String("string")); + } + break; + } + case StringList: { + DomStringList* v = elementStringList(); + if (v != 0) { + v->write(writer, QLatin1String("stringlist")); + } + break; + } + case Number: { + writer.writeTextElement(QLatin1String("number"), QString::number(elementNumber())); + break; + } + case Float: { + writer.writeTextElement(QLatin1String("float"), QString::number(elementFloat(), 'f', 8)); + break; + } + case Double: { + writer.writeTextElement(QLatin1String("double"), QString::number(elementDouble(), 'f', 15)); + break; + } + case Date: { + DomDate* v = elementDate(); + if (v != 0) { + v->write(writer, QLatin1String("date")); + } + break; + } + case Time: { + DomTime* v = elementTime(); + if (v != 0) { + v->write(writer, QLatin1String("time")); + } + break; + } + case DateTime: { + DomDateTime* v = elementDateTime(); + if (v != 0) { + v->write(writer, QLatin1String("datetime")); + } + break; + } + case PointF: { + DomPointF* v = elementPointF(); + if (v != 0) { + v->write(writer, QLatin1String("pointf")); + } + break; + } + case RectF: { + DomRectF* v = elementRectF(); + if (v != 0) { + v->write(writer, QLatin1String("rectf")); + } + break; + } + case SizeF: { + DomSizeF* v = elementSizeF(); + if (v != 0) { + v->write(writer, QLatin1String("sizef")); + } + break; + } + case LongLong: { + writer.writeTextElement(QLatin1String("longLong"), QString::number(elementLongLong())); + break; + } + case Char: { + DomChar* v = elementChar(); + if (v != 0) { + v->write(writer, QLatin1String("char")); + } + break; + } + case Url: { + DomUrl* v = elementUrl(); + if (v != 0) { + v->write(writer, QLatin1String("url")); + } + break; + } + case UInt: { + writer.writeTextElement(QLatin1String("UInt"), QString::number(elementUInt())); + break; + } + case ULongLong: { + writer.writeTextElement(QLatin1String("uLongLong"), QString::number(elementULongLong())); + break; + } + case Brush: { + DomBrush* v = elementBrush(); + if (v != 0) { + v->write(writer, QLatin1String("brush")); + } + break; + } + default: + break; + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomProperty::setElementBool(const QString& a) +{ + clear(false); + m_kind = Bool; + m_bool = a; +} + +DomColor* DomProperty::takeElementColor() +{ + DomColor* a = m_color; + m_color = 0; + return a; +} + +void DomProperty::setElementColor(DomColor* a) +{ + clear(false); + m_kind = Color; + m_color = a; +} + +void DomProperty::setElementCstring(const QString& a) +{ + clear(false); + m_kind = Cstring; + m_cstring = a; +} + +void DomProperty::setElementCursor(int a) +{ + clear(false); + m_kind = Cursor; + m_cursor = a; +} + +void DomProperty::setElementCursorShape(const QString& a) +{ + clear(false); + m_kind = CursorShape; + m_cursorShape = a; +} + +void DomProperty::setElementEnum(const QString& a) +{ + clear(false); + m_kind = Enum; + m_enum = a; +} + +DomFont* DomProperty::takeElementFont() +{ + DomFont* a = m_font; + m_font = 0; + return a; +} + +void DomProperty::setElementFont(DomFont* a) +{ + clear(false); + m_kind = Font; + m_font = a; +} + +DomResourceIcon* DomProperty::takeElementIconSet() +{ + DomResourceIcon* a = m_iconSet; + m_iconSet = 0; + return a; +} + +void DomProperty::setElementIconSet(DomResourceIcon* a) +{ + clear(false); + m_kind = IconSet; + m_iconSet = a; +} + +DomResourcePixmap* DomProperty::takeElementPixmap() +{ + DomResourcePixmap* a = m_pixmap; + m_pixmap = 0; + return a; +} + +void DomProperty::setElementPixmap(DomResourcePixmap* a) +{ + clear(false); + m_kind = Pixmap; + m_pixmap = a; +} + +DomPalette* DomProperty::takeElementPalette() +{ + DomPalette* a = m_palette; + m_palette = 0; + return a; +} + +void DomProperty::setElementPalette(DomPalette* a) +{ + clear(false); + m_kind = Palette; + m_palette = a; +} + +DomPoint* DomProperty::takeElementPoint() +{ + DomPoint* a = m_point; + m_point = 0; + return a; +} + +void DomProperty::setElementPoint(DomPoint* a) +{ + clear(false); + m_kind = Point; + m_point = a; +} + +DomRect* DomProperty::takeElementRect() +{ + DomRect* a = m_rect; + m_rect = 0; + return a; +} + +void DomProperty::setElementRect(DomRect* a) +{ + clear(false); + m_kind = Rect; + m_rect = a; +} + +void DomProperty::setElementSet(const QString& a) +{ + clear(false); + m_kind = Set; + m_set = a; +} + +DomLocale* DomProperty::takeElementLocale() +{ + DomLocale* a = m_locale; + m_locale = 0; + return a; +} + +void DomProperty::setElementLocale(DomLocale* a) +{ + clear(false); + m_kind = Locale; + m_locale = a; +} + +DomSizePolicy* DomProperty::takeElementSizePolicy() +{ + DomSizePolicy* a = m_sizePolicy; + m_sizePolicy = 0; + return a; +} + +void DomProperty::setElementSizePolicy(DomSizePolicy* a) +{ + clear(false); + m_kind = SizePolicy; + m_sizePolicy = a; +} + +DomSize* DomProperty::takeElementSize() +{ + DomSize* a = m_size; + m_size = 0; + return a; +} + +void DomProperty::setElementSize(DomSize* a) +{ + clear(false); + m_kind = Size; + m_size = a; +} + +DomString* DomProperty::takeElementString() +{ + DomString* a = m_string; + m_string = 0; + return a; +} + +void DomProperty::setElementString(DomString* a) +{ + clear(false); + m_kind = String; + m_string = a; +} + +DomStringList* DomProperty::takeElementStringList() +{ + DomStringList* a = m_stringList; + m_stringList = 0; + return a; +} + +void DomProperty::setElementStringList(DomStringList* a) +{ + clear(false); + m_kind = StringList; + m_stringList = a; +} + +void DomProperty::setElementNumber(int a) +{ + clear(false); + m_kind = Number; + m_number = a; +} + +void DomProperty::setElementFloat(float a) +{ + clear(false); + m_kind = Float; + m_float = a; +} + +void DomProperty::setElementDouble(double a) +{ + clear(false); + m_kind = Double; + m_double = a; +} + +DomDate* DomProperty::takeElementDate() +{ + DomDate* a = m_date; + m_date = 0; + return a; +} + +void DomProperty::setElementDate(DomDate* a) +{ + clear(false); + m_kind = Date; + m_date = a; +} + +DomTime* DomProperty::takeElementTime() +{ + DomTime* a = m_time; + m_time = 0; + return a; +} + +void DomProperty::setElementTime(DomTime* a) +{ + clear(false); + m_kind = Time; + m_time = a; +} + +DomDateTime* DomProperty::takeElementDateTime() +{ + DomDateTime* a = m_dateTime; + m_dateTime = 0; + return a; +} + +void DomProperty::setElementDateTime(DomDateTime* a) +{ + clear(false); + m_kind = DateTime; + m_dateTime = a; +} + +DomPointF* DomProperty::takeElementPointF() +{ + DomPointF* a = m_pointF; + m_pointF = 0; + return a; +} + +void DomProperty::setElementPointF(DomPointF* a) +{ + clear(false); + m_kind = PointF; + m_pointF = a; +} + +DomRectF* DomProperty::takeElementRectF() +{ + DomRectF* a = m_rectF; + m_rectF = 0; + return a; +} + +void DomProperty::setElementRectF(DomRectF* a) +{ + clear(false); + m_kind = RectF; + m_rectF = a; +} + +DomSizeF* DomProperty::takeElementSizeF() +{ + DomSizeF* a = m_sizeF; + m_sizeF = 0; + return a; +} + +void DomProperty::setElementSizeF(DomSizeF* a) +{ + clear(false); + m_kind = SizeF; + m_sizeF = a; +} + +void DomProperty::setElementLongLong(qlonglong a) +{ + clear(false); + m_kind = LongLong; + m_longLong = a; +} + +DomChar* DomProperty::takeElementChar() +{ + DomChar* a = m_char; + m_char = 0; + return a; +} + +void DomProperty::setElementChar(DomChar* a) +{ + clear(false); + m_kind = Char; + m_char = a; +} + +DomUrl* DomProperty::takeElementUrl() +{ + DomUrl* a = m_url; + m_url = 0; + return a; +} + +void DomProperty::setElementUrl(DomUrl* a) +{ + clear(false); + m_kind = Url; + m_url = a; +} + +void DomProperty::setElementUInt(uint a) +{ + clear(false); + m_kind = UInt; + m_UInt = a; +} + +void DomProperty::setElementULongLong(qulonglong a) +{ + clear(false); + m_kind = ULongLong; + m_uLongLong = a; +} + +DomBrush* DomProperty::takeElementBrush() +{ + DomBrush* a = m_brush; + m_brush = 0; + return a; +} + +void DomProperty::setElementBrush(DomBrush* a) +{ + clear(false); + m_kind = Brush; + m_brush = a; +} + +void DomConnections::clear(bool clear_all) +{ + qDeleteAll(m_connection); + m_connection.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomConnections::DomConnections() +{ + m_children = 0; +} + +DomConnections::~DomConnections() +{ + qDeleteAll(m_connection); + m_connection.clear(); +} + +void DomConnections::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("connection")) { + DomConnection *v = new DomConnection(); + v->read(reader); + m_connection.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomConnections::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("connection")) { + DomConnection *v = new DomConnection(); + v->read(e); + m_connection.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomConnections::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("connections") : tagName.toLower()); + + for (int i = 0; i < m_connection.size(); ++i) { + DomConnection* v = m_connection[i]; + v->write(writer, QLatin1String("connection")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomConnections::setElementConnection(const QList<DomConnection*>& a) +{ + m_children |= Connection; + m_connection = a; +} + +void DomConnection::clear(bool clear_all) +{ + delete m_hints; + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; + m_hints = 0; +} + +DomConnection::DomConnection() +{ + m_children = 0; + m_hints = 0; +} + +DomConnection::~DomConnection() +{ + delete m_hints; +} + +void DomConnection::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("sender")) { + setElementSender(reader.readElementText()); + continue; + } + if (tag == QLatin1String("signal")) { + setElementSignal(reader.readElementText()); + continue; + } + if (tag == QLatin1String("receiver")) { + setElementReceiver(reader.readElementText()); + continue; + } + if (tag == QLatin1String("slot")) { + setElementSlot(reader.readElementText()); + continue; + } + if (tag == QLatin1String("hints")) { + DomConnectionHints *v = new DomConnectionHints(); + v->read(reader); + setElementHints(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomConnection::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("sender")) { + setElementSender(e.text()); + continue; + } + if (tag == QLatin1String("signal")) { + setElementSignal(e.text()); + continue; + } + if (tag == QLatin1String("receiver")) { + setElementReceiver(e.text()); + continue; + } + if (tag == QLatin1String("slot")) { + setElementSlot(e.text()); + continue; + } + if (tag == QLatin1String("hints")) { + DomConnectionHints *v = new DomConnectionHints(); + v->read(e); + setElementHints(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomConnection::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("connection") : tagName.toLower()); + + if (m_children & Sender) { + writer.writeTextElement(QLatin1String("sender"), m_sender); + } + + if (m_children & Signal) { + writer.writeTextElement(QLatin1String("signal"), m_signal); + } + + if (m_children & Receiver) { + writer.writeTextElement(QLatin1String("receiver"), m_receiver); + } + + if (m_children & Slot) { + writer.writeTextElement(QLatin1String("slot"), m_slot); + } + + if (m_children & Hints) { + m_hints->write(writer, QLatin1String("hints")); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomConnection::setElementSender(const QString& a) +{ + m_children |= Sender; + m_sender = a; +} + +void DomConnection::setElementSignal(const QString& a) +{ + m_children |= Signal; + m_signal = a; +} + +void DomConnection::setElementReceiver(const QString& a) +{ + m_children |= Receiver; + m_receiver = a; +} + +void DomConnection::setElementSlot(const QString& a) +{ + m_children |= Slot; + m_slot = a; +} + +DomConnectionHints* DomConnection::takeElementHints() +{ + DomConnectionHints* a = m_hints; + m_hints = 0; + m_children ^= Hints; + return a; +} + +void DomConnection::setElementHints(DomConnectionHints* a) +{ + delete m_hints; + m_children |= Hints; + m_hints = a; +} + +void DomConnection::clearElementSender() +{ + m_children &= ~Sender; +} + +void DomConnection::clearElementSignal() +{ + m_children &= ~Signal; +} + +void DomConnection::clearElementReceiver() +{ + m_children &= ~Receiver; +} + +void DomConnection::clearElementSlot() +{ + m_children &= ~Slot; +} + +void DomConnection::clearElementHints() +{ + delete m_hints; + m_hints = 0; + m_children &= ~Hints; +} + +void DomConnectionHints::clear(bool clear_all) +{ + qDeleteAll(m_hint); + m_hint.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomConnectionHints::DomConnectionHints() +{ + m_children = 0; +} + +DomConnectionHints::~DomConnectionHints() +{ + qDeleteAll(m_hint); + m_hint.clear(); +} + +void DomConnectionHints::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("hint")) { + DomConnectionHint *v = new DomConnectionHint(); + v->read(reader); + m_hint.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomConnectionHints::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("hint")) { + DomConnectionHint *v = new DomConnectionHint(); + v->read(e); + m_hint.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomConnectionHints::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("connectionhints") : tagName.toLower()); + + for (int i = 0; i < m_hint.size(); ++i) { + DomConnectionHint* v = m_hint[i]; + v->write(writer, QLatin1String("hint")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomConnectionHints::setElementHint(const QList<DomConnectionHint*>& a) +{ + m_children |= Hint; + m_hint = a; +} + +void DomConnectionHint::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + m_has_attr_type = false; + } + + m_children = 0; + m_x = 0; + m_y = 0; +} + +DomConnectionHint::DomConnectionHint() +{ + m_children = 0; + m_has_attr_type = false; + m_x = 0; + m_y = 0; +} + +DomConnectionHint::~DomConnectionHint() +{ +} + +void DomConnectionHint::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("type")) { + setAttributeType(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QString(QLatin1Char('x'))) { + setElementX(reader.readElementText().toInt()); + continue; + } + if (tag == QString(QLatin1Char('y'))) { + setElementY(reader.readElementText().toInt()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomConnectionHint::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("type"))) + setAttributeType(node.attribute(QLatin1String("type"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QString(QLatin1Char('x'))) { + setElementX(e.text().toInt()); + continue; + } + if (tag == QString(QLatin1Char('y'))) { + setElementY(e.text().toInt()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomConnectionHint::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("connectionhint") : tagName.toLower()); + + if (hasAttributeType()) + writer.writeAttribute(QLatin1String("type"), attributeType()); + + if (m_children & X) { + writer.writeTextElement(QString(QLatin1Char('x')), QString::number(m_x)); + } + + if (m_children & Y) { + writer.writeTextElement(QString(QLatin1Char('y')), QString::number(m_y)); + } + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomConnectionHint::setElementX(int a) +{ + m_children |= X; + m_x = a; +} + +void DomConnectionHint::setElementY(int a) +{ + m_children |= Y; + m_y = a; +} + +void DomConnectionHint::clearElementX() +{ + m_children &= ~X; +} + +void DomConnectionHint::clearElementY() +{ + m_children &= ~Y; +} + +void DomScript::clear(bool clear_all) +{ + + if (clear_all) { + m_text.clear(); + m_has_attr_source = false; + m_has_attr_language = false; + } + + m_children = 0; +} + +DomScript::DomScript() +{ + m_children = 0; + m_has_attr_source = false; + m_has_attr_language = false; +} + +DomScript::~DomScript() +{ +} + +void DomScript::read(QXmlStreamReader &reader) +{ + + foreach (const QXmlStreamAttribute &attribute, reader.attributes()) { + QStringRef name = attribute.name(); + if (name == QLatin1String("source")) { + setAttributeSource(attribute.value().toString()); + continue; + } + if (name == QLatin1String("language")) { + setAttributeLanguage(attribute.value().toString()); + continue; + } + reader.raiseError(QLatin1String("Unexpected attribute ") + name.toString()); + } + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomScript::read(const QDomElement &node) +{ + if (node.hasAttribute(QLatin1String("source"))) + setAttributeSource(node.attribute(QLatin1String("source"))); + if (node.hasAttribute(QLatin1String("language"))) + setAttributeLanguage(node.attribute(QLatin1String("language"))); + + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomScript::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("script") : tagName.toLower()); + + if (hasAttributeSource()) + writer.writeAttribute(QLatin1String("source"), attributeSource()); + + if (hasAttributeLanguage()) + writer.writeAttribute(QLatin1String("language"), attributeLanguage()); + + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomWidgetData::clear(bool clear_all) +{ + qDeleteAll(m_property); + m_property.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomWidgetData::DomWidgetData() +{ + m_children = 0; +} + +DomWidgetData::~DomWidgetData() +{ + qDeleteAll(m_property); + m_property.clear(); +} + +void DomWidgetData::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_property.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomWidgetData::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_property.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomWidgetData::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("widgetdata") : tagName.toLower()); + + for (int i = 0; i < m_property.size(); ++i) { + DomProperty* v = m_property[i]; + v->write(writer, QLatin1String("property")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomWidgetData::setElementProperty(const QList<DomProperty*>& a) +{ + m_children |= Property; + m_property = a; +} + +void DomDesignerData::clear(bool clear_all) +{ + qDeleteAll(m_property); + m_property.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomDesignerData::DomDesignerData() +{ + m_children = 0; +} + +DomDesignerData::~DomDesignerData() +{ + qDeleteAll(m_property); + m_property.clear(); +} + +void DomDesignerData::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(reader); + m_property.append(v); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomDesignerData::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("property")) { + DomProperty *v = new DomProperty(); + v->read(e); + m_property.append(v); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomDesignerData::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("designerdata") : tagName.toLower()); + + for (int i = 0; i < m_property.size(); ++i) { + DomProperty* v = m_property[i]; + v->write(writer, QLatin1String("property")); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomDesignerData::setElementProperty(const QList<DomProperty*>& a) +{ + m_children |= Property; + m_property = a; +} + +void DomSlots::clear(bool clear_all) +{ + m_signal.clear(); + m_slot.clear(); + + if (clear_all) { + m_text.clear(); + } + + m_children = 0; +} + +DomSlots::DomSlots() +{ + m_children = 0; +} + +DomSlots::~DomSlots() +{ + m_signal.clear(); + m_slot.clear(); +} + +void DomSlots::read(QXmlStreamReader &reader) +{ + + for (bool finished = false; !finished && !reader.hasError();) { + switch (reader.readNext()) { + case QXmlStreamReader::StartElement : { + const QString tag = reader.name().toString().toLower(); + if (tag == QLatin1String("signal")) { + m_signal.append(reader.readElementText()); + continue; + } + if (tag == QLatin1String("slot")) { + m_slot.append(reader.readElementText()); + continue; + } + reader.raiseError(QLatin1String("Unexpected element ") + tag); + } + break; + case QXmlStreamReader::EndElement : + finished = true; + break; + case QXmlStreamReader::Characters : + if (!reader.isWhitespace()) + m_text.append(reader.text().toString()); + break; + default : + break; + } + } +} + +#ifdef QUILOADER_QDOM_READ +void DomSlots::read(const QDomElement &node) +{ + for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) { + if (!n.isElement()) + continue; + QDomElement e = n.toElement(); + QString tag = e.tagName().toLower(); + if (tag == QLatin1String("signal")) { + m_signal.append(e.text()); + continue; + } + if (tag == QLatin1String("slot")) { + m_slot.append(e.text()); + continue; + } + } + m_text.clear(); + for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling()) { + if (child.isText()) + m_text.append(child.nodeValue()); + } +} +#endif + +void DomSlots::write(QXmlStreamWriter &writer, const QString &tagName) const +{ + writer.writeStartElement(tagName.isEmpty() ? QString::fromUtf8("slots") : tagName.toLower()); + + for (int i = 0; i < m_signal.size(); ++i) { + QString v = m_signal[i]; + writer.writeTextElement(QLatin1String("signal"), v); + } + for (int i = 0; i < m_slot.size(); ++i) { + QString v = m_slot[i]; + writer.writeTextElement(QLatin1String("slot"), v); + } + if (!m_text.isEmpty()) + writer.writeCharacters(m_text); + + writer.writeEndElement(); +} + +void DomSlots::setElementSignal(const QStringList& a) +{ + m_children |= Signal; + m_signal = a; +} + +void DomSlots::setElementSlot(const QStringList& a) +{ + m_children |= Slot; + m_slot = a; +} + +QT_END_NAMESPACE + diff --git a/tools/designer/src/lib/uilib/ui4_p.h b/tools/designer/src/lib/uilib/ui4_p.h new file mode 100644 index 0000000..df02a39 --- /dev/null +++ b/tools/designer/src/lib/uilib/ui4_p.h @@ -0,0 +1,3696 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the tools applications of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience +// of Qt Designer. This header +// file may change from version to version without notice, or even be removed. +// +// We mean it. +// + +// THIS FILE IS AUTOMATICALLY GENERATED + +#ifndef UI4_H +#define UI4_H + +#include <QtCore/QList> +#include <QtCore/QString> +#include <QtCore/QStringList> +#include <QtCore/QXmlStreamReader> +#include <QtCore/QXmlStreamWriter> +#include <QtCore/qglobal.h> + +#if defined(QT_UIC3) + #define QUILOADER_QDOM_READ +#endif + +QT_BEGIN_NAMESPACE + +#ifdef QUILOADER_QDOM_READ + class QDomElement; +#endif + + +#define QDESIGNER_UILIB_EXTERN Q_DECL_EXPORT +#define QDESIGNER_UILIB_IMPORT Q_DECL_IMPORT + +#if defined(QT_DESIGNER_STATIC) || defined(QT_UIC) || defined(QT_UIC3) +# define QDESIGNER_UILIB_EXPORT +#elif defined(QDESIGNER_UILIB_LIBRARY) +# define QDESIGNER_UILIB_EXPORT QDESIGNER_UILIB_EXTERN +#else +# define QDESIGNER_UILIB_EXPORT QDESIGNER_UILIB_IMPORT +#endif + +#ifndef QDESIGNER_UILIB_EXPORT +# define QDESIGNER_UILIB_EXPORT +#endif + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal +{ +#endif + + +/******************************************************************************* +** Forward declarations +*/ + +class DomUI; +class DomIncludes; +class DomInclude; +class DomResources; +class DomResource; +class DomActionGroup; +class DomAction; +class DomActionRef; +class DomButtonGroup; +class DomButtonGroups; +class DomImages; +class DomImage; +class DomImageData; +class DomCustomWidgets; +class DomHeader; +class DomCustomWidget; +class DomProperties; +class DomPropertyData; +class DomSizePolicyData; +class DomLayoutDefault; +class DomLayoutFunction; +class DomTabStops; +class DomLayout; +class DomLayoutItem; +class DomRow; +class DomColumn; +class DomItem; +class DomWidget; +class DomSpacer; +class DomColor; +class DomGradientStop; +class DomGradient; +class DomBrush; +class DomColorRole; +class DomColorGroup; +class DomPalette; +class DomFont; +class DomPoint; +class DomRect; +class DomLocale; +class DomSizePolicy; +class DomSize; +class DomDate; +class DomTime; +class DomDateTime; +class DomStringList; +class DomResourcePixmap; +class DomResourceIcon; +class DomString; +class DomPointF; +class DomRectF; +class DomSizeF; +class DomChar; +class DomUrl; +class DomProperty; +class DomConnections; +class DomConnection; +class DomConnectionHints; +class DomConnectionHint; +class DomScript; +class DomWidgetData; +class DomDesignerData; +class DomSlots; + +/******************************************************************************* +** Declarations +*/ + +class QDESIGNER_UILIB_EXPORT DomUI { +public: + DomUI(); + ~DomUI(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeVersion() const { return m_has_attr_version; } + inline QString attributeVersion() const { return m_attr_version; } + inline void setAttributeVersion(const QString& a) { m_attr_version = a; m_has_attr_version = true; } + inline void clearAttributeVersion() { m_has_attr_version = false; } + + inline bool hasAttributeLanguage() const { return m_has_attr_language; } + inline QString attributeLanguage() const { return m_attr_language; } + inline void setAttributeLanguage(const QString& a) { m_attr_language = a; m_has_attr_language = true; } + inline void clearAttributeLanguage() { m_has_attr_language = false; } + + inline bool hasAttributeDisplayname() const { return m_has_attr_displayname; } + inline QString attributeDisplayname() const { return m_attr_displayname; } + inline void setAttributeDisplayname(const QString& a) { m_attr_displayname = a; m_has_attr_displayname = true; } + inline void clearAttributeDisplayname() { m_has_attr_displayname = false; } + + inline bool hasAttributeStdsetdef() const { return m_has_attr_stdsetdef; } + inline int attributeStdsetdef() const { return m_attr_stdsetdef; } + inline void setAttributeStdsetdef(int a) { m_attr_stdsetdef = a; m_has_attr_stdsetdef = true; } + inline void clearAttributeStdsetdef() { m_has_attr_stdsetdef = false; } + + inline bool hasAttributeStdSetDef() const { return m_has_attr_stdSetDef; } + inline int attributeStdSetDef() const { return m_attr_stdSetDef; } + inline void setAttributeStdSetDef(int a) { m_attr_stdSetDef = a; m_has_attr_stdSetDef = true; } + inline void clearAttributeStdSetDef() { m_has_attr_stdSetDef = false; } + + // child element accessors + inline QString elementAuthor() const { return m_author; } + void setElementAuthor(const QString& a); + inline bool hasElementAuthor() const { return m_children & Author; } + void clearElementAuthor(); + + inline QString elementComment() const { return m_comment; } + void setElementComment(const QString& a); + inline bool hasElementComment() const { return m_children & Comment; } + void clearElementComment(); + + inline QString elementExportMacro() const { return m_exportMacro; } + void setElementExportMacro(const QString& a); + inline bool hasElementExportMacro() const { return m_children & ExportMacro; } + void clearElementExportMacro(); + + inline QString elementClass() const { return m_class; } + void setElementClass(const QString& a); + inline bool hasElementClass() const { return m_children & Class; } + void clearElementClass(); + + inline DomWidget* elementWidget() const { return m_widget; } + DomWidget* takeElementWidget(); + void setElementWidget(DomWidget* a); + inline bool hasElementWidget() const { return m_children & Widget; } + void clearElementWidget(); + + inline DomLayoutDefault* elementLayoutDefault() const { return m_layoutDefault; } + DomLayoutDefault* takeElementLayoutDefault(); + void setElementLayoutDefault(DomLayoutDefault* a); + inline bool hasElementLayoutDefault() const { return m_children & LayoutDefault; } + void clearElementLayoutDefault(); + + inline DomLayoutFunction* elementLayoutFunction() const { return m_layoutFunction; } + DomLayoutFunction* takeElementLayoutFunction(); + void setElementLayoutFunction(DomLayoutFunction* a); + inline bool hasElementLayoutFunction() const { return m_children & LayoutFunction; } + void clearElementLayoutFunction(); + + inline QString elementPixmapFunction() const { return m_pixmapFunction; } + void setElementPixmapFunction(const QString& a); + inline bool hasElementPixmapFunction() const { return m_children & PixmapFunction; } + void clearElementPixmapFunction(); + + inline DomCustomWidgets* elementCustomWidgets() const { return m_customWidgets; } + DomCustomWidgets* takeElementCustomWidgets(); + void setElementCustomWidgets(DomCustomWidgets* a); + inline bool hasElementCustomWidgets() const { return m_children & CustomWidgets; } + void clearElementCustomWidgets(); + + inline DomTabStops* elementTabStops() const { return m_tabStops; } + DomTabStops* takeElementTabStops(); + void setElementTabStops(DomTabStops* a); + inline bool hasElementTabStops() const { return m_children & TabStops; } + void clearElementTabStops(); + + inline DomImages* elementImages() const { return m_images; } + DomImages* takeElementImages(); + void setElementImages(DomImages* a); + inline bool hasElementImages() const { return m_children & Images; } + void clearElementImages(); + + inline DomIncludes* elementIncludes() const { return m_includes; } + DomIncludes* takeElementIncludes(); + void setElementIncludes(DomIncludes* a); + inline bool hasElementIncludes() const { return m_children & Includes; } + void clearElementIncludes(); + + inline DomResources* elementResources() const { return m_resources; } + DomResources* takeElementResources(); + void setElementResources(DomResources* a); + inline bool hasElementResources() const { return m_children & Resources; } + void clearElementResources(); + + inline DomConnections* elementConnections() const { return m_connections; } + DomConnections* takeElementConnections(); + void setElementConnections(DomConnections* a); + inline bool hasElementConnections() const { return m_children & Connections; } + void clearElementConnections(); + + inline DomDesignerData* elementDesignerdata() const { return m_designerdata; } + DomDesignerData* takeElementDesignerdata(); + void setElementDesignerdata(DomDesignerData* a); + inline bool hasElementDesignerdata() const { return m_children & Designerdata; } + void clearElementDesignerdata(); + + inline DomSlots* elementSlots() const { return m_slots; } + DomSlots* takeElementSlots(); + void setElementSlots(DomSlots* a); + inline bool hasElementSlots() const { return m_children & Slots; } + void clearElementSlots(); + + inline DomButtonGroups* elementButtonGroups() const { return m_buttonGroups; } + DomButtonGroups* takeElementButtonGroups(); + void setElementButtonGroups(DomButtonGroups* a); + inline bool hasElementButtonGroups() const { return m_children & ButtonGroups; } + void clearElementButtonGroups(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_version; + bool m_has_attr_version; + + QString m_attr_language; + bool m_has_attr_language; + + QString m_attr_displayname; + bool m_has_attr_displayname; + + int m_attr_stdsetdef; + bool m_has_attr_stdsetdef; + + int m_attr_stdSetDef; + bool m_has_attr_stdSetDef; + + // child element data + uint m_children; + QString m_author; + QString m_comment; + QString m_exportMacro; + QString m_class; + DomWidget* m_widget; + DomLayoutDefault* m_layoutDefault; + DomLayoutFunction* m_layoutFunction; + QString m_pixmapFunction; + DomCustomWidgets* m_customWidgets; + DomTabStops* m_tabStops; + DomImages* m_images; + DomIncludes* m_includes; + DomResources* m_resources; + DomConnections* m_connections; + DomDesignerData* m_designerdata; + DomSlots* m_slots; + DomButtonGroups* m_buttonGroups; + enum Child { + Author = 1, + Comment = 2, + ExportMacro = 4, + Class = 8, + Widget = 16, + LayoutDefault = 32, + LayoutFunction = 64, + PixmapFunction = 128, + CustomWidgets = 256, + TabStops = 512, + Images = 1024, + Includes = 2048, + Resources = 4096, + Connections = 8192, + Designerdata = 16384, + Slots = 32768, + ButtonGroups = 65536 + }; + + DomUI(const DomUI &other); + void operator = (const DomUI&other); +}; + +class QDESIGNER_UILIB_EXPORT DomIncludes { +public: + DomIncludes(); + ~DomIncludes(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QList<DomInclude*> elementInclude() const { return m_include; } + void setElementInclude(const QList<DomInclude*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QList<DomInclude*> m_include; + enum Child { + Include = 1 + }; + + DomIncludes(const DomIncludes &other); + void operator = (const DomIncludes&other); +}; + +class QDESIGNER_UILIB_EXPORT DomInclude { +public: + DomInclude(); + ~DomInclude(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeLocation() const { return m_has_attr_location; } + inline QString attributeLocation() const { return m_attr_location; } + inline void setAttributeLocation(const QString& a) { m_attr_location = a; m_has_attr_location = true; } + inline void clearAttributeLocation() { m_has_attr_location = false; } + + inline bool hasAttributeImpldecl() const { return m_has_attr_impldecl; } + inline QString attributeImpldecl() const { return m_attr_impldecl; } + inline void setAttributeImpldecl(const QString& a) { m_attr_impldecl = a; m_has_attr_impldecl = true; } + inline void clearAttributeImpldecl() { m_has_attr_impldecl = false; } + + // child element accessors +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_location; + bool m_has_attr_location; + + QString m_attr_impldecl; + bool m_has_attr_impldecl; + + // child element data + uint m_children; + + DomInclude(const DomInclude &other); + void operator = (const DomInclude&other); +}; + +class QDESIGNER_UILIB_EXPORT DomResources { +public: + DomResources(); + ~DomResources(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeName() const { return m_has_attr_name; } + inline QString attributeName() const { return m_attr_name; } + inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; } + inline void clearAttributeName() { m_has_attr_name = false; } + + // child element accessors + inline QList<DomResource*> elementInclude() const { return m_include; } + void setElementInclude(const QList<DomResource*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_name; + bool m_has_attr_name; + + // child element data + uint m_children; + QList<DomResource*> m_include; + enum Child { + Include = 1 + }; + + DomResources(const DomResources &other); + void operator = (const DomResources&other); +}; + +class QDESIGNER_UILIB_EXPORT DomResource { +public: + DomResource(); + ~DomResource(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeLocation() const { return m_has_attr_location; } + inline QString attributeLocation() const { return m_attr_location; } + inline void setAttributeLocation(const QString& a) { m_attr_location = a; m_has_attr_location = true; } + inline void clearAttributeLocation() { m_has_attr_location = false; } + + // child element accessors +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_location; + bool m_has_attr_location; + + // child element data + uint m_children; + + DomResource(const DomResource &other); + void operator = (const DomResource&other); +}; + +class QDESIGNER_UILIB_EXPORT DomActionGroup { +public: + DomActionGroup(); + ~DomActionGroup(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeName() const { return m_has_attr_name; } + inline QString attributeName() const { return m_attr_name; } + inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; } + inline void clearAttributeName() { m_has_attr_name = false; } + + // child element accessors + inline QList<DomAction*> elementAction() const { return m_action; } + void setElementAction(const QList<DomAction*>& a); + + inline QList<DomActionGroup*> elementActionGroup() const { return m_actionGroup; } + void setElementActionGroup(const QList<DomActionGroup*>& a); + + inline QList<DomProperty*> elementProperty() const { return m_property; } + void setElementProperty(const QList<DomProperty*>& a); + + inline QList<DomProperty*> elementAttribute() const { return m_attribute; } + void setElementAttribute(const QList<DomProperty*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_name; + bool m_has_attr_name; + + // child element data + uint m_children; + QList<DomAction*> m_action; + QList<DomActionGroup*> m_actionGroup; + QList<DomProperty*> m_property; + QList<DomProperty*> m_attribute; + enum Child { + Action = 1, + ActionGroup = 2, + Property = 4, + Attribute = 8 + }; + + DomActionGroup(const DomActionGroup &other); + void operator = (const DomActionGroup&other); +}; + +class QDESIGNER_UILIB_EXPORT DomAction { +public: + DomAction(); + ~DomAction(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeName() const { return m_has_attr_name; } + inline QString attributeName() const { return m_attr_name; } + inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; } + inline void clearAttributeName() { m_has_attr_name = false; } + + inline bool hasAttributeMenu() const { return m_has_attr_menu; } + inline QString attributeMenu() const { return m_attr_menu; } + inline void setAttributeMenu(const QString& a) { m_attr_menu = a; m_has_attr_menu = true; } + inline void clearAttributeMenu() { m_has_attr_menu = false; } + + // child element accessors + inline QList<DomProperty*> elementProperty() const { return m_property; } + void setElementProperty(const QList<DomProperty*>& a); + + inline QList<DomProperty*> elementAttribute() const { return m_attribute; } + void setElementAttribute(const QList<DomProperty*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_name; + bool m_has_attr_name; + + QString m_attr_menu; + bool m_has_attr_menu; + + // child element data + uint m_children; + QList<DomProperty*> m_property; + QList<DomProperty*> m_attribute; + enum Child { + Property = 1, + Attribute = 2 + }; + + DomAction(const DomAction &other); + void operator = (const DomAction&other); +}; + +class QDESIGNER_UILIB_EXPORT DomActionRef { +public: + DomActionRef(); + ~DomActionRef(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeName() const { return m_has_attr_name; } + inline QString attributeName() const { return m_attr_name; } + inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; } + inline void clearAttributeName() { m_has_attr_name = false; } + + // child element accessors +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_name; + bool m_has_attr_name; + + // child element data + uint m_children; + + DomActionRef(const DomActionRef &other); + void operator = (const DomActionRef&other); +}; + +class QDESIGNER_UILIB_EXPORT DomButtonGroup { +public: + DomButtonGroup(); + ~DomButtonGroup(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeName() const { return m_has_attr_name; } + inline QString attributeName() const { return m_attr_name; } + inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; } + inline void clearAttributeName() { m_has_attr_name = false; } + + // child element accessors + inline QList<DomProperty*> elementProperty() const { return m_property; } + void setElementProperty(const QList<DomProperty*>& a); + + inline QList<DomProperty*> elementAttribute() const { return m_attribute; } + void setElementAttribute(const QList<DomProperty*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_name; + bool m_has_attr_name; + + // child element data + uint m_children; + QList<DomProperty*> m_property; + QList<DomProperty*> m_attribute; + enum Child { + Property = 1, + Attribute = 2 + }; + + DomButtonGroup(const DomButtonGroup &other); + void operator = (const DomButtonGroup&other); +}; + +class QDESIGNER_UILIB_EXPORT DomButtonGroups { +public: + DomButtonGroups(); + ~DomButtonGroups(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QList<DomButtonGroup*> elementButtonGroup() const { return m_buttonGroup; } + void setElementButtonGroup(const QList<DomButtonGroup*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QList<DomButtonGroup*> m_buttonGroup; + enum Child { + ButtonGroup = 1 + }; + + DomButtonGroups(const DomButtonGroups &other); + void operator = (const DomButtonGroups&other); +}; + +class QDESIGNER_UILIB_EXPORT DomImages { +public: + DomImages(); + ~DomImages(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QList<DomImage*> elementImage() const { return m_image; } + void setElementImage(const QList<DomImage*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QList<DomImage*> m_image; + enum Child { + Image = 1 + }; + + DomImages(const DomImages &other); + void operator = (const DomImages&other); +}; + +class QDESIGNER_UILIB_EXPORT DomImage { +public: + DomImage(); + ~DomImage(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeName() const { return m_has_attr_name; } + inline QString attributeName() const { return m_attr_name; } + inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; } + inline void clearAttributeName() { m_has_attr_name = false; } + + // child element accessors + inline DomImageData* elementData() const { return m_data; } + DomImageData* takeElementData(); + void setElementData(DomImageData* a); + inline bool hasElementData() const { return m_children & Data; } + void clearElementData(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_name; + bool m_has_attr_name; + + // child element data + uint m_children; + DomImageData* m_data; + enum Child { + Data = 1 + }; + + DomImage(const DomImage &other); + void operator = (const DomImage&other); +}; + +class QDESIGNER_UILIB_EXPORT DomImageData { +public: + DomImageData(); + ~DomImageData(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeFormat() const { return m_has_attr_format; } + inline QString attributeFormat() const { return m_attr_format; } + inline void setAttributeFormat(const QString& a) { m_attr_format = a; m_has_attr_format = true; } + inline void clearAttributeFormat() { m_has_attr_format = false; } + + inline bool hasAttributeLength() const { return m_has_attr_length; } + inline int attributeLength() const { return m_attr_length; } + inline void setAttributeLength(int a) { m_attr_length = a; m_has_attr_length = true; } + inline void clearAttributeLength() { m_has_attr_length = false; } + + // child element accessors +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_format; + bool m_has_attr_format; + + int m_attr_length; + bool m_has_attr_length; + + // child element data + uint m_children; + + DomImageData(const DomImageData &other); + void operator = (const DomImageData&other); +}; + +class QDESIGNER_UILIB_EXPORT DomCustomWidgets { +public: + DomCustomWidgets(); + ~DomCustomWidgets(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QList<DomCustomWidget*> elementCustomWidget() const { return m_customWidget; } + void setElementCustomWidget(const QList<DomCustomWidget*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QList<DomCustomWidget*> m_customWidget; + enum Child { + CustomWidget = 1 + }; + + DomCustomWidgets(const DomCustomWidgets &other); + void operator = (const DomCustomWidgets&other); +}; + +class QDESIGNER_UILIB_EXPORT DomHeader { +public: + DomHeader(); + ~DomHeader(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeLocation() const { return m_has_attr_location; } + inline QString attributeLocation() const { return m_attr_location; } + inline void setAttributeLocation(const QString& a) { m_attr_location = a; m_has_attr_location = true; } + inline void clearAttributeLocation() { m_has_attr_location = false; } + + // child element accessors +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_location; + bool m_has_attr_location; + + // child element data + uint m_children; + + DomHeader(const DomHeader &other); + void operator = (const DomHeader&other); +}; + +class QDESIGNER_UILIB_EXPORT DomCustomWidget { +public: + DomCustomWidget(); + ~DomCustomWidget(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QString elementClass() const { return m_class; } + void setElementClass(const QString& a); + inline bool hasElementClass() const { return m_children & Class; } + void clearElementClass(); + + inline QString elementExtends() const { return m_extends; } + void setElementExtends(const QString& a); + inline bool hasElementExtends() const { return m_children & Extends; } + void clearElementExtends(); + + inline DomHeader* elementHeader() const { return m_header; } + DomHeader* takeElementHeader(); + void setElementHeader(DomHeader* a); + inline bool hasElementHeader() const { return m_children & Header; } + void clearElementHeader(); + + inline DomSize* elementSizeHint() const { return m_sizeHint; } + DomSize* takeElementSizeHint(); + void setElementSizeHint(DomSize* a); + inline bool hasElementSizeHint() const { return m_children & SizeHint; } + void clearElementSizeHint(); + + inline QString elementAddPageMethod() const { return m_addPageMethod; } + void setElementAddPageMethod(const QString& a); + inline bool hasElementAddPageMethod() const { return m_children & AddPageMethod; } + void clearElementAddPageMethod(); + + inline int elementContainer() const { return m_container; } + void setElementContainer(int a); + inline bool hasElementContainer() const { return m_children & Container; } + void clearElementContainer(); + + inline DomSizePolicyData* elementSizePolicy() const { return m_sizePolicy; } + DomSizePolicyData* takeElementSizePolicy(); + void setElementSizePolicy(DomSizePolicyData* a); + inline bool hasElementSizePolicy() const { return m_children & SizePolicy; } + void clearElementSizePolicy(); + + inline QString elementPixmap() const { return m_pixmap; } + void setElementPixmap(const QString& a); + inline bool hasElementPixmap() const { return m_children & Pixmap; } + void clearElementPixmap(); + + inline DomScript* elementScript() const { return m_script; } + DomScript* takeElementScript(); + void setElementScript(DomScript* a); + inline bool hasElementScript() const { return m_children & Script; } + void clearElementScript(); + + inline DomProperties* elementProperties() const { return m_properties; } + DomProperties* takeElementProperties(); + void setElementProperties(DomProperties* a); + inline bool hasElementProperties() const { return m_children & Properties; } + void clearElementProperties(); + + inline DomSlots* elementSlots() const { return m_slots; } + DomSlots* takeElementSlots(); + void setElementSlots(DomSlots* a); + inline bool hasElementSlots() const { return m_children & Slots; } + void clearElementSlots(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QString m_class; + QString m_extends; + DomHeader* m_header; + DomSize* m_sizeHint; + QString m_addPageMethod; + int m_container; + DomSizePolicyData* m_sizePolicy; + QString m_pixmap; + DomScript* m_script; + DomProperties* m_properties; + DomSlots* m_slots; + enum Child { + Class = 1, + Extends = 2, + Header = 4, + SizeHint = 8, + AddPageMethod = 16, + Container = 32, + SizePolicy = 64, + Pixmap = 128, + Script = 256, + Properties = 512, + Slots = 1024 + }; + + DomCustomWidget(const DomCustomWidget &other); + void operator = (const DomCustomWidget&other); +}; + +class QDESIGNER_UILIB_EXPORT DomProperties { +public: + DomProperties(); + ~DomProperties(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QList<DomPropertyData*> elementProperty() const { return m_property; } + void setElementProperty(const QList<DomPropertyData*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QList<DomPropertyData*> m_property; + enum Child { + Property = 1 + }; + + DomProperties(const DomProperties &other); + void operator = (const DomProperties&other); +}; + +class QDESIGNER_UILIB_EXPORT DomPropertyData { +public: + DomPropertyData(); + ~DomPropertyData(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeType() const { return m_has_attr_type; } + inline QString attributeType() const { return m_attr_type; } + inline void setAttributeType(const QString& a) { m_attr_type = a; m_has_attr_type = true; } + inline void clearAttributeType() { m_has_attr_type = false; } + + // child element accessors +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_type; + bool m_has_attr_type; + + // child element data + uint m_children; + + DomPropertyData(const DomPropertyData &other); + void operator = (const DomPropertyData&other); +}; + +class QDESIGNER_UILIB_EXPORT DomSizePolicyData { +public: + DomSizePolicyData(); + ~DomSizePolicyData(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline int elementHorData() const { return m_horData; } + void setElementHorData(int a); + inline bool hasElementHorData() const { return m_children & HorData; } + void clearElementHorData(); + + inline int elementVerData() const { return m_verData; } + void setElementVerData(int a); + inline bool hasElementVerData() const { return m_children & VerData; } + void clearElementVerData(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + int m_horData; + int m_verData; + enum Child { + HorData = 1, + VerData = 2 + }; + + DomSizePolicyData(const DomSizePolicyData &other); + void operator = (const DomSizePolicyData&other); +}; + +class QDESIGNER_UILIB_EXPORT DomLayoutDefault { +public: + DomLayoutDefault(); + ~DomLayoutDefault(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeSpacing() const { return m_has_attr_spacing; } + inline int attributeSpacing() const { return m_attr_spacing; } + inline void setAttributeSpacing(int a) { m_attr_spacing = a; m_has_attr_spacing = true; } + inline void clearAttributeSpacing() { m_has_attr_spacing = false; } + + inline bool hasAttributeMargin() const { return m_has_attr_margin; } + inline int attributeMargin() const { return m_attr_margin; } + inline void setAttributeMargin(int a) { m_attr_margin = a; m_has_attr_margin = true; } + inline void clearAttributeMargin() { m_has_attr_margin = false; } + + // child element accessors +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + int m_attr_spacing; + bool m_has_attr_spacing; + + int m_attr_margin; + bool m_has_attr_margin; + + // child element data + uint m_children; + + DomLayoutDefault(const DomLayoutDefault &other); + void operator = (const DomLayoutDefault&other); +}; + +class QDESIGNER_UILIB_EXPORT DomLayoutFunction { +public: + DomLayoutFunction(); + ~DomLayoutFunction(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeSpacing() const { return m_has_attr_spacing; } + inline QString attributeSpacing() const { return m_attr_spacing; } + inline void setAttributeSpacing(const QString& a) { m_attr_spacing = a; m_has_attr_spacing = true; } + inline void clearAttributeSpacing() { m_has_attr_spacing = false; } + + inline bool hasAttributeMargin() const { return m_has_attr_margin; } + inline QString attributeMargin() const { return m_attr_margin; } + inline void setAttributeMargin(const QString& a) { m_attr_margin = a; m_has_attr_margin = true; } + inline void clearAttributeMargin() { m_has_attr_margin = false; } + + // child element accessors +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_spacing; + bool m_has_attr_spacing; + + QString m_attr_margin; + bool m_has_attr_margin; + + // child element data + uint m_children; + + DomLayoutFunction(const DomLayoutFunction &other); + void operator = (const DomLayoutFunction&other); +}; + +class QDESIGNER_UILIB_EXPORT DomTabStops { +public: + DomTabStops(); + ~DomTabStops(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QStringList elementTabStop() const { return m_tabStop; } + void setElementTabStop(const QStringList& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QStringList m_tabStop; + enum Child { + TabStop = 1 + }; + + DomTabStops(const DomTabStops &other); + void operator = (const DomTabStops&other); +}; + +class QDESIGNER_UILIB_EXPORT DomLayout { +public: + DomLayout(); + ~DomLayout(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeClass() const { return m_has_attr_class; } + inline QString attributeClass() const { return m_attr_class; } + inline void setAttributeClass(const QString& a) { m_attr_class = a; m_has_attr_class = true; } + inline void clearAttributeClass() { m_has_attr_class = false; } + + inline bool hasAttributeName() const { return m_has_attr_name; } + inline QString attributeName() const { return m_attr_name; } + inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; } + inline void clearAttributeName() { m_has_attr_name = false; } + + inline bool hasAttributeStretch() const { return m_has_attr_stretch; } + inline QString attributeStretch() const { return m_attr_stretch; } + inline void setAttributeStretch(const QString& a) { m_attr_stretch = a; m_has_attr_stretch = true; } + inline void clearAttributeStretch() { m_has_attr_stretch = false; } + + inline bool hasAttributeRowStretch() const { return m_has_attr_rowStretch; } + inline QString attributeRowStretch() const { return m_attr_rowStretch; } + inline void setAttributeRowStretch(const QString& a) { m_attr_rowStretch = a; m_has_attr_rowStretch = true; } + inline void clearAttributeRowStretch() { m_has_attr_rowStretch = false; } + + inline bool hasAttributeColumnStretch() const { return m_has_attr_columnStretch; } + inline QString attributeColumnStretch() const { return m_attr_columnStretch; } + inline void setAttributeColumnStretch(const QString& a) { m_attr_columnStretch = a; m_has_attr_columnStretch = true; } + inline void clearAttributeColumnStretch() { m_has_attr_columnStretch = false; } + + inline bool hasAttributeRowMinimumHeight() const { return m_has_attr_rowMinimumHeight; } + inline QString attributeRowMinimumHeight() const { return m_attr_rowMinimumHeight; } + inline void setAttributeRowMinimumHeight(const QString& a) { m_attr_rowMinimumHeight = a; m_has_attr_rowMinimumHeight = true; } + inline void clearAttributeRowMinimumHeight() { m_has_attr_rowMinimumHeight = false; } + + inline bool hasAttributeColumnMinimumWidth() const { return m_has_attr_columnMinimumWidth; } + inline QString attributeColumnMinimumWidth() const { return m_attr_columnMinimumWidth; } + inline void setAttributeColumnMinimumWidth(const QString& a) { m_attr_columnMinimumWidth = a; m_has_attr_columnMinimumWidth = true; } + inline void clearAttributeColumnMinimumWidth() { m_has_attr_columnMinimumWidth = false; } + + // child element accessors + inline QList<DomProperty*> elementProperty() const { return m_property; } + void setElementProperty(const QList<DomProperty*>& a); + + inline QList<DomProperty*> elementAttribute() const { return m_attribute; } + void setElementAttribute(const QList<DomProperty*>& a); + + inline QList<DomLayoutItem*> elementItem() const { return m_item; } + void setElementItem(const QList<DomLayoutItem*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_class; + bool m_has_attr_class; + + QString m_attr_name; + bool m_has_attr_name; + + QString m_attr_stretch; + bool m_has_attr_stretch; + + QString m_attr_rowStretch; + bool m_has_attr_rowStretch; + + QString m_attr_columnStretch; + bool m_has_attr_columnStretch; + + QString m_attr_rowMinimumHeight; + bool m_has_attr_rowMinimumHeight; + + QString m_attr_columnMinimumWidth; + bool m_has_attr_columnMinimumWidth; + + // child element data + uint m_children; + QList<DomProperty*> m_property; + QList<DomProperty*> m_attribute; + QList<DomLayoutItem*> m_item; + enum Child { + Property = 1, + Attribute = 2, + Item = 4 + }; + + DomLayout(const DomLayout &other); + void operator = (const DomLayout&other); +}; + +class QDESIGNER_UILIB_EXPORT DomLayoutItem { +public: + DomLayoutItem(); + ~DomLayoutItem(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeRow() const { return m_has_attr_row; } + inline int attributeRow() const { return m_attr_row; } + inline void setAttributeRow(int a) { m_attr_row = a; m_has_attr_row = true; } + inline void clearAttributeRow() { m_has_attr_row = false; } + + inline bool hasAttributeColumn() const { return m_has_attr_column; } + inline int attributeColumn() const { return m_attr_column; } + inline void setAttributeColumn(int a) { m_attr_column = a; m_has_attr_column = true; } + inline void clearAttributeColumn() { m_has_attr_column = false; } + + inline bool hasAttributeRowSpan() const { return m_has_attr_rowSpan; } + inline int attributeRowSpan() const { return m_attr_rowSpan; } + inline void setAttributeRowSpan(int a) { m_attr_rowSpan = a; m_has_attr_rowSpan = true; } + inline void clearAttributeRowSpan() { m_has_attr_rowSpan = false; } + + inline bool hasAttributeColSpan() const { return m_has_attr_colSpan; } + inline int attributeColSpan() const { return m_attr_colSpan; } + inline void setAttributeColSpan(int a) { m_attr_colSpan = a; m_has_attr_colSpan = true; } + inline void clearAttributeColSpan() { m_has_attr_colSpan = false; } + + // child element accessors + enum Kind { Unknown = 0, Widget, Layout, Spacer }; + inline Kind kind() const { return m_kind; } + + inline DomWidget* elementWidget() const { return m_widget; } + DomWidget* takeElementWidget(); + void setElementWidget(DomWidget* a); + + inline DomLayout* elementLayout() const { return m_layout; } + DomLayout* takeElementLayout(); + void setElementLayout(DomLayout* a); + + inline DomSpacer* elementSpacer() const { return m_spacer; } + DomSpacer* takeElementSpacer(); + void setElementSpacer(DomSpacer* a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + int m_attr_row; + bool m_has_attr_row; + + int m_attr_column; + bool m_has_attr_column; + + int m_attr_rowSpan; + bool m_has_attr_rowSpan; + + int m_attr_colSpan; + bool m_has_attr_colSpan; + + // child element data + Kind m_kind; + DomWidget* m_widget; + DomLayout* m_layout; + DomSpacer* m_spacer; + + DomLayoutItem(const DomLayoutItem &other); + void operator = (const DomLayoutItem&other); +}; + +class QDESIGNER_UILIB_EXPORT DomRow { +public: + DomRow(); + ~DomRow(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QList<DomProperty*> elementProperty() const { return m_property; } + void setElementProperty(const QList<DomProperty*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QList<DomProperty*> m_property; + enum Child { + Property = 1 + }; + + DomRow(const DomRow &other); + void operator = (const DomRow&other); +}; + +class QDESIGNER_UILIB_EXPORT DomColumn { +public: + DomColumn(); + ~DomColumn(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QList<DomProperty*> elementProperty() const { return m_property; } + void setElementProperty(const QList<DomProperty*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QList<DomProperty*> m_property; + enum Child { + Property = 1 + }; + + DomColumn(const DomColumn &other); + void operator = (const DomColumn&other); +}; + +class QDESIGNER_UILIB_EXPORT DomItem { +public: + DomItem(); + ~DomItem(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeRow() const { return m_has_attr_row; } + inline int attributeRow() const { return m_attr_row; } + inline void setAttributeRow(int a) { m_attr_row = a; m_has_attr_row = true; } + inline void clearAttributeRow() { m_has_attr_row = false; } + + inline bool hasAttributeColumn() const { return m_has_attr_column; } + inline int attributeColumn() const { return m_attr_column; } + inline void setAttributeColumn(int a) { m_attr_column = a; m_has_attr_column = true; } + inline void clearAttributeColumn() { m_has_attr_column = false; } + + // child element accessors + inline QList<DomProperty*> elementProperty() const { return m_property; } + void setElementProperty(const QList<DomProperty*>& a); + + inline QList<DomItem*> elementItem() const { return m_item; } + void setElementItem(const QList<DomItem*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + int m_attr_row; + bool m_has_attr_row; + + int m_attr_column; + bool m_has_attr_column; + + // child element data + uint m_children; + QList<DomProperty*> m_property; + QList<DomItem*> m_item; + enum Child { + Property = 1, + Item = 2 + }; + + DomItem(const DomItem &other); + void operator = (const DomItem&other); +}; + +class QDESIGNER_UILIB_EXPORT DomWidget { +public: + DomWidget(); + ~DomWidget(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeClass() const { return m_has_attr_class; } + inline QString attributeClass() const { return m_attr_class; } + inline void setAttributeClass(const QString& a) { m_attr_class = a; m_has_attr_class = true; } + inline void clearAttributeClass() { m_has_attr_class = false; } + + inline bool hasAttributeName() const { return m_has_attr_name; } + inline QString attributeName() const { return m_attr_name; } + inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; } + inline void clearAttributeName() { m_has_attr_name = false; } + + inline bool hasAttributeNative() const { return m_has_attr_native; } + inline bool attributeNative() const { return m_attr_native; } + inline void setAttributeNative(bool a) { m_attr_native = a; m_has_attr_native = true; } + inline void clearAttributeNative() { m_has_attr_native = false; } + + // child element accessors + inline QStringList elementClass() const { return m_class; } + void setElementClass(const QStringList& a); + + inline QList<DomProperty*> elementProperty() const { return m_property; } + void setElementProperty(const QList<DomProperty*>& a); + + inline QList<DomScript*> elementScript() const { return m_script; } + void setElementScript(const QList<DomScript*>& a); + + inline QList<DomWidgetData*> elementWidgetData() const { return m_widgetData; } + void setElementWidgetData(const QList<DomWidgetData*>& a); + + inline QList<DomProperty*> elementAttribute() const { return m_attribute; } + void setElementAttribute(const QList<DomProperty*>& a); + + inline QList<DomRow*> elementRow() const { return m_row; } + void setElementRow(const QList<DomRow*>& a); + + inline QList<DomColumn*> elementColumn() const { return m_column; } + void setElementColumn(const QList<DomColumn*>& a); + + inline QList<DomItem*> elementItem() const { return m_item; } + void setElementItem(const QList<DomItem*>& a); + + inline QList<DomLayout*> elementLayout() const { return m_layout; } + void setElementLayout(const QList<DomLayout*>& a); + + inline QList<DomWidget*> elementWidget() const { return m_widget; } + void setElementWidget(const QList<DomWidget*>& a); + + inline QList<DomAction*> elementAction() const { return m_action; } + void setElementAction(const QList<DomAction*>& a); + + inline QList<DomActionGroup*> elementActionGroup() const { return m_actionGroup; } + void setElementActionGroup(const QList<DomActionGroup*>& a); + + inline QList<DomActionRef*> elementAddAction() const { return m_addAction; } + void setElementAddAction(const QList<DomActionRef*>& a); + + inline QStringList elementZOrder() const { return m_zOrder; } + void setElementZOrder(const QStringList& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_class; + bool m_has_attr_class; + + QString m_attr_name; + bool m_has_attr_name; + + bool m_attr_native; + bool m_has_attr_native; + + // child element data + uint m_children; + QStringList m_class; + QList<DomProperty*> m_property; + QList<DomScript*> m_script; + QList<DomWidgetData*> m_widgetData; + QList<DomProperty*> m_attribute; + QList<DomRow*> m_row; + QList<DomColumn*> m_column; + QList<DomItem*> m_item; + QList<DomLayout*> m_layout; + QList<DomWidget*> m_widget; + QList<DomAction*> m_action; + QList<DomActionGroup*> m_actionGroup; + QList<DomActionRef*> m_addAction; + QStringList m_zOrder; + enum Child { + Class = 1, + Property = 2, + Script = 4, + WidgetData = 8, + Attribute = 16, + Row = 32, + Column = 64, + Item = 128, + Layout = 256, + Widget = 512, + Action = 1024, + ActionGroup = 2048, + AddAction = 4096, + ZOrder = 8192 + }; + + DomWidget(const DomWidget &other); + void operator = (const DomWidget&other); +}; + +class QDESIGNER_UILIB_EXPORT DomSpacer { +public: + DomSpacer(); + ~DomSpacer(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeName() const { return m_has_attr_name; } + inline QString attributeName() const { return m_attr_name; } + inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; } + inline void clearAttributeName() { m_has_attr_name = false; } + + // child element accessors + inline QList<DomProperty*> elementProperty() const { return m_property; } + void setElementProperty(const QList<DomProperty*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_name; + bool m_has_attr_name; + + // child element data + uint m_children; + QList<DomProperty*> m_property; + enum Child { + Property = 1 + }; + + DomSpacer(const DomSpacer &other); + void operator = (const DomSpacer&other); +}; + +class QDESIGNER_UILIB_EXPORT DomColor { +public: + DomColor(); + ~DomColor(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeAlpha() const { return m_has_attr_alpha; } + inline int attributeAlpha() const { return m_attr_alpha; } + inline void setAttributeAlpha(int a) { m_attr_alpha = a; m_has_attr_alpha = true; } + inline void clearAttributeAlpha() { m_has_attr_alpha = false; } + + // child element accessors + inline int elementRed() const { return m_red; } + void setElementRed(int a); + inline bool hasElementRed() const { return m_children & Red; } + void clearElementRed(); + + inline int elementGreen() const { return m_green; } + void setElementGreen(int a); + inline bool hasElementGreen() const { return m_children & Green; } + void clearElementGreen(); + + inline int elementBlue() const { return m_blue; } + void setElementBlue(int a); + inline bool hasElementBlue() const { return m_children & Blue; } + void clearElementBlue(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + int m_attr_alpha; + bool m_has_attr_alpha; + + // child element data + uint m_children; + int m_red; + int m_green; + int m_blue; + enum Child { + Red = 1, + Green = 2, + Blue = 4 + }; + + DomColor(const DomColor &other); + void operator = (const DomColor&other); +}; + +class QDESIGNER_UILIB_EXPORT DomGradientStop { +public: + DomGradientStop(); + ~DomGradientStop(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributePosition() const { return m_has_attr_position; } + inline double attributePosition() const { return m_attr_position; } + inline void setAttributePosition(double a) { m_attr_position = a; m_has_attr_position = true; } + inline void clearAttributePosition() { m_has_attr_position = false; } + + // child element accessors + inline DomColor* elementColor() const { return m_color; } + DomColor* takeElementColor(); + void setElementColor(DomColor* a); + inline bool hasElementColor() const { return m_children & Color; } + void clearElementColor(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + double m_attr_position; + bool m_has_attr_position; + + // child element data + uint m_children; + DomColor* m_color; + enum Child { + Color = 1 + }; + + DomGradientStop(const DomGradientStop &other); + void operator = (const DomGradientStop&other); +}; + +class QDESIGNER_UILIB_EXPORT DomGradient { +public: + DomGradient(); + ~DomGradient(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeStartX() const { return m_has_attr_startX; } + inline double attributeStartX() const { return m_attr_startX; } + inline void setAttributeStartX(double a) { m_attr_startX = a; m_has_attr_startX = true; } + inline void clearAttributeStartX() { m_has_attr_startX = false; } + + inline bool hasAttributeStartY() const { return m_has_attr_startY; } + inline double attributeStartY() const { return m_attr_startY; } + inline void setAttributeStartY(double a) { m_attr_startY = a; m_has_attr_startY = true; } + inline void clearAttributeStartY() { m_has_attr_startY = false; } + + inline bool hasAttributeEndX() const { return m_has_attr_endX; } + inline double attributeEndX() const { return m_attr_endX; } + inline void setAttributeEndX(double a) { m_attr_endX = a; m_has_attr_endX = true; } + inline void clearAttributeEndX() { m_has_attr_endX = false; } + + inline bool hasAttributeEndY() const { return m_has_attr_endY; } + inline double attributeEndY() const { return m_attr_endY; } + inline void setAttributeEndY(double a) { m_attr_endY = a; m_has_attr_endY = true; } + inline void clearAttributeEndY() { m_has_attr_endY = false; } + + inline bool hasAttributeCentralX() const { return m_has_attr_centralX; } + inline double attributeCentralX() const { return m_attr_centralX; } + inline void setAttributeCentralX(double a) { m_attr_centralX = a; m_has_attr_centralX = true; } + inline void clearAttributeCentralX() { m_has_attr_centralX = false; } + + inline bool hasAttributeCentralY() const { return m_has_attr_centralY; } + inline double attributeCentralY() const { return m_attr_centralY; } + inline void setAttributeCentralY(double a) { m_attr_centralY = a; m_has_attr_centralY = true; } + inline void clearAttributeCentralY() { m_has_attr_centralY = false; } + + inline bool hasAttributeFocalX() const { return m_has_attr_focalX; } + inline double attributeFocalX() const { return m_attr_focalX; } + inline void setAttributeFocalX(double a) { m_attr_focalX = a; m_has_attr_focalX = true; } + inline void clearAttributeFocalX() { m_has_attr_focalX = false; } + + inline bool hasAttributeFocalY() const { return m_has_attr_focalY; } + inline double attributeFocalY() const { return m_attr_focalY; } + inline void setAttributeFocalY(double a) { m_attr_focalY = a; m_has_attr_focalY = true; } + inline void clearAttributeFocalY() { m_has_attr_focalY = false; } + + inline bool hasAttributeRadius() const { return m_has_attr_radius; } + inline double attributeRadius() const { return m_attr_radius; } + inline void setAttributeRadius(double a) { m_attr_radius = a; m_has_attr_radius = true; } + inline void clearAttributeRadius() { m_has_attr_radius = false; } + + inline bool hasAttributeAngle() const { return m_has_attr_angle; } + inline double attributeAngle() const { return m_attr_angle; } + inline void setAttributeAngle(double a) { m_attr_angle = a; m_has_attr_angle = true; } + inline void clearAttributeAngle() { m_has_attr_angle = false; } + + inline bool hasAttributeType() const { return m_has_attr_type; } + inline QString attributeType() const { return m_attr_type; } + inline void setAttributeType(const QString& a) { m_attr_type = a; m_has_attr_type = true; } + inline void clearAttributeType() { m_has_attr_type = false; } + + inline bool hasAttributeSpread() const { return m_has_attr_spread; } + inline QString attributeSpread() const { return m_attr_spread; } + inline void setAttributeSpread(const QString& a) { m_attr_spread = a; m_has_attr_spread = true; } + inline void clearAttributeSpread() { m_has_attr_spread = false; } + + inline bool hasAttributeCoordinateMode() const { return m_has_attr_coordinateMode; } + inline QString attributeCoordinateMode() const { return m_attr_coordinateMode; } + inline void setAttributeCoordinateMode(const QString& a) { m_attr_coordinateMode = a; m_has_attr_coordinateMode = true; } + inline void clearAttributeCoordinateMode() { m_has_attr_coordinateMode = false; } + + // child element accessors + inline QList<DomGradientStop*> elementGradientStop() const { return m_gradientStop; } + void setElementGradientStop(const QList<DomGradientStop*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + double m_attr_startX; + bool m_has_attr_startX; + + double m_attr_startY; + bool m_has_attr_startY; + + double m_attr_endX; + bool m_has_attr_endX; + + double m_attr_endY; + bool m_has_attr_endY; + + double m_attr_centralX; + bool m_has_attr_centralX; + + double m_attr_centralY; + bool m_has_attr_centralY; + + double m_attr_focalX; + bool m_has_attr_focalX; + + double m_attr_focalY; + bool m_has_attr_focalY; + + double m_attr_radius; + bool m_has_attr_radius; + + double m_attr_angle; + bool m_has_attr_angle; + + QString m_attr_type; + bool m_has_attr_type; + + QString m_attr_spread; + bool m_has_attr_spread; + + QString m_attr_coordinateMode; + bool m_has_attr_coordinateMode; + + // child element data + uint m_children; + QList<DomGradientStop*> m_gradientStop; + enum Child { + GradientStop = 1 + }; + + DomGradient(const DomGradient &other); + void operator = (const DomGradient&other); +}; + +class QDESIGNER_UILIB_EXPORT DomBrush { +public: + DomBrush(); + ~DomBrush(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeBrushStyle() const { return m_has_attr_brushStyle; } + inline QString attributeBrushStyle() const { return m_attr_brushStyle; } + inline void setAttributeBrushStyle(const QString& a) { m_attr_brushStyle = a; m_has_attr_brushStyle = true; } + inline void clearAttributeBrushStyle() { m_has_attr_brushStyle = false; } + + // child element accessors + enum Kind { Unknown = 0, Color, Texture, Gradient }; + inline Kind kind() const { return m_kind; } + + inline DomColor* elementColor() const { return m_color; } + DomColor* takeElementColor(); + void setElementColor(DomColor* a); + + inline DomProperty* elementTexture() const { return m_texture; } + DomProperty* takeElementTexture(); + void setElementTexture(DomProperty* a); + + inline DomGradient* elementGradient() const { return m_gradient; } + DomGradient* takeElementGradient(); + void setElementGradient(DomGradient* a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_brushStyle; + bool m_has_attr_brushStyle; + + // child element data + Kind m_kind; + DomColor* m_color; + DomProperty* m_texture; + DomGradient* m_gradient; + + DomBrush(const DomBrush &other); + void operator = (const DomBrush&other); +}; + +class QDESIGNER_UILIB_EXPORT DomColorRole { +public: + DomColorRole(); + ~DomColorRole(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeRole() const { return m_has_attr_role; } + inline QString attributeRole() const { return m_attr_role; } + inline void setAttributeRole(const QString& a) { m_attr_role = a; m_has_attr_role = true; } + inline void clearAttributeRole() { m_has_attr_role = false; } + + // child element accessors + inline DomBrush* elementBrush() const { return m_brush; } + DomBrush* takeElementBrush(); + void setElementBrush(DomBrush* a); + inline bool hasElementBrush() const { return m_children & Brush; } + void clearElementBrush(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_role; + bool m_has_attr_role; + + // child element data + uint m_children; + DomBrush* m_brush; + enum Child { + Brush = 1 + }; + + DomColorRole(const DomColorRole &other); + void operator = (const DomColorRole&other); +}; + +class QDESIGNER_UILIB_EXPORT DomColorGroup { +public: + DomColorGroup(); + ~DomColorGroup(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QList<DomColorRole*> elementColorRole() const { return m_colorRole; } + void setElementColorRole(const QList<DomColorRole*>& a); + + inline QList<DomColor*> elementColor() const { return m_color; } + void setElementColor(const QList<DomColor*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QList<DomColorRole*> m_colorRole; + QList<DomColor*> m_color; + enum Child { + ColorRole = 1, + Color = 2 + }; + + DomColorGroup(const DomColorGroup &other); + void operator = (const DomColorGroup&other); +}; + +class QDESIGNER_UILIB_EXPORT DomPalette { +public: + DomPalette(); + ~DomPalette(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline DomColorGroup* elementActive() const { return m_active; } + DomColorGroup* takeElementActive(); + void setElementActive(DomColorGroup* a); + inline bool hasElementActive() const { return m_children & Active; } + void clearElementActive(); + + inline DomColorGroup* elementInactive() const { return m_inactive; } + DomColorGroup* takeElementInactive(); + void setElementInactive(DomColorGroup* a); + inline bool hasElementInactive() const { return m_children & Inactive; } + void clearElementInactive(); + + inline DomColorGroup* elementDisabled() const { return m_disabled; } + DomColorGroup* takeElementDisabled(); + void setElementDisabled(DomColorGroup* a); + inline bool hasElementDisabled() const { return m_children & Disabled; } + void clearElementDisabled(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + DomColorGroup* m_active; + DomColorGroup* m_inactive; + DomColorGroup* m_disabled; + enum Child { + Active = 1, + Inactive = 2, + Disabled = 4 + }; + + DomPalette(const DomPalette &other); + void operator = (const DomPalette&other); +}; + +class QDESIGNER_UILIB_EXPORT DomFont { +public: + DomFont(); + ~DomFont(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QString elementFamily() const { return m_family; } + void setElementFamily(const QString& a); + inline bool hasElementFamily() const { return m_children & Family; } + void clearElementFamily(); + + inline int elementPointSize() const { return m_pointSize; } + void setElementPointSize(int a); + inline bool hasElementPointSize() const { return m_children & PointSize; } + void clearElementPointSize(); + + inline int elementWeight() const { return m_weight; } + void setElementWeight(int a); + inline bool hasElementWeight() const { return m_children & Weight; } + void clearElementWeight(); + + inline bool elementItalic() const { return m_italic; } + void setElementItalic(bool a); + inline bool hasElementItalic() const { return m_children & Italic; } + void clearElementItalic(); + + inline bool elementBold() const { return m_bold; } + void setElementBold(bool a); + inline bool hasElementBold() const { return m_children & Bold; } + void clearElementBold(); + + inline bool elementUnderline() const { return m_underline; } + void setElementUnderline(bool a); + inline bool hasElementUnderline() const { return m_children & Underline; } + void clearElementUnderline(); + + inline bool elementStrikeOut() const { return m_strikeOut; } + void setElementStrikeOut(bool a); + inline bool hasElementStrikeOut() const { return m_children & StrikeOut; } + void clearElementStrikeOut(); + + inline bool elementAntialiasing() const { return m_antialiasing; } + void setElementAntialiasing(bool a); + inline bool hasElementAntialiasing() const { return m_children & Antialiasing; } + void clearElementAntialiasing(); + + inline QString elementStyleStrategy() const { return m_styleStrategy; } + void setElementStyleStrategy(const QString& a); + inline bool hasElementStyleStrategy() const { return m_children & StyleStrategy; } + void clearElementStyleStrategy(); + + inline bool elementKerning() const { return m_kerning; } + void setElementKerning(bool a); + inline bool hasElementKerning() const { return m_children & Kerning; } + void clearElementKerning(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QString m_family; + int m_pointSize; + int m_weight; + bool m_italic; + bool m_bold; + bool m_underline; + bool m_strikeOut; + bool m_antialiasing; + QString m_styleStrategy; + bool m_kerning; + enum Child { + Family = 1, + PointSize = 2, + Weight = 4, + Italic = 8, + Bold = 16, + Underline = 32, + StrikeOut = 64, + Antialiasing = 128, + StyleStrategy = 256, + Kerning = 512 + }; + + DomFont(const DomFont &other); + void operator = (const DomFont&other); +}; + +class QDESIGNER_UILIB_EXPORT DomPoint { +public: + DomPoint(); + ~DomPoint(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline int elementX() const { return m_x; } + void setElementX(int a); + inline bool hasElementX() const { return m_children & X; } + void clearElementX(); + + inline int elementY() const { return m_y; } + void setElementY(int a); + inline bool hasElementY() const { return m_children & Y; } + void clearElementY(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + int m_x; + int m_y; + enum Child { + X = 1, + Y = 2 + }; + + DomPoint(const DomPoint &other); + void operator = (const DomPoint&other); +}; + +class QDESIGNER_UILIB_EXPORT DomRect { +public: + DomRect(); + ~DomRect(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline int elementX() const { return m_x; } + void setElementX(int a); + inline bool hasElementX() const { return m_children & X; } + void clearElementX(); + + inline int elementY() const { return m_y; } + void setElementY(int a); + inline bool hasElementY() const { return m_children & Y; } + void clearElementY(); + + inline int elementWidth() const { return m_width; } + void setElementWidth(int a); + inline bool hasElementWidth() const { return m_children & Width; } + void clearElementWidth(); + + inline int elementHeight() const { return m_height; } + void setElementHeight(int a); + inline bool hasElementHeight() const { return m_children & Height; } + void clearElementHeight(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + int m_x; + int m_y; + int m_width; + int m_height; + enum Child { + X = 1, + Y = 2, + Width = 4, + Height = 8 + }; + + DomRect(const DomRect &other); + void operator = (const DomRect&other); +}; + +class QDESIGNER_UILIB_EXPORT DomLocale { +public: + DomLocale(); + ~DomLocale(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeLanguage() const { return m_has_attr_language; } + inline QString attributeLanguage() const { return m_attr_language; } + inline void setAttributeLanguage(const QString& a) { m_attr_language = a; m_has_attr_language = true; } + inline void clearAttributeLanguage() { m_has_attr_language = false; } + + inline bool hasAttributeCountry() const { return m_has_attr_country; } + inline QString attributeCountry() const { return m_attr_country; } + inline void setAttributeCountry(const QString& a) { m_attr_country = a; m_has_attr_country = true; } + inline void clearAttributeCountry() { m_has_attr_country = false; } + + // child element accessors +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_language; + bool m_has_attr_language; + + QString m_attr_country; + bool m_has_attr_country; + + // child element data + uint m_children; + + DomLocale(const DomLocale &other); + void operator = (const DomLocale&other); +}; + +class QDESIGNER_UILIB_EXPORT DomSizePolicy { +public: + DomSizePolicy(); + ~DomSizePolicy(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeHSizeType() const { return m_has_attr_hSizeType; } + inline QString attributeHSizeType() const { return m_attr_hSizeType; } + inline void setAttributeHSizeType(const QString& a) { m_attr_hSizeType = a; m_has_attr_hSizeType = true; } + inline void clearAttributeHSizeType() { m_has_attr_hSizeType = false; } + + inline bool hasAttributeVSizeType() const { return m_has_attr_vSizeType; } + inline QString attributeVSizeType() const { return m_attr_vSizeType; } + inline void setAttributeVSizeType(const QString& a) { m_attr_vSizeType = a; m_has_attr_vSizeType = true; } + inline void clearAttributeVSizeType() { m_has_attr_vSizeType = false; } + + // child element accessors + inline int elementHSizeType() const { return m_hSizeType; } + void setElementHSizeType(int a); + inline bool hasElementHSizeType() const { return m_children & HSizeType; } + void clearElementHSizeType(); + + inline int elementVSizeType() const { return m_vSizeType; } + void setElementVSizeType(int a); + inline bool hasElementVSizeType() const { return m_children & VSizeType; } + void clearElementVSizeType(); + + inline int elementHorStretch() const { return m_horStretch; } + void setElementHorStretch(int a); + inline bool hasElementHorStretch() const { return m_children & HorStretch; } + void clearElementHorStretch(); + + inline int elementVerStretch() const { return m_verStretch; } + void setElementVerStretch(int a); + inline bool hasElementVerStretch() const { return m_children & VerStretch; } + void clearElementVerStretch(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_hSizeType; + bool m_has_attr_hSizeType; + + QString m_attr_vSizeType; + bool m_has_attr_vSizeType; + + // child element data + uint m_children; + int m_hSizeType; + int m_vSizeType; + int m_horStretch; + int m_verStretch; + enum Child { + HSizeType = 1, + VSizeType = 2, + HorStretch = 4, + VerStretch = 8 + }; + + DomSizePolicy(const DomSizePolicy &other); + void operator = (const DomSizePolicy&other); +}; + +class QDESIGNER_UILIB_EXPORT DomSize { +public: + DomSize(); + ~DomSize(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline int elementWidth() const { return m_width; } + void setElementWidth(int a); + inline bool hasElementWidth() const { return m_children & Width; } + void clearElementWidth(); + + inline int elementHeight() const { return m_height; } + void setElementHeight(int a); + inline bool hasElementHeight() const { return m_children & Height; } + void clearElementHeight(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + int m_width; + int m_height; + enum Child { + Width = 1, + Height = 2 + }; + + DomSize(const DomSize &other); + void operator = (const DomSize&other); +}; + +class QDESIGNER_UILIB_EXPORT DomDate { +public: + DomDate(); + ~DomDate(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline int elementYear() const { return m_year; } + void setElementYear(int a); + inline bool hasElementYear() const { return m_children & Year; } + void clearElementYear(); + + inline int elementMonth() const { return m_month; } + void setElementMonth(int a); + inline bool hasElementMonth() const { return m_children & Month; } + void clearElementMonth(); + + inline int elementDay() const { return m_day; } + void setElementDay(int a); + inline bool hasElementDay() const { return m_children & Day; } + void clearElementDay(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + int m_year; + int m_month; + int m_day; + enum Child { + Year = 1, + Month = 2, + Day = 4 + }; + + DomDate(const DomDate &other); + void operator = (const DomDate&other); +}; + +class QDESIGNER_UILIB_EXPORT DomTime { +public: + DomTime(); + ~DomTime(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline int elementHour() const { return m_hour; } + void setElementHour(int a); + inline bool hasElementHour() const { return m_children & Hour; } + void clearElementHour(); + + inline int elementMinute() const { return m_minute; } + void setElementMinute(int a); + inline bool hasElementMinute() const { return m_children & Minute; } + void clearElementMinute(); + + inline int elementSecond() const { return m_second; } + void setElementSecond(int a); + inline bool hasElementSecond() const { return m_children & Second; } + void clearElementSecond(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + int m_hour; + int m_minute; + int m_second; + enum Child { + Hour = 1, + Minute = 2, + Second = 4 + }; + + DomTime(const DomTime &other); + void operator = (const DomTime&other); +}; + +class QDESIGNER_UILIB_EXPORT DomDateTime { +public: + DomDateTime(); + ~DomDateTime(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline int elementHour() const { return m_hour; } + void setElementHour(int a); + inline bool hasElementHour() const { return m_children & Hour; } + void clearElementHour(); + + inline int elementMinute() const { return m_minute; } + void setElementMinute(int a); + inline bool hasElementMinute() const { return m_children & Minute; } + void clearElementMinute(); + + inline int elementSecond() const { return m_second; } + void setElementSecond(int a); + inline bool hasElementSecond() const { return m_children & Second; } + void clearElementSecond(); + + inline int elementYear() const { return m_year; } + void setElementYear(int a); + inline bool hasElementYear() const { return m_children & Year; } + void clearElementYear(); + + inline int elementMonth() const { return m_month; } + void setElementMonth(int a); + inline bool hasElementMonth() const { return m_children & Month; } + void clearElementMonth(); + + inline int elementDay() const { return m_day; } + void setElementDay(int a); + inline bool hasElementDay() const { return m_children & Day; } + void clearElementDay(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + int m_hour; + int m_minute; + int m_second; + int m_year; + int m_month; + int m_day; + enum Child { + Hour = 1, + Minute = 2, + Second = 4, + Year = 8, + Month = 16, + Day = 32 + }; + + DomDateTime(const DomDateTime &other); + void operator = (const DomDateTime&other); +}; + +class QDESIGNER_UILIB_EXPORT DomStringList { +public: + DomStringList(); + ~DomStringList(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QStringList elementString() const { return m_string; } + void setElementString(const QStringList& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QStringList m_string; + enum Child { + String = 1 + }; + + DomStringList(const DomStringList &other); + void operator = (const DomStringList&other); +}; + +class QDESIGNER_UILIB_EXPORT DomResourcePixmap { +public: + DomResourcePixmap(); + ~DomResourcePixmap(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeResource() const { return m_has_attr_resource; } + inline QString attributeResource() const { return m_attr_resource; } + inline void setAttributeResource(const QString& a) { m_attr_resource = a; m_has_attr_resource = true; } + inline void clearAttributeResource() { m_has_attr_resource = false; } + + inline bool hasAttributeAlias() const { return m_has_attr_alias; } + inline QString attributeAlias() const { return m_attr_alias; } + inline void setAttributeAlias(const QString& a) { m_attr_alias = a; m_has_attr_alias = true; } + inline void clearAttributeAlias() { m_has_attr_alias = false; } + + // child element accessors +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_resource; + bool m_has_attr_resource; + + QString m_attr_alias; + bool m_has_attr_alias; + + // child element data + uint m_children; + + DomResourcePixmap(const DomResourcePixmap &other); + void operator = (const DomResourcePixmap&other); +}; + +class QDESIGNER_UILIB_EXPORT DomResourceIcon { +public: + DomResourceIcon(); + ~DomResourceIcon(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeResource() const { return m_has_attr_resource; } + inline QString attributeResource() const { return m_attr_resource; } + inline void setAttributeResource(const QString& a) { m_attr_resource = a; m_has_attr_resource = true; } + inline void clearAttributeResource() { m_has_attr_resource = false; } + + // child element accessors + inline DomResourcePixmap* elementNormalOff() const { return m_normalOff; } + DomResourcePixmap* takeElementNormalOff(); + void setElementNormalOff(DomResourcePixmap* a); + inline bool hasElementNormalOff() const { return m_children & NormalOff; } + void clearElementNormalOff(); + + inline DomResourcePixmap* elementNormalOn() const { return m_normalOn; } + DomResourcePixmap* takeElementNormalOn(); + void setElementNormalOn(DomResourcePixmap* a); + inline bool hasElementNormalOn() const { return m_children & NormalOn; } + void clearElementNormalOn(); + + inline DomResourcePixmap* elementDisabledOff() const { return m_disabledOff; } + DomResourcePixmap* takeElementDisabledOff(); + void setElementDisabledOff(DomResourcePixmap* a); + inline bool hasElementDisabledOff() const { return m_children & DisabledOff; } + void clearElementDisabledOff(); + + inline DomResourcePixmap* elementDisabledOn() const { return m_disabledOn; } + DomResourcePixmap* takeElementDisabledOn(); + void setElementDisabledOn(DomResourcePixmap* a); + inline bool hasElementDisabledOn() const { return m_children & DisabledOn; } + void clearElementDisabledOn(); + + inline DomResourcePixmap* elementActiveOff() const { return m_activeOff; } + DomResourcePixmap* takeElementActiveOff(); + void setElementActiveOff(DomResourcePixmap* a); + inline bool hasElementActiveOff() const { return m_children & ActiveOff; } + void clearElementActiveOff(); + + inline DomResourcePixmap* elementActiveOn() const { return m_activeOn; } + DomResourcePixmap* takeElementActiveOn(); + void setElementActiveOn(DomResourcePixmap* a); + inline bool hasElementActiveOn() const { return m_children & ActiveOn; } + void clearElementActiveOn(); + + inline DomResourcePixmap* elementSelectedOff() const { return m_selectedOff; } + DomResourcePixmap* takeElementSelectedOff(); + void setElementSelectedOff(DomResourcePixmap* a); + inline bool hasElementSelectedOff() const { return m_children & SelectedOff; } + void clearElementSelectedOff(); + + inline DomResourcePixmap* elementSelectedOn() const { return m_selectedOn; } + DomResourcePixmap* takeElementSelectedOn(); + void setElementSelectedOn(DomResourcePixmap* a); + inline bool hasElementSelectedOn() const { return m_children & SelectedOn; } + void clearElementSelectedOn(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_resource; + bool m_has_attr_resource; + + // child element data + uint m_children; + DomResourcePixmap* m_normalOff; + DomResourcePixmap* m_normalOn; + DomResourcePixmap* m_disabledOff; + DomResourcePixmap* m_disabledOn; + DomResourcePixmap* m_activeOff; + DomResourcePixmap* m_activeOn; + DomResourcePixmap* m_selectedOff; + DomResourcePixmap* m_selectedOn; + enum Child { + NormalOff = 1, + NormalOn = 2, + DisabledOff = 4, + DisabledOn = 8, + ActiveOff = 16, + ActiveOn = 32, + SelectedOff = 64, + SelectedOn = 128 + }; + + DomResourceIcon(const DomResourceIcon &other); + void operator = (const DomResourceIcon&other); +}; + +class QDESIGNER_UILIB_EXPORT DomString { +public: + DomString(); + ~DomString(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeNotr() const { return m_has_attr_notr; } + inline QString attributeNotr() const { return m_attr_notr; } + inline void setAttributeNotr(const QString& a) { m_attr_notr = a; m_has_attr_notr = true; } + inline void clearAttributeNotr() { m_has_attr_notr = false; } + + inline bool hasAttributeComment() const { return m_has_attr_comment; } + inline QString attributeComment() const { return m_attr_comment; } + inline void setAttributeComment(const QString& a) { m_attr_comment = a; m_has_attr_comment = true; } + inline void clearAttributeComment() { m_has_attr_comment = false; } + + inline bool hasAttributeExtraComment() const { return m_has_attr_extraComment; } + inline QString attributeExtraComment() const { return m_attr_extraComment; } + inline void setAttributeExtraComment(const QString& a) { m_attr_extraComment = a; m_has_attr_extraComment = true; } + inline void clearAttributeExtraComment() { m_has_attr_extraComment = false; } + + // child element accessors +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_notr; + bool m_has_attr_notr; + + QString m_attr_comment; + bool m_has_attr_comment; + + QString m_attr_extraComment; + bool m_has_attr_extraComment; + + // child element data + uint m_children; + + DomString(const DomString &other); + void operator = (const DomString&other); +}; + +class QDESIGNER_UILIB_EXPORT DomPointF { +public: + DomPointF(); + ~DomPointF(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline double elementX() const { return m_x; } + void setElementX(double a); + inline bool hasElementX() const { return m_children & X; } + void clearElementX(); + + inline double elementY() const { return m_y; } + void setElementY(double a); + inline bool hasElementY() const { return m_children & Y; } + void clearElementY(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + double m_x; + double m_y; + enum Child { + X = 1, + Y = 2 + }; + + DomPointF(const DomPointF &other); + void operator = (const DomPointF&other); +}; + +class QDESIGNER_UILIB_EXPORT DomRectF { +public: + DomRectF(); + ~DomRectF(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline double elementX() const { return m_x; } + void setElementX(double a); + inline bool hasElementX() const { return m_children & X; } + void clearElementX(); + + inline double elementY() const { return m_y; } + void setElementY(double a); + inline bool hasElementY() const { return m_children & Y; } + void clearElementY(); + + inline double elementWidth() const { return m_width; } + void setElementWidth(double a); + inline bool hasElementWidth() const { return m_children & Width; } + void clearElementWidth(); + + inline double elementHeight() const { return m_height; } + void setElementHeight(double a); + inline bool hasElementHeight() const { return m_children & Height; } + void clearElementHeight(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + double m_x; + double m_y; + double m_width; + double m_height; + enum Child { + X = 1, + Y = 2, + Width = 4, + Height = 8 + }; + + DomRectF(const DomRectF &other); + void operator = (const DomRectF&other); +}; + +class QDESIGNER_UILIB_EXPORT DomSizeF { +public: + DomSizeF(); + ~DomSizeF(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline double elementWidth() const { return m_width; } + void setElementWidth(double a); + inline bool hasElementWidth() const { return m_children & Width; } + void clearElementWidth(); + + inline double elementHeight() const { return m_height; } + void setElementHeight(double a); + inline bool hasElementHeight() const { return m_children & Height; } + void clearElementHeight(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + double m_width; + double m_height; + enum Child { + Width = 1, + Height = 2 + }; + + DomSizeF(const DomSizeF &other); + void operator = (const DomSizeF&other); +}; + +class QDESIGNER_UILIB_EXPORT DomChar { +public: + DomChar(); + ~DomChar(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline int elementUnicode() const { return m_unicode; } + void setElementUnicode(int a); + inline bool hasElementUnicode() const { return m_children & Unicode; } + void clearElementUnicode(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + int m_unicode; + enum Child { + Unicode = 1 + }; + + DomChar(const DomChar &other); + void operator = (const DomChar&other); +}; + +class QDESIGNER_UILIB_EXPORT DomUrl { +public: + DomUrl(); + ~DomUrl(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline DomString* elementString() const { return m_string; } + DomString* takeElementString(); + void setElementString(DomString* a); + inline bool hasElementString() const { return m_children & String; } + void clearElementString(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + DomString* m_string; + enum Child { + String = 1 + }; + + DomUrl(const DomUrl &other); + void operator = (const DomUrl&other); +}; + +class QDESIGNER_UILIB_EXPORT DomProperty { +public: + DomProperty(); + ~DomProperty(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeName() const { return m_has_attr_name; } + inline QString attributeName() const { return m_attr_name; } + inline void setAttributeName(const QString& a) { m_attr_name = a; m_has_attr_name = true; } + inline void clearAttributeName() { m_has_attr_name = false; } + + inline bool hasAttributeStdset() const { return m_has_attr_stdset; } + inline int attributeStdset() const { return m_attr_stdset; } + inline void setAttributeStdset(int a) { m_attr_stdset = a; m_has_attr_stdset = true; } + inline void clearAttributeStdset() { m_has_attr_stdset = false; } + + // child element accessors + enum Kind { Unknown = 0, Bool, Color, Cstring, Cursor, CursorShape, Enum, Font, IconSet, Pixmap, Palette, Point, Rect, Set, Locale, SizePolicy, Size, String, StringList, Number, Float, Double, Date, Time, DateTime, PointF, RectF, SizeF, LongLong, Char, Url, UInt, ULongLong, Brush }; + inline Kind kind() const { return m_kind; } + + inline QString elementBool() const { return m_bool; } + void setElementBool(const QString& a); + + inline DomColor* elementColor() const { return m_color; } + DomColor* takeElementColor(); + void setElementColor(DomColor* a); + + inline QString elementCstring() const { return m_cstring; } + void setElementCstring(const QString& a); + + inline int elementCursor() const { return m_cursor; } + void setElementCursor(int a); + + inline QString elementCursorShape() const { return m_cursorShape; } + void setElementCursorShape(const QString& a); + + inline QString elementEnum() const { return m_enum; } + void setElementEnum(const QString& a); + + inline DomFont* elementFont() const { return m_font; } + DomFont* takeElementFont(); + void setElementFont(DomFont* a); + + inline DomResourceIcon* elementIconSet() const { return m_iconSet; } + DomResourceIcon* takeElementIconSet(); + void setElementIconSet(DomResourceIcon* a); + + inline DomResourcePixmap* elementPixmap() const { return m_pixmap; } + DomResourcePixmap* takeElementPixmap(); + void setElementPixmap(DomResourcePixmap* a); + + inline DomPalette* elementPalette() const { return m_palette; } + DomPalette* takeElementPalette(); + void setElementPalette(DomPalette* a); + + inline DomPoint* elementPoint() const { return m_point; } + DomPoint* takeElementPoint(); + void setElementPoint(DomPoint* a); + + inline DomRect* elementRect() const { return m_rect; } + DomRect* takeElementRect(); + void setElementRect(DomRect* a); + + inline QString elementSet() const { return m_set; } + void setElementSet(const QString& a); + + inline DomLocale* elementLocale() const { return m_locale; } + DomLocale* takeElementLocale(); + void setElementLocale(DomLocale* a); + + inline DomSizePolicy* elementSizePolicy() const { return m_sizePolicy; } + DomSizePolicy* takeElementSizePolicy(); + void setElementSizePolicy(DomSizePolicy* a); + + inline DomSize* elementSize() const { return m_size; } + DomSize* takeElementSize(); + void setElementSize(DomSize* a); + + inline DomString* elementString() const { return m_string; } + DomString* takeElementString(); + void setElementString(DomString* a); + + inline DomStringList* elementStringList() const { return m_stringList; } + DomStringList* takeElementStringList(); + void setElementStringList(DomStringList* a); + + inline int elementNumber() const { return m_number; } + void setElementNumber(int a); + + inline float elementFloat() const { return m_float; } + void setElementFloat(float a); + + inline double elementDouble() const { return m_double; } + void setElementDouble(double a); + + inline DomDate* elementDate() const { return m_date; } + DomDate* takeElementDate(); + void setElementDate(DomDate* a); + + inline DomTime* elementTime() const { return m_time; } + DomTime* takeElementTime(); + void setElementTime(DomTime* a); + + inline DomDateTime* elementDateTime() const { return m_dateTime; } + DomDateTime* takeElementDateTime(); + void setElementDateTime(DomDateTime* a); + + inline DomPointF* elementPointF() const { return m_pointF; } + DomPointF* takeElementPointF(); + void setElementPointF(DomPointF* a); + + inline DomRectF* elementRectF() const { return m_rectF; } + DomRectF* takeElementRectF(); + void setElementRectF(DomRectF* a); + + inline DomSizeF* elementSizeF() const { return m_sizeF; } + DomSizeF* takeElementSizeF(); + void setElementSizeF(DomSizeF* a); + + inline qlonglong elementLongLong() const { return m_longLong; } + void setElementLongLong(qlonglong a); + + inline DomChar* elementChar() const { return m_char; } + DomChar* takeElementChar(); + void setElementChar(DomChar* a); + + inline DomUrl* elementUrl() const { return m_url; } + DomUrl* takeElementUrl(); + void setElementUrl(DomUrl* a); + + inline uint elementUInt() const { return m_UInt; } + void setElementUInt(uint a); + + inline qulonglong elementULongLong() const { return m_uLongLong; } + void setElementULongLong(qulonglong a); + + inline DomBrush* elementBrush() const { return m_brush; } + DomBrush* takeElementBrush(); + void setElementBrush(DomBrush* a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_name; + bool m_has_attr_name; + + int m_attr_stdset; + bool m_has_attr_stdset; + + // child element data + Kind m_kind; + QString m_bool; + DomColor* m_color; + QString m_cstring; + int m_cursor; + QString m_cursorShape; + QString m_enum; + DomFont* m_font; + DomResourceIcon* m_iconSet; + DomResourcePixmap* m_pixmap; + DomPalette* m_palette; + DomPoint* m_point; + DomRect* m_rect; + QString m_set; + DomLocale* m_locale; + DomSizePolicy* m_sizePolicy; + DomSize* m_size; + DomString* m_string; + DomStringList* m_stringList; + int m_number; + float m_float; + double m_double; + DomDate* m_date; + DomTime* m_time; + DomDateTime* m_dateTime; + DomPointF* m_pointF; + DomRectF* m_rectF; + DomSizeF* m_sizeF; + qlonglong m_longLong; + DomChar* m_char; + DomUrl* m_url; + uint m_UInt; + qulonglong m_uLongLong; + DomBrush* m_brush; + + DomProperty(const DomProperty &other); + void operator = (const DomProperty&other); +}; + +class QDESIGNER_UILIB_EXPORT DomConnections { +public: + DomConnections(); + ~DomConnections(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QList<DomConnection*> elementConnection() const { return m_connection; } + void setElementConnection(const QList<DomConnection*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QList<DomConnection*> m_connection; + enum Child { + Connection = 1 + }; + + DomConnections(const DomConnections &other); + void operator = (const DomConnections&other); +}; + +class QDESIGNER_UILIB_EXPORT DomConnection { +public: + DomConnection(); + ~DomConnection(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QString elementSender() const { return m_sender; } + void setElementSender(const QString& a); + inline bool hasElementSender() const { return m_children & Sender; } + void clearElementSender(); + + inline QString elementSignal() const { return m_signal; } + void setElementSignal(const QString& a); + inline bool hasElementSignal() const { return m_children & Signal; } + void clearElementSignal(); + + inline QString elementReceiver() const { return m_receiver; } + void setElementReceiver(const QString& a); + inline bool hasElementReceiver() const { return m_children & Receiver; } + void clearElementReceiver(); + + inline QString elementSlot() const { return m_slot; } + void setElementSlot(const QString& a); + inline bool hasElementSlot() const { return m_children & Slot; } + void clearElementSlot(); + + inline DomConnectionHints* elementHints() const { return m_hints; } + DomConnectionHints* takeElementHints(); + void setElementHints(DomConnectionHints* a); + inline bool hasElementHints() const { return m_children & Hints; } + void clearElementHints(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QString m_sender; + QString m_signal; + QString m_receiver; + QString m_slot; + DomConnectionHints* m_hints; + enum Child { + Sender = 1, + Signal = 2, + Receiver = 4, + Slot = 8, + Hints = 16 + }; + + DomConnection(const DomConnection &other); + void operator = (const DomConnection&other); +}; + +class QDESIGNER_UILIB_EXPORT DomConnectionHints { +public: + DomConnectionHints(); + ~DomConnectionHints(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QList<DomConnectionHint*> elementHint() const { return m_hint; } + void setElementHint(const QList<DomConnectionHint*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QList<DomConnectionHint*> m_hint; + enum Child { + Hint = 1 + }; + + DomConnectionHints(const DomConnectionHints &other); + void operator = (const DomConnectionHints&other); +}; + +class QDESIGNER_UILIB_EXPORT DomConnectionHint { +public: + DomConnectionHint(); + ~DomConnectionHint(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeType() const { return m_has_attr_type; } + inline QString attributeType() const { return m_attr_type; } + inline void setAttributeType(const QString& a) { m_attr_type = a; m_has_attr_type = true; } + inline void clearAttributeType() { m_has_attr_type = false; } + + // child element accessors + inline int elementX() const { return m_x; } + void setElementX(int a); + inline bool hasElementX() const { return m_children & X; } + void clearElementX(); + + inline int elementY() const { return m_y; } + void setElementY(int a); + inline bool hasElementY() const { return m_children & Y; } + void clearElementY(); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_type; + bool m_has_attr_type; + + // child element data + uint m_children; + int m_x; + int m_y; + enum Child { + X = 1, + Y = 2 + }; + + DomConnectionHint(const DomConnectionHint &other); + void operator = (const DomConnectionHint&other); +}; + +class QDESIGNER_UILIB_EXPORT DomScript { +public: + DomScript(); + ~DomScript(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + inline bool hasAttributeSource() const { return m_has_attr_source; } + inline QString attributeSource() const { return m_attr_source; } + inline void setAttributeSource(const QString& a) { m_attr_source = a; m_has_attr_source = true; } + inline void clearAttributeSource() { m_has_attr_source = false; } + + inline bool hasAttributeLanguage() const { return m_has_attr_language; } + inline QString attributeLanguage() const { return m_attr_language; } + inline void setAttributeLanguage(const QString& a) { m_attr_language = a; m_has_attr_language = true; } + inline void clearAttributeLanguage() { m_has_attr_language = false; } + + // child element accessors +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + QString m_attr_source; + bool m_has_attr_source; + + QString m_attr_language; + bool m_has_attr_language; + + // child element data + uint m_children; + + DomScript(const DomScript &other); + void operator = (const DomScript&other); +}; + +class QDESIGNER_UILIB_EXPORT DomWidgetData { +public: + DomWidgetData(); + ~DomWidgetData(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QList<DomProperty*> elementProperty() const { return m_property; } + void setElementProperty(const QList<DomProperty*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QList<DomProperty*> m_property; + enum Child { + Property = 1 + }; + + DomWidgetData(const DomWidgetData &other); + void operator = (const DomWidgetData&other); +}; + +class QDESIGNER_UILIB_EXPORT DomDesignerData { +public: + DomDesignerData(); + ~DomDesignerData(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QList<DomProperty*> elementProperty() const { return m_property; } + void setElementProperty(const QList<DomProperty*>& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QList<DomProperty*> m_property; + enum Child { + Property = 1 + }; + + DomDesignerData(const DomDesignerData &other); + void operator = (const DomDesignerData&other); +}; + +class QDESIGNER_UILIB_EXPORT DomSlots { +public: + DomSlots(); + ~DomSlots(); + + void read(QXmlStreamReader &reader); +#ifdef QUILOADER_QDOM_READ + void read(const QDomElement &node); +#endif + void write(QXmlStreamWriter &writer, const QString &tagName = QString()) const; + inline QString text() const { return m_text; } + inline void setText(const QString &s) { m_text = s; } + + // attribute accessors + // child element accessors + inline QStringList elementSignal() const { return m_signal; } + void setElementSignal(const QStringList& a); + + inline QStringList elementSlot() const { return m_slot; } + void setElementSlot(const QStringList& a); + +private: + QString m_text; + void clear(bool clear_all = true); + + // attribute data + // child element data + uint m_children; + QStringList m_signal; + QStringList m_slot; + enum Child { + Signal = 1, + Slot = 2 + }; + + DomSlots(const DomSlots &other); + void operator = (const DomSlots&other); +}; + + +#ifdef QFORMINTERNAL_NAMESPACE +} +#endif + +QT_END_NAMESPACE + +#endif // UI4_H diff --git a/tools/designer/src/lib/uilib/uilib.pri b/tools/designer/src/lib/uilib/uilib.pri new file mode 100644 index 0000000..cbf415b --- /dev/null +++ b/tools/designer/src/lib/uilib/uilib.pri @@ -0,0 +1,31 @@ + +INCLUDEPATH += $$PWD + +DEFINES += QT_DESIGNER + +# Input +HEADERS += \ + $$PWD/ui4_p.h \ + $$PWD/abstractformbuilder.h \ + $$PWD/formbuilder.h \ + $$PWD/container.h \ + $$PWD/customwidget.h \ + $$PWD/properties_p.h \ + $$PWD/formbuilderextra_p.h \ + $$PWD/resourcebuilder_p.h \ + $$PWD/textbuilder_p.h + +SOURCES += \ + $$PWD/abstractformbuilder.cpp \ + $$PWD/formbuilder.cpp \ + $$PWD/ui4.cpp \ + $$PWD/properties.cpp \ + $$PWD/formbuilderextra.cpp \ + $$PWD/resourcebuilder.cpp \ + $$PWD/textbuilder.cpp + +!contains(DEFINES, QT_FORMBUILDER_NO_SCRIPT) { + QT += script + HEADERS += $$PWD/formscriptrunner_p.h + SOURCES += $$PWD/formscriptrunner.cpp +} diff --git a/tools/designer/src/lib/uilib/uilib_global.h b/tools/designer/src/lib/uilib/uilib_global.h new file mode 100644 index 0000000..796fa79 --- /dev/null +++ b/tools/designer/src/lib/uilib/uilib_global.h @@ -0,0 +1,64 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef UILIB_GLOBAL_H +#define UILIB_GLOBAL_H + +#include <QtCore/qglobal.h> + +QT_BEGIN_HEADER +QT_BEGIN_NAMESPACE + +#define QDESIGNER_UILIB_EXTERN Q_DECL_EXPORT +#define QDESIGNER_UILIB_IMPORT Q_DECL_IMPORT + +#ifdef QT_DESIGNER_STATIC +# define QDESIGNER_UILIB_EXPORT +#elif defined(QDESIGNER_UILIB_LIBRARY) +# define QDESIGNER_UILIB_EXPORT QDESIGNER_UILIB_EXTERN +#else +# define QDESIGNER_UILIB_EXPORT QDESIGNER_UILIB_IMPORT +#endif + +QT_END_NAMESPACE +QT_END_HEADER + +#endif // UILIB_GLOBAL_H diff --git a/tools/designer/src/lib/uilib/widgets.table b/tools/designer/src/lib/uilib/widgets.table new file mode 100644 index 0000000..9b87278 --- /dev/null +++ b/tools/designer/src/lib/uilib/widgets.table @@ -0,0 +1,148 @@ + +#ifndef DECLARE_WIDGET_1 +# define DECLARE_WIDGET_1(a,b) DECLARE_WIDGET(a,b) +#endif + +// widgets +#ifndef QT_NO_CHECKBOX +DECLARE_WIDGET(QCheckBox, "text") +#endif +#ifndef QT_NO_COMBOBOX +DECLARE_WIDGET(QComboBox, "") +#endif +#ifndef QT_NO_DATETIMEEDIT +DECLARE_WIDGET(QDateTimeEdit, "") +#endif +#ifndef QT_NO_DATEEDIT +DECLARE_WIDGET(QDateEdit, "") +#endif +#ifndef QT_NO_TIMEEDIT +DECLARE_WIDGET(QTimeEdit, "") +#endif +#ifndef QT_NO_DIAL +DECLARE_WIDGET(QDial, "") +#endif +DECLARE_WIDGET(QDialog, "") +#ifndef QT_NO_DOCKWIDGET +DECLARE_WIDGET(QDockWidget, "") +#endif +DECLARE_WIDGET(QFrame, "") +#ifndef QT_NO_GROUPBOX +DECLARE_WIDGET(QGroupBox, "") +#endif +#ifndef QT_NO_SCROLLAREA +DECLARE_WIDGET(QScrollArea, "") +#endif +#ifndef QT_NO_LCDNUMBER +DECLARE_WIDGET(QLCDNumber, "") +#endif +DECLARE_WIDGET(QLabel, "") +#ifndef QT_NO_LINEEDIT +DECLARE_WIDGET(QLineEdit, "") +#endif +#ifndef QT_NO_LISTVIEW +DECLARE_WIDGET(QListView, "") +#endif +#ifndef QT_NO_LISTWIDGET +DECLARE_WIDGET(QListWidget, "") +#endif +#ifndef QT_NO_MAINWINDOW +DECLARE_WIDGET(QMainWindow, "") +#endif +#ifndef QT_NO_MDIAREA +DECLARE_WIDGET(QMdiArea, "") +#endif +#ifndef QT_NO_MENU +DECLARE_WIDGET(QMenu, "") +#endif +#ifndef QT_NO_MENUBAR +DECLARE_WIDGET(QMenuBar, "") +#endif +#ifndef QT_NO_PROGRESSBAR +DECLARE_WIDGET(QProgressBar, "") +#endif +DECLARE_WIDGET(QPushButton, "text") +DECLARE_WIDGET(QRadioButton, "text") +DECLARE_WIDGET(QCommandLinkButton, "text") +#ifndef QT_NO_SCROLLBAR +DECLARE_WIDGET(QScrollBar, "") +#endif +#ifndef QT_NO_SLIDER +DECLARE_WIDGET(QSlider, "") +#endif +#ifndef QT_NO_SPINBOX +DECLARE_WIDGET(QSpinBox, "") +DECLARE_WIDGET(QDoubleSpinBox, "") +#endif +#ifndef QT_NO_TABWIDGET +DECLARE_WIDGET(QTabWidget, "") +#endif +#ifndef QT_NO_TABLEVIEW +DECLARE_WIDGET(QTableView, "") +#endif +#ifndef QT_NO_TABLEWIDGET +DECLARE_WIDGET(QTableWidget, "") +#endif +#ifndef QT_NO_TEXTBROWSER +DECLARE_WIDGET(QTextBrowser, "") +#endif +#ifndef QT_NO_TEXTEDIT +DECLARE_WIDGET(QTextEdit, "") +DECLARE_WIDGET(QPlainTextEdit, "") +#endif +#ifndef QT_NO_TOOLBAR +DECLARE_WIDGET(QToolBar, "") +#endif +#ifndef QT_NO_TOOLBOX +DECLARE_WIDGET(QToolBox, "") +#endif +#ifndef QT_NO_TOOLBUTTON +DECLARE_WIDGET(QToolButton, "text") +#endif +#ifndef QT_NO_TREEVIEW +DECLARE_WIDGET(QTreeView, "") +#endif +#ifndef QT_NO_TREEWIDGET +DECLARE_WIDGET(QTreeWidget, "") +#endif +DECLARE_WIDGET(QWidget, "") +#ifndef QT_NO_WORKSPACE +DECLARE_WIDGET(QWorkspace, "") +#endif +#ifndef QT_NO_SPLITTER +DECLARE_WIDGET(QSplitter, "") +#endif +#ifndef QT_NO_STACKEDWIDGET +DECLARE_WIDGET(QStackedWidget, "") +#endif +#ifndef QT_NO_STATUSBAR +DECLARE_WIDGET(QStatusBar, "") +#endif +DECLARE_WIDGET(QDialogButtonBox, "") +#ifndef QT_NO_FONTCOMBOBOX +DECLARE_WIDGET(QFontComboBox, "") +#endif +#ifndef QT_NO_CALENDARWIDGET +DECLARE_WIDGET(QCalendarWidget, "") +#endif +#ifndef QT_NO_COLUMNVIEW +DECLARE_WIDGET(QColumnView, "") +#endif + +#ifndef QT_NO_WIZARD +DECLARE_WIDGET(QWizard, "") +DECLARE_WIDGET(QWizardPage, "") +#endif + +#if !defined(QT_NO_GRAPHICSVIEW) || (QT_EDITION & QT_MODULE_GRAPHICSVIEW) != QT_MODULE_GRAPHICSVIEW +DECLARE_WIDGET_1(QGraphicsView, "") +#endif + +// layouts +DECLARE_LAYOUT(QGridLayout, "") +DECLARE_LAYOUT(QHBoxLayout, "") +DECLARE_LAYOUT(QStackedLayout, "") +DECLARE_LAYOUT(QVBoxLayout, "") +#ifndef QT_NO_FORMLAYOUT +DECLARE_LAYOUT(QFormLayout, "") +#endif |