diff options
Diffstat (limited to 'tools/designer/src/uitools/quiloader.cpp')
| -rw-r--r-- | tools/designer/src/uitools/quiloader.cpp | 927 |
1 files changed, 927 insertions, 0 deletions
diff --git a/tools/designer/src/uitools/quiloader.cpp b/tools/designer/src/uitools/quiloader.cpp new file mode 100644 index 0000000..d3d1d54 --- /dev/null +++ b/tools/designer/src/uitools/quiloader.cpp @@ -0,0 +1,927 @@ +/**************************************************************************** +** +** 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 "quiloader.h" +#include "quiloader_p.h" +#include "customwidget.h" + +#include <formbuilder.h> +#include <formbuilderextra_p.h> +#include <textbuilder_p.h> +#include <ui4_p.h> + +#include <QtCore/qdebug.h> +#include <QtGui/QAction> +#include <QtGui/QActionGroup> +#include <QtGui/QApplication> +#include <QtCore/QDir> +#include <QtCore/QLibraryInfo> +#include <QtGui/QLayout> +#include <QtGui/QWidget> +#include <QtCore/QMap> +#include <QtGui/QTabWidget> +#include <QtGui/QTreeWidget> +#include <QtGui/QListWidget> +#include <QtGui/QTableWidget> +#include <QtGui/QToolBox> +#include <QtGui/QComboBox> +#include <QtGui/QFontComboBox> + +QT_BEGIN_NAMESPACE + +typedef QMap<QString, bool> widget_map; +Q_GLOBAL_STATIC(widget_map, g_widgets) + +class QUiLoader; +class QUiLoaderPrivate; + +#ifdef QFORMINTERNAL_NAMESPACE +namespace QFormInternal +{ +#endif + +class TranslatingTextBuilder : public QTextBuilder +{ +public: + TranslatingTextBuilder(bool trEnabled, const QByteArray &className) : + m_trEnabled(trEnabled), m_className(className) {} + + virtual QVariant loadText(const DomProperty *icon) const; + + virtual QVariant toNativeValue(const QVariant &value) const; + +private: + bool m_trEnabled; + QByteArray m_className; +}; + +QVariant TranslatingTextBuilder::loadText(const DomProperty *text) const +{ + const DomString *str = text->elementString(); + if (!str) + return QVariant(); + if (str->hasAttributeNotr()) { + const QString notr = str->attributeNotr(); + if (notr == QLatin1String("true") || notr == QLatin1String("yes")) + return qVariantFromValue(str->text()); + } + QUiTranslatableStringValue strVal; + strVal.setValue(str->text().toUtf8()); + if (str->hasAttributeComment()) + strVal.setComment(str->attributeComment().toUtf8()); + return qVariantFromValue(strVal); +} + +QVariant TranslatingTextBuilder::toNativeValue(const QVariant &value) const +{ + if (qVariantCanConvert<QUiTranslatableStringValue>(value)) { + QUiTranslatableStringValue tsv = qVariantValue<QUiTranslatableStringValue>(value); + if (!m_trEnabled) + return QString::fromUtf8(tsv.value().data()); + return qVariantFromValue( + QApplication::translate(m_className, tsv.value(), tsv.comment(), + QCoreApplication::UnicodeUTF8)); + } + if (qVariantCanConvert<QString>(value)) + return qVariantFromValue(qVariantValue<QString>(value)); + return value; +} + +// This is "exported" to linguist +const QUiItemRolePair qUiItemRoles[] = { + { Qt::DisplayRole, Qt::DisplayPropertyRole }, +#ifndef QT_NO_TOOLTIP + { Qt::ToolTipRole, Qt::ToolTipPropertyRole }, +#endif +#ifndef QT_NO_STATUSTIP + { Qt::StatusTipRole, Qt::StatusTipPropertyRole }, +#endif +#ifndef QT_NO_WHATSTHIS + { Qt::WhatsThisRole, Qt::WhatsThisPropertyRole }, +#endif + { -1 , -1 } +}; + +static void recursiveReTranslate(QTreeWidgetItem *item, const QByteArray &class_name) +{ + const QUiItemRolePair *irs = qUiItemRoles; + + int cnt = item->columnCount(); + for (int i = 0; i < cnt; ++i) { + for (unsigned j = 0; irs[j].shadowRole >= 0; j++) { + QVariant v = item->data(i, irs[j].shadowRole); + if (v.isValid()) { + QUiTranslatableStringValue tsv = qVariantValue<QUiTranslatableStringValue>(v); + const QString text = QApplication::translate(class_name, + tsv.value(), tsv.comment(), + QCoreApplication::UnicodeUTF8); + item->setData(i, irs[j].realRole, text); + } + } + } + + cnt = item->childCount(); + for (int i = 0; i < cnt; ++i) + recursiveReTranslate(item->child(i), class_name); +} + +template<typename T> +static void reTranslateWidgetItem(T *item, const QByteArray &class_name) +{ + const QUiItemRolePair *irs = qUiItemRoles; + + for (unsigned j = 0; irs[j].shadowRole >= 0; j++) { + QVariant v = item->data(irs[j].shadowRole); + if (v.isValid()) { + QUiTranslatableStringValue tsv = qVariantValue<QUiTranslatableStringValue>(v); + const QString text = QApplication::translate(class_name, + tsv.value(), tsv.comment(), + QCoreApplication::UnicodeUTF8); + item->setData(irs[j].realRole, text); + } + } +} + +static void reTranslateTableItem(QTableWidgetItem *item, const QByteArray &class_name) +{ + if (item) + reTranslateWidgetItem(item, class_name); +} + +#define RETRANSLATE_SUBWIDGET_PROP(mainWidget, setter, propName) \ + do { \ + QVariant v = mainWidget->widget(i)->property(propName); \ + if (v.isValid()) { \ + QUiTranslatableStringValue tsv = qVariantValue<QUiTranslatableStringValue>(v); \ + const QString text = QApplication::translate(m_className, \ + tsv.value(), tsv.comment(), \ + QCoreApplication::UnicodeUTF8); \ + mainWidget->setter(i, text); \ + } \ + } while (0) + +class TranslationWatcher: public QObject +{ + Q_OBJECT + +public: + TranslationWatcher(QObject *parent, const QByteArray &className): + QObject(parent), + m_className(className) + { + } + + virtual bool eventFilter(QObject *o, QEvent *event) + { + if (event->type() == QEvent::LanguageChange) { + foreach (const QByteArray &prop, o->dynamicPropertyNames()) { + if (prop.startsWith(PROP_GENERIC_PREFIX)) { + const QByteArray propName = prop.mid(sizeof(PROP_GENERIC_PREFIX) - 1); + const QUiTranslatableStringValue tsv = + qVariantValue<QUiTranslatableStringValue>(o->property(prop)); + const QString text = QApplication::translate(m_className, + tsv.value(), tsv.comment(), + QCoreApplication::UnicodeUTF8); + o->setProperty(propName, text); + } + } + if (0) { +#ifndef QT_NO_TABWIDGET + } else if (QTabWidget *tabw = qobject_cast<QTabWidget*>(o)) { + const int cnt = tabw->count(); + for (int i = 0; i < cnt; ++i) { + RETRANSLATE_SUBWIDGET_PROP(tabw, setTabText, PROP_TABPAGETEXT); +# ifndef QT_NO_TOOLTIP + RETRANSLATE_SUBWIDGET_PROP(tabw, setTabToolTip, PROP_TABPAGETOOLTIP); +# endif +# ifndef QT_NO_WHATSTHIS + RETRANSLATE_SUBWIDGET_PROP(tabw, setTabWhatsThis, PROP_TABPAGEWHATSTHIS); +# endif + } +#endif +#ifndef QT_NO_LISTWIDGET + } else if (QListWidget *listw = qobject_cast<QListWidget*>(o)) { + const int cnt = listw->count(); + for (int i = 0; i < cnt; ++i) + reTranslateWidgetItem(listw->item(i), m_className); +#endif +#ifndef QT_NO_TREEWIDGET + } else if (QTreeWidget *treew = qobject_cast<QTreeWidget*>(o)) { + if (QTreeWidgetItem *item = treew->headerItem()) + recursiveReTranslate(item, m_className); + const int cnt = treew->topLevelItemCount(); + for (int i = 0; i < cnt; ++i) { + QTreeWidgetItem *item = treew->topLevelItem(i); + recursiveReTranslate(item, m_className); + } +#endif +#ifndef QT_NO_TABLEWIDGET + } else if (QTableWidget *tablew = qobject_cast<QTableWidget*>(o)) { + const int row_cnt = tablew->rowCount(); + const int col_cnt = tablew->columnCount(); + for (int j = 0; j < col_cnt; ++j) + reTranslateTableItem(tablew->verticalHeaderItem(j), m_className); + for (int i = 0; i < row_cnt; ++i) { + reTranslateTableItem(tablew->horizontalHeaderItem(i), m_className); + for (int j = 0; j < col_cnt; ++j) + reTranslateTableItem(tablew->item(i, j), m_className); + } +#endif +#ifndef QT_NO_COMBOBOX + } else if (QComboBox *combow = qobject_cast<QComboBox*>(o)) { + if (!qobject_cast<QFontComboBox*>(o)) { + const int cnt = combow->count(); + for (int i = 0; i < cnt; ++i) { + const QVariant v = combow->itemData(i, Qt::DisplayPropertyRole); + if (v.isValid()) { + QUiTranslatableStringValue tsv = qVariantValue<QUiTranslatableStringValue>(v); + const QString text = QApplication::translate(m_className, + tsv.value(), tsv.comment(), + QCoreApplication::UnicodeUTF8); + combow->setItemText(i, text); + } + } + } +#endif +#ifndef QT_NO_TOOLBOX + } else if (QToolBox *toolw = qobject_cast<QToolBox*>(o)) { + const int cnt = toolw->count(); + for (int i = 0; i < cnt; ++i) { + RETRANSLATE_SUBWIDGET_PROP(toolw, setItemText, PROP_TOOLITEMTEXT); +# ifndef QT_NO_TOOLTIP + RETRANSLATE_SUBWIDGET_PROP(toolw, setItemToolTip, PROP_TOOLITEMTOOLTIP); +# endif + } +#endif + } + } + return false; + } + +private: + QByteArray m_className; +}; + +class FormBuilderPrivate: public QFormBuilder +{ + friend class QT_PREPEND_NAMESPACE(QUiLoader); + friend class QT_PREPEND_NAMESPACE(QUiLoaderPrivate); + typedef QFormBuilder ParentClass; + +public: + QUiLoader *loader; + + bool dynamicTr; + bool trEnabled; + + FormBuilderPrivate(): loader(0), dynamicTr(false), trEnabled(true), m_trwatch(0) {} + + QWidget *defaultCreateWidget(const QString &className, QWidget *parent, const QString &name) + { + return ParentClass::createWidget(className, parent, name); + } + + QLayout *defaultCreateLayout(const QString &className, QObject *parent, const QString &name) + { + return ParentClass::createLayout(className, parent, name); + } + + QAction *defaultCreateAction(QObject *parent, const QString &name) + { + return ParentClass::createAction(parent, name); + } + + QActionGroup *defaultCreateActionGroup(QObject *parent, const QString &name) + { + return ParentClass::createActionGroup(parent, name); + } + + virtual QWidget *createWidget(const QString &className, QWidget *parent, const QString &name) + { + if (QWidget *widget = loader->createWidget(className, parent, name)) { + widget->setObjectName(name); + return widget; + } + + return 0; + } + + virtual QLayout *createLayout(const QString &className, QObject *parent, const QString &name) + { + if (QLayout *layout = loader->createLayout(className, parent, name)) { + layout->setObjectName(name); + return layout; + } + + return 0; + } + + virtual QActionGroup *createActionGroup(QObject *parent, const QString &name) + { + if (QActionGroup *actionGroup = loader->createActionGroup(parent, name)) { + actionGroup->setObjectName(name); + return actionGroup; + } + + return 0; + } + + virtual QAction *createAction(QObject *parent, const QString &name) + { + if (QAction *action = loader->createAction(parent, name)) { + action->setObjectName(name); + return action; + } + + return 0; + } + + virtual void applyProperties(QObject *o, const QList<DomProperty*> &properties); + virtual QWidget *create(DomUI *ui, QWidget *parentWidget); + virtual QWidget *create(DomWidget *ui_widget, QWidget *parentWidget); + virtual bool addItem(DomWidget *ui_widget, QWidget *widget, QWidget *parentWidget); + +private: + QByteArray m_class; + TranslationWatcher *m_trwatch; +}; + +static QString convertTranslatable(const DomProperty *p, const QByteArray &className, + QUiTranslatableStringValue *strVal) +{ + if (p->kind() != DomProperty::String) + return QString(); + const DomString *dom_str = p->elementString(); + if (!dom_str) + return QString(); + if (dom_str->hasAttributeNotr()) { + const QString notr = dom_str->attributeNotr(); + if (notr == QLatin1String("yes") || notr == QLatin1String("true")) + return QString(); + } + strVal->setValue(dom_str->text().toUtf8()); + strVal->setComment(dom_str->attributeComment().toUtf8()); + if (strVal->value().isEmpty() && strVal->comment().isEmpty()) + return QString(); + return QApplication::translate(className, + strVal->value(), strVal->comment(), + QCoreApplication::UnicodeUTF8); +} + +void FormBuilderPrivate::applyProperties(QObject *o, const QList<DomProperty*> &properties) +{ + typedef QList<DomProperty*> DomPropertyList; + + QFormBuilder::applyProperties(o, properties); + + if (!m_trwatch) + m_trwatch = new TranslationWatcher(o, m_class); + + if (properties.empty()) + return; + + // Unlike string item roles, string properties are not loaded via the textBuilder + // (as they are "shadowed" by the property sheets in designer). So do the initial + // translation here. + bool anyTrs = false; + foreach (const DomProperty *p, properties) { + QUiTranslatableStringValue strVal; + const QString text = convertTranslatable(p, m_class, &strVal); + if (text.isEmpty()) + continue; + const QByteArray name = p->attributeName().toUtf8(); + if (dynamicTr) { + o->setProperty(PROP_GENERIC_PREFIX + name, qVariantFromValue(strVal)); + anyTrs = trEnabled; + } + o->setProperty(name, text); + } + if (anyTrs) + o->installEventFilter(m_trwatch); +} + +QWidget *FormBuilderPrivate::create(DomUI *ui, QWidget *parentWidget) +{ + m_class = ui->elementClass().toUtf8(); + m_trwatch = 0; + setTextBuilder(new TranslatingTextBuilder(trEnabled, m_class)); + return QFormBuilder::create(ui, parentWidget); +} + +QWidget *FormBuilderPrivate::create(DomWidget *ui_widget, QWidget *parentWidget) +{ + QWidget *w = QFormBuilder::create(ui_widget, parentWidget); + if (w == 0) + return 0; + + if (0) { +#ifndef QT_NO_TABWIDGET + } else if (qobject_cast<QTabWidget*>(w)) { +#endif +#ifndef QT_NO_LISTWIDGET + } else if (qobject_cast<QListWidget*>(w)) { +#endif +#ifndef QT_NO_TREEWIDGET + } else if (qobject_cast<QTreeWidget*>(w)) { +#endif +#ifndef QT_NO_TABLEWIDGET + } else if (qobject_cast<QTableWidget*>(w)) { +#endif +#ifndef QT_NO_COMBOBOX + } else if (qobject_cast<QComboBox*>(w)) { + if (qobject_cast<QFontComboBox*>(w)) + return w; +#endif +#ifndef QT_NO_TOOLBOX + } else if (qobject_cast<QToolBox*>(w)) { +#endif + } else { + return w; + } + if (dynamicTr && trEnabled) + w->installEventFilter(m_trwatch); + return w; +} + +#define TRANSLATE_SUBWIDGET_PROP(mainWidget, attribute, setter, propName) \ + do { \ + if (const DomProperty *p##attribute = attributes.value(strings.attribute)) { \ + QUiTranslatableStringValue strVal; \ + const QString text = convertTranslatable(p##attribute, m_class, &strVal); \ + if (!text.isEmpty()) { \ + if (dynamicTr) \ + mainWidget->widget(i)->setProperty(propName, qVariantFromValue(strVal)); \ + mainWidget->setter(i, text); \ + } \ + } \ + } while (0) + +bool FormBuilderPrivate::addItem(DomWidget *ui_widget, QWidget *widget, QWidget *parentWidget) +{ + if (parentWidget == 0) + return true; + + if (!ParentClass::addItem(ui_widget, widget, parentWidget)) + return false; + + // Check special cases. First: Custom container + const QString className = QLatin1String(parentWidget->metaObject()->className()); + if (!QFormBuilderExtra::instance(this)->customWidgetAddPageMethod(className).isEmpty()) + return true; + + const QFormBuilderStrings &strings = QFormBuilderStrings::instance(); + + if (0) { +#ifndef QT_NO_TABWIDGET + } else if (QTabWidget *tabWidget = qobject_cast<QTabWidget*>(parentWidget)) { + const DomPropertyHash attributes = propertyMap(ui_widget->elementAttribute()); + const int i = tabWidget->count() - 1; + TRANSLATE_SUBWIDGET_PROP(tabWidget, titleAttribute, setTabText, PROP_TABPAGETEXT); +# ifndef QT_NO_TOOLTIP + TRANSLATE_SUBWIDGET_PROP(tabWidget, toolTipAttribute, setTabToolTip, PROP_TABPAGETOOLTIP); +# endif +# ifndef QT_NO_WHATSTHIS + TRANSLATE_SUBWIDGET_PROP(tabWidget, whatsThisAttribute, setTabWhatsThis, PROP_TABPAGEWHATSTHIS); +# endif +#endif +#ifndef QT_NO_TOOLBOX + } else if (QToolBox *toolBox = qobject_cast<QToolBox*>(parentWidget)) { + const DomPropertyHash attributes = propertyMap(ui_widget->elementAttribute()); + const int i = toolBox->count() - 1; + TRANSLATE_SUBWIDGET_PROP(toolBox, labelAttribute, setItemText, PROP_TOOLITEMTEXT); +# ifndef QT_NO_TOOLTIP + TRANSLATE_SUBWIDGET_PROP(toolBox, toolTipAttribute, setItemToolTip, PROP_TOOLITEMTOOLTIP); +# endif +#endif + } + + return true; +} + +#ifdef QFORMINTERNAL_NAMESPACE +} +#endif + +class QUiLoaderPrivate +{ +public: +#ifdef QFORMINTERNAL_NAMESPACE + QFormInternal::FormBuilderPrivate builder; +#else + FormBuilderPrivate builder; +#endif + + void setupWidgetMap() const; +}; + +void QUiLoaderPrivate::setupWidgetMap() const +{ + if (!g_widgets()->isEmpty()) + return; + +#define DECLARE_WIDGET(a, b) g_widgets()->insert(QLatin1String(#a), true); +#define DECLARE_LAYOUT(a, b) + +#include "widgets.table" + +#undef DECLARE_WIDGET +#undef DECLARE_WIDGET_1 +#undef DECLARE_LAYOUT +} + +/*! + \class QUiLoader + \inmodule QtUiTools + + \brief The QUiLoader class allows standalone applications dynamically + create user interfaces at run-time using the information stored in + .ui files or specified plugin paths. + + In addition, you can customize of creating an user interface by + deriving your own loader class. + + If you have a custom component or an application that embeds Qt + Designer, you can also use the QFormBuilder class provided by the + QtDesigner module to create user interfaces from .ui files. + + The QUiLoader class provides a collection of functions that allows + you to create widgets based on the information stored in \c .ui + files (created with Qt Designer) or available in the specified + plugin paths. The specified plugin paths can be retrieved using + the pluginPaths() function. You can retrieve the contents of an \c + .ui file using the load() function. For example: + + \snippet doc/src/snippets/quiloader/mywidget.cpp 0 + + By including the user interface in the form's resources (\c myform.qrc), + we ensure that it will be present at run-time: + + \quotefile doc/src/snippets/quiloader/mywidget.qrc + + The availableWidgets() function returns a QStringList with the + class names of the widgets available in the specified plugin + paths. You can create any of these widgets using the + createWidget() function. For example: + + \snippet doc/src/snippets/quiloader/main.cpp 0 + + You can make a custom widget available to the loader using the + addPluginPath() function, and you can remove all the available widgets + by calling the clearPluginPaths() function. + + The createAction(), createActionGroup(), createLayout() and + createWidget() functions are used internally by the QUiLoader class + whenever it has to create an action, action group, layout or + widget respectively. For that reason, you can subclass the QUiLoader + class and reimplement these functions to intervene the process of + constructing an user interface. For example, you might want to + create a list of the actions created when loading a form or + creating a custom widget. + + For a complete example using the QUiLoader class, see the \l + {designer/calculatorbuilder}{Calculator Builder} example. + + \sa QtUiTools, QFormBuilder +*/ + +/*! + Creates a form loader with the given \a parent. +*/ +QUiLoader::QUiLoader(QObject *parent) + : QObject(parent), d_ptr(new QUiLoaderPrivate) +{ + Q_D(QUiLoader); + + d->builder.loader = this; + + QStringList paths; + foreach (const QString &path, QApplication::libraryPaths()) { + QString libPath = path; + libPath += QDir::separator(); + libPath += QLatin1String("designer"); + paths.append(libPath); + } + + d->builder.setPluginPath(paths); +} + +/*! + Destroys the loader. +*/ +QUiLoader::~QUiLoader() +{ + delete d_ptr; +} + +/*! + Loads a form from the given \a device and creates a new widget with the given + \a parentWidget to hold its contents. + + \sa createWidget() +*/ +QWidget *QUiLoader::load(QIODevice *device, QWidget *parentWidget) +{ + Q_D(QUiLoader); + // QXmlStreamReader will report errors on open failure. + if (!device->isOpen()) + device->open(QIODevice::ReadOnly|QIODevice::Text); + return d->builder.load(device, parentWidget); +} + +/*! + Returns a list naming the paths the loader searches when locating + custom widget plugins. + + \sa addPluginPath(), clearPluginPaths() +*/ +QStringList QUiLoader::pluginPaths() const +{ + Q_D(const QUiLoader); + return d->builder.pluginPaths(); +} + +/*! + Clears the list of paths the loader searches when locating + plugins. + + \sa addPluginPath(), pluginPaths() +*/ +void QUiLoader::clearPluginPaths() +{ + Q_D(QUiLoader); + d->builder.clearPluginPaths(); +} + +/*! + Adds the given \a path to the list of paths the loader searches + when locating plugins. + + \sa pluginPaths(), clearPluginPaths() +*/ +void QUiLoader::addPluginPath(const QString &path) +{ + Q_D(QUiLoader); + d->builder.addPluginPath(path); +} + +/*! + Creates a new widget with the given \a parent and \a name + using the class specified by \a className. You can use this + function to create any of the widgets returned by the + availableWidgets() function. + + The function is also used internally by the QUiLoader class whenever + it has to create a widget. For that reason, you can subclass the + QUiLoader class and reimplement this function to intervene in the + process of constructing a user interface or widget. + + \sa availableWidgets(), load() +*/ +QWidget *QUiLoader::createWidget(const QString &className, QWidget *parent, const QString &name) +{ + Q_D(QUiLoader); + return d->builder.defaultCreateWidget(className, parent, name); +} + +/*! + Creates a new layout with the given \a parent and \a name + using the class specified by \a className. + + The function is used internally by the QUiLoader class whenever it + has to create a layout. For that reason, you can subclass the + QUiLoader class and reimplement this function to intervene the + process of constructing an user interface or widget. + + \sa createWidget(), load() +*/ +QLayout *QUiLoader::createLayout(const QString &className, QObject *parent, const QString &name) +{ + Q_D(QUiLoader); + return d->builder.defaultCreateLayout(className, parent, name); +} + +/*! + Creates a new action group with the given \a parent and \a name. + + The function is used internally by the QUiLoader class whenever it + has to create an action group. For that reason, you can subclass + the QUiLoader class and reimplement this function to intervene the + process of constructing an user interface or widget. + + \sa createAction(), createWidget(), load() + */ +QActionGroup *QUiLoader::createActionGroup(QObject *parent, const QString &name) +{ + Q_D(QUiLoader); + return d->builder.defaultCreateActionGroup(parent, name); +} + +/*! + Creates a new action with the given \a parent and \a name. + + The function is used internally by the QUiLoader class whenever it + has to create an action. For that reason, you can subclass the + QUiLoader class and reimplement this function to intervene the + process of constructing an user interface or widget. + + \sa createActionGroup(), createWidget(), load() +*/ +QAction *QUiLoader::createAction(QObject *parent, const QString &name) +{ + Q_D(QUiLoader); + return d->builder.defaultCreateAction(parent, name); +} + +/*! + Returns a list naming the available widgets that can be built + using the createWidget() function, i.e all the widgets specified + within the given plugin paths. + + \sa pluginPaths(), createWidget() + +*/ +QStringList QUiLoader::availableWidgets() const +{ + Q_D(const QUiLoader); + + d->setupWidgetMap(); + widget_map available = *g_widgets(); + + foreach (QDesignerCustomWidgetInterface *plugin, d->builder.customWidgets()) { + available.insert(plugin->name(), true); + } + + return available.keys(); +} + + +/*! + Returns a list naming the available layouts that can be built + using the createLayout() function + + \sa createLayout() + \since 4.5 +*/ + +QStringList QUiLoader::availableLayouts() const +{ + QStringList rc; +#define DECLARE_WIDGET(a, b) +#define DECLARE_LAYOUT(a, b) rc.push_back(QLatin1String(#a)); + +#include "widgets.table" + +#undef DECLARE_WIDGET +#undef DECLARE_LAYOUT + return rc; +} + +/*! + Sets the working directory of the loader to \a dir. The loader + looks for other resources, such as icons and resource files, + in paths relative to this directory. + + \sa workingDirectory() +*/ + +void QUiLoader::setWorkingDirectory(const QDir &dir) +{ + Q_D(QUiLoader); + d->builder.setWorkingDirectory(dir); +} + +/*! + Returns the working directory of the loader. + + \sa setWorkingDirectory() +*/ + +QDir QUiLoader::workingDirectory() const +{ + Q_D(const QUiLoader); + return d->builder.workingDirectory(); +} + +/*! + Sets whether the execution of scripts is enabled to \a enabled. + \since 4.3 + \internal +*/ + +void QUiLoader::setScriptingEnabled(bool enabled) +{ + Q_D(QUiLoader); + d->builder.setScriptingEnabled(enabled); +} + +/*! + Returns whether the execution of scripts is enabled. + \sa setScriptingEnabled() + \since 4.3 + \internal +*/ + +bool QUiLoader::isScriptingEnabled() const +{ + Q_D(const QUiLoader); + return d->builder.isScriptingEnabled(); +} + +/*! + Sets whether user interfaces loaded by this loader automatically + retranslate themselves upon receiving a language change event or not, + depending on \a enabled. + + \since 4.5 +*/ + +void QUiLoader::setLanguageChangeEnabled(bool enabled) +{ + Q_D(QUiLoader); + d->builder.dynamicTr = enabled; +} + +/*! + Returns whether dynamic retranslation on language change is enabled. + \sa setLanguageChangeEnabled() + \since 4.5 +*/ + +bool QUiLoader::isLanguageChangeEnabled() const +{ + Q_D(const QUiLoader); + return d->builder.dynamicTr; +} + +/*! + \internal + + Sets whether user interfaces loaded by this loader are translated + at all. Note that this is orthogonal to languageChangeEnabled. + + \since 4.5 +*/ + +void QUiLoader::setTranslationEnabled(bool enabled) +{ + Q_D(QUiLoader); + d->builder.trEnabled = enabled; +} + +/*! + \internal + + Returns whether translation is enabled. + \sa setTranslationEnabled() + + \since 4.5 +*/ + +bool QUiLoader::isTranslationEnabled() const +{ + Q_D(const QUiLoader); + return d->builder.trEnabled; +} + +QT_END_NAMESPACE + +#include "quiloader.moc" |