--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gui/itemviews/qabstractitemview.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,4068 @@
+/****************************************************************************
+**
+** 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 "qabstractitemview.h"
+
+#ifndef QT_NO_ITEMVIEWS
+#include <qpointer.h>
+#include <qapplication.h>
+#include <qclipboard.h>
+#include <qpainter.h>
+#include <qstyle.h>
+#include <qdrag.h>
+#include <qevent.h>
+#include <qscrollbar.h>
+#include <qwhatsthis.h>
+#include <qtooltip.h>
+#include <qdatetime.h>
+#include <qlineedit.h>
+#include <qspinbox.h>
+#include <qstyleditemdelegate.h>
+#include <private/qabstractitemview_p.h>
+#include <private/qabstractitemmodel_p.h>
+#ifndef QT_NO_ACCESSIBILITY
+#include <qaccessible.h>
+#endif
+#include <private/qsoftkeymanager_p.h>
+
+QT_BEGIN_NAMESPACE
+
+QAbstractItemViewPrivate::QAbstractItemViewPrivate()
+ : model(QAbstractItemModelPrivate::staticEmptyModel()),
+ itemDelegate(0),
+ selectionModel(0),
+ ctrlDragSelectionFlag(QItemSelectionModel::NoUpdate),
+ selectionMode(QAbstractItemView::ExtendedSelection),
+ selectionBehavior(QAbstractItemView::SelectItems),
+ currentlyCommittingEditor(0),
+ pressedModifiers(Qt::NoModifier),
+ pressedPosition(QPoint(-1, -1)),
+ pressedAlreadySelected(false),
+ viewportEnteredNeeded(false),
+ state(QAbstractItemView::NoState),
+ editTriggers(QAbstractItemView::DoubleClicked|QAbstractItemView::EditKeyPressed),
+ lastTrigger(QAbstractItemView::NoEditTriggers),
+ tabKeyNavigation(false),
+#ifndef QT_NO_DRAGANDDROP
+ showDropIndicator(true),
+ dragEnabled(false),
+ dragDropMode(QAbstractItemView::NoDragDrop),
+ overwrite(false),
+ dropIndicatorPosition(QAbstractItemView::OnItem),
+ defaultDropAction(Qt::IgnoreAction),
+#endif
+#ifdef QT_SOFTKEYS_ENABLED
+ doneSoftKey(0),
+#endif
+ autoScroll(true),
+ autoScrollMargin(16),
+ autoScrollCount(0),
+ shouldScrollToCurrentOnShow(false),
+ alternatingColors(false),
+ textElideMode(Qt::ElideRight),
+ verticalScrollMode(QAbstractItemView::ScrollPerItem),
+ horizontalScrollMode(QAbstractItemView::ScrollPerItem),
+ currentIndexSet(false),
+ wrapItemText(false),
+ delayedPendingLayout(false)
+{
+}
+
+QAbstractItemViewPrivate::~QAbstractItemViewPrivate()
+{
+}
+
+void QAbstractItemViewPrivate::init()
+{
+ Q_Q(QAbstractItemView);
+ q->setItemDelegate(new QStyledItemDelegate(q));
+
+ vbar->setRange(0, 0);
+ hbar->setRange(0, 0);
+
+ QObject::connect(vbar, SIGNAL(actionTriggered(int)),
+ q, SLOT(verticalScrollbarAction(int)));
+ QObject::connect(hbar, SIGNAL(actionTriggered(int)),
+ q, SLOT(horizontalScrollbarAction(int)));
+ QObject::connect(vbar, SIGNAL(valueChanged(int)),
+ q, SLOT(verticalScrollbarValueChanged(int)));
+ QObject::connect(hbar, SIGNAL(valueChanged(int)),
+ q, SLOT(horizontalScrollbarValueChanged(int)));
+
+ viewport->setBackgroundRole(QPalette::Base);
+
+ doDelayedItemsLayout();
+
+ q->setAttribute(Qt::WA_InputMethodEnabled);
+
+#ifdef QT_SOFTKEYS_ENABLED
+ doneSoftKey = QSoftKeyManager::createKeyedAction(QSoftKeyManager::DoneSoftKey, Qt::Key_Back, q);
+#endif
+}
+
+void QAbstractItemViewPrivate::checkMouseMove(const QPersistentModelIndex &index)
+{
+ //we take a persistent model index because the model might change by emitting signals
+ Q_Q(QAbstractItemView);
+ if (viewportEnteredNeeded || enteredIndex != index) {
+ viewportEnteredNeeded = false;
+
+ if (index.isValid()) {
+ emit q->entered(index);
+#ifndef QT_NO_STATUSTIP
+ QString statustip = model->data(index, Qt::StatusTipRole).toString();
+ if (parent && !statustip.isEmpty()) {
+ QStatusTipEvent tip(statustip);
+ QApplication::sendEvent(parent, &tip);
+ }
+#endif
+ } else {
+#ifndef QT_NO_STATUSTIP
+ if (parent) {
+ QString emptyString;
+ QStatusTipEvent tip( emptyString );
+ QApplication::sendEvent(parent, &tip);
+ }
+#endif
+ emit q->viewportEntered();
+ }
+ enteredIndex = index;
+ }
+}
+
+
+/*!
+ \class QAbstractItemView
+
+ \brief The QAbstractItemView class provides the basic functionality for
+ item view classes.
+
+ \ingroup model-view
+
+
+ QAbstractItemView class is the base class for every standard view
+ that uses a QAbstractItemModel. QAbstractItemView is an abstract
+ class and cannot itself be instantiated. It provides a standard
+ interface for interoperating with models through the signals and
+ slots mechanism, enabling subclasses to be kept up-to-date with
+ changes to their models. This class provides standard support for
+ keyboard and mouse navigation, viewport scrolling, item editing,
+ and selections. The keyboard navigation implements this
+ functionality:
+
+ \table
+ \header
+ \o Keys
+ \o Functionality
+ \row
+ \o Arrow keys
+ \o Changes the current item and selects it.
+ \row
+ \o Ctrl+Arrow keys
+ \o Changes the current item but does not select it.
+ \row
+ \o Shift+Arrow keys
+ \o Changes the current item and selects it. The previously
+ selected item(s) is not deselected.
+ \row
+ \o Ctr+Space
+ \o Toggles selection of the current item.
+ \row
+ \o Tab/Backtab
+ \o Changes the current item to the next/previous item.
+ \row
+ \o Home/End
+ \o Selects the first/last item in the model.
+ \row
+ \o Page up/Page down
+ \o Scrolls the rows shown up/down by the number of
+ visible rows in the view.
+ \row
+ \o Ctrl+A
+ \o Selects all items in the model.
+ \endtable
+
+ Note that the above table assumes that the
+ \l{selectionMode}{selection mode} allows the operations. For
+ instance, you cannot select items if the selection mode is
+ QAbstractItemView::NoSelection.
+
+ The QAbstractItemView class is one of the \l{Model/View Classes}
+ and is part of Qt's \l{Model/View Programming}{model/view framework}.
+
+ The view classes that inherit QAbstractItemView only need
+ to implement their own view-specific functionality, such as
+ drawing items, returning the geometry of items, finding items,
+ etc.
+
+ QAbstractItemView provides common slots such as edit() and
+ setCurrentIndex(). Many protected slots are also provided, including
+ dataChanged(), rowsInserted(), rowsAboutToBeRemoved(), selectionChanged(),
+ and currentChanged().
+
+ The root item is returned by rootIndex(), and the current item by
+ currentIndex(). To make sure that an item is visible use
+ scrollTo().
+
+ Some of QAbstractItemView's functions are concerned with
+ scrolling, for example setHorizontalScrollMode() and
+ setVerticalScrollMode(). To set the range of the scroll bars, you
+ can, for example, reimplement the view's resizeEvent() function:
+
+ \snippet doc/src/snippets/code/src_gui_itemviews_qabstractitemview.cpp 0
+
+ Note that the range is not updated until the widget is shown.
+
+ Several other functions are concerned with selection control; for
+ example setSelectionMode(), and setSelectionBehavior(). This class
+ provides a default selection model to work with
+ (selectionModel()), but this can be replaced by using
+ setSelectionModel() with an instance of QItemSelectionModel.
+
+ For complete control over the display and editing of items you can
+ specify a delegate with setItemDelegate().
+
+ QAbstractItemView provides a lot of protected functions. Some are
+ concerned with editing, for example, edit(), and commitData(),
+ whilst others are keyboard and mouse event handlers.
+
+ \note If you inherit QAbstractItemView and intend to update the contents
+ of the viewport, you should use viewport->update() instead of
+ \l{QWidget::update()}{update()} as all painting operations take place on the
+ viewport.
+
+ \sa {View Classes}, {Model/View Programming}, QAbstractItemModel, {Chart Example}
+*/
+
+/*!
+ \enum QAbstractItemView::SelectionMode
+
+ This enum indicates how the view responds to user selections:
+
+ \value SingleSelection When the user selects an item, any already-selected
+ item becomes unselected, and the user cannot unselect the selected item by
+ clicking on it.
+
+ \value ContiguousSelection When the user selects an item in the usual way,
+ the selection is cleared and the new item selected. However, if the user
+ presses the Shift key while clicking on an item, all items between the
+ current item and the clicked item are selected or unselected, depending on
+ the state of the clicked item.
+
+ \value ExtendedSelection When the user selects an item in the usual way,
+ the selection is cleared and the new item selected. However, if the user
+ presses the Ctrl key when clicking on an item, the clicked item gets
+ toggled and all other items are left untouched. If the user presses the
+ Shift key while clicking on an item, all items between the current item
+ and the clicked item are selected or unselected, depending on the state of
+ the clicked item. Multiple items can be selected by dragging the mouse over
+ them.
+
+ \value MultiSelection When the user selects an item in the usual way, the
+ selection status of that item is toggled and the other items are left
+ alone. Multiple items can be toggled by dragging the mouse over them.
+
+ \value NoSelection Items cannot be selected.
+
+ The most commonly used modes are SingleSelection and ExtendedSelection.
+*/
+
+/*!
+ \enum QAbstractItemView::SelectionBehavior
+
+ \value SelectItems Selecting single items.
+ \value SelectRows Selecting only rows.
+ \value SelectColumns Selecting only columns.
+*/
+
+/*!
+ \enum QAbstractItemView::ScrollHint
+
+ \value EnsureVisible Scroll to ensure that the item is visible.
+ \value PositionAtTop Scroll to position the item at the top of the
+ viewport.
+ \value PositionAtBottom Scroll to position the item at the bottom of the
+ viewport.
+ \value PositionAtCenter Scroll to position the item at the center of the
+ viewport.
+*/
+
+
+/*!
+ \enum QAbstractItemView::EditTrigger
+
+ This enum describes actions which will initiate item editing.
+
+ \value NoEditTriggers No editing possible.
+ \value CurrentChanged Editing start whenever current item changes.
+ \value DoubleClicked Editing starts when an item is double clicked.
+ \value SelectedClicked Editing starts when clicking on an already selected
+ item.
+ \value EditKeyPressed Editing starts when the platform edit key has been
+ pressed over an item.
+ \value AnyKeyPressed Editing starts when any key is pressed over an item.
+ \value AllEditTriggers Editing starts for all above actions.
+*/
+
+/*!
+ \enum QAbstractItemView::CursorAction
+
+ This enum describes the different ways to navigate between items,
+ \sa moveCursor()
+
+ \value MoveUp Move to the item above the current item.
+ \value MoveDown Move to the item below the current item.
+ \value MoveLeft Move to the item left of the current item.
+ \value MoveRight Move to the item right of the current item.
+ \value MoveHome Move to the top-left corner item.
+ \value MoveEnd Move to the bottom-right corner item.
+ \value MovePageUp Move one page up above the current item.
+ \value MovePageDown Move one page down below the current item.
+ \value MoveNext Move to the item after the current item.
+ \value MovePrevious Move to the item before the current item.
+*/
+
+/*!
+ \enum QAbstractItemView::State
+
+ Describes the different states the view can be in. This is usually
+ only interesting when reimplementing your own view.
+
+ \value NoState The is the default state.
+ \value DraggingState The user is dragging items.
+ \value DragSelectingState The user is selecting items.
+ \value EditingState The user is editing an item in a widget editor.
+ \value ExpandingState The user is opening a branch of items.
+ \value CollapsingState The user is closing a branch of items.
+ \value AnimatingState The item view is performing an animation.
+*/
+
+/*!
+ \since 4.2
+ \enum QAbstractItemView::ScrollMode
+
+ \value ScrollPerItem The view will scroll the contents one item at a time.
+ \value ScrollPerPixel The view will scroll the contents one pixel at a time.
+*/
+
+/*!
+ \fn QRect QAbstractItemView::visualRect(const QModelIndex &index) const = 0
+ Returns the rectangle on the viewport occupied by the item at \a index.
+
+ If your item is displayed in several areas then visualRect should return
+ the primary area that contains index and not the complete area that index
+ might encompasses, touch or cause drawing.
+
+ In the base class this is a pure virtual function.
+
+ \sa indexAt(), visualRegionForSelection()
+*/
+
+/*!
+ \fn void QAbstractItemView::scrollTo(const QModelIndex &index, ScrollHint hint) = 0
+
+ Scrolls the view if necessary to ensure that the item at \a index
+ is visible. The view will try to position the item according to the given \a hint.
+
+ In the base class this is a pure virtual function.
+*/
+
+/*!
+ \fn QModelIndex QAbstractItemView::indexAt(const QPoint &point) const = 0
+
+ Returns the model index of the item at the viewport coordinates \a point.
+
+ In the base class this is a pure virtual function.
+
+ \sa visualRect()
+*/
+
+/*!
+ \fn void QAbstractItemView::activated(const QModelIndex &index)
+
+ This signal is emitted when the item specified by \a index is
+ activated by the user. How to activate items depends on the
+ platform; e.g., by single- or double-clicking the item, or by
+ pressing the Return or Enter key when the item is current.
+
+ \sa clicked(), doubleClicked(), entered(), pressed()
+*/
+
+/*!
+ \fn void QAbstractItemView::entered(const QModelIndex &index)
+
+ This signal is emitted when the mouse cursor enters the item
+ specified by \a index.
+ Mouse tracking needs to be enabled for this feature to work.
+
+ \sa viewportEntered(), activated(), clicked(), doubleClicked(), pressed()
+*/
+
+/*!
+ \fn void QAbstractItemView::viewportEntered()
+
+ This signal is emitted when the mouse cursor enters the viewport.
+ Mouse tracking needs to be enabled for this feature to work.
+
+ \sa entered()
+*/
+
+/*!
+ \fn void QAbstractItemView::pressed(const QModelIndex &index)
+
+ This signal is emitted when a mouse button is pressed. The item
+ the mouse was pressed on is specified by \a index. The signal is
+ only emitted when the index is valid.
+
+ Use the QApplication::mouseButtons() function to get the state
+ of the mouse buttons.
+
+ \sa activated(), clicked(), doubleClicked(), entered()
+*/
+
+/*!
+ \fn void QAbstractItemView::clicked(const QModelIndex &index)
+
+ This signal is emitted when a mouse button is clicked. The item
+ the mouse was clicked on is specified by \a index. The signal is
+ only emitted when the index is valid.
+
+ \sa activated(), doubleClicked(), entered(), pressed()
+*/
+
+/*!
+ \fn void QAbstractItemView::doubleClicked(const QModelIndex &index)
+
+ This signal is emitted when a mouse button is double-clicked. The
+ item the mouse was double-clicked on is specified by \a index.
+ The signal is only emitted when the index is valid.
+
+ \sa clicked(), activated()
+*/
+
+/*!
+ \fn QModelIndex QAbstractItemView::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers) = 0
+
+ Returns a QModelIndex object pointing to the next object in the view,
+ based on the given \a cursorAction and keyboard modifiers specified
+ by \a modifiers.
+
+ In the base class this is a pure virtual function.
+*/
+
+/*!
+ \fn int QAbstractItemView::horizontalOffset() const = 0
+
+ Returns the horizontal offset of the view.
+
+ In the base class this is a pure virtual function.
+
+ \sa verticalOffset()
+*/
+
+/*!
+ \fn int QAbstractItemView::verticalOffset() const = 0
+
+ Returns the vertical offset of the view.
+
+ In the base class this is a pure virtual function.
+
+ \sa horizontalOffset()
+*/
+
+/*!
+ \fn bool QAbstractItemView::isIndexHidden(const QModelIndex &index) const
+
+ Returns true if the item referred to by the given \a index is hidden in the view,
+ otherwise returns false.
+
+ Hiding is a view specific feature. For example in TableView a column can be marked
+ as hidden or a row in the TreeView.
+
+ In the base class this is a pure virtual function.
+*/
+
+/*!
+ \fn void QAbstractItemView::setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags flags)
+
+ Applies the selection \a flags to the items in or touched by the
+ rectangle, \a rect.
+
+ When implementing your own itemview setSelection should call
+ selectionModel()->select(selection, flags) where selection
+ is either an empty QModelIndex or a QItemSelection that contains
+ all items that are contained in \a rect.
+
+ \sa selectionCommand(), selectedIndexes()
+*/
+
+/*!
+ \fn QRegion QAbstractItemView::visualRegionForSelection(const QItemSelection &selection) const = 0
+
+ Returns the region from the viewport of the items in the given
+ \a selection.
+
+ In the base class this is a pure virtual function.
+
+ \sa visualRect(), selectedIndexes()
+*/
+
+/*!
+ \fn void QAbstractItemView::update()
+ \internal
+*/
+
+/*!
+ Constructs an abstract item view with the given \a parent.
+*/
+QAbstractItemView::QAbstractItemView(QWidget *parent)
+ : QAbstractScrollArea(*(new QAbstractItemViewPrivate), parent)
+{
+ d_func()->init();
+}
+
+/*!
+ \internal
+*/
+QAbstractItemView::QAbstractItemView(QAbstractItemViewPrivate &dd, QWidget *parent)
+ : QAbstractScrollArea(dd, parent)
+{
+ d_func()->init();
+}
+
+/*!
+ Destroys the view.
+*/
+QAbstractItemView::~QAbstractItemView()
+{
+}
+
+/*!
+ Sets the \a model for the view to present.
+
+ This function will create and set a new selection model, replacing any
+ model that was previously set with setSelectionModel(). However, the old
+ selection model will not be deleted as it may be shared between several
+ views. We recommend that you delete the old selection model if it is no
+ longer required. This is done with the following code:
+
+ \snippet doc/src/snippets/code/src_gui_itemviews_qabstractitemview.cpp 2
+
+ If both the old model and the old selection model do not have parents, or
+ if their parents are long-lived objects, it may be preferable to call their
+ deleteLater() functions to explicitly delete them.
+
+ The view \e{does not} take ownership of the model unless it is the model's
+ parent object because the view may be shared between many different views.
+
+ \sa selectionModel(), setSelectionModel()
+*/
+void QAbstractItemView::setModel(QAbstractItemModel *model)
+{
+ Q_D(QAbstractItemView);
+ if (model == d->model)
+ return;
+ if (d->model && d->model != QAbstractItemModelPrivate::staticEmptyModel()) {
+ disconnect(d->model, SIGNAL(destroyed()),
+ this, SLOT(_q_modelDestroyed()));
+ disconnect(d->model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
+ this, SLOT(dataChanged(QModelIndex,QModelIndex)));
+ disconnect(d->model, SIGNAL(rowsInserted(QModelIndex,int,int)),
+ this, SLOT(rowsInserted(QModelIndex,int,int)));
+ disconnect(d->model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
+ this, SLOT(rowsAboutToBeRemoved(QModelIndex,int,int)));
+ disconnect(d->model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
+ this, SLOT(_q_rowsRemoved(QModelIndex,int,int)));
+ disconnect(d->model, SIGNAL(columnsAboutToBeRemoved(QModelIndex,int,int)),
+ this, SLOT(_q_columnsAboutToBeRemoved(QModelIndex,int,int)));
+ disconnect(d->model, SIGNAL(columnsRemoved(QModelIndex,int,int)),
+ this, SLOT(_q_columnsRemoved(QModelIndex,int,int)));
+ disconnect(d->model, SIGNAL(columnsInserted(QModelIndex,int,int)),
+ this, SLOT(_q_columnsInserted(QModelIndex,int,int)));
+
+ disconnect(d->model, SIGNAL(modelReset()), this, SLOT(reset()));
+ disconnect(d->model, SIGNAL(layoutChanged()), this, SLOT(_q_layoutChanged()));
+ }
+ d->model = (model ? model : QAbstractItemModelPrivate::staticEmptyModel());
+
+ // These asserts do basic sanity checking of the model
+ Q_ASSERT_X(d->model->index(0,0) == d->model->index(0,0),
+ "QAbstractItemView::setModel",
+ "A model should return the exact same index "
+ "(including its internal id/pointer) when asked for it twice in a row.");
+ Q_ASSERT_X(d->model->index(0,0).parent() == QModelIndex(),
+ "QAbstractItemView::setModel",
+ "The parent of a top level index should be invalid");
+
+ if (d->model != QAbstractItemModelPrivate::staticEmptyModel()) {
+ connect(d->model, SIGNAL(destroyed()),
+ this, SLOT(_q_modelDestroyed()));
+ connect(d->model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
+ this, SLOT(dataChanged(QModelIndex,QModelIndex)));
+ connect(d->model, SIGNAL(rowsInserted(QModelIndex,int,int)),
+ this, SLOT(rowsInserted(QModelIndex,int,int)));
+ connect(d->model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
+ this, SLOT(rowsAboutToBeRemoved(QModelIndex,int,int)));
+ connect(d->model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
+ this, SLOT(_q_rowsRemoved(QModelIndex,int,int)));
+ connect(d->model, SIGNAL(columnsAboutToBeRemoved(QModelIndex,int,int)),
+ this, SLOT(_q_columnsAboutToBeRemoved(QModelIndex,int,int)));
+ connect(d->model, SIGNAL(columnsRemoved(QModelIndex,int,int)),
+ this, SLOT(_q_columnsRemoved(QModelIndex,int,int)));
+ connect(d->model, SIGNAL(columnsInserted(QModelIndex,int,int)),
+ this, SLOT(_q_columnsInserted(QModelIndex,int,int)));
+
+ connect(d->model, SIGNAL(modelReset()), this, SLOT(reset()));
+ connect(d->model, SIGNAL(layoutChanged()), this, SLOT(_q_layoutChanged()));
+ }
+ setSelectionModel(new QItemSelectionModel(d->model, this));
+ reset(); // kill editors, set new root and do layout
+}
+
+/*!
+ Returns the model that this view is presenting.
+*/
+QAbstractItemModel *QAbstractItemView::model() const
+{
+ Q_D(const QAbstractItemView);
+ return (d->model == QAbstractItemModelPrivate::staticEmptyModel() ? 0 : d->model);
+}
+
+/*!
+ Sets the current selection model to the given \a selectionModel.
+
+ Note that, if you call setModel() after this function, the given \a selectionModel
+ will be replaced by one created by the view.
+
+ \note It is up to the application to delete the old selection model if it is no
+ longer needed; i.e., if it is not being used by other views. This will happen
+ automatically when its parent object is deleted. However, if it does not have a
+ parent, or if the parent is a long-lived object, it may be preferable to call its
+ deleteLater() function to explicitly delete it.
+
+ \sa selectionModel(), setModel(), clearSelection()
+*/
+void QAbstractItemView::setSelectionModel(QItemSelectionModel *selectionModel)
+{
+ // ### if the given model is null, we should use the original selection model
+ Q_ASSERT(selectionModel);
+ Q_D(QAbstractItemView);
+
+ if (selectionModel->model() != d->model) {
+ qWarning("QAbstractItemView::setSelectionModel() failed: "
+ "Trying to set a selection model, which works on "
+ "a different model than the view.");
+ return;
+ }
+
+ if (d->selectionModel) {
+ disconnect(d->selectionModel, SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
+ this, SLOT(selectionChanged(QItemSelection,QItemSelection)));
+ disconnect(d->selectionModel, SIGNAL(currentChanged(QModelIndex,QModelIndex)),
+ this, SLOT(currentChanged(QModelIndex,QModelIndex)));
+ }
+
+ d->selectionModel = selectionModel;
+
+ if (d->selectionModel) {
+ connect(d->selectionModel, SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
+ this, SLOT(selectionChanged(QItemSelection,QItemSelection)));
+ connect(d->selectionModel, SIGNAL(currentChanged(QModelIndex,QModelIndex)),
+ this, SLOT(currentChanged(QModelIndex,QModelIndex)));
+ }
+}
+
+/*!
+ Returns the current selection model.
+
+ \sa setSelectionModel(), selectedIndexes()
+*/
+QItemSelectionModel* QAbstractItemView::selectionModel() const
+{
+ Q_D(const QAbstractItemView);
+ return d->selectionModel;
+}
+
+/*!
+ Sets the item delegate for this view and its model to \a delegate.
+ This is useful if you want complete control over the editing and
+ display of items.
+
+ Any existing delegate will be removed, but not deleted. QAbstractItemView
+ does not take ownership of \a delegate.
+
+ \warning You should not share the same instance of a delegate between 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.
+
+ \sa itemDelegate()
+*/
+void QAbstractItemView::setItemDelegate(QAbstractItemDelegate *delegate)
+{
+ Q_D(QAbstractItemView);
+ if (delegate == d->itemDelegate)
+ return;
+
+ if (d->itemDelegate) {
+ if (d->delegateRefCount(d->itemDelegate) == 1) {
+ disconnect(d->itemDelegate, SIGNAL(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)),
+ this, SLOT(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)));
+ disconnect(d->itemDelegate, SIGNAL(commitData(QWidget*)), this, SLOT(commitData(QWidget*)));
+ disconnect(d->itemDelegate, SIGNAL(sizeHintChanged(QModelIndex)), this, SLOT(doItemsLayout()));
+ }
+ }
+
+ if (delegate) {
+ if (d->delegateRefCount(delegate) == 0) {
+ connect(delegate, SIGNAL(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)),
+ this, SLOT(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)));
+ connect(delegate, SIGNAL(commitData(QWidget*)), this, SLOT(commitData(QWidget*)));
+ qRegisterMetaType<QModelIndex>("QModelIndex");
+ connect(delegate, SIGNAL(sizeHintChanged(QModelIndex)), this, SLOT(doItemsLayout()), Qt::QueuedConnection);
+ }
+ }
+ d->itemDelegate = delegate;
+ viewport()->update();
+}
+
+/*!
+ Returns the item delegate used by this view and model. This is
+ either one set with setItemDelegate(), or the default one.
+
+ \sa setItemDelegate()
+*/
+QAbstractItemDelegate *QAbstractItemView::itemDelegate() const
+{
+ return d_func()->itemDelegate;
+}
+
+/*!
+ \reimp
+*/
+QVariant QAbstractItemView::inputMethodQuery(Qt::InputMethodQuery query) const
+{
+ const QModelIndex current = currentIndex();
+ if (!current.isValid() || query != Qt::ImMicroFocus)
+ return QAbstractScrollArea::inputMethodQuery(query);
+ return visualRect(current);
+}
+
+/*!
+ \since 4.2
+
+ Sets the given item \a delegate used by this view and model for the given
+ \a row. All items on \a row will be drawn and managed by \a delegate
+ instead of using the default delegate (i.e., itemDelegate()).
+
+ Any existing row delegate for \a row will be removed, but not
+ deleted. QAbstractItemView does not take ownership of \a delegate.
+
+ \note If a delegate has been assigned to both a row and a column, the row
+ delegate (i.e., this delegate) will take presedence and manage the
+ intersecting cell index.
+
+ \warning You should not share the same instance of a delegate between 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.
+
+ \sa itemDelegateForRow(), setItemDelegateForColumn(), itemDelegate()
+*/
+void QAbstractItemView::setItemDelegateForRow(int row, QAbstractItemDelegate *delegate)
+{
+ Q_D(QAbstractItemView);
+ if (QAbstractItemDelegate *rowDelegate = d->rowDelegates.value(row, 0)) {
+ if (d->delegateRefCount(rowDelegate) == 1) {
+ disconnect(rowDelegate, SIGNAL(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)),
+ this, SLOT(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)));
+ disconnect(rowDelegate, SIGNAL(commitData(QWidget*)), this, SLOT(commitData(QWidget*)));
+ }
+ d->rowDelegates.remove(row);
+ }
+ if (delegate) {
+ if (d->delegateRefCount(delegate) == 0) {
+ connect(delegate, SIGNAL(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)),
+ this, SLOT(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)));
+ connect(delegate, SIGNAL(commitData(QWidget*)), this, SLOT(commitData(QWidget*)));
+ }
+ d->rowDelegates.insert(row, delegate);
+ }
+ viewport()->update();
+}
+
+/*!
+ \since 4.2
+
+ Returns the item delegate used by this view and model for the given \a row,
+ or 0 if no delegate has been assigned. You can call itemDelegate() to get a
+ pointer to the current delegate for a given index.
+
+ \sa setItemDelegateForRow(), itemDelegateForColumn(), setItemDelegate()
+*/
+QAbstractItemDelegate *QAbstractItemView::itemDelegateForRow(int row) const
+{
+ Q_D(const QAbstractItemView);
+ return d->rowDelegates.value(row, 0);
+}
+
+/*!
+ \since 4.2
+
+ Sets the given item \a delegate used by this view and model for the given
+ \a column. All items on \a column will be drawn and managed by \a delegate
+ instead of using the default delegate (i.e., itemDelegate()).
+
+ Any existing column delegate for \a column will be removed, but not
+ deleted. QAbstractItemView does not take ownership of \a delegate.
+
+ \note If a delegate has been assigned to both a row and a column, the row
+ delegate will take presedence and manage the intersecting cell index.
+
+ \warning You should not share the same instance of a delegate between 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.
+
+ \sa itemDelegateForColumn(), setItemDelegateForRow(), itemDelegate()
+*/
+void QAbstractItemView::setItemDelegateForColumn(int column, QAbstractItemDelegate *delegate)
+{
+ Q_D(QAbstractItemView);
+ if (QAbstractItemDelegate *columnDelegate = d->columnDelegates.value(column, 0)) {
+ if (d->delegateRefCount(columnDelegate) == 1) {
+ disconnect(columnDelegate, SIGNAL(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)),
+ this, SLOT(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)));
+ disconnect(columnDelegate, SIGNAL(commitData(QWidget*)), this, SLOT(commitData(QWidget*)));
+ }
+ d->columnDelegates.remove(column);
+ }
+ if (delegate) {
+ if (d->delegateRefCount(delegate) == 0) {
+ connect(delegate, SIGNAL(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)),
+ this, SLOT(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)));
+ connect(delegate, SIGNAL(commitData(QWidget*)), this, SLOT(commitData(QWidget*)));
+ }
+ d->columnDelegates.insert(column, delegate);
+ }
+ viewport()->update();
+}
+
+/*!
+ \since 4.2
+
+ Returns the item delegate used by this view and model for the given \a
+ column. You can call itemDelegate() to get a pointer to the current delegate
+ for a given index.
+
+ \sa setItemDelegateForColumn(), itemDelegateForRow(), itemDelegate()
+*/
+QAbstractItemDelegate *QAbstractItemView::itemDelegateForColumn(int column) const
+{
+ Q_D(const QAbstractItemView);
+ return d->columnDelegates.value(column, 0);
+}
+
+/*!
+ Returns the item delegate used by this view and model for
+ the given \a index.
+*/
+QAbstractItemDelegate *QAbstractItemView::itemDelegate(const QModelIndex &index) const
+{
+ Q_D(const QAbstractItemView);
+ return d->delegateForIndex(index);
+}
+
+/*!
+ \property QAbstractItemView::selectionMode
+ \brief which selection mode the view operates in
+
+ This property controls whether the user can select one or many items
+ and, in many-item selections, whether the selection must be a
+ continuous range of items.
+
+ \sa SelectionMode SelectionBehavior
+*/
+void QAbstractItemView::setSelectionMode(SelectionMode mode)
+{
+ Q_D(QAbstractItemView);
+ d->selectionMode = mode;
+}
+
+QAbstractItemView::SelectionMode QAbstractItemView::selectionMode() const
+{
+ Q_D(const QAbstractItemView);
+ return d->selectionMode;
+}
+
+/*!
+ \property QAbstractItemView::selectionBehavior
+ \brief which selection behavior the view uses
+
+ This property holds whether selections are done
+ in terms of single items, rows or columns.
+
+ \sa SelectionMode SelectionBehavior
+*/
+
+void QAbstractItemView::setSelectionBehavior(QAbstractItemView::SelectionBehavior behavior)
+{
+ Q_D(QAbstractItemView);
+ d->selectionBehavior = behavior;
+}
+
+QAbstractItemView::SelectionBehavior QAbstractItemView::selectionBehavior() const
+{
+ Q_D(const QAbstractItemView);
+ return d->selectionBehavior;
+}
+
+/*!
+ Sets the current item to be the item at \a index.
+
+ Unless the current selection mode is
+ \l{QAbstractItemView::}{NoSelection}, the item is also be selected.
+ Note that this function also updates the starting position for any
+ new selections the user performs.
+
+ To set an item as the current item without selecting it, call
+
+ \c{selectionModel()->setCurrentIndex(index, QItemSelectionModel::NoUpdate);}
+
+ \sa currentIndex(), currentChanged(), selectionMode
+*/
+void QAbstractItemView::setCurrentIndex(const QModelIndex &index)
+{
+ Q_D(QAbstractItemView);
+ if (d->selectionModel && (!index.isValid() || d->isIndexEnabled(index))) {
+ QItemSelectionModel::SelectionFlags command = selectionCommand(index, 0);
+ d->selectionModel->setCurrentIndex(index, command);
+ d->currentIndexSet = true;
+ if ((command & QItemSelectionModel::Current) == 0)
+ d->pressedPosition = visualRect(currentIndex()).center() + d->offset();
+ }
+}
+
+/*!
+ Returns the model index of the current item.
+
+ \sa setCurrentIndex()
+*/
+QModelIndex QAbstractItemView::currentIndex() const
+{
+ Q_D(const QAbstractItemView);
+ return d->selectionModel ? d->selectionModel->currentIndex() : QModelIndex();
+}
+
+
+/*!
+ Reset the internal state of the view.
+
+ \warning This function will reset open editors, scroll bar positions,
+ selections, etc. Existing changes will not be committed. If you would like
+ to save your changes when resetting the view, you can reimplement this
+ function, commit your changes, and then call the superclass'
+ implementation.
+*/
+void QAbstractItemView::reset()
+{
+ Q_D(QAbstractItemView);
+ d->delayedReset.stop(); //make sure we stop the timer
+ QList<QEditorInfo>::const_iterator it = d->editors.constBegin();
+ for (; it != d->editors.constEnd(); ++it)
+ d->releaseEditor(it->editor);
+ d->editors.clear();
+ d->persistent.clear();
+ d->currentIndexSet = false;
+ setState(NoState);
+ setRootIndex(QModelIndex());
+ if (d->selectionModel)
+ d->selectionModel->reset();
+}
+
+/*!
+ Sets the root item to the item at the given \a index.
+
+ \sa rootIndex()
+*/
+void QAbstractItemView::setRootIndex(const QModelIndex &index)
+{
+ Q_D(QAbstractItemView);
+ if (index.isValid() && index.model() != d->model) {
+ qWarning("QAbstractItemView::setRootIndex failed : index must be from the currently set model");
+ return;
+ }
+ d->root = index;
+ d->doDelayedItemsLayout();
+}
+
+/*!
+ Returns the model index of the model's root item. The root item is
+ the parent item to the view's toplevel items. The root can be invalid.
+
+ \sa setRootIndex()
+*/
+QModelIndex QAbstractItemView::rootIndex() const
+{
+ return QModelIndex(d_func()->root);
+}
+
+/*!
+ Selects all items in the view.
+ This function will use the selection behavior
+ set on the view when selecting.
+
+ \sa setSelection(), selectedIndexes(), clearSelection()
+*/
+void QAbstractItemView::selectAll()
+{
+ Q_D(QAbstractItemView);
+ SelectionMode mode = d->selectionMode;
+ if (mode == MultiSelection || mode == ExtendedSelection)
+ d->selectAll(QItemSelectionModel::ClearAndSelect
+ |d->selectionBehaviorFlags());
+ else if (mode != SingleSelection)
+ d->selectAll(selectionCommand(d->model->index(0, 0, d->root)));
+}
+
+/*!
+ Starts editing the item corresponding to the given \a index if it is
+ editable.
+
+ Note that this function does not change the current index. Since the current
+ index defines the next and previous items to edit, users may find that
+ keyboard navigation does not work as expected. To provide consistent navigation
+ behavior, call setCurrentIndex() before this function with the same model
+ index.
+
+ \sa QModelIndex::flags()
+*/
+void QAbstractItemView::edit(const QModelIndex &index)
+{
+ Q_D(QAbstractItemView);
+ if (!d->isIndexValid(index))
+ qWarning("edit: index was invalid");
+ if (!edit(index, AllEditTriggers, 0))
+ qWarning("edit: editing failed");
+}
+
+/*!
+ Deselects all selected items. The current index will not be changed.
+
+ \sa setSelection(), selectAll()
+*/
+void QAbstractItemView::clearSelection()
+{
+ Q_D(QAbstractItemView);
+ if (d->selectionModel)
+ d->selectionModel->clearSelection();
+}
+
+/*!
+ \internal
+
+ This function is intended to lay out the items in the view.
+ The default implementation just calls updateGeometries() and updates the viewport.
+*/
+void QAbstractItemView::doItemsLayout()
+{
+ Q_D(QAbstractItemView);
+ d->interruptDelayedItemsLayout();
+ updateGeometries();
+ d->viewport->update();
+}
+
+/*!
+ \property QAbstractItemView::editTriggers
+ \brief which actions will initiate item editing
+
+ This property is a selection of flags defined by
+ \l{EditTrigger}, combined using the OR
+ operator. The view will only initiate the editing of an item if the
+ action performed is set in this property.
+*/
+void QAbstractItemView::setEditTriggers(EditTriggers actions)
+{
+ Q_D(QAbstractItemView);
+ d->editTriggers = actions;
+}
+
+QAbstractItemView::EditTriggers QAbstractItemView::editTriggers() const
+{
+ Q_D(const QAbstractItemView);
+ return d->editTriggers;
+}
+
+/*!
+ \since 4.2
+ \property QAbstractItemView::verticalScrollMode
+ \brief how the view scrolls its contents in the vertical direction
+
+ This property controlls how the view scroll its contents vertically.
+ Scrolling can be done either per pixel or per item.
+*/
+
+void QAbstractItemView::setVerticalScrollMode(ScrollMode mode)
+{
+ Q_D(QAbstractItemView);
+ if (mode == d->verticalScrollMode)
+ return;
+ QModelIndex topLeft = indexAt(QPoint(0, 0));
+ d->verticalScrollMode = mode;
+ updateGeometries(); // update the scroll bars
+ scrollTo(topLeft, QAbstractItemView::PositionAtTop);
+}
+
+QAbstractItemView::ScrollMode QAbstractItemView::verticalScrollMode() const
+{
+ Q_D(const QAbstractItemView);
+ return d->verticalScrollMode;
+}
+
+/*!
+ \since 4.2
+ \property QAbstractItemView::horizontalScrollMode
+ \brief how the view scrolls its contents in the horizontal direction
+
+ This property controlls how the view scroll its contents horizontally.
+ Scrolling can be done either per pixel or per item.
+*/
+
+void QAbstractItemView::setHorizontalScrollMode(ScrollMode mode)
+{
+ Q_D(QAbstractItemView);
+ d->horizontalScrollMode = mode;
+ updateGeometries(); // update the scroll bars
+}
+
+QAbstractItemView::ScrollMode QAbstractItemView::horizontalScrollMode() const
+{
+ Q_D(const QAbstractItemView);
+ return d->horizontalScrollMode;
+}
+
+#ifndef QT_NO_DRAGANDDROP
+/*!
+ \since 4.2
+ \property QAbstractItemView::dragDropOverwriteMode
+ \brief the view's drag and drop behavior
+
+ If its value is \c true, the selected data will overwrite the
+ existing item data when dropped, while moving the data will clear
+ the item. If its value is \c false, the selected data will be
+ inserted as a new item when the data is dropped. When the data is
+ moved, the item is removed as well.
+
+ The default value is \c false, as in the QListView and QTreeView
+ subclasses. In the QTableView subclass, on the other hand, the
+ property has been set to \c true.
+
+ Note: This is not intended to prevent overwriting of items.
+ The model's implementation of flags() should do that by not
+ returning Qt::ItemIsDropEnabled.
+
+ \sa dragDropMode
+*/
+void QAbstractItemView::setDragDropOverwriteMode(bool overwrite)
+{
+ Q_D(QAbstractItemView);
+ d->overwrite = overwrite;
+}
+
+bool QAbstractItemView::dragDropOverwriteMode() const
+{
+ Q_D(const QAbstractItemView);
+ return d->overwrite;
+}
+#endif
+
+/*!
+ \property QAbstractItemView::autoScroll
+ \brief whether autoscrolling in drag move events is enabled
+
+ If this property is set to true (the default), the
+ QAbstractItemView automatically scrolls the contents of the view
+ if the user drags within 16 pixels of the viewport edge. If the current
+ item changes, then the view will scroll automatically to ensure that the
+ current item is fully visible.
+
+ This property only works if the viewport accepts drops. Autoscroll is
+ switched off by setting this property to false.
+*/
+
+void QAbstractItemView::setAutoScroll(bool enable)
+{
+ Q_D(QAbstractItemView);
+ d->autoScroll = enable;
+}
+
+bool QAbstractItemView::hasAutoScroll() const
+{
+ Q_D(const QAbstractItemView);
+ return d->autoScroll;
+}
+
+/*!
+ \since 4.4
+ \property QAbstractItemView::autoScrollMargin
+ \brief the size of the area when auto scrolling is triggered
+
+ This property controlls the size of the area at the edge of the viewport that
+ triggers autoscrolling. The default value is 16 pixels.
+*/
+void QAbstractItemView::setAutoScrollMargin(int margin)
+{
+ Q_D(QAbstractItemView);
+ d->autoScrollMargin = margin;
+}
+
+int QAbstractItemView::autoScrollMargin() const
+{
+ Q_D(const QAbstractItemView);
+ return d->autoScrollMargin;
+}
+
+/*!
+ \property QAbstractItemView::tabKeyNavigation
+ \brief whether item navigation with tab and backtab is enabled.
+*/
+
+void QAbstractItemView::setTabKeyNavigation(bool enable)
+{
+ Q_D(QAbstractItemView);
+ d->tabKeyNavigation = enable;
+}
+
+bool QAbstractItemView::tabKeyNavigation() const
+{
+ Q_D(const QAbstractItemView);
+ return d->tabKeyNavigation;
+}
+
+#ifndef QT_NO_DRAGANDDROP
+/*!
+ \property QAbstractItemView::showDropIndicator
+ \brief whether the drop indicator is shown when dragging items and dropping.
+
+ \sa dragEnabled DragDropMode dragDropOverwriteMode acceptDrops
+*/
+
+void QAbstractItemView::setDropIndicatorShown(bool enable)
+{
+ Q_D(QAbstractItemView);
+ d->showDropIndicator = enable;
+}
+
+bool QAbstractItemView::showDropIndicator() const
+{
+ Q_D(const QAbstractItemView);
+ return d->showDropIndicator;
+}
+
+/*!
+ \property QAbstractItemView::dragEnabled
+ \brief whether the view supports dragging of its own items
+
+ \sa showDropIndicator DragDropMode dragDropOverwriteMode acceptDrops
+*/
+
+void QAbstractItemView::setDragEnabled(bool enable)
+{
+ Q_D(QAbstractItemView);
+ d->dragEnabled = enable;
+}
+
+bool QAbstractItemView::dragEnabled() const
+{
+ Q_D(const QAbstractItemView);
+ return d->dragEnabled;
+}
+
+/*!
+ \since 4.2
+ \enum QAbstractItemView::DragDropMode
+
+ Describes the various drag and drop events the view can act upon.
+ By default the view does not support dragging or dropping (\c
+ NoDragDrop).
+
+ \value NoDragDrop Does not support dragging or dropping.
+ \value DragOnly The view supports dragging of its own items
+ \value DropOnly The view accepts drops
+ \value DragDrop The view supports both dragging and dropping
+ \value InternalMove The view accepts move (\bold{not copy}) operations only
+ from itself.
+
+ Note that the model used needs to provide support for drag and drop operations.
+
+ \sa setDragDropMode() {Using Drag and Drop with Item Views}
+*/
+
+/*!
+ \property QAbstractItemView::dragDropMode
+ \brief the drag and drop event the view will act upon
+
+ \since 4.2
+ \sa showDropIndicator dragDropOverwriteMode
+*/
+void QAbstractItemView::setDragDropMode(DragDropMode behavior)
+{
+ Q_D(QAbstractItemView);
+ d->dragDropMode = behavior;
+ setDragEnabled(behavior == DragOnly || behavior == DragDrop || behavior == InternalMove);
+ setAcceptDrops(behavior == DropOnly || behavior == DragDrop || behavior == InternalMove);
+}
+
+QAbstractItemView::DragDropMode QAbstractItemView::dragDropMode() const
+{
+ Q_D(const QAbstractItemView);
+ DragDropMode setBehavior = d->dragDropMode;
+ if (!dragEnabled() && !acceptDrops())
+ return NoDragDrop;
+
+ if (dragEnabled() && !acceptDrops())
+ return DragOnly;
+
+ if (!dragEnabled() && acceptDrops())
+ return DropOnly;
+
+ if (dragEnabled() && acceptDrops()) {
+ if (setBehavior == InternalMove)
+ return setBehavior;
+ else
+ return DragDrop;
+ }
+
+ return NoDragDrop;
+}
+
+/*!
+ \property QAbstractItemView::defaultDropAction
+ \brief the drop action that will be used by default in QAbstractItemView::drag()
+
+ If the property is not set, the drop action is CopyAction when the supported
+ actions support CopyAction.
+
+ \since 4.6
+ \sa showDropIndicator dragDropOverwriteMode
+*/
+void QAbstractItemView::setDefaultDropAction(Qt::DropAction dropAction)
+{
+ Q_D(QAbstractItemView);
+ d->defaultDropAction = dropAction;
+}
+
+Qt::DropAction QAbstractItemView::defaultDropAction() const
+{
+ Q_D(const QAbstractItemView);
+ return d->defaultDropAction;
+}
+
+#endif // QT_NO_DRAGANDDROP
+
+/*!
+ \property QAbstractItemView::alternatingRowColors
+ \brief whether to draw the background using alternating colors
+
+ If this property is true, the item background will be drawn using
+ QPalette::Base and QPalette::AlternateBase; otherwise the background
+ will be drawn using the QPalette::Base color.
+
+ By default, this property is false.
+*/
+void QAbstractItemView::setAlternatingRowColors(bool enable)
+{
+ Q_D(QAbstractItemView);
+ d->alternatingColors = enable;
+ if (isVisible())
+ d->viewport->update();
+}
+
+bool QAbstractItemView::alternatingRowColors() const
+{
+ Q_D(const QAbstractItemView);
+ return d->alternatingColors;
+}
+
+/*!
+ \property QAbstractItemView::iconSize
+ \brief the size of items' icons
+
+ Setting this property when the view is visible will cause the
+ items to be laid out again.
+*/
+void QAbstractItemView::setIconSize(const QSize &size)
+{
+ Q_D(QAbstractItemView);
+ if (size == d->iconSize)
+ return;
+ d->iconSize = size;
+ d->doDelayedItemsLayout();
+}
+
+QSize QAbstractItemView::iconSize() const
+{
+ Q_D(const QAbstractItemView);
+ return d->iconSize;
+}
+
+/*!
+ \property QAbstractItemView::textElideMode
+
+ \brief the position of the "..." in elided text.
+
+ The default value for all item views is Qt::ElideRight.
+*/
+void QAbstractItemView::setTextElideMode(Qt::TextElideMode mode)
+{
+ Q_D(QAbstractItemView);
+ d->textElideMode = mode;
+}
+
+Qt::TextElideMode QAbstractItemView::textElideMode() const
+{
+ return d_func()->textElideMode;
+}
+
+/*!
+ \reimp
+*/
+bool QAbstractItemView::focusNextPrevChild(bool next)
+{
+ Q_D(QAbstractItemView);
+ if (d->tabKeyNavigation && isEnabled() && d->viewport->isEnabled()) {
+ QKeyEvent event(QEvent::KeyPress, next ? Qt::Key_Tab : Qt::Key_Backtab, Qt::NoModifier);
+ keyPressEvent(&event);
+ if (event.isAccepted())
+ return true;
+ }
+ return QAbstractScrollArea::focusNextPrevChild(next);
+}
+
+/*!
+ \reimp
+*/
+bool QAbstractItemView::event(QEvent *event)
+{
+ Q_D(QAbstractItemView);
+ switch (event->type()) {
+ case QEvent::Paint:
+ //we call this here because the scrollbars' visibility might be altered
+ //so this can't be done in the paintEvent method
+ d->executePostedLayout(); //make sure we set the layout properly
+ break;
+ case QEvent::Show:
+ d->executePostedLayout(); //make sure we set the layout properly
+ if (d->shouldScrollToCurrentOnShow) {
+ d->shouldScrollToCurrentOnShow = false;
+ const QModelIndex current = currentIndex();
+ if (current.isValid() && (d->state == QAbstractItemView::EditingState || d->autoScroll))
+ scrollTo(current);
+ }
+ break;
+ case QEvent::LocaleChange:
+ viewport()->update();
+ break;
+ case QEvent::LayoutDirectionChange:
+ case QEvent::ApplicationLayoutDirectionChange:
+ updateGeometries();
+ break;
+ case QEvent::StyleChange:
+ doItemsLayout();
+ break;
+ case QEvent::FocusOut:
+ d->checkPersistentEditorFocus();
+ break;
+ case QEvent::FontChange:
+ d->doDelayedItemsLayout(); // the size of the items will change
+ break;
+ default:
+ break;
+ }
+ return QAbstractScrollArea::event(event);
+}
+
+/*!
+ \fn bool QAbstractItemView::viewportEvent(QEvent *event)
+
+ This function is used to handle tool tips, and What's
+ This? mode, if the given \a event is a QEvent::ToolTip,or a
+ QEvent::WhatsThis. It passes all other
+ events on to its base class viewportEvent() handler.
+*/
+bool QAbstractItemView::viewportEvent(QEvent *event)
+{
+ Q_D(QAbstractItemView);
+ switch (event->type()) {
+ case QEvent::HoverEnter: {
+ QHoverEvent *he = static_cast<QHoverEvent*>(event);
+ d->hover = indexAt(he->pos());
+ update(d->hover);
+ break; }
+ case QEvent::HoverLeave: {
+ update(d->hover); // update old
+ d->hover = QModelIndex();
+ break; }
+ case QEvent::HoverMove: {
+ QHoverEvent *he = static_cast<QHoverEvent*>(event);
+ QModelIndex old = d->hover;
+ d->hover = indexAt(he->pos());
+ if (d->hover != old)
+ d->viewport->update(visualRect(old)|visualRect(d->hover));
+ break; }
+ case QEvent::Enter:
+ d->viewportEnteredNeeded = true;
+ break;
+ case QEvent::Leave:
+ d->enteredIndex = QModelIndex();
+ break;
+ case QEvent::ToolTip:
+ case QEvent::QueryWhatsThis:
+ case QEvent::WhatsThis: {
+ QHelpEvent *he = static_cast<QHelpEvent*>(event);
+ const QModelIndex index = indexAt(he->pos());
+ QStyleOptionViewItemV4 option = d->viewOptionsV4();
+ option.rect = visualRect(index);
+ option.state |= (index == currentIndex() ? QStyle::State_HasFocus : QStyle::State_None);
+ bool retval = false;
+ // ### Qt 5: make this a normal function call to a virtual function
+ QMetaObject::invokeMethod(d->delegateForIndex(index), "helpEvent",
+ Q_RETURN_ARG(bool, retval),
+ Q_ARG(QHelpEvent *, he),
+ Q_ARG(QAbstractItemView *, this),
+ Q_ARG(QStyleOptionViewItem, option),
+ Q_ARG(QModelIndex, index));
+ return retval;
+ }
+ case QEvent::FontChange:
+ d->doDelayedItemsLayout(); // the size of the items will change
+ break;
+ case QEvent::WindowActivate:
+ case QEvent::WindowDeactivate:
+ d->viewport->update();
+ break;
+ default:
+ break;
+ }
+ return QAbstractScrollArea::viewportEvent(event);
+}
+
+/*!
+ This function is called with the given \a event when a mouse button is pressed
+ while the cursor is inside the widget. If a valid item is pressed on it is made
+ into the current item. This function emits the pressed() signal.
+*/
+void QAbstractItemView::mousePressEvent(QMouseEvent *event)
+{
+ Q_D(QAbstractItemView);
+ d->delayedAutoScroll.stop(); //any interaction with the view cancel the auto scrolling
+ QPoint pos = event->pos();
+ QPersistentModelIndex index = indexAt(pos);
+
+ if (!d->selectionModel
+ || (d->state == EditingState && d->hasEditor(index)))
+ return;
+
+ d->pressedAlreadySelected = d->selectionModel->isSelected(index);
+ d->pressedIndex = index;
+ d->pressedModifiers = event->modifiers();
+ QItemSelectionModel::SelectionFlags command = selectionCommand(index, event);
+ QPoint offset = d->offset();
+ if ((command & QItemSelectionModel::Current) == 0)
+ d->pressedPosition = pos + offset;
+ else if (!indexAt(d->pressedPosition).isValid())
+ d->pressedPosition = visualRect(currentIndex()).center() + offset;
+
+ if (edit(index, NoEditTriggers, event))
+ return;
+
+ if (index.isValid() && d->isIndexEnabled(index)) {
+ // we disable scrollTo for mouse press so the item doesn't change position
+ // when the user is interacting with it (ie. clicking on it)
+ bool autoScroll = d->autoScroll;
+ d->autoScroll = false;
+ d->selectionModel->setCurrentIndex(index, QItemSelectionModel::NoUpdate);
+ d->autoScroll = autoScroll;
+ QRect rect(d->pressedPosition - offset, pos);
+ if (command.testFlag(QItemSelectionModel::Toggle)) {
+ command &= ~QItemSelectionModel::Toggle;
+ d->ctrlDragSelectionFlag = d->selectionModel->isSelected(index) ? QItemSelectionModel::Deselect : QItemSelectionModel::Select;
+ command |= d->ctrlDragSelectionFlag;
+ }
+ setSelection(rect, command);
+
+ // signal handlers may change the model
+ emit pressed(index);
+ if (d->autoScroll) {
+ //we delay the autoscrolling to filter out double click event
+ //100 is to be sure that there won't be a double-click misinterpreted as a 2 single clicks
+ d->delayedAutoScroll.start(QApplication::doubleClickInterval()+100, this);
+ }
+
+ } else {
+ // Forces a finalize() even if mouse is pressed, but not on a item
+ d->selectionModel->select(QModelIndex(), QItemSelectionModel::Select);
+ }
+}
+
+/*!
+ This function is called with the given \a event when a mouse move event is
+ sent to the widget. If a selection is in progress and new items are moved
+ over the selection is extended; if a drag is in progress it is continued.
+*/
+void QAbstractItemView::mouseMoveEvent(QMouseEvent *event)
+{
+ Q_D(QAbstractItemView);
+ QPoint topLeft;
+ QPoint bottomRight = event->pos();
+
+ if (state() == ExpandingState || state() == CollapsingState)
+ return;
+
+#ifndef QT_NO_DRAGANDDROP
+ if (state() == DraggingState) {
+ topLeft = d->pressedPosition - d->offset();
+ if ((topLeft - bottomRight).manhattanLength() > QApplication::startDragDistance()) {
+ d->pressedIndex = QModelIndex();
+ startDrag(d->model->supportedDragActions());
+ setState(NoState); // the startDrag will return when the dnd operation is done
+ stopAutoScroll();
+ }
+ return;
+ }
+#endif // QT_NO_DRAGANDDROP
+
+ QPersistentModelIndex index = indexAt(bottomRight);
+ QModelIndex buddy = d->model->buddy(d->pressedIndex);
+ if ((state() == EditingState && d->hasEditor(buddy))
+ || edit(index, NoEditTriggers, event))
+ return;
+
+ if (d->selectionMode != SingleSelection)
+ topLeft = d->pressedPosition - d->offset();
+ else
+ topLeft = bottomRight;
+
+ d->checkMouseMove(index);
+
+#ifndef QT_NO_DRAGANDDROP
+ if (d->pressedIndex.isValid()
+ && d->dragEnabled
+ && (state() != DragSelectingState)
+ && (event->buttons() != Qt::NoButton)
+ && !d->selectedDraggableIndexes().isEmpty()) {
+ setState(DraggingState);
+ return;
+ }
+#endif
+
+ if ((event->buttons() & Qt::LeftButton) && d->selectionAllowed(index) && d->selectionModel) {
+ setState(DragSelectingState);
+ QItemSelectionModel::SelectionFlags command = selectionCommand(index, event);
+ if (d->ctrlDragSelectionFlag != QItemSelectionModel::NoUpdate && command.testFlag(QItemSelectionModel::Toggle)) {
+ command &= ~QItemSelectionModel::Toggle;
+ command |= d->ctrlDragSelectionFlag;
+ }
+
+ // Do the normalize ourselves, since QRect::normalized() is flawed
+ QRect selectionRect = QRect(topLeft, bottomRight);
+ setSelection(selectionRect, command);
+
+ // set at the end because it might scroll the view
+ if (index.isValid()
+ && (index != d->selectionModel->currentIndex())
+ && d->isIndexEnabled(index))
+ d->selectionModel->setCurrentIndex(index, QItemSelectionModel::NoUpdate);
+ }
+}
+
+/*!
+ This function is called with the given \a event when a mouse button is released,
+ after a mouse press event on the widget. If a user presses the mouse inside your
+ widget and then drags the mouse to another location before releasing the mouse button,
+ your widget receives the release event. The function will emit the clicked() signal if an
+ item was being pressed.
+*/
+void QAbstractItemView::mouseReleaseEvent(QMouseEvent *event)
+{
+ Q_D(QAbstractItemView);
+
+ QPoint pos = event->pos();
+ QPersistentModelIndex index = indexAt(pos);
+
+ if (state() == EditingState) {
+ if (d->isIndexValid(index)
+ && d->isIndexEnabled(index)
+ && d->sendDelegateEvent(index, event))
+ update(index);
+ return;
+ }
+
+ bool click = (index == d->pressedIndex && index.isValid());
+ bool selectedClicked = click && (event->button() & Qt::LeftButton) && d->pressedAlreadySelected;
+ EditTrigger trigger = (selectedClicked ? SelectedClicked : NoEditTriggers);
+ bool edited = edit(index, trigger, event);
+
+ d->ctrlDragSelectionFlag = QItemSelectionModel::NoUpdate;
+
+ //in the case the user presses on no item we might decide to clear the selection
+ if (d->selectionModel && !index.isValid())
+ d->selectionModel->select(QModelIndex(), selectionCommand(index, event));
+
+ setState(NoState);
+
+ if (click) {
+ emit clicked(index);
+ if (edited)
+ return;
+ if (style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick, 0, this))
+ emit activated(index);
+ }
+}
+
+/*!
+ This function is called with the given \a event when a mouse button is
+ double clicked inside the widget. If the double-click is on a valid item it
+ emits the doubleClicked() signal and calls edit() on the item.
+*/
+void QAbstractItemView::mouseDoubleClickEvent(QMouseEvent *event)
+{
+ Q_D(QAbstractItemView);
+
+ QModelIndex index = indexAt(event->pos());
+ if (!index.isValid()
+ || !d->isIndexEnabled(index)
+ || (d->pressedIndex != index)) {
+ QMouseEvent me(QEvent::MouseButtonPress,
+ event->pos(), event->button(),
+ event->buttons(), event->modifiers());
+ mousePressEvent(&me);
+ return;
+ }
+ // signal handlers may change the model
+ QPersistentModelIndex persistent = index;
+ emit doubleClicked(persistent);
+ if ((event->button() & Qt::LeftButton) && !edit(persistent, DoubleClicked, event)
+ && !style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick, 0, this))
+ emit activated(persistent);
+}
+
+#ifndef QT_NO_DRAGANDDROP
+
+/*!
+ This function is called with the given \a event when a drag and drop operation enters
+ the widget. If the drag is over a valid dropping place (e.g. over an item that
+ accepts drops), the event is accepted; otherwise it is ignored.
+
+ \sa dropEvent() startDrag()
+*/
+void QAbstractItemView::dragEnterEvent(QDragEnterEvent *event)
+{
+ if (dragDropMode() == InternalMove
+ && (event->source() != this|| !(event->possibleActions() & Qt::MoveAction)))
+ return;
+
+ if (d_func()->canDecode(event)) {
+ event->accept();
+ setState(DraggingState);
+ } else {
+ event->ignore();
+ }
+}
+
+/*!
+ This function is called continuously with the given \a event during a drag and
+ drop operation over the widget. It can cause the view to scroll if, for example,
+ the user drags a selection to view's right or bottom edge. In this case, the
+ event will be accepted; otherwise it will be ignored.
+
+ \sa dropEvent() startDrag()
+*/
+void QAbstractItemView::dragMoveEvent(QDragMoveEvent *event)
+{
+ Q_D(QAbstractItemView);
+ if (dragDropMode() == InternalMove
+ && (event->source() != this || !(event->possibleActions() & Qt::MoveAction)))
+ return;
+
+ // ignore by default
+ event->ignore();
+
+ QModelIndex index = indexAt(event->pos());
+ d->hover = index;
+ if (!d->droppingOnItself(event, index)
+ && d->canDecode(event)) {
+
+ if (index.isValid() && d->showDropIndicator) {
+ QRect rect = visualRect(index);
+ d->dropIndicatorPosition = d->position(event->pos(), rect, index);
+ switch (d->dropIndicatorPosition) {
+ case AboveItem:
+ if (d->isIndexDropEnabled(index.parent())) {
+ d->dropIndicatorRect = QRect(rect.left(), rect.top(), rect.width(), 0);
+ event->accept();
+ } else {
+ d->dropIndicatorRect = QRect();
+ }
+ break;
+ case BelowItem:
+ if (d->isIndexDropEnabled(index.parent())) {
+ d->dropIndicatorRect = QRect(rect.left(), rect.bottom(), rect.width(), 0);
+ event->accept();
+ } else {
+ d->dropIndicatorRect = QRect();
+ }
+ break;
+ case OnItem:
+ if (d->isIndexDropEnabled(index)) {
+ d->dropIndicatorRect = rect;
+ event->accept();
+ } else {
+ d->dropIndicatorRect = QRect();
+ }
+ break;
+ case OnViewport:
+ d->dropIndicatorRect = QRect();
+ if (d->isIndexDropEnabled(rootIndex())) {
+ event->accept(); // allow dropping in empty areas
+ }
+ break;
+ }
+ } else {
+ d->dropIndicatorRect = QRect();
+ d->dropIndicatorPosition = OnViewport;
+ if (d->isIndexDropEnabled(rootIndex())) {
+ event->accept(); // allow dropping in empty areas
+ }
+ }
+ d->viewport->update();
+ } // can decode
+
+ if (d->shouldAutoScroll(event->pos()))
+ startAutoScroll();
+}
+
+/*!
+ \internal
+ Return true if this is a move from ourself and \a index is a child of the selection that
+ is being moved.
+ */
+bool QAbstractItemViewPrivate::droppingOnItself(QDropEvent *event, const QModelIndex &index)
+{
+ Q_Q(QAbstractItemView);
+ Qt::DropAction dropAction = event->dropAction();
+ if (q->dragDropMode() == QAbstractItemView::InternalMove)
+ dropAction = Qt::MoveAction;
+ if (event->source() == q
+ && event->possibleActions() & Qt::MoveAction
+ && dropAction == Qt::MoveAction) {
+ QModelIndexList selectedIndexes = q->selectedIndexes();
+ QModelIndex child = index;
+ while (child.isValid() && child != root) {
+ if (selectedIndexes.contains(child))
+ return true;
+ child = child.parent();
+ }
+ }
+ return false;
+}
+
+/*!
+ \fn void QAbstractItemView::dragLeaveEvent(QDragLeaveEvent *event)
+
+ This function is called when the item being dragged leaves the view.
+ The \a event describes the state of the drag and drop operation.
+*/
+void QAbstractItemView::dragLeaveEvent(QDragLeaveEvent *)
+{
+ Q_D(QAbstractItemView);
+ stopAutoScroll();
+ setState(NoState);
+ d->hover = QModelIndex();
+ d->viewport->update();
+}
+
+/*!
+ This function is called with the given \a event when a drop event occurs over
+ the widget. If the model accepts the even position the drop event is accepted;
+ otherwise it is ignored.
+
+ \sa startDrag()
+*/
+void QAbstractItemView::dropEvent(QDropEvent *event)
+{
+ Q_D(QAbstractItemView);
+ if (dragDropMode() == InternalMove) {
+ if (event->source() != this || !(event->possibleActions() & Qt::MoveAction))
+ return;
+ }
+
+ QModelIndex index;
+ int col = -1;
+ int row = -1;
+ if (d->dropOn(event, &row, &col, &index)) {
+ if (d->model->dropMimeData(event->mimeData(),
+ dragDropMode() == InternalMove ? Qt::MoveAction : event->dropAction(), row, col, index)) {
+ if (dragDropMode() == InternalMove)
+ event->setDropAction(Qt::MoveAction);
+ event->accept();
+ }
+ }
+ stopAutoScroll();
+ setState(NoState);
+ d->viewport->update();
+}
+
+/*!
+ If the event hasn't already been accepted, determines the index to drop on.
+
+ if (row == -1 && col == -1)
+ // append to this drop index
+ else
+ // place at row, col in drop index
+
+ If it returns true a drop can be done, and dropRow, dropCol and dropIndex reflects the position of the drop.
+ \internal
+ */
+bool QAbstractItemViewPrivate::dropOn(QDropEvent *event, int *dropRow, int *dropCol, QModelIndex *dropIndex)
+{
+ Q_Q(QAbstractItemView);
+ if (event->isAccepted())
+ return false;
+
+ QModelIndex index;
+ // rootIndex() (i.e. the viewport) might be a valid index
+ if (viewport->rect().contains(event->pos())) {
+ index = q->indexAt(event->pos());
+ if (!index.isValid() || !q->visualRect(index).contains(event->pos()))
+ index = root;
+ }
+
+ // If we are allowed to do the drop
+ if (model->supportedDropActions() & event->dropAction()) {
+ int row = -1;
+ int col = -1;
+ if (index != root) {
+ dropIndicatorPosition = position(event->pos(), q->visualRect(index), index);
+ switch (dropIndicatorPosition) {
+ case QAbstractItemView::AboveItem:
+ row = index.row();
+ col = index.column();
+ index = index.parent();
+ break;
+ case QAbstractItemView::BelowItem:
+ row = index.row() + 1;
+ col = index.column();
+ index = index.parent();
+ break;
+ case QAbstractItemView::OnItem:
+ case QAbstractItemView::OnViewport:
+ break;
+ }
+ } else {
+ dropIndicatorPosition = QAbstractItemView::OnViewport;
+ }
+ *dropIndex = index;
+ *dropRow = row;
+ *dropCol = col;
+ if (!droppingOnItself(event, index))
+ return true;
+ }
+ return false;
+}
+
+QAbstractItemView::DropIndicatorPosition
+QAbstractItemViewPrivate::position(const QPoint &pos, const QRect &rect, const QModelIndex &index) const
+{
+ QAbstractItemView::DropIndicatorPosition r = QAbstractItemView::OnViewport;
+ if (!overwrite) {
+ const int margin = 2;
+ if (pos.y() - rect.top() < margin) {
+ r = QAbstractItemView::AboveItem;
+ } else if (rect.bottom() - pos.y() < margin) {
+ r = QAbstractItemView::BelowItem;
+ } else if (rect.contains(pos, true)) {
+ r = QAbstractItemView::OnItem;
+ }
+ } else {
+ QRect touchingRect = rect;
+ touchingRect.adjust(-1, -1, 1, 1);
+ if (touchingRect.contains(pos, false)) {
+ r = QAbstractItemView::OnItem;
+ }
+ }
+
+ if (r == QAbstractItemView::OnItem && (!(model->flags(index) & Qt::ItemIsDropEnabled)))
+ r = pos.y() < rect.center().y() ? QAbstractItemView::AboveItem : QAbstractItemView::BelowItem;
+
+ return r;
+}
+
+#endif // QT_NO_DRAGANDDROP
+
+/*!
+ This function is called with the given \a event when the widget obtains the focus.
+ By default, the event is ignored.
+
+ \sa setFocus(), focusOutEvent()
+*/
+void QAbstractItemView::focusInEvent(QFocusEvent *event)
+{
+ Q_D(QAbstractItemView);
+ QAbstractScrollArea::focusInEvent(event);
+ if (selectionModel()
+ && !d->currentIndexSet
+ && !currentIndex().isValid()) {
+ bool autoScroll = d->autoScroll;
+ d->autoScroll = false;
+ QModelIndex index = moveCursor(MoveNext, Qt::NoModifier); // first visible index
+ if (index.isValid() && d->isIndexEnabled(index))
+ selectionModel()->setCurrentIndex(index, QItemSelectionModel::NoUpdate);
+ d->autoScroll = autoScroll;
+ }
+ d->viewport->update();
+}
+
+/*!
+ This function is called with the given \a event when the widget
+ looses the focus. By default, the event is ignored.
+
+ \sa clearFocus(), focusInEvent()
+*/
+void QAbstractItemView::focusOutEvent(QFocusEvent *event)
+{
+ Q_D(QAbstractItemView);
+ QAbstractScrollArea::focusOutEvent(event);
+ d->viewport->update();
+}
+
+/*!
+ This function is called with the given \a event when a key event is sent to
+ the widget. The default implementation handles basic cursor movement, e.g. Up,
+ Down, Left, Right, Home, PageUp, and PageDown; the activated() signal is
+ emitted if the current index is valid and the activation key is pressed
+ (e.g. Enter or Return, depending on the platform).
+ This function is where editing is initiated by key press, e.g. if F2 is
+ pressed.
+
+ \sa edit(), moveCursor(), keyboardSearch(), tabKeyNavigation
+*/
+void QAbstractItemView::keyPressEvent(QKeyEvent *event)
+{
+ Q_D(QAbstractItemView);
+ d->delayedAutoScroll.stop(); //any interaction with the view cancel the auto scrolling
+
+#ifdef QT_KEYPAD_NAVIGATION
+ switch (event->key()) {
+ case Qt::Key_Select:
+ if (QApplication::keypadNavigationEnabled()) {
+ if (!hasEditFocus()) {
+ setEditFocus(true);
+#ifdef QT_SOFTKEYS_ENABLED
+ addAction(d->doneSoftKey);
+#endif
+ return;
+ }
+ }
+ break;
+ case Qt::Key_Back:
+ if (QApplication::keypadNavigationEnabled() && hasEditFocus()) {
+#ifdef QT_SOFTKEYS_ENABLED
+ removeAction(d->doneSoftKey);
+#endif
+ setEditFocus(false);
+ } else {
+ event->ignore();
+ }
+ return;
+ default:
+ if (QApplication::keypadNavigationEnabled() && !hasEditFocus()) {
+ event->ignore();
+ return;
+ }
+ }
+#endif
+
+#if !defined(QT_NO_CLIPBOARD) && !defined(QT_NO_SHORTCUT)
+ if (event == QKeySequence::Copy) {
+ QVariant variant;
+ if (d->model)
+ variant = d->model->data(currentIndex(), Qt::DisplayRole);
+ if (variant.type() == QVariant::String)
+ QApplication::clipboard()->setText(variant.toString());
+ event->accept();
+ }
+#endif
+
+ QPersistentModelIndex newCurrent;
+ switch (event->key()) {
+ case Qt::Key_Down:
+ newCurrent = moveCursor(MoveDown, event->modifiers());
+ break;
+ case Qt::Key_Up:
+ newCurrent = moveCursor(MoveUp, event->modifiers());
+ break;
+ case Qt::Key_Left:
+ newCurrent = moveCursor(MoveLeft, event->modifiers());
+ break;
+ case Qt::Key_Right:
+ newCurrent = moveCursor(MoveRight, event->modifiers());
+ break;
+ case Qt::Key_Home:
+ newCurrent = moveCursor(MoveHome, event->modifiers());
+ break;
+ case Qt::Key_End:
+ newCurrent = moveCursor(MoveEnd, event->modifiers());
+ break;
+ case Qt::Key_PageUp:
+ newCurrent = moveCursor(MovePageUp, event->modifiers());
+ break;
+ case Qt::Key_PageDown:
+ newCurrent = moveCursor(MovePageDown, event->modifiers());
+ break;
+ case Qt::Key_Tab:
+ if (d->tabKeyNavigation)
+ newCurrent = moveCursor(MoveNext, event->modifiers());
+ break;
+ case Qt::Key_Backtab:
+ if (d->tabKeyNavigation)
+ newCurrent = moveCursor(MovePrevious, event->modifiers());
+ break;
+ }
+
+ QPersistentModelIndex oldCurrent = currentIndex();
+ if (newCurrent != oldCurrent && newCurrent.isValid() && d->isIndexEnabled(newCurrent)) {
+ if (!hasFocus() && QApplication::focusWidget() == indexWidget(oldCurrent))
+ setFocus();
+ QItemSelectionModel::SelectionFlags command = selectionCommand(newCurrent, event);
+ if (command != QItemSelectionModel::NoUpdate
+ || style()->styleHint(QStyle::SH_ItemView_MovementWithoutUpdatingSelection, 0, this)) {
+ // note that we don't check if the new current index is enabled because moveCursor() makes sure it is
+ if (command & QItemSelectionModel::Current) {
+ d->selectionModel->setCurrentIndex(newCurrent, QItemSelectionModel::NoUpdate);
+ if (!indexAt(d->pressedPosition).isValid())
+ d->pressedPosition = visualRect(oldCurrent).center() + d->offset();
+ QRect rect(d->pressedPosition - d->offset(), visualRect(newCurrent).center());
+ setSelection(rect, command);
+ } else {
+ d->selectionModel->setCurrentIndex(newCurrent, command);
+ d->pressedPosition = visualRect(newCurrent).center() + d->offset();
+ // We copy the same behaviour as for mousePressEvent().
+ QRect rect(d->pressedPosition - d->offset(), QSize(1, 1));
+ setSelection(rect, command);
+ }
+ return;
+ }
+ }
+
+ switch (event->key()) {
+ // ignored keys
+ case Qt::Key_Down:
+ case Qt::Key_Up:
+#ifdef QT_KEYPAD_NAVIGATION
+ if (QApplication::keypadNavigationEnabled()) {
+ event->accept(); // don't change focus
+ break;
+ }
+#endif
+ case Qt::Key_Left:
+ case Qt::Key_Right:
+#ifdef QT_KEYPAD_NAVIGATION
+ if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) {
+ event->accept(); // don't change horizontal focus in directional mode
+ break;
+ }
+#endif // QT_KEYPAD_NAVIGATION
+ case Qt::Key_Home:
+ case Qt::Key_End:
+ case Qt::Key_PageUp:
+ case Qt::Key_PageDown:
+ case Qt::Key_Escape:
+ case Qt::Key_Shift:
+ case Qt::Key_Control:
+ event->ignore();
+ break;
+ case Qt::Key_Space:
+ case Qt::Key_Select:
+ if (!edit(currentIndex(), AnyKeyPressed, event) && d->selectionModel)
+ d->selectionModel->select(currentIndex(), selectionCommand(currentIndex(), event));
+#ifdef QT_KEYPAD_NAVIGATION
+ if ( event->key()==Qt::Key_Select ) {
+ // Also do Key_Enter action.
+ if (currentIndex().isValid()) {
+ if (state() != EditingState)
+ emit activated(currentIndex());
+ } else {
+ event->ignore();
+ }
+ }
+#endif
+ break;
+#ifdef Q_WS_MAC
+ case Qt::Key_Enter:
+ case Qt::Key_Return:
+ // Propagate the enter if you couldn't edit the item and there are no
+ // current editors (if there are editors, the event was most likely propagated from it).
+ if (!edit(currentIndex(), EditKeyPressed, event) && d->editors.isEmpty())
+ event->ignore();
+ break;
+#else
+ case Qt::Key_F2:
+ if (!edit(currentIndex(), EditKeyPressed, event))
+ event->ignore();
+ break;
+ case Qt::Key_Enter:
+ case Qt::Key_Return:
+ // ### we can't open the editor on enter, becuse
+ // some widgets will forward the enter event back
+ // to the viewport, starting an endless loop
+ if (state() != EditingState || hasFocus()) {
+ if (currentIndex().isValid())
+ emit activated(currentIndex());
+ event->ignore();
+ }
+ break;
+#endif
+ case Qt::Key_A:
+ if (event->modifiers() & Qt::ControlModifier) {
+ selectAll();
+ break;
+ }
+ default: {
+#ifdef Q_WS_MAC
+ if (event->key() == Qt::Key_O && event->modifiers() & Qt::ControlModifier && currentIndex().isValid()) {
+ emit activated(currentIndex());
+ break;
+ }
+#endif
+ bool modified = (event->modifiers() & (Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier));
+ if (!event->text().isEmpty() && !modified && !edit(currentIndex(), AnyKeyPressed, event)) {
+ keyboardSearch(event->text());
+ event->accept();
+ } else {
+ event->ignore();
+ }
+ break; }
+ }
+}
+
+/*!
+ This function is called with the given \a event when a resize event is sent to
+ the widget.
+
+ \sa QWidget::resizeEvent()
+*/
+void QAbstractItemView::resizeEvent(QResizeEvent *event)
+{
+ QAbstractScrollArea::resizeEvent(event);
+ updateGeometries();
+}
+
+/*!
+ This function is called with the given \a event when a timer event is sent
+ to the widget.
+
+ \sa QObject::timerEvent()
+*/
+void QAbstractItemView::timerEvent(QTimerEvent *event)
+{
+ Q_D(QAbstractItemView);
+ if (event->timerId() == d->fetchMoreTimer.timerId())
+ d->fetchMore();
+ else if (event->timerId() == d->delayedReset.timerId())
+ reset();
+ else if (event->timerId() == d->autoScrollTimer.timerId())
+ doAutoScroll();
+ else if (event->timerId() == d->updateTimer.timerId())
+ d->updateDirtyRegion();
+ else if (event->timerId() == d->delayedEditing.timerId()) {
+ d->delayedEditing.stop();
+ edit(currentIndex());
+ } else if (event->timerId() == d->delayedLayout.timerId()) {
+ d->delayedLayout.stop();
+ if (isVisible()) {
+ d->interruptDelayedItemsLayout();
+ doItemsLayout();
+ const QModelIndex current = currentIndex();
+ if (current.isValid() && d->state == QAbstractItemView::EditingState)
+ scrollTo(current);
+ }
+ } else if (event->timerId() == d->delayedAutoScroll.timerId()) {
+ d->delayedAutoScroll.stop();
+ //end of the timer: if the current item is still the same as the one when the mouse press occurred
+ //we only get here if there was no double click
+ if (d->pressedIndex.isValid() && d->pressedIndex == currentIndex())
+ scrollTo(d->pressedIndex);
+ }
+}
+
+/*!
+ \reimp
+*/
+void QAbstractItemView::inputMethodEvent(QInputMethodEvent *event)
+{
+ if (event->commitString().isEmpty() && event->preeditString().isEmpty()) {
+ event->ignore();
+ return;
+ }
+ if (!edit(currentIndex(), AnyKeyPressed, event)) {
+ if (!event->commitString().isEmpty())
+ keyboardSearch(event->commitString());
+ event->ignore();
+ }
+}
+
+#ifndef QT_NO_DRAGANDDROP
+/*!
+ \enum QAbstractItemView::DropIndicatorPosition
+
+ This enum indicates the position of the drop indicator in
+ relation to the index at the current mouse position:
+
+ \value OnItem The item will be dropped on the index.
+
+ \value AboveItem The item will be dropped above the index.
+
+ \value BelowItem The item will be dropped below the index.
+
+ \value OnViewport The item will be dropped onto a region of the viewport with
+ no items. The way each view handles items dropped onto the viewport depends on
+ the behavior of the underlying model in use.
+*/
+
+
+/*!
+ \since 4.1
+
+ Returns the position of the drop indicator in relation to the closest item.
+*/
+QAbstractItemView::DropIndicatorPosition QAbstractItemView::dropIndicatorPosition() const
+{
+ Q_D(const QAbstractItemView);
+ return d->dropIndicatorPosition;
+}
+#endif
+
+/*!
+ This convenience function returns a list of all selected and
+ non-hidden item indexes in the view. The list contains no
+ duplicates, and is not sorted.
+
+ \sa QItemSelectionModel::selectedIndexes()
+*/
+QModelIndexList QAbstractItemView::selectedIndexes() const
+{
+ Q_D(const QAbstractItemView);
+ QModelIndexList indexes;
+ if (d->selectionModel) {
+ indexes = d->selectionModel->selectedIndexes();
+ QList<QModelIndex>::iterator it = indexes.begin();
+ while (it != indexes.end())
+ if (isIndexHidden(*it))
+ it = indexes.erase(it);
+ else
+ ++it;
+ }
+ return indexes;
+}
+
+/*!
+ Starts editing the item at \a index, creating an editor if
+ necessary, and returns true if the view's \l{State} is now
+ EditingState; otherwise returns false.
+
+ The action that caused the editing process is described by
+ \a trigger, and the associated event is specified by \a event.
+
+ Editing can be forced by specifying the \a trigger to be
+ QAbstractItemView::AllEditTriggers.
+
+ \sa closeEditor()
+*/
+bool QAbstractItemView::edit(const QModelIndex &index, EditTrigger trigger, QEvent *event)
+{
+ Q_D(QAbstractItemView);
+
+ if (!d->isIndexValid(index))
+ return false;
+
+ if (QWidget *w = (d->persistent.isEmpty() ? static_cast<QWidget*>(0) : d->editorForIndex(index).editor.data())) {
+ if (w->focusPolicy() == Qt::NoFocus)
+ return false;
+ w->setFocus();
+ return true;
+ }
+
+ if (trigger == DoubleClicked) {
+ d->delayedEditing.stop();
+ d->delayedAutoScroll.stop();
+ } else if (trigger == CurrentChanged) {
+ d->delayedEditing.stop();
+ }
+
+ if (d->sendDelegateEvent(index, event)) {
+ update(index);
+ return true;
+ }
+
+ // save the previous trigger before updating
+ EditTriggers lastTrigger = d->lastTrigger;
+ d->lastTrigger = trigger;
+
+ if (!d->shouldEdit(trigger, d->model->buddy(index)))
+ return false;
+
+ if (d->delayedEditing.isActive())
+ return false;
+
+ // we will receive a mouseButtonReleaseEvent after a
+ // mouseDoubleClickEvent, so we need to check the previous trigger
+ if (lastTrigger == DoubleClicked && trigger == SelectedClicked)
+ return false;
+
+ // we may get a double click event later
+ if (trigger == SelectedClicked)
+ d->delayedEditing.start(QApplication::doubleClickInterval(), this);
+ else
+ d->openEditor(index, d->shouldForwardEvent(trigger, event) ? event : 0);
+
+ return true;
+}
+
+/*!
+ \internal
+ Updates the data shown in the open editor widgets in the view.
+*/
+void QAbstractItemView::updateEditorData()
+{
+ Q_D(QAbstractItemView);
+ d->updateEditorData(QModelIndex(), QModelIndex());
+}
+
+/*!
+ \internal
+ Updates the geometry of the open editor widgets in the view.
+*/
+void QAbstractItemView::updateEditorGeometries()
+{
+ Q_D(QAbstractItemView);
+ if(d->editors.isEmpty())
+ return;
+ QStyleOptionViewItemV4 option = d->viewOptionsV4();
+ QList<QEditorInfo>::iterator it = d->editors.begin();
+ QWidgetList editorsToRelease;
+ while (it != d->editors.end()) {
+ QModelIndex index = it->index;
+ QWidget *editor = it->editor;
+ if (index.isValid() && editor) {
+ option.rect = visualRect(index);
+ if (option.rect.isValid()) {
+ editor->show();
+ QAbstractItemDelegate *delegate = d->delegateForIndex(index);
+ if (delegate)
+ delegate->updateEditorGeometry(editor, option, index);
+ } else {
+ editor->hide();
+ }
+ ++it;
+ } else {
+ it = d->editors.erase(it);
+ editorsToRelease << editor;
+ }
+ }
+
+ //we release the editor outside of the loop because it might change the focus and try
+ //to change the d->editors list.
+ for (int i = 0; i < editorsToRelease.count(); ++i) {
+ d->releaseEditor(editorsToRelease.at(i));
+ }
+}
+
+/*!
+ \since 4.4
+
+ Updates the geometry of the child widgets of the view.
+*/
+void QAbstractItemView::updateGeometries()
+{
+ updateEditorGeometries();
+ d_func()->fetchMoreTimer.start(0, this); //fetch more later
+}
+
+/*!
+ \internal
+*/
+void QAbstractItemView::verticalScrollbarValueChanged(int value)
+{
+ Q_D(QAbstractItemView);
+ if (verticalScrollBar()->maximum() == value && d->model->canFetchMore(d->root))
+ d->model->fetchMore(d->root);
+ d->checkMouseMove(viewport()->mapFromGlobal(QCursor::pos()));
+}
+
+/*!
+ \internal
+*/
+void QAbstractItemView::horizontalScrollbarValueChanged(int value)
+{
+ Q_D(QAbstractItemView);
+ if (horizontalScrollBar()->maximum() == value && d->model->canFetchMore(d->root))
+ d->model->fetchMore(d->root);
+ d->checkMouseMove(viewport()->mapFromGlobal(QCursor::pos()));
+}
+
+/*!
+ \internal
+*/
+void QAbstractItemView::verticalScrollbarAction(int)
+{
+ //do nothing
+}
+
+/*!
+ \internal
+*/
+void QAbstractItemView::horizontalScrollbarAction(int)
+{
+ //do nothing
+}
+
+/*!
+ Closes the given \a editor, and releases it. The \a hint is
+ used to specify how the view should respond to the end of the editing
+ operation. For example, the hint may indicate that the next item in
+ the view should be opened for editing.
+
+ \sa edit(), commitData()
+*/
+
+void QAbstractItemView::closeEditor(QWidget *editor, QAbstractItemDelegate::EndEditHint hint)
+{
+ Q_D(QAbstractItemView);
+
+ // Close the editor
+ if (editor) {
+ bool isPersistent = d->persistent.contains(editor);
+ bool hadFocus = editor->hasFocus();
+ QModelIndex index = d->indexForEditor(editor);
+ if (!index.isValid())
+ return; // the editor was not registered
+
+ if (!isPersistent) {
+ setState(NoState);
+ QModelIndex index = d->indexForEditor(editor);
+ editor->removeEventFilter(d->delegateForIndex(index));
+ d->removeEditor(editor);
+ }
+ if (hadFocus)
+ setFocus(); // this will send a focusLost event to the editor
+ else
+ d->checkPersistentEditorFocus();
+
+ QPointer<QWidget> ed = editor;
+ QApplication::sendPostedEvents(editor, 0);
+ editor = ed;
+
+ if (!isPersistent && editor)
+ d->releaseEditor(editor);
+ }
+
+ // The EndEditHint part
+ QItemSelectionModel::SelectionFlags flags = QItemSelectionModel::ClearAndSelect
+ | d->selectionBehaviorFlags();
+ switch (hint) {
+ case QAbstractItemDelegate::EditNextItem: {
+ QModelIndex index = moveCursor(MoveNext, Qt::NoModifier);
+ if (index.isValid()) {
+ QPersistentModelIndex persistent(index);
+ d->selectionModel->setCurrentIndex(persistent, flags);
+ // currentChanged signal would have already started editing
+ if (index.flags() & Qt::ItemIsEditable
+ && (!(editTriggers() & QAbstractItemView::CurrentChanged)))
+ edit(persistent);
+ } break; }
+ case QAbstractItemDelegate::EditPreviousItem: {
+ QModelIndex index = moveCursor(MovePrevious, Qt::NoModifier);
+ if (index.isValid()) {
+ QPersistentModelIndex persistent(index);
+ d->selectionModel->setCurrentIndex(persistent, flags);
+ // currentChanged signal would have already started editing
+ if (index.flags() & Qt::ItemIsEditable
+ && (!(editTriggers() & QAbstractItemView::CurrentChanged)))
+ edit(persistent);
+ } break; }
+ case QAbstractItemDelegate::SubmitModelCache:
+ d->model->submit();
+ break;
+ case QAbstractItemDelegate::RevertModelCache:
+ d->model->revert();
+ break;
+ default:
+ break;
+ }
+}
+
+/*!
+ Commit the data in the \a editor to the model.
+
+ \sa closeEditor()
+*/
+void QAbstractItemView::commitData(QWidget *editor)
+{
+ Q_D(QAbstractItemView);
+ if (!editor || !d->itemDelegate || d->currentlyCommittingEditor)
+ return;
+ QModelIndex index = d->indexForEditor(editor);
+ if (!index.isValid())
+ return;
+ d->currentlyCommittingEditor = editor;
+ QAbstractItemDelegate *delegate = d->delegateForIndex(index);
+ editor->removeEventFilter(delegate);
+ delegate->setModelData(editor, d->model, index);
+ editor->installEventFilter(delegate);
+ d->currentlyCommittingEditor = 0;
+}
+
+/*!
+ This function is called when the given \a editor has been destroyed.
+
+ \sa closeEditor()
+*/
+void QAbstractItemView::editorDestroyed(QObject *editor)
+{
+ Q_D(QAbstractItemView);
+ QWidget *w = qobject_cast<QWidget*>(editor);
+ d->removeEditor(w);
+ d->persistent.remove(w);
+ if (state() == EditingState)
+ setState(NoState);
+}
+
+/*!
+ \obsolete
+ Sets the horizontal scroll bar's steps per item to \a steps.
+
+ This is the number of steps used by the horizontal scroll bar to
+ represent the width of an item.
+
+ Note that if the view has a horizontal header, the item steps
+ will be ignored and the header section size will be used instead.
+
+ \sa horizontalStepsPerItem() setVerticalStepsPerItem()
+*/
+void QAbstractItemView::setHorizontalStepsPerItem(int steps)
+{
+ Q_UNUSED(steps);
+ // do nothing
+}
+
+/*!
+ \obsolete
+ Returns the horizontal scroll bar's steps per item.
+
+ \sa setHorizontalStepsPerItem() verticalStepsPerItem()
+*/
+int QAbstractItemView::horizontalStepsPerItem() const
+{
+ return 1;
+}
+
+/*!
+ \obsolete
+ Sets the vertical scroll bar's steps per item to \a steps.
+
+ This is the number of steps used by the vertical scroll bar to
+ represent the height of an item.
+
+ Note that if the view has a vertical header, the item steps
+ will be ignored and the header section size will be used instead.
+
+ \sa verticalStepsPerItem() setHorizontalStepsPerItem()
+*/
+void QAbstractItemView::setVerticalStepsPerItem(int steps)
+{
+ Q_UNUSED(steps);
+ // do nothing
+}
+
+/*!
+ \obsolete
+ Returns the vertical scroll bar's steps per item.
+
+ \sa setVerticalStepsPerItem() horizontalStepsPerItem()
+*/
+int QAbstractItemView::verticalStepsPerItem() const
+{
+ return 1;
+}
+
+/*!
+ Moves to and selects the item best matching the string \a search.
+ If no item is found nothing happens.
+
+ In the default implementation, the search is reset if \a search is empty, or
+ the time interval since the last search has exceeded
+ QApplication::keyboardInputInterval().
+*/
+void QAbstractItemView::keyboardSearch(const QString &search)
+{
+ Q_D(QAbstractItemView);
+ if (!d->model->rowCount(d->root) || !d->model->columnCount(d->root))
+ return;
+
+ QModelIndex start = currentIndex().isValid() ? currentIndex()
+ : d->model->index(0, 0, d->root);
+ QTime now(QTime::currentTime());
+ bool skipRow = false;
+ if (search.isEmpty()
+ || (d->keyboardInputTime.msecsTo(now) > QApplication::keyboardInputInterval())) {
+ d->keyboardInput = search;
+ skipRow = currentIndex().isValid(); //if it is not valid we should really start at QModelIndex(0,0)
+ } else {
+ d->keyboardInput += search;
+ }
+ d->keyboardInputTime = now;
+
+ // special case for searches with same key like 'aaaaa'
+ bool sameKey = false;
+ if (d->keyboardInput.length() > 1) {
+ int c = d->keyboardInput.count(d->keyboardInput.at(d->keyboardInput.length() - 1));
+ sameKey = (c == d->keyboardInput.length());
+ if (sameKey)
+ skipRow = true;
+ }
+
+ // skip if we are searching for the same key or a new search started
+ if (skipRow) {
+ QModelIndex parent = start.parent();
+ int newRow = (start.row() < d->model->rowCount(parent) - 1) ? start.row() + 1 : 0;
+ start = d->model->index(newRow, start.column(), parent);
+ }
+
+ // search from start with wraparound
+ const QString searchString = sameKey ? QString(d->keyboardInput.at(0)) : d->keyboardInput;
+ QModelIndex current = start;
+ QModelIndexList match;
+ QModelIndex firstMatch;
+ QModelIndex startMatch;
+ QModelIndexList previous;
+ do {
+ match = d->model->match(current, Qt::DisplayRole, searchString);
+ if (match == previous)
+ break;
+ firstMatch = match.value(0);
+ previous = match;
+ if (firstMatch.isValid()) {
+ if (d->isIndexEnabled(firstMatch)) {
+ setCurrentIndex(firstMatch);
+ break;
+ }
+ int row = firstMatch.row() + 1;
+ if (row >= d->model->rowCount(firstMatch.parent()))
+ row = 0;
+ current = firstMatch.sibling(row, firstMatch.column());
+
+ //avoid infinite loop if all the matching items are disabled.
+ if (!startMatch.isValid())
+ startMatch = firstMatch;
+ else if (startMatch == firstMatch)
+ break;
+ }
+ } while (current != start && firstMatch.isValid());
+}
+
+/*!
+ Returns the size hint for the item with the specified \a index or
+ an invalid size for invalid indexes.
+
+ \sa sizeHintForRow(), sizeHintForColumn()
+*/
+QSize QAbstractItemView::sizeHintForIndex(const QModelIndex &index) const
+{
+ Q_D(const QAbstractItemView);
+ if (!d->isIndexValid(index) || !d->itemDelegate)
+ return QSize();
+ return d->delegateForIndex(index)->sizeHint(d->viewOptionsV4(), index);
+}
+
+/*!
+ Returns the height size hint for the specified \a row or -1 if
+ there is no model.
+
+ The returned height is calculated using the size hints of the
+ given \a row's items, i.e. the returned value is the maximum
+ height among the items. Note that to control the height of a row,
+ you must reimplement the QAbstractItemDelegate::sizeHint()
+ function.
+
+ This function is used in views with a vertical header to find the
+ size hint for a header section based on the contents of the given
+ \a row.
+
+ \sa sizeHintForColumn()
+*/
+int QAbstractItemView::sizeHintForRow(int row) const
+{
+ Q_D(const QAbstractItemView);
+
+ if (row < 0 || row >= d->model->rowCount() || !model())
+ return -1;
+
+ QStyleOptionViewItemV4 option = d->viewOptionsV4();
+ int height = 0;
+ int colCount = d->model->columnCount(d->root);
+ QModelIndex index;
+ for (int c = 0; c < colCount; ++c) {
+ index = d->model->index(row, c, d->root);
+ if (QWidget *editor = d->editorForIndex(index).editor)
+ height = qMax(height, editor->size().height());
+ int hint = d->delegateForIndex(index)->sizeHint(option, index).height();
+ height = qMax(height, hint);
+ }
+ return height;
+}
+
+/*!
+ Returns the width size hint for the specified \a column or -1 if there is no model.
+
+ This function is used in views with a horizontal header to find the size hint for
+ a header section based on the contents of the given \a column.
+
+ \sa sizeHintForRow()
+*/
+int QAbstractItemView::sizeHintForColumn(int column) const
+{
+ Q_D(const QAbstractItemView);
+
+ if (column < 0 || column >= d->model->columnCount() || !model())
+ return -1;
+
+ QStyleOptionViewItemV4 option = d->viewOptionsV4();
+ int width = 0;
+ int rows = d->model->rowCount(d->root);
+ QModelIndex index;
+ for (int r = 0; r < rows; ++r) {
+ index = d->model->index(r, column, d->root);
+ if (QWidget *editor = d->editorForIndex(index).editor)
+ width = qMax(width, editor->sizeHint().width());
+ int hint = d->delegateForIndex(index)->sizeHint(option, index).width();
+ width = qMax(width, hint);
+ }
+ return width;
+}
+
+/*!
+ Opens a persistent editor on the item at the given \a index.
+ If no editor exists, the delegate will create a new editor.
+
+ \sa closePersistentEditor()
+*/
+void QAbstractItemView::openPersistentEditor(const QModelIndex &index)
+{
+ Q_D(QAbstractItemView);
+ QStyleOptionViewItemV4 options = d->viewOptionsV4();
+ options.rect = visualRect(index);
+ options.state |= (index == currentIndex() ? QStyle::State_HasFocus : QStyle::State_None);
+
+ QWidget *editor = d->editor(index, options);
+ if (editor) {
+ editor->show();
+ d->persistent.insert(editor);
+ }
+}
+
+/*!
+ Closes the persistent editor for the item at the given \a index.
+
+ \sa openPersistentEditor()
+*/
+void QAbstractItemView::closePersistentEditor(const QModelIndex &index)
+{
+ Q_D(QAbstractItemView);
+ QWidget *editor = d->editorForIndex(index).editor;
+ if (editor) {
+ if (index == selectionModel()->currentIndex())
+ closeEditor(editor, QAbstractItemDelegate::RevertModelCache);
+ d->persistent.remove(editor);
+ d->removeEditor(editor);
+ d->releaseEditor(editor);
+ }
+}
+
+/*!
+ \since 4.1
+
+ Sets the given \a widget on the item at the given \a index, passing the
+ ownership of the widget to the viewport.
+
+ If \a index is invalid (e.g., if you pass the root index), this function
+ will do nothing.
+
+ The given \a widget's \l{QWidget}{autoFillBackground} property must be set
+ to true, otherwise the widget's background will be transparent, showing
+ both the model data and the item at the given \a index.
+
+ If index widget A is replaced with index widget B, index widget A will be
+ deleted. For example, in the code snippet below, the QLineEdit object will
+ be deleted.
+
+ \snippet doc/src/snippets/code/src_gui_itemviews_qabstractitemview.cpp 1
+
+ This function should only be used to display static content within the
+ visible area corresponding to an item of data. If you want to display
+ custom dynamic content or implement a custom editor widget, subclass
+ QItemDelegate instead.
+
+ \sa {Delegate Classes}
+*/
+void QAbstractItemView::setIndexWidget(const QModelIndex &index, QWidget *widget)
+{
+ Q_D(QAbstractItemView);
+ if (!d->isIndexValid(index))
+ return;
+ if (QWidget *oldWidget = indexWidget(index)) {
+ d->removeEditor(oldWidget);
+ oldWidget->deleteLater();
+ }
+ if (widget) {
+ widget->setParent(viewport());
+ d->persistent.insert(widget);
+ d->addEditor(index, widget, true);
+ widget->show();
+ dataChanged(index, index); // update the geometry
+ if (!d->delayedPendingLayout)
+ widget->setGeometry(visualRect(index));
+ }
+}
+
+/*!
+ \since 4.1
+
+ Returns the widget for the item at the given \a index.
+*/
+QWidget* QAbstractItemView::indexWidget(const QModelIndex &index) const
+{
+ Q_D(const QAbstractItemView);
+ if (!d->isIndexValid(index))
+ return 0;
+ return d->editorForIndex(index).editor;
+}
+
+/*!
+ \since 4.1
+
+ Scrolls the view to the top.
+
+ \sa scrollTo(), scrollToBottom()
+*/
+void QAbstractItemView::scrollToTop()
+{
+ verticalScrollBar()->setValue(verticalScrollBar()->minimum());
+}
+
+/*!
+ \since 4.1
+
+ Scrolls the view to the bottom.
+
+ \sa scrollTo(), scrollToTop()
+*/
+void QAbstractItemView::scrollToBottom()
+{
+ Q_D(QAbstractItemView);
+ if (d->delayedPendingLayout) {
+ d->executePostedLayout();
+ updateGeometries();
+ }
+ verticalScrollBar()->setValue(verticalScrollBar()->maximum());
+}
+
+/*!
+ \since 4.3
+
+ Updates the area occupied by the given \a index.
+
+*/
+void QAbstractItemView::update(const QModelIndex &index)
+{
+ Q_D(QAbstractItemView);
+ if (index.isValid()) {
+ const QRect rect = visualRect(index);
+ //this test is important for peformance reason
+ //For example in dataChanged we simply update all the cells without checking
+ //it can be a major bottleneck to update rects that aren't even part of the viewport
+ if (d->viewport->rect().intersects(rect))
+ d->viewport->update(rect);
+ }
+}
+
+/*!
+ This slot is called when items are changed in the model. The
+ changed items are those from \a topLeft to \a bottomRight
+ inclusive. If just one item is changed \a topLeft == \a
+ bottomRight.
+*/
+void QAbstractItemView::dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
+{
+ // Single item changed
+ Q_D(QAbstractItemView);
+ if (topLeft == bottomRight && topLeft.isValid()) {
+ const QEditorInfo editorInfo = d->editorForIndex(topLeft);
+ //we don't update the edit data if it is static
+ if (!editorInfo.isStatic && editorInfo.editor) {
+ QAbstractItemDelegate *delegate = d->delegateForIndex(topLeft);
+ if (delegate) {
+ delegate->setEditorData(editorInfo.editor, topLeft);
+ }
+ }
+ if (isVisible() && !d->delayedPendingLayout) {
+ // otherwise the items will be update later anyway
+ update(topLeft);
+ }
+ return;
+ }
+ d->updateEditorData(topLeft, bottomRight);
+ if (!isVisible() || d->delayedPendingLayout)
+ return; // no need to update
+ d->viewport->update();
+}
+
+/*!
+ This slot is called when rows are inserted. The new rows are those
+ under the given \a parent from \a start to \a end inclusive. The
+ base class implementation calls fetchMore() on the model to check
+ for more data.
+
+ \sa rowsAboutToBeRemoved()
+*/
+void QAbstractItemView::rowsInserted(const QModelIndex &, int, int)
+{
+ if (!isVisible())
+ d_func()->fetchMoreTimer.start(0, this); //fetch more later
+ else
+ updateEditorGeometries();
+}
+
+/*!
+ This slot is called when rows are about to be removed. The deleted rows are
+ those under the given \a parent from \a start to \a end inclusive.
+
+ \sa rowsInserted()
+*/
+void QAbstractItemView::rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
+{
+ Q_D(QAbstractItemView);
+
+ setState(CollapsingState);
+
+ // Ensure one selected item in single selection mode.
+ QModelIndex current = currentIndex();
+ if (d->selectionMode == SingleSelection
+ && current.isValid()
+ && current.row() >= start
+ && current.row() <= end
+ && current.parent() == parent) {
+ int totalToRemove = end - start + 1;
+ if (d->model->rowCount(parent) <= totalToRemove) { // no more children
+ QModelIndex index = parent;
+ while (index != d->root && !d->isIndexEnabled(index))
+ index = index.parent();
+ if (index != d->root)
+ setCurrentIndex(index);
+ } else {
+ int row = end + 1;
+ QModelIndex next;
+ do { // find the next visible and enabled item
+ next = d->model->index(row++, current.column(), current.parent());
+ } while (next.isValid() && (isIndexHidden(next) || !d->isIndexEnabled(next)));
+ if (row > d->model->rowCount(parent)) {
+ row = start - 1;
+ do { // find the previous visible and enabled item
+ next = d->model->index(row--, current.column(), current.parent());
+ } while (next.isValid() && (isIndexHidden(next) || !d->isIndexEnabled(next)));
+ }
+ setCurrentIndex(next);
+ }
+ }
+
+ // Remove all affected editors; this is more efficient than waiting for updateGeometries() to clean out editors for invalid indexes
+ for (int i = d->editors.size() - 1; i >= 0; --i) {
+ const QModelIndex index = d->editors.at(i).index;
+ QWidget *editor = d->editors.at(i).editor;
+ if (index.row() >= start && index.row() <= end && d->model->parent(index) == parent) {
+ d->editors.removeAt(i);
+ d->releaseEditor(editor);
+ }
+ }
+}
+
+/*!
+ \internal
+
+ This slot is called when rows have been removed. The deleted
+ rows are those under the given \a parent from \a start to \a end
+ inclusive.
+*/
+void QAbstractItemViewPrivate::_q_rowsRemoved(const QModelIndex &, int, int)
+{
+ Q_Q(QAbstractItemView);
+ if (q->isVisible())
+ q->updateEditorGeometries();
+ q->setState(QAbstractItemView::NoState);
+}
+
+/*!
+ \internal
+
+ This slot is called when columns are about to be removed. The deleted
+ columns are those under the given \a parent from \a start to \a end
+ inclusive.
+*/
+void QAbstractItemViewPrivate::_q_columnsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
+{
+ Q_Q(QAbstractItemView);
+
+ q->setState(QAbstractItemView::CollapsingState);
+
+ // Ensure one selected item in single selection mode.
+ QModelIndex current = q->currentIndex();
+ if (current.isValid()
+ && selectionMode == QAbstractItemView::SingleSelection
+ && current.column() >= start
+ && current.column() <= end) {
+ int totalToRemove = end - start + 1;
+ if (model->columnCount(parent) < totalToRemove) { // no more columns
+ QModelIndex index = parent;
+ while (index.isValid() && !isIndexEnabled(index))
+ index = index.parent();
+ if (index.isValid())
+ q->setCurrentIndex(index);
+ } else {
+ int column = end;
+ QModelIndex next;
+ do { // find the next visible and enabled item
+ next = model->index(current.row(), column++, current.parent());
+ } while (next.isValid() && (q->isIndexHidden(next) || !isIndexEnabled(next)));
+ q->setCurrentIndex(next);
+ }
+ }
+
+ // Remove all affected editors; this is more efficient than waiting for updateGeometries() to clean out editors for invalid indexes
+ QList<QEditorInfo>::iterator it = editors.begin();
+ while (it != editors.end()) {
+ QModelIndex index = it->index;
+ if (index.column() <= start && index.column() >= end && model->parent(index) == parent) {
+ QWidget *editor = it->editor;
+ it = editors.erase(it);
+ releaseEditor(editor);
+ } else {
+ ++it;
+ }
+ }
+}
+
+/*!
+ \internal
+
+ This slot is called when columns have been removed. The deleted
+ rows are those under the given \a parent from \a start to \a end
+ inclusive.
+*/
+void QAbstractItemViewPrivate::_q_columnsRemoved(const QModelIndex &, int, int)
+{
+ Q_Q(QAbstractItemView);
+ if (q->isVisible())
+ q->updateEditorGeometries();
+ q->setState(QAbstractItemView::NoState);
+}
+
+/*!
+ \internal
+
+ This slot is called when rows have been inserted.
+*/
+void QAbstractItemViewPrivate::_q_columnsInserted(const QModelIndex &, int, int)
+{
+ Q_Q(QAbstractItemView);
+ if (q->isVisible())
+ q->updateEditorGeometries();
+}
+
+
+
+/*!
+ \internal
+*/
+void QAbstractItemViewPrivate::_q_modelDestroyed()
+{
+ model = QAbstractItemModelPrivate::staticEmptyModel();
+ doDelayedReset();
+}
+
+/*!
+ \internal
+
+ This slot is called when the layout is changed.
+*/
+void QAbstractItemViewPrivate::_q_layoutChanged()
+{
+ doDelayedItemsLayout();
+}
+
+/*!
+ This slot is called when the selection is changed. The previous
+ selection (which may be empty), is specified by \a deselected, and the
+ new selection by \a selected.
+
+ \sa setSelection()
+*/
+void QAbstractItemView::selectionChanged(const QItemSelection &selected,
+ const QItemSelection &deselected)
+{
+ Q_D(QAbstractItemView);
+ if (isVisible() && updatesEnabled()) {
+ d->viewport->update(visualRegionForSelection(deselected) | visualRegionForSelection(selected));
+ }
+}
+
+/*!
+ This slot is called when a new item becomes the current item.
+ The previous current item is specified by the \a previous index, and the new
+ item by the \a current index.
+
+ If you want to know about changes to items see the
+ dataChanged() signal.
+*/
+void QAbstractItemView::currentChanged(const QModelIndex ¤t, const QModelIndex &previous)
+{
+ Q_D(QAbstractItemView);
+ Q_ASSERT(d->model);
+
+ if (previous.isValid()) {
+ QModelIndex buddy = d->model->buddy(previous);
+ QWidget *editor = d->editorForIndex(buddy).editor;
+ if (editor && !d->persistent.contains(editor)) {
+ commitData(editor);
+ if (current.row() != previous.row())
+ closeEditor(editor, QAbstractItemDelegate::SubmitModelCache);
+ else
+ closeEditor(editor, QAbstractItemDelegate::NoHint);
+ }
+ if (isVisible()) {
+ update(previous);
+ }
+ }
+
+ if (current.isValid() && !d->autoScrollTimer.isActive()) {
+ if (isVisible()) {
+ if (d->autoScroll)
+ scrollTo(current);
+ update(current);
+ edit(current, CurrentChanged, 0);
+ if (current.row() == (d->model->rowCount(d->root) - 1))
+ d->fetchMore();
+ } else {
+ d->shouldScrollToCurrentOnShow = d->autoScroll;
+ }
+ }
+}
+
+#ifndef QT_NO_DRAGANDDROP
+/*!
+ Starts a drag by calling drag->exec() using the given \a supportedActions.
+*/
+void QAbstractItemView::startDrag(Qt::DropActions supportedActions)
+{
+ Q_D(QAbstractItemView);
+ QModelIndexList indexes = d->selectedDraggableIndexes();
+ if (indexes.count() > 0) {
+ QMimeData *data = d->model->mimeData(indexes);
+ if (!data)
+ return;
+ QRect rect;
+ QPixmap pixmap = d->renderToPixmap(indexes, &rect);
+ rect.adjust(horizontalOffset(), verticalOffset(), 0, 0);
+ QDrag *drag = new QDrag(this);
+ drag->setPixmap(pixmap);
+ drag->setMimeData(data);
+ drag->setHotSpot(d->pressedPosition - rect.topLeft());
+ Qt::DropAction defaultDropAction = Qt::IgnoreAction;
+ if (d->defaultDropAction != Qt::IgnoreAction && (supportedActions & d->defaultDropAction))
+ defaultDropAction = d->defaultDropAction;
+ else if (supportedActions & Qt::CopyAction && dragDropMode() != QAbstractItemView::InternalMove)
+ defaultDropAction = Qt::CopyAction;
+ if (drag->exec(supportedActions, defaultDropAction) == Qt::MoveAction)
+ d->clearOrRemove();
+ }
+}
+#endif // QT_NO_DRAGANDDROP
+
+/*!
+ Returns a QStyleOptionViewItem structure populated with the view's
+ palette, font, state, alignments etc.
+*/
+QStyleOptionViewItem QAbstractItemView::viewOptions() const
+{
+ Q_D(const QAbstractItemView);
+ QStyleOptionViewItem option;
+ option.init(this);
+ option.state &= ~QStyle::State_MouseOver;
+ option.font = font();
+
+#ifndef Q_WS_MAC
+ // On mac the focus appearance follows window activation
+ // not widget activation
+ if (!hasFocus())
+ option.state &= ~QStyle::State_Active;
+#endif
+
+ option.state &= ~QStyle::State_HasFocus;
+ if (d->iconSize.isValid()) {
+ option.decorationSize = d->iconSize;
+ } else {
+ int pm = style()->pixelMetric(QStyle::PM_SmallIconSize, 0, this);
+ option.decorationSize = QSize(pm, pm);
+ }
+ option.decorationPosition = QStyleOptionViewItem::Left;
+ option.decorationAlignment = Qt::AlignCenter;
+ option.displayAlignment = Qt::AlignLeft|Qt::AlignVCenter;
+ option.textElideMode = d->textElideMode;
+ option.rect = QRect();
+ option.showDecorationSelected = style()->styleHint(QStyle::SH_ItemView_ShowDecorationSelected, 0, this);
+ return option;
+}
+
+QStyleOptionViewItemV4 QAbstractItemViewPrivate::viewOptionsV4() const
+{
+ Q_Q(const QAbstractItemView);
+ QStyleOptionViewItemV4 option = q->viewOptions();
+ if (wrapItemText)
+ option.features = QStyleOptionViewItemV2::WrapText;
+ option.locale = q->locale();
+ option.locale.setNumberOptions(QLocale::OmitGroupSeparator);
+ option.widget = q;
+ return option;
+}
+
+/*!
+ Returns the item view's state.
+
+ \sa setState()
+*/
+QAbstractItemView::State QAbstractItemView::state() const
+{
+ Q_D(const QAbstractItemView);
+ return d->state;
+}
+
+/*!
+ Sets the item view's state to the given \a state.
+
+ \sa state()
+*/
+void QAbstractItemView::setState(State state)
+{
+ Q_D(QAbstractItemView);
+ d->state = state;
+}
+
+/*!
+ Schedules a layout of the items in the view to be executed when the
+ event processing starts.
+
+ Even if scheduleDelayedItemsLayout() is called multiple times before
+ events are processed, the view will only do the layout once.
+
+ \sa executeDelayedItemsLayout()
+*/
+void QAbstractItemView::scheduleDelayedItemsLayout()
+{
+ Q_D(QAbstractItemView);
+ d->doDelayedItemsLayout();
+}
+
+/*!
+ Executes the scheduled layouts without waiting for the event processing
+ to begin.
+
+ \sa scheduleDelayedItemsLayout()
+*/
+void QAbstractItemView::executeDelayedItemsLayout()
+{
+ Q_D(QAbstractItemView);
+ d->executePostedLayout();
+}
+
+/*!
+ \since 4.1
+
+ Marks the given \a region as dirty and schedules it to be updated.
+ You only need to call this function if you are implementing
+ your own view subclass.
+
+ \sa scrollDirtyRegion(), dirtyRegionOffset()
+*/
+
+void QAbstractItemView::setDirtyRegion(const QRegion ®ion)
+{
+ Q_D(QAbstractItemView);
+ d->setDirtyRegion(region);
+}
+
+/*!
+ Prepares the view for scrolling by (\a{dx},\a{dy}) pixels by moving the dirty regions in the
+ opposite direction. You only need to call this function if you are implementing a scrolling
+ viewport in your view subclass.
+
+ If you implement scrollContentsBy() in a subclass of QAbstractItemView, call this function
+ before you call QWidget::scroll() on the viewport. Alternatively, just call update().
+
+ \sa scrollContentsBy(), dirtyRegionOffset(), setDirtyRegion()
+*/
+void QAbstractItemView::scrollDirtyRegion(int dx, int dy)
+{
+ Q_D(QAbstractItemView);
+ d->scrollDirtyRegion(dx, dy);
+}
+
+/*!
+ Returns the offset of the dirty regions in the view.
+
+ If you use scrollDirtyRegion() and implement a paintEvent() in a subclass of
+ QAbstractItemView, you should translate the area given by the paint event with
+ the offset returned from this function.
+
+ \sa scrollDirtyRegion(), setDirtyRegion()
+*/
+QPoint QAbstractItemView::dirtyRegionOffset() const
+{
+ Q_D(const QAbstractItemView);
+ return d->scrollDelayOffset;
+}
+
+/*!
+ \internal
+*/
+void QAbstractItemView::startAutoScroll()
+{
+ d_func()->startAutoScroll();
+}
+
+/*!
+ \internal
+*/
+void QAbstractItemView::stopAutoScroll()
+{
+ d_func()->stopAutoScroll();
+}
+
+/*!
+ \internal
+*/
+void QAbstractItemView::doAutoScroll()
+{
+ // find how much we should scroll with
+ Q_D(QAbstractItemView);
+ int verticalStep = verticalScrollBar()->pageStep();
+ int horizontalStep = horizontalScrollBar()->pageStep();
+ if (d->autoScrollCount < qMax(verticalStep, horizontalStep))
+ ++d->autoScrollCount;
+
+ int margin = d->autoScrollMargin;
+ int verticalValue = verticalScrollBar()->value();
+ int horizontalValue = horizontalScrollBar()->value();
+
+ QPoint pos = d->viewport->mapFromGlobal(QCursor::pos());
+ QRect area = static_cast<QAbstractItemView*>(d->viewport)->d_func()->clipRect(); // access QWidget private by bending C++ rules
+
+ // do the scrolling if we are in the scroll margins
+ if (pos.y() - area.top() < margin)
+ verticalScrollBar()->setValue(verticalValue - d->autoScrollCount);
+ else if (area.bottom() - pos.y() < margin)
+ verticalScrollBar()->setValue(verticalValue + d->autoScrollCount);
+ if (pos.x() - area.left() < margin)
+ horizontalScrollBar()->setValue(horizontalValue - d->autoScrollCount);
+ else if (area.right() - pos.x() < margin)
+ horizontalScrollBar()->setValue(horizontalValue + d->autoScrollCount);
+ // if nothing changed, stop scrolling
+ bool verticalUnchanged = (verticalValue == verticalScrollBar()->value());
+ bool horizontalUnchanged = (horizontalValue == horizontalScrollBar()->value());
+ if (verticalUnchanged && horizontalUnchanged) {
+ stopAutoScroll();
+ } else {
+#ifndef QT_NO_DRAGANDDROP
+ d->dropIndicatorRect = QRect();
+ d->dropIndicatorPosition = QAbstractItemView::OnViewport;
+#endif
+ d->viewport->update();
+ }
+}
+
+/*!
+ Returns the SelectionFlags to be used when updating a selection with
+ to include the \a index specified. The \a event is a user input event,
+ such as a mouse or keyboard event.
+
+ Reimplement this function to define your own selection behavior.
+
+ \sa setSelection()
+*/
+QItemSelectionModel::SelectionFlags QAbstractItemView::selectionCommand(const QModelIndex &index,
+ const QEvent *event) const
+{
+ Q_D(const QAbstractItemView);
+ switch (d->selectionMode) {
+ case NoSelection: // Never update selection model
+ return QItemSelectionModel::NoUpdate;
+ case SingleSelection: // ClearAndSelect on valid index otherwise NoUpdate
+ if (event && event->type() == QEvent::MouseButtonRelease)
+ return QItemSelectionModel::NoUpdate;
+ return QItemSelectionModel::ClearAndSelect|d->selectionBehaviorFlags();
+ case MultiSelection:
+ return d->multiSelectionCommand(index, event);
+ case ExtendedSelection:
+ return d->extendedSelectionCommand(index, event);
+ case ContiguousSelection:
+ return d->contiguousSelectionCommand(index, event);
+ }
+ return QItemSelectionModel::NoUpdate;
+}
+
+QItemSelectionModel::SelectionFlags QAbstractItemViewPrivate::multiSelectionCommand(
+ const QModelIndex &index, const QEvent *event) const
+{
+ Q_UNUSED(index);
+
+ if (event) {
+ switch (event->type()) {
+ case QEvent::KeyPress:
+ if (static_cast<const QKeyEvent*>(event)->key() == Qt::Key_Space
+ || static_cast<const QKeyEvent*>(event)->key() == Qt::Key_Select)
+ return QItemSelectionModel::Toggle|selectionBehaviorFlags();
+ break;
+ case QEvent::MouseButtonPress:
+ if (static_cast<const QMouseEvent*>(event)->button() == Qt::LeftButton)
+ return QItemSelectionModel::Toggle|selectionBehaviorFlags(); // toggle
+ break;
+ case QEvent::MouseButtonRelease:
+ if (static_cast<const QMouseEvent*>(event)->button() == Qt::LeftButton)
+ return QItemSelectionModel::NoUpdate|selectionBehaviorFlags(); // finalize
+ break;
+ case QEvent::MouseMove:
+ if (static_cast<const QMouseEvent*>(event)->buttons() & Qt::LeftButton)
+ return QItemSelectionModel::ToggleCurrent|selectionBehaviorFlags(); // toggle drag select
+ default:
+ break;
+ }
+ return QItemSelectionModel::NoUpdate;
+ }
+
+ return QItemSelectionModel::Toggle|selectionBehaviorFlags();
+}
+
+QItemSelectionModel::SelectionFlags QAbstractItemViewPrivate::extendedSelectionCommand(
+ const QModelIndex &index, const QEvent *event) const
+{
+ Qt::KeyboardModifiers modifiers = QApplication::keyboardModifiers();
+ if (event) {
+ switch (event->type()) {
+ case QEvent::MouseMove: {
+ // Toggle on MouseMove
+ modifiers = static_cast<const QMouseEvent*>(event)->modifiers();
+ if (modifiers & Qt::ControlModifier)
+ return QItemSelectionModel::ToggleCurrent|selectionBehaviorFlags();
+ break;
+ }
+ case QEvent::MouseButtonPress: {
+ modifiers = static_cast<const QMouseEvent*>(event)->modifiers();
+ const Qt::MouseButton button = static_cast<const QMouseEvent*>(event)->button();
+ const bool rightButtonPressed = button & Qt::RightButton;
+ const bool shiftKeyPressed = modifiers & Qt::ShiftModifier;
+ const bool controlKeyPressed = modifiers & Qt::ControlModifier;
+ const bool indexIsSelected = selectionModel->isSelected(index);
+ if ((shiftKeyPressed || controlKeyPressed) && rightButtonPressed)
+ return QItemSelectionModel::NoUpdate;
+ if (!shiftKeyPressed && !controlKeyPressed && indexIsSelected)
+ return QItemSelectionModel::NoUpdate;
+ if (!index.isValid() && !rightButtonPressed && !shiftKeyPressed && !controlKeyPressed)
+ return QItemSelectionModel::Clear;
+ if (!index.isValid())
+ return QItemSelectionModel::NoUpdate;
+ break;
+ }
+ case QEvent::MouseButtonRelease: {
+ // ClearAndSelect on MouseButtonRelease if MouseButtonPress on selected item or empty area
+ modifiers = static_cast<const QMouseEvent*>(event)->modifiers();
+ const Qt::MouseButton button = static_cast<const QMouseEvent*>(event)->button();
+ const bool rightButtonPressed = button & Qt::RightButton;
+ const bool shiftKeyPressed = modifiers & Qt::ShiftModifier;
+ const bool controlKeyPressed = modifiers & Qt::ControlModifier;
+ if (((index == pressedIndex && selectionModel->isSelected(index))
+ || !index.isValid()) && state != QAbstractItemView::DragSelectingState
+ && !shiftKeyPressed && !controlKeyPressed && !rightButtonPressed)
+ return QItemSelectionModel::ClearAndSelect|selectionBehaviorFlags();
+ return QItemSelectionModel::NoUpdate;
+ }
+ case QEvent::KeyPress: {
+ // NoUpdate on Key movement and Ctrl
+ modifiers = static_cast<const QKeyEvent*>(event)->modifiers();
+ switch (static_cast<const QKeyEvent*>(event)->key()) {
+ case Qt::Key_Backtab:
+ modifiers = modifiers & ~Qt::ShiftModifier; // special case for backtab
+ case Qt::Key_Down:
+ case Qt::Key_Up:
+ case Qt::Key_Left:
+ case Qt::Key_Right:
+ case Qt::Key_Home:
+ case Qt::Key_End:
+ case Qt::Key_PageUp:
+ case Qt::Key_PageDown:
+ case Qt::Key_Tab:
+ if (modifiers & Qt::ControlModifier
+#ifdef QT_KEYPAD_NAVIGATION
+ // Preserve historical tab order navigation behavior
+ || QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder
+#endif
+ )
+ return QItemSelectionModel::NoUpdate;
+ break;
+ case Qt::Key_Select:
+ return QItemSelectionModel::Toggle|selectionBehaviorFlags();
+ case Qt::Key_Space:// Toggle on Ctrl-Qt::Key_Space, Select on Space
+ if (modifiers & Qt::ControlModifier)
+ return QItemSelectionModel::Toggle|selectionBehaviorFlags();
+ return QItemSelectionModel::Select|selectionBehaviorFlags();
+ default:
+ break;
+ }
+ }
+ default:
+ break;
+ }
+ }
+
+ if (modifiers & Qt::ShiftModifier)
+ return QItemSelectionModel::SelectCurrent|selectionBehaviorFlags();
+ if (modifiers & Qt::ControlModifier)
+ return QItemSelectionModel::Toggle|selectionBehaviorFlags();
+ if (state == QAbstractItemView::DragSelectingState) {
+ //when drag-selecting we need to clear any previous selection and select the current one
+ return QItemSelectionModel::Clear|QItemSelectionModel::SelectCurrent|selectionBehaviorFlags();
+ }
+
+ return QItemSelectionModel::ClearAndSelect|selectionBehaviorFlags();
+}
+
+QItemSelectionModel::SelectionFlags
+QAbstractItemViewPrivate::contiguousSelectionCommand(const QModelIndex &index,
+ const QEvent *event) const
+{
+ QItemSelectionModel::SelectionFlags flags = extendedSelectionCommand(index, event);
+ const int Mask = QItemSelectionModel::Clear | QItemSelectionModel::Select
+ | QItemSelectionModel::Deselect | QItemSelectionModel::Toggle
+ | QItemSelectionModel::Current;
+
+ switch (flags & Mask) {
+ case QItemSelectionModel::Clear:
+ case QItemSelectionModel::ClearAndSelect:
+ case QItemSelectionModel::SelectCurrent:
+ return flags;
+ case QItemSelectionModel::NoUpdate:
+ if (event &&
+ (event->type() == QEvent::MouseButtonPress
+ || event->type() == QEvent::MouseButtonRelease))
+ return flags;
+ return QItemSelectionModel::ClearAndSelect|selectionBehaviorFlags();
+ default:
+ return QItemSelectionModel::SelectCurrent|selectionBehaviorFlags();
+ }
+}
+
+void QAbstractItemViewPrivate::fetchMore()
+{
+ fetchMoreTimer.stop();
+ if (!model->canFetchMore(root))
+ return;
+ int last = model->rowCount(root) - 1;
+ if (last < 0) {
+ model->fetchMore(root);
+ return;
+ }
+
+ QModelIndex index = model->index(last, 0, root);
+ QRect rect = q_func()->visualRect(index);
+ if (viewport->rect().intersects(rect))
+ model->fetchMore(root);
+}
+
+bool QAbstractItemViewPrivate::shouldEdit(QAbstractItemView::EditTrigger trigger,
+ const QModelIndex &index) const
+{
+ if (!index.isValid())
+ return false;
+ Qt::ItemFlags flags = model->flags(index);
+ if (((flags & Qt::ItemIsEditable) == 0) || ((flags & Qt::ItemIsEnabled) == 0))
+ return false;
+ if (state == QAbstractItemView::EditingState)
+ return false;
+ if (hasEditor(index))
+ return false;
+ if (trigger == QAbstractItemView::AllEditTriggers) // force editing
+ return true;
+ if ((trigger & editTriggers) == QAbstractItemView::SelectedClicked
+ && !selectionModel->isSelected(index))
+ return false;
+ return (trigger & editTriggers);
+}
+
+bool QAbstractItemViewPrivate::shouldForwardEvent(QAbstractItemView::EditTrigger trigger,
+ const QEvent *event) const
+{
+ if (!event || (trigger & editTriggers) != QAbstractItemView::AnyKeyPressed)
+ return false;
+
+ switch (event->type()) {
+ case QEvent::KeyPress:
+ case QEvent::MouseButtonDblClick:
+ case QEvent::MouseButtonPress:
+ case QEvent::MouseButtonRelease:
+ case QEvent::MouseMove:
+ return true;
+ default:
+ break;
+ };
+
+ return false;
+}
+
+bool QAbstractItemViewPrivate::shouldAutoScroll(const QPoint &pos) const
+{
+ if (!autoScroll)
+ return false;
+ QRect area = static_cast<QAbstractItemView*>(viewport)->d_func()->clipRect(); // access QWidget private by bending C++ rules
+ return (pos.y() - area.top() < autoScrollMargin)
+ || (area.bottom() - pos.y() < autoScrollMargin)
+ || (pos.x() - area.left() < autoScrollMargin)
+ || (area.right() - pos.x() < autoScrollMargin);
+}
+
+void QAbstractItemViewPrivate::doDelayedItemsLayout(int delay)
+{
+ if (!delayedPendingLayout) {
+ delayedPendingLayout = true;
+ delayedLayout.start(delay, q_func());
+ }
+}
+
+void QAbstractItemViewPrivate::interruptDelayedItemsLayout() const
+{
+ delayedLayout.stop();
+ delayedPendingLayout = false;
+}
+
+
+
+QWidget *QAbstractItemViewPrivate::editor(const QModelIndex &index,
+ const QStyleOptionViewItem &options)
+{
+ Q_Q(QAbstractItemView);
+ QWidget *w = editorForIndex(index).editor;
+ if (!w) {
+ QAbstractItemDelegate *delegate = delegateForIndex(index);
+ if (!delegate)
+ return 0;
+ w = delegate->createEditor(viewport, options, index);
+ if (w) {
+ w->installEventFilter(delegate);
+ QObject::connect(w, SIGNAL(destroyed(QObject*)), q, SLOT(editorDestroyed(QObject*)));
+ delegate->updateEditorGeometry(w, options, index);
+ delegate->setEditorData(w, index);
+ addEditor(index, w, false);
+ if (w->parent() == viewport)
+ QWidget::setTabOrder(q, w);
+
+ // Special cases for some editors containing QLineEdit
+ QWidget *focusWidget = w;
+ while (QWidget *fp = focusWidget->focusProxy())
+ focusWidget = fp;
+#ifndef QT_NO_LINEEDIT
+ if (QLineEdit *le = qobject_cast<QLineEdit*>(focusWidget))
+ le->selectAll();
+#endif
+#ifndef QT_NO_SPINBOX
+ if (QSpinBox *sb = qobject_cast<QSpinBox*>(focusWidget))
+ sb->selectAll();
+ else if (QDoubleSpinBox *dsb = qobject_cast<QDoubleSpinBox*>(focusWidget))
+ dsb->selectAll();
+#endif
+ }
+ }
+ return w;
+}
+
+void QAbstractItemViewPrivate::updateEditorData(const QModelIndex &tl, const QModelIndex &br)
+{
+ // we are counting on having relatively few editors
+ const bool checkIndexes = tl.isValid() && br.isValid();
+ const QModelIndex parent = tl.parent();
+ QList<QEditorInfo>::const_iterator it = editors.constBegin();
+ for (; it != editors.constEnd(); ++it) {
+ QWidget *editor = it->editor;
+ const QModelIndex index = it->index;
+ if (it->isStatic || editor == 0 || !index.isValid() ||
+ (checkIndexes
+ && (index.row() < tl.row() || index.row() > br.row()
+ || index.column() < tl.column() || index.column() > br.column()
+ || index.parent() != parent)))
+ continue;
+
+ QAbstractItemDelegate *delegate = delegateForIndex(index);
+ if (delegate) {
+ delegate->setEditorData(editor, index);
+ }
+ }
+}
+
+/*!
+ \internal
+
+ In DND if something has been moved then this is called.
+ Typically this means you should "remove" the selected item or row,
+ but the behavior is view dependant (table just clears the selected indexes for example).
+
+ Either remove the selected rows or clear them
+*/
+void QAbstractItemViewPrivate::clearOrRemove()
+{
+#ifndef QT_NO_DRAGANDDROP
+ const QItemSelection selection = selectionModel->selection();
+ QList<QItemSelectionRange>::const_iterator it = selection.constBegin();
+
+ if (!overwrite) {
+ for (; it != selection.constEnd(); ++it) {
+ QModelIndex parent = (*it).parent();
+ if ((*it).left() != 0)
+ continue;
+ if ((*it).right() != (model->columnCount(parent) - 1))
+ continue;
+ int count = (*it).bottom() - (*it).top() + 1;
+ model->removeRows((*it).top(), count, parent);
+ }
+ } else {
+ // we can't remove the rows so reset the items (i.e. the view is like a table)
+ QModelIndexList list = selection.indexes();
+ for (int i=0; i < list.size(); ++i) {
+ QModelIndex index = list.at(i);
+ QMap<int, QVariant> roles = model->itemData(index);
+ for (QMap<int, QVariant>::Iterator it = roles.begin(); it != roles.end(); ++it)
+ it.value() = QVariant();
+ model->setItemData(index, roles);
+ }
+ }
+#endif
+}
+
+/*!
+ \internal
+
+ When persistent aeditor gets/loses focus, we need to check
+ and setcorrectly the current index.
+*/
+void QAbstractItemViewPrivate::checkPersistentEditorFocus()
+{
+ Q_Q(QAbstractItemView);
+ if (QWidget *widget = QApplication::focusWidget()) {
+ if (persistent.contains(widget)) {
+ //a persistent editor has gained the focus
+ QModelIndex index = indexForEditor(widget);
+ if (selectionModel->currentIndex() != index)
+ q->setCurrentIndex(index);
+ }
+ }
+}
+
+
+QEditorInfo QAbstractItemViewPrivate::editorForIndex(const QModelIndex &index) const
+{
+ QList<QEditorInfo>::const_iterator it = editors.constBegin();
+ for (; it != editors.constEnd(); ++it) {
+ if (it->index == index)
+ return *it;
+ }
+
+ return QEditorInfo();
+}
+
+QModelIndex QAbstractItemViewPrivate::indexForEditor(QWidget *editor) const
+{
+ QList<QEditorInfo>::const_iterator it = editors.constBegin();
+ for (; it != editors.constEnd(); ++it) {
+ if (it->editor == editor)
+ return it->index;
+ }
+ return QModelIndex();
+}
+
+void QAbstractItemViewPrivate::removeEditor(QWidget *editor)
+{
+ QList<QEditorInfo>::iterator it = editors.begin();
+ for (; it != editors.end(); ) {
+ if (it->editor == editor)
+ it = editors.erase(it);
+ else
+ ++it;
+ }
+}
+
+void QAbstractItemViewPrivate::addEditor(const QModelIndex &index, QWidget *editor, bool isStatic)
+{
+ editors.append(QEditorInfo(index, editor, isStatic));
+}
+
+bool QAbstractItemViewPrivate::sendDelegateEvent(const QModelIndex &index, QEvent *event) const
+{
+ Q_Q(const QAbstractItemView);
+ QModelIndex buddy = model->buddy(index);
+ QStyleOptionViewItemV4 options = viewOptionsV4();
+ options.rect = q->visualRect(buddy);
+ options.state |= (buddy == q->currentIndex() ? QStyle::State_HasFocus : QStyle::State_None);
+ QAbstractItemDelegate *delegate = delegateForIndex(index);
+ return (event && delegate && delegate->editorEvent(event, model, options, buddy));
+}
+
+bool QAbstractItemViewPrivate::openEditor(const QModelIndex &index, QEvent *event)
+{
+ Q_Q(QAbstractItemView);
+
+ QModelIndex buddy = model->buddy(index);
+ QStyleOptionViewItemV4 options = viewOptionsV4();
+ options.rect = q->visualRect(buddy);
+ options.state |= (buddy == q->currentIndex() ? QStyle::State_HasFocus : QStyle::State_None);
+
+ QWidget *w = editor(buddy, options);
+ if (!w)
+ return false;
+
+ if (event)
+ QApplication::sendEvent(w->focusProxy() ? w->focusProxy() : w, event);
+
+ q->setState(QAbstractItemView::EditingState);
+ w->show();
+ w->setFocus();
+
+ return true;
+}
+
+/*
+ \internal
+
+ returns the pair QRect/QModelIndex that should be painted on the viewports's rect
+*/
+
+QItemViewPaintPairs QAbstractItemViewPrivate::draggablePaintPairs(const QModelIndexList &indexes, QRect *r) const
+{
+ Q_ASSERT(r);
+ Q_Q(const QAbstractItemView);
+ QRect &rect = *r;
+ const QRect viewportRect = viewport->rect();
+ QItemViewPaintPairs ret;
+ for (int i = 0; i < indexes.count(); ++i) {
+ const QModelIndex &index = indexes.at(i);
+ const QRect current = q->visualRect(index);
+ if (current.intersects(viewportRect)) {
+ ret += qMakePair(current, index);
+ rect |= current;
+ }
+ }
+ rect &= viewportRect;
+ return ret;
+}
+
+QPixmap QAbstractItemViewPrivate::renderToPixmap(const QModelIndexList &indexes, QRect *r) const
+{
+ Q_ASSERT(r);
+ QItemViewPaintPairs paintPairs = draggablePaintPairs(indexes, r);
+ if (paintPairs.isEmpty())
+ return QPixmap();
+ QPixmap pixmap(r->size());
+ pixmap.fill(Qt::transparent);
+ QPainter painter(&pixmap);
+ QStyleOptionViewItemV4 option = viewOptionsV4();
+ option.state |= QStyle::State_Selected;
+ for (int j = 0; j < paintPairs.count(); ++j) {
+ option.rect = paintPairs.at(j).first.translated(-r->topLeft());
+ const QModelIndex ¤t = paintPairs.at(j).second;
+ delegateForIndex(current)->paint(&painter, option, current);
+ }
+ return pixmap;
+}
+
+void QAbstractItemViewPrivate::selectAll(QItemSelectionModel::SelectionFlags command)
+{
+ if (!selectionModel)
+ return;
+
+ QItemSelection selection;
+ QModelIndex tl = model->index(0, 0, root);
+ QModelIndex br = model->index(model->rowCount(root) - 1,
+ model->columnCount(root) - 1,
+ root);
+ selection.append(QItemSelectionRange(tl, br));
+ selectionModel->select(selection, command);
+}
+
+QModelIndexList QAbstractItemViewPrivate::selectedDraggableIndexes() const
+{
+ Q_Q(const QAbstractItemView);
+ QModelIndexList indexes = q->selectedIndexes();
+ for(int i = indexes.count() - 1 ; i >= 0; --i) {
+ if (!isIndexDragEnabled(indexes.at(i)))
+ indexes.removeAt(i);
+ }
+ return indexes;
+}
+
+
+QT_END_NAMESPACE
+
+#include "moc_qabstractitemview.cpp"
+
+#endif // QT_NO_ITEMVIEWS