--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gui/itemviews/qdatawidgetmapper.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,849 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module 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 Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qdatawidgetmapper.h"
+
+#ifndef QT_NO_DATAWIDGETMAPPER
+
+#include "qabstractitemmodel.h"
+#include "qitemdelegate.h"
+#include "qmetaobject.h"
+#include "qwidget.h"
+#include "private/qobject_p.h"
+#include "private/qabstractitemmodel_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QDataWidgetMapperPrivate: public QObjectPrivate
+{
+public:
+ Q_DECLARE_PUBLIC(QDataWidgetMapper)
+
+ QDataWidgetMapperPrivate()
+ : model(QAbstractItemModelPrivate::staticEmptyModel()), delegate(0),
+ orientation(Qt::Horizontal), submitPolicy(QDataWidgetMapper::AutoSubmit)
+ {
+ }
+
+ QAbstractItemModel *model;
+ QAbstractItemDelegate *delegate;
+ Qt::Orientation orientation;
+ QDataWidgetMapper::SubmitPolicy submitPolicy;
+ QPersistentModelIndex rootIndex;
+ QPersistentModelIndex currentTopLeft;
+
+ inline int itemCount()
+ {
+ return orientation == Qt::Horizontal
+ ? model->rowCount(rootIndex)
+ : model->columnCount(rootIndex);
+ }
+
+ inline int currentIdx() const
+ {
+ return orientation == Qt::Horizontal ? currentTopLeft.row() : currentTopLeft.column();
+ }
+
+ inline QModelIndex indexAt(int itemPos)
+ {
+ return orientation == Qt::Horizontal
+ ? model->index(currentIdx(), itemPos, rootIndex)
+ : model->index(itemPos, currentIdx(), rootIndex);
+ }
+
+ inline void flipEventFilters(QAbstractItemDelegate *oldDelegate,
+ QAbstractItemDelegate *newDelegate)
+ {
+ for (int i = 0; i < widgetMap.count(); ++i) {
+ QWidget *w = widgetMap.at(i).widget;
+ if (!w)
+ continue;
+ w->removeEventFilter(oldDelegate);
+ w->installEventFilter(newDelegate);
+ }
+ }
+
+ void populate();
+
+ // private slots
+ void _q_dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight);
+ void _q_commitData(QWidget *);
+ void _q_closeEditor(QWidget *, QAbstractItemDelegate::EndEditHint);
+ void _q_modelDestroyed();
+
+ struct WidgetMapper
+ {
+ inline WidgetMapper(QWidget *w = 0, int c = 0, const QModelIndex &i = QModelIndex())
+ : widget(w), section(c), currentIndex(i) {}
+ inline WidgetMapper(QWidget *w, int c, const QModelIndex &i, const QByteArray &p)
+ : widget(w), section(c), currentIndex(i), property(p) {}
+
+ QPointer<QWidget> widget;
+ int section;
+ QPersistentModelIndex currentIndex;
+ QByteArray property;
+ };
+
+ void populate(WidgetMapper &m);
+ int findWidget(QWidget *w) const;
+
+ bool commit(const WidgetMapper &m);
+
+ QList<WidgetMapper> widgetMap;
+};
+
+int QDataWidgetMapperPrivate::findWidget(QWidget *w) const
+{
+ for (int i = 0; i < widgetMap.count(); ++i) {
+ if (widgetMap.at(i).widget == w)
+ return i;
+ }
+ return -1;
+}
+
+bool QDataWidgetMapperPrivate::commit(const WidgetMapper &m)
+{
+ if (m.widget.isNull())
+ return true; // just ignore
+
+ if (!m.currentIndex.isValid())
+ return false;
+
+ // Create copy to avoid passing the widget mappers data
+ QModelIndex idx = m.currentIndex;
+ if (m.property.isEmpty())
+ delegate->setModelData(m.widget, model, idx);
+ else
+ model->setData(idx, m.widget->property(m.property), Qt::EditRole);
+
+ return true;
+}
+
+void QDataWidgetMapperPrivate::populate(WidgetMapper &m)
+{
+ if (m.widget.isNull())
+ return;
+
+ m.currentIndex = indexAt(m.section);
+ if (m.property.isEmpty())
+ delegate->setEditorData(m.widget, m.currentIndex);
+ else
+ m.widget->setProperty(m.property, m.currentIndex.data(Qt::EditRole));
+}
+
+void QDataWidgetMapperPrivate::populate()
+{
+ for (int i = 0; i < widgetMap.count(); ++i)
+ populate(widgetMap[i]);
+}
+
+static bool qContainsIndex(const QModelIndex &idx, const QModelIndex &topLeft,
+ const QModelIndex &bottomRight)
+{
+ return idx.row() >= topLeft.row() && idx.row() <= bottomRight.row()
+ && idx.column() >= topLeft.column() && idx.column() <= bottomRight.column();
+}
+
+void QDataWidgetMapperPrivate::_q_dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
+{
+ if (topLeft.parent() != rootIndex)
+ return; // not in our hierarchy
+
+ for (int i = 0; i < widgetMap.count(); ++i) {
+ WidgetMapper &m = widgetMap[i];
+ if (qContainsIndex(m.currentIndex, topLeft, bottomRight))
+ populate(m);
+ }
+}
+
+void QDataWidgetMapperPrivate::_q_commitData(QWidget *w)
+{
+ if (submitPolicy == QDataWidgetMapper::ManualSubmit)
+ return;
+
+ int idx = findWidget(w);
+ if (idx == -1)
+ return; // not our widget
+
+ commit(widgetMap.at(idx));
+}
+
+class QFocusHelper: public QWidget
+{
+public:
+ bool focusNextPrevChild(bool next)
+ {
+ return QWidget::focusNextPrevChild(next);
+ }
+
+ static inline void focusNextPrevChild(QWidget *w, bool next)
+ {
+ static_cast<QFocusHelper *>(w)->focusNextPrevChild(next);
+ }
+};
+
+void QDataWidgetMapperPrivate::_q_closeEditor(QWidget *w, QAbstractItemDelegate::EndEditHint hint)
+{
+ int idx = findWidget(w);
+ if (idx == -1)
+ return; // not our widget
+
+ switch (hint) {
+ case QAbstractItemDelegate::RevertModelCache: {
+ populate(widgetMap[idx]);
+ break; }
+ case QAbstractItemDelegate::EditNextItem:
+ QFocusHelper::focusNextPrevChild(w, true);
+ break;
+ case QAbstractItemDelegate::EditPreviousItem:
+ QFocusHelper::focusNextPrevChild(w, false);
+ break;
+ case QAbstractItemDelegate::SubmitModelCache:
+ case QAbstractItemDelegate::NoHint:
+ // nothing
+ break;
+ }
+}
+
+void QDataWidgetMapperPrivate::_q_modelDestroyed()
+{
+ Q_Q(QDataWidgetMapper);
+
+ model = 0;
+ q->setModel(QAbstractItemModelPrivate::staticEmptyModel());
+}
+
+/*!
+ \class QDataWidgetMapper
+ \brief The QDataWidgetMapper class provides mapping between a section
+ of a data model to widgets.
+ \since 4.2
+ \ingroup model-view
+ \ingroup advanced
+
+ QDataWidgetMapper can be used to create data-aware widgets by mapping
+ them to sections of an item model. A section is a column of a model
+ if the orientation is horizontal (the default), otherwise a row.
+
+ Every time the current index changes, each widget is updated with data
+ from the model via the property specified when its mapping was made.
+ If the user edits the contents of a widget, the changes are read using
+ the same property and written back to the model.
+ By default, each widget's \l{Q_PROPERTY()}{user property} is used to
+ transfer data between the model and the widget. Since Qt 4.3, an
+ additional addMapping() function enables a named property to be used
+ instead of the default user property.
+
+ It is possible to set an item delegate to support custom widgets. By default,
+ a QItemDelegate is used to synchronize the model with the widgets.
+
+ Let us assume that we have an item model named \c{model} with the following contents:
+
+ \table
+ \row \o 1 \o Qt Norway \o Oslo
+ \row \o 2 \o Qt Australia \o Brisbane
+ \row \o 3 \o Qt USA \o Palo Alto
+ \row \o 4 \o Qt China \o Beijing
+ \row \o 5 \o Qt Germany \o Berlin
+ \endtable
+
+ The following code will map the columns of the model to widgets called \c mySpinBox,
+ \c myLineEdit and \c{myCountryChooser}:
+
+ \snippet doc/src/snippets/code/src_gui_itemviews_qdatawidgetmapper.cpp 0
+
+ After the call to toFirst(), \c mySpinBox displays the value \c{1}, \c myLineEdit
+ displays \c {Nokia Corporation and/or its subsidiary(-ies)} and \c myCountryChooser displays \c{Oslo}. The
+ navigational functions toFirst(), toNext(), toPrevious(), toLast() and setCurrentIndex()
+ can be used to navigate in the model and update the widgets with contents from
+ the model.
+
+ The setRootIndex() function enables a particular item in a model to be
+ specified as the root index - children of this item will be mapped to
+ the relevant widgets in the user interface.
+
+ QDataWidgetMapper supports two submit policies, \c AutoSubmit and \c{ManualSubmit}.
+ \c AutoSubmit will update the model as soon as the current widget loses focus,
+ \c ManualSubmit will not update the model unless submit() is called. \c ManualSubmit
+ is useful when displaying a dialog that lets the user cancel all modifications.
+ Also, other views that display the model won't update until the user finishes
+ all their modifications and submits.
+
+ Note that QDataWidgetMapper keeps track of external modifications. If the contents
+ of the model are updated in another module of the application, the widgets are
+ updated as well.
+
+ \sa QAbstractItemModel, QAbstractItemDelegate
+ */
+
+/*! \enum QDataWidgetMapper::SubmitPolicy
+
+ This enum describes the possible submit policies a QDataWidgetMapper
+ supports.
+
+ \value AutoSubmit Whenever a widget loses focus, the widget's current
+ value is set to the item model.
+ \value ManualSubmit The model is not updated until submit() is called.
+ */
+
+/*!
+ \fn void QDataWidgetMapper::currentIndexChanged(int index)
+
+ This signal is emitted after the current index has changed and
+ all widgets were populated with new data. \a index is the new
+ current index.
+
+ \sa currentIndex(), setCurrentIndex()
+ */
+
+/*!
+ Constructs a new QDataWidgetMapper with parent object \a parent.
+ By default, the orientation is horizontal and the submit policy
+ is \c{AutoSubmit}.
+
+ \sa setOrientation(), setSubmitPolicy()
+ */
+QDataWidgetMapper::QDataWidgetMapper(QObject *parent)
+ : QObject(*new QDataWidgetMapperPrivate, parent)
+{
+ setItemDelegate(new QItemDelegate(this));
+}
+
+/*!
+ Destroys the object.
+ */
+QDataWidgetMapper::~QDataWidgetMapper()
+{
+}
+
+/*!
+ Sets the current model to \a model. If another model was set,
+ all mappings to that old model are cleared.
+
+ \sa model()
+ */
+void QDataWidgetMapper::setModel(QAbstractItemModel *model)
+{
+ Q_D(QDataWidgetMapper);
+
+ if (d->model == model)
+ return;
+
+ if (d->model) {
+ disconnect(d->model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this,
+ SLOT(_q_dataChanged(QModelIndex,QModelIndex)));
+ disconnect(d->model, SIGNAL(destroyed()), this,
+ SLOT(_q_modelDestroyed()));
+ }
+ clearMapping();
+ d->rootIndex = QModelIndex();
+ d->currentTopLeft = QModelIndex();
+
+ d->model = model;
+
+ connect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
+ SLOT(_q_dataChanged(QModelIndex,QModelIndex)));
+ connect(model, SIGNAL(destroyed()), SLOT(_q_modelDestroyed()));
+}
+
+/*!
+ Returns the current model.
+
+ \sa setModel()
+ */
+QAbstractItemModel *QDataWidgetMapper::model() const
+{
+ Q_D(const QDataWidgetMapper);
+ return d->model == QAbstractItemModelPrivate::staticEmptyModel()
+ ? static_cast<QAbstractItemModel *>(0)
+ : d->model;
+}
+
+/*!
+ Sets the item delegate to \a delegate. The delegate will be used to write
+ data from the model into the widget and from the widget to the model,
+ using QAbstractItemDelegate::setEditorData() and QAbstractItemDelegate::setModelData().
+
+ The delegate also decides when to apply data and when to change the editor,
+ using QAbstractItemDelegate::commitData() and QAbstractItemDelegate::closeEditor().
+
+ \warning You should not share the same instance of a delegate between widget mappers
+ or views. Doing so can cause incorrect or unintuitive editing behavior since each
+ view connected to a given delegate may receive the \l{QAbstractItemDelegate::}{closeEditor()}
+ signal, and attempt to access, modify or close an editor that has already been closed.
+ */
+void QDataWidgetMapper::setItemDelegate(QAbstractItemDelegate *delegate)
+{
+ Q_D(QDataWidgetMapper);
+ QAbstractItemDelegate *oldDelegate = d->delegate;
+ if (oldDelegate) {
+ disconnect(oldDelegate, SIGNAL(commitData(QWidget*)), this, SLOT(_q_commitData(QWidget*)));
+ disconnect(oldDelegate, SIGNAL(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)),
+ this, SLOT(_q_closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)));
+ }
+
+ d->delegate = delegate;
+
+ if (delegate) {
+ connect(delegate, SIGNAL(commitData(QWidget*)), SLOT(_q_commitData(QWidget*)));
+ connect(delegate, SIGNAL(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)),
+ SLOT(_q_closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)));
+ }
+
+ d->flipEventFilters(oldDelegate, delegate);
+}
+
+/*!
+ Returns the current item delegate.
+ */
+QAbstractItemDelegate *QDataWidgetMapper::itemDelegate() const
+{
+ Q_D(const QDataWidgetMapper);
+ return d->delegate;
+}
+
+/*!
+ Sets the root item to \a index. This can be used to display
+ a branch of a tree. Pass an invalid model index to display
+ the top-most branch.
+
+ \sa rootIndex()
+ */
+void QDataWidgetMapper::setRootIndex(const QModelIndex &index)
+{
+ Q_D(QDataWidgetMapper);
+ d->rootIndex = index;
+}
+
+/*!
+ Returns the current root index.
+
+ \sa setRootIndex()
+*/
+QModelIndex QDataWidgetMapper::rootIndex() const
+{
+ Q_D(const QDataWidgetMapper);
+ return QModelIndex(d->rootIndex);
+}
+
+/*!
+ Adds a mapping between a \a widget and a \a section from the model.
+ The \a section is a column in the model if the orientation is
+ horizontal (the default), otherwise a row.
+
+ For the following example, we assume a model \c myModel that
+ has two columns: the first one contains the names of people in a
+ group, and the second column contains their ages. The first column
+ is mapped to the QLineEdit \c nameLineEdit, and the second is
+ mapped to the QSpinBox \c{ageSpinBox}:
+
+ \snippet doc/src/snippets/code/src_gui_itemviews_qdatawidgetmapper.cpp 1
+
+ \bold{Notes:}
+ \list
+ \o If the \a widget is already mapped to a section, the
+ old mapping will be replaced by the new one.
+ \o Only one-to-one mappings between sections and widgets are allowed.
+ It is not possible to map a single section to multiple widgets, or to
+ map a single widget to multiple sections.
+ \endlist
+
+ \sa removeMapping(), mappedSection(), clearMapping()
+ */
+void QDataWidgetMapper::addMapping(QWidget *widget, int section)
+{
+ Q_D(QDataWidgetMapper);
+
+ removeMapping(widget);
+ d->widgetMap.append(QDataWidgetMapperPrivate::WidgetMapper(widget, section, d->indexAt(section)));
+ widget->installEventFilter(d->delegate);
+}
+
+/*!
+ \since 4.3
+
+ Essentially the same as addMapping(), but adds the possibility to specify
+ the property to use specifying \a propertyName.
+
+ \sa addMapping()
+*/
+
+void QDataWidgetMapper::addMapping(QWidget *widget, int section, const QByteArray &propertyName)
+{
+ Q_D(QDataWidgetMapper);
+
+ removeMapping(widget);
+ d->widgetMap.append(QDataWidgetMapperPrivate::WidgetMapper(widget, section, d->indexAt(section), propertyName));
+ widget->installEventFilter(d->delegate);
+}
+
+/*!
+ Removes the mapping for the given \a widget.
+
+ \sa addMapping(), clearMapping()
+ */
+void QDataWidgetMapper::removeMapping(QWidget *widget)
+{
+ Q_D(QDataWidgetMapper);
+
+ int idx = d->findWidget(widget);
+ if (idx == -1)
+ return;
+
+ d->widgetMap.removeAt(idx);
+ widget->removeEventFilter(d->delegate);
+}
+
+/*!
+ Returns the section the \a widget is mapped to or -1
+ if the widget is not mapped.
+
+ \sa addMapping(), removeMapping()
+ */
+int QDataWidgetMapper::mappedSection(QWidget *widget) const
+{
+ Q_D(const QDataWidgetMapper);
+
+ int idx = d->findWidget(widget);
+ if (idx == -1)
+ return -1;
+
+ return d->widgetMap.at(idx).section;
+}
+
+/*!
+ \since 4.3
+ Returns the name of the property that is used when mapping
+ data to the given \a widget.
+
+ \sa mappedSection(), addMapping(), removeMapping()
+*/
+
+QByteArray QDataWidgetMapper::mappedPropertyName(QWidget *widget) const
+{
+ Q_D(const QDataWidgetMapper);
+
+ int idx = d->findWidget(widget);
+ if (idx == -1)
+ return QByteArray();
+ const QDataWidgetMapperPrivate::WidgetMapper &m = d->widgetMap.at(idx);
+ if (m.property.isEmpty())
+ return m.widget->metaObject()->userProperty().name();
+ else
+ return m.property;
+}
+
+/*!
+ Returns the widget that is mapped at \a section, or
+ 0 if no widget is mapped at that section.
+
+ \sa addMapping(), removeMapping()
+ */
+QWidget *QDataWidgetMapper::mappedWidgetAt(int section) const
+{
+ Q_D(const QDataWidgetMapper);
+
+ for (int i = 0; i < d->widgetMap.count(); ++i) {
+ if (d->widgetMap.at(i).section == section)
+ return d->widgetMap.at(i).widget;
+ }
+
+ return 0;
+}
+
+/*!
+ Repopulates all widgets with the current data of the model.
+ All unsubmitted changes will be lost.
+
+ \sa submit(), setSubmitPolicy()
+ */
+void QDataWidgetMapper::revert()
+{
+ Q_D(QDataWidgetMapper);
+
+ d->populate();
+}
+
+/*!
+ Submits all changes from the mapped widgets to the model.
+
+ For every mapped section, the item delegate reads the current
+ value from the widget and sets it in the model. Finally, the
+ model's \l {QAbstractItemModel::}{submit()} method is invoked.
+
+ Returns true if all the values were submitted, otherwise false.
+
+ Note: For database models, QSqlQueryModel::lastError() can be
+ used to retrieve the last error.
+
+ \sa revert(), setSubmitPolicy()
+ */
+bool QDataWidgetMapper::submit()
+{
+ Q_D(QDataWidgetMapper);
+
+ for (int i = 0; i < d->widgetMap.count(); ++i) {
+ const QDataWidgetMapperPrivate::WidgetMapper &m = d->widgetMap.at(i);
+ if (!d->commit(m))
+ return false;
+ }
+
+ return d->model->submit();
+}
+
+/*!
+ Populates the widgets with data from the first row of the model
+ if the orientation is horizontal (the default), otherwise
+ with data from the first column.
+
+ This is equivalent to calling \c setCurrentIndex(0).
+
+ \sa toLast(), setCurrentIndex()
+ */
+void QDataWidgetMapper::toFirst()
+{
+ setCurrentIndex(0);
+}
+
+/*!
+ Populates the widgets with data from the last row of the model
+ if the orientation is horizontal (the default), otherwise
+ with data from the last column.
+
+ Calls setCurrentIndex() internally.
+
+ \sa toFirst(), setCurrentIndex()
+ */
+void QDataWidgetMapper::toLast()
+{
+ Q_D(QDataWidgetMapper);
+ setCurrentIndex(d->itemCount() - 1);
+}
+
+
+/*!
+ Populates the widgets with data from the next row of the model
+ if the orientation is horizontal (the default), otherwise
+ with data from the next column.
+
+ Calls setCurrentIndex() internally. Does nothing if there is
+ no next row in the model.
+
+ \sa toPrevious(), setCurrentIndex()
+ */
+void QDataWidgetMapper::toNext()
+{
+ Q_D(QDataWidgetMapper);
+ setCurrentIndex(d->currentIdx() + 1);
+}
+
+/*!
+ Populates the widgets with data from the previous row of the model
+ if the orientation is horizontal (the default), otherwise
+ with data from the previous column.
+
+ Calls setCurrentIndex() internally. Does nothing if there is
+ no previous row in the model.
+
+ \sa toNext(), setCurrentIndex()
+ */
+void QDataWidgetMapper::toPrevious()
+{
+ Q_D(QDataWidgetMapper);
+ setCurrentIndex(d->currentIdx() - 1);
+}
+
+/*!
+ \property QDataWidgetMapper::currentIndex
+ \brief the current row or column
+
+ The widgets are populated with with data from the row at \a index
+ if the orientation is horizontal (the default), otherwise with
+ data from the column at \a index.
+
+ \sa setCurrentModelIndex(), toFirst(), toNext(), toPrevious(), toLast()
+*/
+void QDataWidgetMapper::setCurrentIndex(int index)
+{
+ Q_D(QDataWidgetMapper);
+
+ if (index < 0 || index >= d->itemCount())
+ return;
+ d->currentTopLeft = d->orientation == Qt::Horizontal
+ ? d->model->index(index, 0, d->rootIndex)
+ : d->model->index(0, index, d->rootIndex);
+ d->populate();
+
+ emit currentIndexChanged(index);
+}
+
+int QDataWidgetMapper::currentIndex() const
+{
+ Q_D(const QDataWidgetMapper);
+ return d->currentIdx();
+}
+
+/*!
+ Sets the current index to the row of the \a index if the
+ orientation is horizontal (the default), otherwise to the
+ column of the \a index.
+
+ Calls setCurrentIndex() internally. This convenience slot can be
+ connected to the signal \l
+ {QItemSelectionModel::}{currentRowChanged()} or \l
+ {QItemSelectionModel::}{currentColumnChanged()} of another view's
+ \l {QItemSelectionModel}{selection model}.
+
+ The following example illustrates how to update all widgets
+ with new data whenever the selection of a QTableView named
+ \c myTableView changes:
+
+ \snippet doc/src/snippets/code/src_gui_itemviews_qdatawidgetmapper.cpp 2
+
+ \sa currentIndex()
+*/
+void QDataWidgetMapper::setCurrentModelIndex(const QModelIndex &index)
+{
+ Q_D(QDataWidgetMapper);
+
+ if (!index.isValid()
+ || index.model() != d->model
+ || index.parent() != d->rootIndex)
+ return;
+
+ setCurrentIndex(d->orientation == Qt::Horizontal ? index.row() : index.column());
+}
+
+/*!
+ Clears all mappings.
+
+ \sa addMapping(), removeMapping()
+ */
+void QDataWidgetMapper::clearMapping()
+{
+ Q_D(QDataWidgetMapper);
+
+ while (!d->widgetMap.isEmpty()) {
+ QWidget *w = d->widgetMap.takeLast().widget;
+ if (w)
+ w->removeEventFilter(d->delegate);
+ }
+}
+
+/*!
+ \property QDataWidgetMapper::orientation
+ \brief the orientation of the model
+
+ If the orientation is Qt::Horizontal (the default), a widget is
+ mapped to a column of a data model. The widget will be populated
+ with the model's data from its mapped column and the row that
+ currentIndex() points at.
+
+ Use Qt::Horizontal for tabular data that looks like this:
+
+ \table
+ \row \o 1 \o Qt Norway \o Oslo
+ \row \o 2 \o Qt Australia \o Brisbane
+ \row \o 3 \o Qt USA \o Silicon Valley
+ \row \o 4 \o Qt China \o Beijing
+ \row \o 5 \o Qt Germany \o Berlin
+ \endtable
+
+ If the orientation is set to Qt::Vertical, a widget is mapped to
+ a row. Calling setCurrentIndex() will change the current column.
+ The widget will be populates with the model's data from its
+ mapped row and the column that currentIndex() points at.
+
+ Use Qt::Vertical for tabular data that looks like this:
+
+ \table
+ \row \o 1 \o 2 \o 3 \o 4 \o 5
+ \row \o Qt Norway \o Qt Australia \o Qt USA \o Qt China \o Qt Germany
+ \row \o Oslo \o Brisbane \o Silicon Valley \o Beijing \i Berlin
+ \endtable
+
+ Changing the orientation clears all existing mappings.
+*/
+void QDataWidgetMapper::setOrientation(Qt::Orientation orientation)
+{
+ Q_D(QDataWidgetMapper);
+
+ if (d->orientation == orientation)
+ return;
+
+ clearMapping();
+ d->orientation = orientation;
+}
+
+Qt::Orientation QDataWidgetMapper::orientation() const
+{
+ Q_D(const QDataWidgetMapper);
+ return d->orientation;
+}
+
+/*!
+ \property QDataWidgetMapper::submitPolicy
+ \brief the current submit policy
+
+ Changing the current submit policy will revert all widgets
+ to the current data from the model.
+*/
+void QDataWidgetMapper::setSubmitPolicy(SubmitPolicy policy)
+{
+ Q_D(QDataWidgetMapper);
+ if (policy == d->submitPolicy)
+ return;
+
+ revert();
+ d->submitPolicy = policy;
+}
+
+QDataWidgetMapper::SubmitPolicy QDataWidgetMapper::submitPolicy() const
+{
+ Q_D(const QDataWidgetMapper);
+ return d->submitPolicy;
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qdatawidgetmapper.cpp"
+
+#endif // QT_NO_DATAWIDGETMAPPER