QSortFilterProxyModelPrivate Class Reference

Inheritance diagram for QSortFilterProxyModelPrivate:

Classes
struct	Mapping

Public Functions
void	_q_clearMapping ()
void	_q_sourceAboutToBeReset ()
void	_q_sourceColumnsAboutToBeInserted (const QModelIndex &source_parent, int start, int end)
void	_q_sourceColumnsAboutToBeRemoved (const QModelIndex &source_parent, int start, int end)
void	_q_sourceColumnsInserted (const QModelIndex &source_parent, int start, int end)
void	_q_sourceColumnsRemoved (const QModelIndex &source_parent, int start, int end)
void	_q_sourceDataChanged (const QModelIndex &source_top_left, const QModelIndex &source_bottom_right)
void	_q_sourceHeaderDataChanged (Qt::Orientation orientation, int start, int end)
void	_q_sourceLayoutAboutToBeChanged ()
void	_q_sourceLayoutChanged ()
virtual void	_q_sourceModelDestroyed ()
void	_q_sourceReset ()
void	_q_sourceRowsAboutToBeInserted (const QModelIndex &source_parent, int start, int end)
void	_q_sourceRowsAboutToBeRemoved (const QModelIndex &source_parent, int start, int end)
void	_q_sourceRowsInserted (const QModelIndex &source_parent, int start, int end)
void	_q_sourceRowsRemoved (const QModelIndex &source_parent, int start, int end)
void	build_source_to_proxy_mapping (const QVector< int > &proxy_to_source, QVector< int > &source_to_proxy) const
bool	can_create_mapping (const QModelIndex &source_parent) const
QModelIndex	create_index (int row, int column, QHash< QModelIndex, Mapping *>::const_iterator it) const
QHash< QModelIndex, Mapping * >::const_iterator	create_mapping (const QModelIndex &source_parent) const
void	filter_changed (const QModelIndex &source_parent=QModelIndex())
	Updates the proxy model (adds/removes rows) based on the new filter. More...
QSet< int >	handle_filter_changed (QVector< int > &source_to_proxy, QVector< int > &proxy_to_source, const QModelIndex &source_parent, Qt::Orientation orient)
QHash< QModelIndex, Mapping * >::const_iterator	index_to_iterator (const QModelIndex &proxy_index) const
void	insert_source_items (QVector< int > &source_to_proxy, QVector< int > &proxy_to_source, const QVector< int > &source_items, const QModelIndex &source_parent, Qt::Orientation orient, bool emit_signal=true)
	Given source-to-proxy mapping source_to_proxy and proxy-to-source mapping proxy_to_source, inserts the given source_items into this proxy model. More...
QVector< QPair< int, int > >	proxy_intervals_for_source_items (const QVector< int > &source_to_proxy, const QVector< int > &source_items) const
	Given source-to-proxy mapping source_to_proxy and the set of source items source_items (which are part of that mapping), determines the corresponding proxy item intervals that should be removed from the proxy model. More...
QVector< QPair< int, QVector< int > > >	proxy_intervals_for_source_items_to_add (const QVector< int > &proxy_to_source, const QVector< int > &source_items, const QModelIndex &source_parent, Qt::Orientation orient) const
	Given proxy-to-source mapping proxy_to_source and a set of unmapped source items source_items, determines the proxy item intervals at which the subsets of source items should be inserted (but does not actually add them to the mapping). More...
void	proxy_item_range (const QVector< int > &source_to_proxy, const QVector< int > &source_items, int &proxy_low, int &proxy_high) const
QModelIndex	proxy_to_source (const QModelIndex &proxyIndex) const
void	remove_from_mapping (const QModelIndex &source_parent)
void	remove_proxy_interval (QVector< int > &source_to_proxy, QVector< int > &proxy_to_source, int proxy_start, int proxy_end, const QModelIndex &proxy_parent, Qt::Orientation orient, bool emit_signal=true)
	Given source-to-proxy mapping source_to_proxy and proxy-to-source mapping proxy_to_source, removes items from proxy_start to proxy_end (inclusive) from this proxy model. More...
void	remove_source_items (QVector< int > &source_to_proxy, QVector< int > &proxy_to_source, const QVector< int > &source_items, const QModelIndex &source_parent, Qt::Orientation orient, bool emit_signal=true)
	Given source-to-proxy mapping src_to_proxy and proxy-to-source mapping proxy_to_source, removes source_items from this proxy model. More...
void	sort ()
	Sorts the existing mappings. More...
void	sort_source_rows (QVector< int > &source_rows, const QModelIndex &source_parent) const
	Sorts the given source_rows according to current sort column and order. More...
void	source_items_about_to_be_removed (const QModelIndex &source_parent, int start, int end, Qt::Orientation orient)
	Handles source model items removal (columnsAboutToBeRemoved(), rowsAboutToBeRemoved()). More...
void	source_items_inserted (const QModelIndex &source_parent, int start, int end, Qt::Orientation orient)
	Handles source model items insertion (columnsInserted(), rowsInserted()). More...
void	source_items_removed (const QModelIndex &source_parent, int start, int end, Qt::Orientation orient)
	Handles source model items removal (columnsRemoved(), rowsRemoved()). More...
QModelIndex	source_to_proxy (const QModelIndex &sourceIndex) const
QModelIndexPairList	store_persistent_indexes ()
	Maps the persistent proxy indexes to source indexes and returns the list of source indexes. More...
void	update_persistent_indexes (const QModelIndexPairList &source_indexes)
	Maps source_indexes to proxy indexes and stores those as persistent indexes. More...
bool	update_source_sort_column ()
void	updateChildrenMapping (const QModelIndex &source_parent, Mapping *parent_mapping, Qt::Orientation orient, int start, int end, int delta_item_count, bool remove)
Public Functions inherited from QAbstractProxyModelPrivate
	QAbstractProxyModelPrivate ()
Public Functions inherited from QAbstractItemModelPrivate
bool	allowMove (const QModelIndex &srcParent, int srcFirst, int srcLast, const QModelIndex &destinationParent, int destinationChild, Qt::Orientation orientation)
	Returns whether a move operation is valid. More...
void	columnsAboutToBeInserted (const QModelIndex &parent, int first, int last)
void	columnsAboutToBeRemoved (const QModelIndex &parent, int first, int last)
void	columnsInserted (const QModelIndex &parent, int first, int last)
void	columnsRemoved (const QModelIndex &parent, int first, int last)
QModelIndex	createIndex (int row, int column, void *data=0) const
QModelIndex	createIndex (int row, int column, int id) const
bool	indexValid (const QModelIndex &index) const
void	invalidatePersistentIndex (const QModelIndex &index)
void	invalidatePersistentIndexes ()
void	itemsAboutToBeMoved (const QModelIndex &srcParent, int srcFirst, int srcLast, const QModelIndex &destinationParent, int destinationChild, Qt::Orientation)
void	itemsMoved (const QModelIndex &srcParent, int srcFirst, int srcLast, const QModelIndex &destinationParent, int destinationChild, Qt::Orientation orientation)
void	movePersistentIndexes (QVector< QPersistentModelIndexData *> indexes, int change, const QModelIndex &parent, Qt::Orientation orientation)
	Moves persistent indexes indexes by amount change. More...
	QAbstractItemModelPrivate ()
void	removePersistentIndexData (QPersistentModelIndexData *data)
void	rowsAboutToBeInserted (const QModelIndex &parent, int first, int last)
void	rowsAboutToBeRemoved (const QModelIndex &parent, int first, int last)
void	rowsInserted (const QModelIndex &parent, int first, int last)
void	rowsRemoved (const QModelIndex &parent, int first, int last)
Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)
void	addConnection (int signal, Connection *c)
void	cleanConnectionLists ()
void	connectNotify (const char *signal)
void	deleteChildren ()
void	disconnectNotify (const char *signal)
bool	isSender (const QObject *receiver, const char *signal) const
bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...
void	moveToThread_helper ()
	QObjectPrivate (int version=QObjectPrivateVersion)
QObjectList	receiverList (const char *signal) const
QObjectList	senderList () const
void	setParent_helper (QObject *)
void	setThreadData_helper (QThreadData *currentData, QThreadData *targetData)
int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...
virtual	~QObjectPrivate ()
Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Public Variables
bool	dynamic_sortfilter
int	filter_column
QRegExp	filter_regexp
int	filter_role
QRowsRemoval	itemsBeingRemoved
int	proxy_sort_column
QModelIndexPairList	saved_persistent_indexes
Qt::CaseSensitivity	sort_casesensitivity
bool	sort_localeaware
Qt::SortOrder	sort_order
int	sort_role
QHash< QModelIndex, Mapping * >	source_index_mapping
int	source_sort_column
Public Variables inherited from QAbstractProxyModelPrivate
QAbstractItemModel *	model
Public Variables inherited from QAbstractItemModelPrivate
QStack< Change >	changes
struct QAbstractItemModelPrivate::Persistent	persistent
QHash< int, QByteArray >	roleNames
Qt::DropActions	supportedDragActions
Public Variables inherited from QObjectPrivate
union {
QObject *   currentChildBeingDeleted
QAbstractDeclarativeData *   declarativeData
};
quint32	connectedSignals [2]
QObjectConnectionListVector *	connectionLists
Sender *	currentSender
QList< QPointer< QObject > >	eventFilters
ExtraData *	extraData
QString	objectName
Connection *	senders
QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount
QThreadData *	threadData
void *	unused
Public Variables inherited from QObjectData
uint	blockSig: 1
QObjectList	children
uint	hasGuards: 1
uint	inEventHandler: 1
uint	inThreadChangeEvent: 1
uint	isWidget: 1
QMetaObject *	metaObject
uint	ownObjectName: 1
QObject *	parent
uint	pendTimer: 1
int	postedEvents
QObject *	q_ptr
uint	receiveChildEvents: 1
uint	sendChildEvents: 1
uint	unused: 22
uint	wasDeleted: 1

Additional Inherited Members
Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject *, QMetaObject::Call, int, void **)
Static Public Functions inherited from QAbstractItemModelPrivate
static const QHash< int, QByteArray > &	defaultRoleNames ()
static QAbstractItemModel *	staticEmptyModel ()
static bool	variantLessThan (const QVariant &v1, const QVariant &v2)
	This function is used by our Q{Tree,Widget,Table}WidgetModel classes to sort. More...
Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)
static QObjectPrivate *	get (QObject *o)
static void	resetCurrentSender (QObject *receiver, Sender *currentSender, Sender *previousSender)
static Sender *	setCurrentSender (QObject *receiver, Sender *sender)
static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Detailed Description

Definition at line 143 of file qsortfilterproxymodel.cpp.

Functions

_q_clearMapping()

void QSortFilterProxyModelPrivate::_q_clearMapping

(

)

Definition at line 296 of file qsortfilterproxymodel.cpp.

{
    // store the persistent indexes
    QModelIndexPairList source_indexes = store_persistent_indexes();

    qDeleteAll(source_index_mapping);
    source_index_mapping.clear();
    if (dynamic_sortfilter && update_source_sort_column()) {
        //update_source_sort_column might have created wrong mapping so we have to clear it again
        qDeleteAll(source_index_mapping);
        source_index_mapping.clear();
    }

    // update the persistent indexes
    update_persistent_indexes(source_indexes);
}

_q_sourceAboutToBeReset()

void QSortFilterProxyModelPrivate::_q_sourceAboutToBeReset

(

)

Definition at line 1274 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);
    q->beginResetModel();
}

_q_sourceColumnsAboutToBeInserted()

void QSortFilterProxyModelPrivate::_q_sourceColumnsAboutToBeInserted	(	const QModelIndex &	source_parent,
		int	start,
		int	end
	)

Definition at line 1356 of file qsortfilterproxymodel.cpp.

{
    Q_UNUSED(start);
    Q_UNUSED(end);
    //Force the creation of a mapping now, even if its empty.
    //We need it because the proxy can be acessed at the moment it emits columnsAboutToBeInserted in insert_source_items
    if (can_create_mapping(source_parent))
        create_mapping(source_parent);
}

_q_sourceColumnsAboutToBeRemoved()

void QSortFilterProxyModelPrivate::_q_sourceColumnsAboutToBeRemoved	(	const QModelIndex &	source_parent,
		int	start,
		int	end
	)

Definition at line 1387 of file qsortfilterproxymodel.cpp.

{
    source_items_about_to_be_removed(source_parent, start, end,
                                     Qt::Horizontal);
}

_q_sourceColumnsInserted()

void QSortFilterProxyModelPrivate::_q_sourceColumnsInserted	(	const QModelIndex &	source_parent,
		int	start,
		int	end
	)

Definition at line 1367 of file qsortfilterproxymodel.cpp.

{
    Q_Q(const QSortFilterProxyModel);
    source_items_inserted(source_parent, start, end, Qt::Horizontal);

    if (source_parent.isValid())
        return; //we sort according to the root column only
    if (source_sort_column == -1) {
        //we update the source_sort_column depending on the proxy_sort_column
        if (update_source_sort_column() && dynamic_sortfilter)
            sort();
    } else {
        if (start <= source_sort_column)
            source_sort_column += end - start + 1;

        proxy_sort_column = q->mapFromSource(model->index(0,source_sort_column, source_parent)).column();
    }
}

_q_sourceColumnsRemoved()

void QSortFilterProxyModelPrivate::_q_sourceColumnsRemoved	(	const QModelIndex &	source_parent,
		int	start,
		int	end
	)

Definition at line 1394 of file qsortfilterproxymodel.cpp.

{
    Q_Q(const QSortFilterProxyModel);
    source_items_removed(source_parent, start, end, Qt::Horizontal);

    if (source_parent.isValid())
        return; //we sort according to the root column only
    if (start <= source_sort_column) {
        if (end < source_sort_column)
            source_sort_column -= end - start + 1;
        else
            source_sort_column = -1;
    }

    proxy_sort_column = q->mapFromSource(model->index(0,source_sort_column, source_parent)).column();
}

_q_sourceDataChanged()

void QSortFilterProxyModelPrivate::_q_sourceDataChanged	(	const QModelIndex &	source_top_left,
		const QModelIndex &	source_bottom_right
	)

Definition at line 1153 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);
    if (!source_top_left.isValid() || !source_bottom_right.isValid())
        return;
    QModelIndex source_parent = source_top_left.parent();
    IndexMap::const_iterator it = source_index_mapping.find(source_parent);
    if (it == source_index_mapping.constEnd()) {
        // Don't care, since we don't have mapping for this index
        return;
    }
    Mapping *m = it.value();

    // Figure out how the source changes affect us
    QVector<int> source_rows_remove;
    QVector<int> source_rows_insert;
    QVector<int> source_rows_change;
    QVector<int> source_rows_resort;
    int end = qMin(source_bottom_right.row(), m->proxy_rows.count() - 1);
    for (int source_row = source_top_left.row(); source_row <= end; ++source_row) {
        if (dynamic_sortfilter) {
            if (m->proxy_rows.at(source_row) != -1) {
                if (!q->filterAcceptsRow(source_row, source_parent)) {
                    // This source row no longer satisfies the filter, so it must be removed
                    source_rows_remove.append(source_row);
                } else if (source_sort_column >= source_top_left.column() && source_sort_column <= source_bottom_right.column()) {
                    // This source row has changed in a way that may affect sorted order
                    source_rows_resort.append(source_row);
                } else {
                    // This row has simply changed, without affecting filtering nor sorting
                    source_rows_change.append(source_row);
                }
            } else {
                if (!itemsBeingRemoved.contains(source_parent, source_row) && q->filterAcceptsRow(source_row, source_parent)) {
                    // This source row now satisfies the filter, so it must be added
                    source_rows_insert.append(source_row);
                }
            }
        } else {
            if (m->proxy_rows.at(source_row) != -1)
                source_rows_change.append(source_row);
        }
    }

    if (!source_rows_remove.isEmpty()) {
        remove_source_items(m->proxy_rows, m->source_rows,
                            source_rows_remove, source_parent, Qt::Vertical);
        QSet<int> source_rows_remove_set = qVectorToSet(source_rows_remove);
        QVector<QModelIndex>::iterator it = m->mapped_children.end();
        while (it != m->mapped_children.begin()) {
            --it;
            const QModelIndex source_child_index = *it;
            if (source_rows_remove_set.contains(source_child_index.row())) {
                it = m->mapped_children.erase(it);
                remove_from_mapping(source_child_index);
            }
        }
    }

    if (!source_rows_resort.isEmpty()) {
        // Re-sort the rows
        emit q->layoutAboutToBeChanged();
        QModelIndexPairList source_indexes = store_persistent_indexes();
        remove_source_items(m->proxy_rows, m->source_rows, source_rows_resort,
                            source_parent, Qt::Vertical, false);
        sort_source_rows(source_rows_resort, source_parent);
        insert_source_items(m->proxy_rows, m->source_rows, source_rows_resort,
                            source_parent, Qt::Vertical, false);
        update_persistent_indexes(source_indexes);
        emit q->layoutChanged();
    // Make sure we also emit dataChanged for the rows
    source_rows_change += source_rows_resort;
    }

    if (!source_rows_change.isEmpty()) {
        // Find the proxy row range
        int proxy_start_row;
        int proxy_end_row;
        proxy_item_range(m->proxy_rows, source_rows_change,
                         proxy_start_row, proxy_end_row);
        // ### Find the proxy column range also
        if (proxy_end_row >= 0) {
            // the row was accepted, but some columns might still be filtered out
            int source_left_column = source_top_left.column();
            while (source_left_column < source_bottom_right.column()
                   && m->proxy_columns.at(source_left_column) == -1)
                ++source_left_column;
            const QModelIndex proxy_top_left = create_index(
                proxy_start_row, m->proxy_columns.at(source_left_column), it);
            int source_right_column = source_bottom_right.column();
            while (source_right_column > source_top_left.column()
                   && m->proxy_columns.at(source_right_column) == -1)
                --source_right_column;
            const QModelIndex proxy_bottom_right = create_index(
                proxy_end_row, m->proxy_columns.at(source_right_column), it);
            emit q->dataChanged(proxy_top_left, proxy_bottom_right);
        }
    }

    if (!source_rows_insert.isEmpty()) {
        sort_source_rows(source_rows_insert, source_parent);
        insert_source_items(m->proxy_rows, m->source_rows,
                            source_rows_insert, source_parent, Qt::Vertical);
    }
}

_q_sourceHeaderDataChanged()

void QSortFilterProxyModelPrivate::_q_sourceHeaderDataChanged	(	Qt::Orientation	orientation,
		int	start,
		int	end
	)

Definition at line 1260 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);
    Mapping *m = create_mapping(QModelIndex()).value();
    int proxy_start = (orientation == Qt::Vertical
                       ? m->proxy_rows.at(start)
                       : m->proxy_columns.at(start));
    int proxy_end = (orientation == Qt::Vertical
                     ? m->proxy_rows.at(end)
                     : m->proxy_columns.at(end));
    emit q->headerDataChanged(orientation, proxy_start, proxy_end);
}

_q_sourceLayoutAboutToBeChanged()

void QSortFilterProxyModelPrivate::_q_sourceLayoutAboutToBeChanged

(

)

Definition at line 1292 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);
    saved_persistent_indexes.clear();
    emit q->layoutAboutToBeChanged();
    if (persistent.indexes.isEmpty())
        return;

    saved_persistent_indexes = store_persistent_indexes();
}

_q_sourceLayoutChanged()

void QSortFilterProxyModelPrivate::_q_sourceLayoutChanged

(

)

Definition at line 1303 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);

    qDeleteAll(source_index_mapping);
    source_index_mapping.clear();

    update_persistent_indexes(saved_persistent_indexes);
    saved_persistent_indexes.clear();

    if (dynamic_sortfilter && update_source_sort_column()) {
        //update_source_sort_column might have created wrong mapping so we have to clear it again
        qDeleteAll(source_index_mapping);
        source_index_mapping.clear();
    }

    emit q->layoutChanged();
}

_q_sourceModelDestroyed()

void QSortFilterProxyModelPrivate::_q_sourceModelDestroyed ( )

virtual

Reimplemented from QAbstractProxyModelPrivate.

Definition at line 281 of file qsortfilterproxymodel.cpp.

{
    QAbstractProxyModelPrivate::_q_sourceModelDestroyed();
    _q_clearMapping();
}

_q_sourceReset()

void QSortFilterProxyModelPrivate::_q_sourceReset

(

)

Definition at line 1280 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);
    invalidatePersistentIndexes();
    _q_clearMapping();
    // All internal structures are deleted in clear()
    q->endResetModel();
    update_source_sort_column();
    if (dynamic_sortfilter)
        sort();
}

_q_sourceRowsAboutToBeInserted()

void QSortFilterProxyModelPrivate::_q_sourceRowsAboutToBeInserted	(	const QModelIndex &	source_parent,
		int	start,
		int	end
	)

Definition at line 1322 of file qsortfilterproxymodel.cpp.

{
    Q_UNUSED(start);
    Q_UNUSED(end);
    //Force the creation of a mapping now, even if its empty.
    //We need it because the proxy can be acessed at the moment it emits rowsAboutToBeInserted in insert_source_items
    if (can_create_mapping(source_parent))
        create_mapping(source_parent);
}

_q_sourceRowsAboutToBeRemoved()

void QSortFilterProxyModelPrivate::_q_sourceRowsAboutToBeRemoved	(	const QModelIndex &	source_parent,
		int	start,
		int	end
	)

Definition at line 1341 of file qsortfilterproxymodel.cpp.

{
    itemsBeingRemoved = QRowsRemoval(source_parent, start, end);
    source_items_about_to_be_removed(source_parent, start, end,
                                     Qt::Vertical);
}

_q_sourceRowsInserted()

void QSortFilterProxyModelPrivate::_q_sourceRowsInserted	(	const QModelIndex &	source_parent,
		int	start,
		int	end
	)

Definition at line 1333 of file qsortfilterproxymodel.cpp.

{
    source_items_inserted(source_parent, start, end, Qt::Vertical);
    if (update_source_sort_column() && dynamic_sortfilter) //previous call to update_source_sort_column may fail if the model has no column.
        sort();                      // now it should succeed so we need to make sure to sort again
}

_q_sourceRowsRemoved()

void QSortFilterProxyModelPrivate::_q_sourceRowsRemoved	(	const QModelIndex &	source_parent,
		int	start,
		int	end
	)

Definition at line 1349 of file qsortfilterproxymodel.cpp.

{
    itemsBeingRemoved = QRowsRemoval();
    source_items_removed(source_parent, start, end, Qt::Vertical);
}

build_source_to_proxy_mapping()

void QSortFilterProxyModelPrivate::build_source_to_proxy_mapping	(	const QVector< int > &	proxy_to_source,
		QVector< int > &	source_to_proxy
	)		const

Warning

This function is not part of the public interface.

Definition at line 1005 of file qsortfilterproxymodel.cpp.

{
    source_to_proxy.fill(-1);
    int proxy_count = proxy_to_source.size();
    for (int i = 0; i < proxy_count; ++i)
        source_to_proxy[proxy_to_source.at(i)] = i;
}

can_create_mapping()

bool QSortFilterProxyModelPrivate::can_create_mapping

(

const QModelIndex &

source_parent

)

const

Definition at line 398 of file qsortfilterproxymodel.cpp.

{
    if (source_parent.isValid()) {
        QModelIndex source_grand_parent = source_parent.parent();
        IndexMap::const_iterator it = source_index_mapping.constFind(source_grand_parent);
        if (it == source_index_mapping.constEnd()) {
            // Don't care, since we don't have mapping for the grand parent
            return false;
        }
        Mapping *gm = it.value();
        if (gm->proxy_rows.at(source_parent.row()) == -1 ||
            gm->proxy_columns.at(source_parent.column()) == -1) {
            // Don't care, since parent is filtered
            return false;
        }
    }
    return true;
}

create_index()

QModelIndex QSortFilterProxyModelPrivate::create_index ( int  row, int  column, QHash< QModelIndex, Mapping *>::const_iterator  it  ) const

inline

Definition at line 197 of file qsortfilterproxymodel.cpp.

    {
        return q_func()->createIndex(row, column, *it);
    }

create_mapping()

IndexMap::const_iterator QSortFilterProxyModelPrivate::create_mapping

(

const QModelIndex &

source_parent

)

const

Definition at line 313 of file qsortfilterproxymodel.cpp.

{
    Q_Q(const QSortFilterProxyModel);

    IndexMap::const_iterator it = source_index_mapping.constFind(source_parent);
    if (it != source_index_mapping.constEnd()) // was mapped already
        return it;

    Mapping *m = new Mapping;

    int source_rows = model->rowCount(source_parent);
    m->source_rows.reserve(source_rows);
    for (int i = 0; i < source_rows; ++i) {
        if (q->filterAcceptsRow(i, source_parent))
            m->source_rows.append(i);
    }
    int source_cols = model->columnCount(source_parent);
    m->source_columns.reserve(source_cols);
    for (int i = 0; i < source_cols; ++i) {
        if (q->filterAcceptsColumn(i, source_parent))
            m->source_columns.append(i);
    }

    sort_source_rows(m->source_rows, source_parent);
    m->proxy_rows.resize(source_rows);
    build_source_to_proxy_mapping(m->source_rows, m->proxy_rows);
    m->proxy_columns.resize(source_cols);
    build_source_to_proxy_mapping(m->source_columns, m->proxy_columns);

    it = IndexMap::const_iterator(source_index_mapping.insert(source_parent, m));
    m->map_iter = it;

    if (source_parent.isValid()) {
        QModelIndex source_grand_parent = source_parent.parent();
        IndexMap::const_iterator it2 = create_mapping(source_grand_parent);
        Q_ASSERT(it2 != source_index_mapping.constEnd());
        it2.value()->mapped_children.append(source_parent);
    }

    Q_ASSERT(it != source_index_mapping.constEnd());
    Q_ASSERT(it.value());

    return it;
}

filter_changed()

void QSortFilterProxyModelPrivate::filter_changed

(

const QModelIndex &

source_parent = QModelIndex()

)

Updates the proxy model (adds/removes rows) based on the new filter.

Warning

This function is not part of the public interface.

Definition at line 1070 of file qsortfilterproxymodel.cpp.

{
    IndexMap::const_iterator it = source_index_mapping.constFind(source_parent);
    if (it == source_index_mapping.constEnd())
        return;
    Mapping *m = it.value();
    QSet<int> rows_removed = handle_filter_changed(m->proxy_rows, m->source_rows, source_parent, Qt::Vertical);
    QSet<int> columns_removed = handle_filter_changed(m->proxy_columns, m->source_columns, source_parent, Qt::Horizontal);

    // We need to iterate over a copy of m->mapped_children because otherwise it may be changed by other code, invalidating
    // the iterator it2.
    // The m->mapped_children vector can be appended to with indexes which are no longer filtered
    // out (in create_mapping) when this function recurses for child indexes.
    const QVector<QModelIndex> mappedChildren = m->mapped_children;
    QVector<int> indexesToRemove;
    for (int i = 0; i < mappedChildren.size(); ++i) {
        const QModelIndex source_child_index = mappedChildren.at(i);
        if (rows_removed.contains(source_child_index.row()) || columns_removed.contains(source_child_index.column())) {
            indexesToRemove.push_back(i);
            remove_from_mapping(source_child_index);
        } else {
            filter_changed(source_child_index);
        }
    }
    QVector<int>::const_iterator removeIt = indexesToRemove.constEnd();
    const QVector<int>::const_iterator removeBegin = indexesToRemove.constBegin();

    // We can't just remove these items from mappedChildren while iterating above and then
    // do something like m->mapped_children = mappedChildren, because mapped_children might
    // be appended to in create_mapping, and we would lose those new items.
    // Because they are always appended in create_mapping, we can still remove them by
    // position here.
    while (removeIt != removeBegin) {
        --removeIt;
        m->mapped_children.remove(*removeIt);
    }
}

handle_filter_changed()

QSet< int > QSortFilterProxyModelPrivate::handle_filter_changed	(	QVector< int > &	source_to_proxy,
		QVector< int > &	proxy_to_source,
		const QModelIndex &	source_parent,
		Qt::Orientation	orient
	)

Warning

This function is not part of the public interface. returns the removed items indexes

Definition at line 1112 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);
    // Figure out which mapped items to remove
    QVector<int> source_items_remove;
    for (int i = 0; i < proxy_to_source.count(); ++i) {
        const int source_item = proxy_to_source.at(i);
        if ((orient == Qt::Vertical)
            ? !q->filterAcceptsRow(source_item, source_parent)
            : !q->filterAcceptsColumn(source_item, source_parent)) {
            // This source item does not satisfy the filter, so it must be removed
            source_items_remove.append(source_item);
        }
    }
    // Figure out which non-mapped items to insert
    QVector<int> source_items_insert;
    int source_count = source_to_proxy.size();
    for (int source_item = 0; source_item < source_count; ++source_item) {
        if (source_to_proxy.at(source_item) == -1) {
            if ((orient == Qt::Vertical)
                ? q->filterAcceptsRow(source_item, source_parent)
                : q->filterAcceptsColumn(source_item, source_parent)) {
                // This source item satisfies the filter, so it must be added
                source_items_insert.append(source_item);
            }
        }
    }
    if (!source_items_remove.isEmpty() || !source_items_insert.isEmpty()) {
        // Do item removal and insertion
        remove_source_items(source_to_proxy, proxy_to_source,
                            source_items_remove, source_parent, orient);
        if (orient == Qt::Vertical)
            sort_source_rows(source_items_insert, source_parent);
        insert_source_items(source_to_proxy, proxy_to_source,
                            source_items_insert, source_parent, orient);
    }
    return qVectorToSet(source_items_remove);
}

index_to_iterator()

QHash<QModelIndex, Mapping *>::const_iterator QSortFilterProxyModelPrivate::index_to_iterator ( const QModelIndex &  proxy_index ) const

inline

Definition at line 183 of file qsortfilterproxymodel.cpp.

    {
        Q_ASSERT(proxy_index.isValid());
        Q_ASSERT(proxy_index.model() == q_func());
        const void *p = proxy_index.internalPointer();
        Q_ASSERT(p);
        QHash<QModelIndex, Mapping *>::const_iterator it =
            static_cast<const Mapping*>(p)->map_iter;
        Q_ASSERT(it != source_index_mapping.constEnd());
        Q_ASSERT(it.value());
        return it;
    }

insert_source_items()

void QSortFilterProxyModelPrivate::insert_source_items	(	QVector< int > &	source_to_proxy,
		QVector< int > &	proxy_to_source,
		const QVector< int > &	source_items,
		const QModelIndex &	source_parent,
		Qt::Orientation	orient,
		bool	emit_signal = true
	)

Given source-to-proxy mapping source_to_proxy and proxy-to-source mapping proxy_to_source, inserts the given source_items into this proxy model.

Warning

This function is not part of the public interface.

The source items are inserted in intervals (based on some sorted order), so that the proper rows/columnsInserted(start, end) signals will be generated.

Definition at line 682 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);
    QModelIndex proxy_parent = q->mapFromSource(source_parent);
    if (!proxy_parent.isValid() && source_parent.isValid())
        return; // nothing to do (source_parent is not mapped)

    QVector<QPair<int, QVector<int> > > proxy_intervals;
    proxy_intervals = proxy_intervals_for_source_items_to_add(
        proxy_to_source, source_items, source_parent, orient);

    for (int i = proxy_intervals.size()-1; i >= 0; --i) {
        QPair<int, QVector<int> > interval = proxy_intervals.at(i);
        int proxy_start = interval.first;
        QVector<int> source_items = interval.second;
        int proxy_end = proxy_start + source_items.size() - 1;

        if (emit_signal) {
            if (orient == Qt::Vertical)
                q->beginInsertRows(proxy_parent, proxy_start, proxy_end);
            else
                q->beginInsertColumns(proxy_parent, proxy_start, proxy_end);
        }

        for (int i = 0; i < source_items.size(); ++i)
            proxy_to_source.insert(proxy_start + i, source_items.at(i));

        build_source_to_proxy_mapping(proxy_to_source, source_to_proxy);

        if (emit_signal) {
            if (orient == Qt::Vertical)
                q->endInsertRows();
            else
                q->endInsertColumns();
        }
    }
}

proxy_intervals_for_source_items()

QVector< QPair< int, int > > QSortFilterProxyModelPrivate::proxy_intervals_for_source_items	(	const QVector< int > &	source_to_proxy,
		const QVector< int > &	source_items
	)		const

Given source-to-proxy mapping source_to_proxy and the set of source items source_items (which are part of that mapping), determines the corresponding proxy item intervals that should be removed from the proxy model.

Warning

This function is not part of the public interface.

The result is a vector of pairs, where each pair represents a (start, end) tuple, sorted in ascending order.

Definition at line 496 of file qsortfilterproxymodel.cpp.

{
    QVector<QPair<int, int> > proxy_intervals;
    if (source_items.isEmpty())
        return proxy_intervals;

    int source_items_index = 0;
    while (source_items_index < source_items.size()) {
        int first_proxy_item = source_to_proxy.at(source_items.at(source_items_index));
        Q_ASSERT(first_proxy_item != -1);
        int last_proxy_item = first_proxy_item;
        ++source_items_index;
        // Find end of interval
        while ((source_items_index < source_items.size())
               && (source_to_proxy.at(source_items.at(source_items_index)) == last_proxy_item + 1)) {
            ++last_proxy_item;
            ++source_items_index;
        }
        // Add interval to result
        proxy_intervals.append(QPair<int, int>(first_proxy_item, last_proxy_item));
    }
    qStableSort(proxy_intervals.begin(), proxy_intervals.end());
    return proxy_intervals;
}

proxy_intervals_for_source_items_to_add()

QVector< QPair< int, QVector< int > > > QSortFilterProxyModelPrivate::proxy_intervals_for_source_items_to_add	(	const QVector< int > &	proxy_to_source,
		const QVector< int > &	source_items,
		const QModelIndex &	source_parent,
		Qt::Orientation	orient
	)		const

Given proxy-to-source mapping proxy_to_source and a set of unmapped source items source_items, determines the proxy item intervals at which the subsets of source items should be inserted (but does not actually add them to the mapping).

Warning

This function is not part of the public interface.

The result is a vector of pairs, each pair representing a tuple (start, items), where items is a vector containing the (sorted) source items that should be inserted at that proxy model location.

Definition at line 605 of file qsortfilterproxymodel.cpp.

{
    Q_Q(const QSortFilterProxyModel);
    QVector<QPair<int, QVector<int> > > proxy_intervals;
    if (source_items.isEmpty())
        return proxy_intervals;

    int proxy_low = 0;
    int proxy_item = 0;
    int source_items_index = 0;
    QVector<int> source_items_in_interval;
    bool compare = (orient == Qt::Vertical && source_sort_column >= 0 && dynamic_sortfilter);
    while (source_items_index < source_items.size()) {
        source_items_in_interval.clear();
        int first_new_source_item = source_items.at(source_items_index);
        source_items_in_interval.append(first_new_source_item);
        ++source_items_index;

        // Find proxy item at which insertion should be started
        int proxy_high = proxy_to_source.size() - 1;
        QModelIndex i1 = compare ? model->index(first_new_source_item, source_sort_column, source_parent) : QModelIndex();
        while (proxy_low <= proxy_high) {
            proxy_item = (proxy_low + proxy_high) / 2;
            if (compare) {
                QModelIndex i2 = model->index(proxy_to_source.at(proxy_item), source_sort_column, source_parent);
                if ((sort_order == Qt::AscendingOrder) ? q->lessThan(i1, i2) : q->lessThan(i2, i1))
                    proxy_high = proxy_item - 1;
                else
                    proxy_low = proxy_item + 1;
            } else {
                if (first_new_source_item < proxy_to_source.at(proxy_item))
                    proxy_high = proxy_item - 1;
                else
                    proxy_low = proxy_item + 1;
            }
        }
        proxy_item = proxy_low;

        // Find the sequence of new source items that should be inserted here
        if (proxy_item >= proxy_to_source.size()) {
            for ( ; source_items_index < source_items.size(); ++source_items_index)
                source_items_in_interval.append(source_items.at(source_items_index));
        } else {
            i1 = compare ? model->index(proxy_to_source.at(proxy_item), source_sort_column, source_parent) : QModelIndex();
            for ( ; source_items_index < source_items.size(); ++source_items_index) {
                int new_source_item = source_items.at(source_items_index);
                if (compare) {
                    QModelIndex i2 = model->index(new_source_item, source_sort_column, source_parent);
                    if ((sort_order == Qt::AscendingOrder) ? q->lessThan(i1, i2) : q->lessThan(i2, i1))
                        break;
                } else {
                    if (proxy_to_source.at(proxy_item) < new_source_item)
                        break;
                }
                source_items_in_interval.append(new_source_item);
            }
        }

        // Add interval to result
        proxy_intervals.append(QPair<int, QVector<int> >(proxy_item, source_items_in_interval));
    }
    return proxy_intervals;
}

proxy_item_range()

void QSortFilterProxyModelPrivate::proxy_item_range	(	const QVector< int > &	source_to_proxy,
		const QVector< int > &	source_items,
		int &	proxy_low,
		int &	proxy_high
	)		const

Warning

This function is not part of the public interface.

Definition at line 986 of file qsortfilterproxymodel.cpp.

{
    proxy_low = INT_MAX;
    proxy_high = INT_MIN;
    for (int i = 0; i < source_items.count(); ++i) {
        int proxy_item = source_to_proxy.at(source_items.at(i));
        Q_ASSERT(proxy_item != -1);
        if (proxy_item < proxy_low)
            proxy_low = proxy_item;
        if (proxy_item > proxy_high)
            proxy_high = proxy_item;
    }
}

proxy_to_source()

QModelIndex QSortFilterProxyModelPrivate::proxy_to_source

(

const QModelIndex &

proxyIndex

)

const

Definition at line 359 of file qsortfilterproxymodel.cpp.

{
    if (!proxy_index.isValid())
        return QModelIndex(); // for now; we may want to be able to set a root index later
    if (proxy_index.model() != q_func()) {
        qWarning() << "QSortFilterProxyModel: index from wrong model passed to mapToSource";
        Q_ASSERT(!"QSortFilterProxyModel: index from wrong model passed to mapToSource");
        return QModelIndex();
    }
    IndexMap::const_iterator it = index_to_iterator(proxy_index);
    Mapping *m = it.value();
    if ((proxy_index.row() >= m->source_rows.size()) || (proxy_index.column() >= m->source_columns.size()))
        return QModelIndex();
    int source_row = m->source_rows.at(proxy_index.row());
    int source_col = m->source_columns.at(proxy_index.column());
    return model->index(source_row, source_col, it.key());
}

remove_from_mapping()

void QSortFilterProxyModelPrivate::remove_from_mapping

(

const QModelIndex &

source_parent

)

Definition at line 287 of file qsortfilterproxymodel.cpp.

{
    if (Mapping *m = source_index_mapping.take(source_parent)) {
        for (int i = 0; i < m->mapped_children.size(); ++i)
            remove_from_mapping(m->mapped_children.at(i));
        delete m;
    }
}

remove_proxy_interval()

void QSortFilterProxyModelPrivate::remove_proxy_interval	(	QVector< int > &	source_to_proxy,
		QVector< int > &	proxy_to_source,
		int	proxy_start,
		int	proxy_end,
		const QModelIndex &	proxy_parent,
		Qt::Orientation	orient,
		bool	emit_signal = true
	)

Given source-to-proxy mapping source_to_proxy and proxy-to-source mapping proxy_to_source, removes items from proxy_start to proxy_end (inclusive) from this proxy model.

Warning

This function is not part of the public interface.

Definition at line 565 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);
    if (emit_signal) {
        if (orient == Qt::Vertical)
            q->beginRemoveRows(proxy_parent, proxy_start, proxy_end);
        else
            q->beginRemoveColumns(proxy_parent, proxy_start, proxy_end);
    }

    // Remove items from proxy-to-source mapping
    proxy_to_source.remove(proxy_start, proxy_end - proxy_start + 1);

    build_source_to_proxy_mapping(proxy_to_source, source_to_proxy);

    if (emit_signal) {
        if (orient == Qt::Vertical)
            q->endRemoveRows();
        else
            q->endRemoveColumns();
    }
}

remove_source_items()

void QSortFilterProxyModelPrivate::remove_source_items	(	QVector< int > &	source_to_proxy,
		QVector< int > &	proxy_to_source,
		const QVector< int > &	source_items,
		const QModelIndex &	source_parent,
		Qt::Orientation	orient,
		bool	emit_signal = true
	)

Given source-to-proxy mapping src_to_proxy and proxy-to-source mapping proxy_to_source, removes source_items from this proxy model.

Warning

This function is not part of the public interface.

The corresponding proxy items are removed in intervals, so that the proper rows/columnsRemoved(start, end) signals will be generated.

Definition at line 533 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);
    QModelIndex proxy_parent = q->mapFromSource(source_parent);
    if (!proxy_parent.isValid() && source_parent.isValid())
        return; // nothing to do (already removed)

    QVector<QPair<int, int> > proxy_intervals;
    proxy_intervals = proxy_intervals_for_source_items(source_to_proxy, source_items);

    for (int i = proxy_intervals.size()-1; i >= 0; --i) {
        QPair<int, int> interval = proxy_intervals.at(i);
        int proxy_start = interval.first;
        int proxy_end = interval.second;
        remove_proxy_interval(source_to_proxy, proxy_to_source, proxy_start, proxy_end,
                              proxy_parent, orient, emit_signal);
    }
}

sort()

void QSortFilterProxyModelPrivate::sort

(

)

Sorts the existing mappings.

Warning

This function is not part of the public interface.

Definition at line 425 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);
    emit q->layoutAboutToBeChanged();
    QModelIndexPairList source_indexes = store_persistent_indexes();
    IndexMap::const_iterator it = source_index_mapping.constBegin();
    for (; it != source_index_mapping.constEnd(); ++it) {
        QModelIndex source_parent = it.key();
        Mapping *m = it.value();
        sort_source_rows(m->source_rows, source_parent);
        build_source_to_proxy_mapping(m->source_rows, m->proxy_rows);
    }
    update_persistent_indexes(source_indexes);
    emit q->layoutChanged();
}

sort_source_rows()

void QSortFilterProxyModelPrivate::sort_source_rows	(	QVector< int > &	source_rows,
		const QModelIndex &	source_parent
	)		const

Sorts the given source_rows according to current sort column and order.

Warning

This function is not part of the public interface.

Definition at line 465 of file qsortfilterproxymodel.cpp.

{
    Q_Q(const QSortFilterProxyModel);
    if (source_sort_column >= 0) {
        if (sort_order == Qt::AscendingOrder) {
            QSortFilterProxyModelLessThan lt(source_sort_column, source_parent, model, q);
            qStableSort(source_rows.begin(), source_rows.end(), lt);
        } else {
            QSortFilterProxyModelGreaterThan gt(source_sort_column, source_parent, model, q);
            qStableSort(source_rows.begin(), source_rows.end(), gt);
        }
    } else { // restore the source model order
        qStableSort(source_rows.begin(), source_rows.end());
    }
}

source_items_about_to_be_removed()

void QSortFilterProxyModelPrivate::source_items_about_to_be_removed	(	const QModelIndex &	source_parent,
		int	start,
		int	end,
		Qt::Orientation	orient
	)

Handles source model items removal (columnsAboutToBeRemoved(), rowsAboutToBeRemoved()).

Warning

This function is not part of the public interface.

Definition at line 842 of file qsortfilterproxymodel.cpp.

{
    if ((start < 0) || (end < 0))
        return;
    IndexMap::const_iterator it = source_index_mapping.constFind(source_parent);
    if (it == source_index_mapping.constEnd()) {
        // Don't care, since we don't have mapping for this index
        return;
    }

    Mapping *m = it.value();
    QVector<int> &source_to_proxy = (orient == Qt::Vertical) ? m->proxy_rows : m->proxy_columns;
    QVector<int> &proxy_to_source = (orient == Qt::Vertical) ? m->source_rows : m->source_columns;

    // figure out which items to remove
    QVector<int> source_items_to_remove;
    int proxy_count = proxy_to_source.size();
    for (int proxy_item = 0; proxy_item < proxy_count; ++proxy_item) {
        int source_item = proxy_to_source.at(proxy_item);
        if ((source_item >= start) && (source_item <= end))
            source_items_to_remove.append(source_item);
    }

    remove_source_items(source_to_proxy, proxy_to_source, source_items_to_remove,
                        source_parent, orient);
}

source_items_inserted()

void QSortFilterProxyModelPrivate::source_items_inserted	(	const QModelIndex &	source_parent,
		int	start,
		int	end,
		Qt::Orientation	orient
	)

Handles source model items insertion (columnsInserted(), rowsInserted()).

Warning

This function is not part of the public interface.

Determines 1) which of the inserted items to also insert into proxy model (filtering), 2) where to insert the items into the proxy model (sorting), then inserts those items. The items are inserted into the proxy model in intervals (based on sorted order), so that the proper rows/columnsInserted(start, end) signals will be generated.

Definition at line 738 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);
    if ((start < 0) || (end < 0))
        return;
    IndexMap::const_iterator it = source_index_mapping.constFind(source_parent);
    if (it == source_index_mapping.constEnd()) {
        if (!can_create_mapping(source_parent))
            return;
        it = create_mapping(source_parent);
        Mapping *m = it.value();
        QModelIndex proxy_parent = q->mapFromSource(source_parent);
        if (m->source_rows.count() > 0) {
            q->beginInsertRows(proxy_parent, 0, m->source_rows.count() - 1);
            q->endInsertRows();
        }
        if (m->source_columns.count() > 0) {
            q->beginInsertColumns(proxy_parent, 0, m->source_columns.count() - 1);
            q->endInsertColumns();
        }
        return;
    }

    Mapping *m = it.value();
    QVector<int> &source_to_proxy = (orient == Qt::Vertical) ? m->proxy_rows : m->proxy_columns;
    QVector<int> &proxy_to_source = (orient == Qt::Vertical) ? m->source_rows : m->source_columns;

    int delta_item_count = end - start + 1;
    int old_item_count = source_to_proxy.size();

    updateChildrenMapping(source_parent, m, orient, start, end, delta_item_count, false);

    // Expand source-to-proxy mapping to account for new items
    if (start < 0 || start > source_to_proxy.size()) {
        qWarning("QSortFilterProxyModel: invalid inserted rows reported by source model");
        remove_from_mapping(source_parent);
        return;
    }
    source_to_proxy.insert(start, delta_item_count, -1);

    if (start < old_item_count) {
        // Adjust existing "stale" indexes in proxy-to-source mapping
        int proxy_count = proxy_to_source.size();
        for (int proxy_item = 0; proxy_item < proxy_count; ++proxy_item) {
            int source_item = proxy_to_source.at(proxy_item);
            if (source_item >= start)
                proxy_to_source.replace(proxy_item, source_item + delta_item_count);
        }
        build_source_to_proxy_mapping(proxy_to_source, source_to_proxy);
    }

    // Figure out which items to add to mapping based on filter
    QVector<int> source_items;
    for (int i = start; i <= end; ++i) {
        if ((orient == Qt::Vertical)
            ? q->filterAcceptsRow(i, source_parent)
            : q->filterAcceptsColumn(i, source_parent)) {
            source_items.append(i);
        }
    }

    if (model->rowCount(source_parent) == delta_item_count) {
        // Items were inserted where there were none before.
        // If it was new rows make sure to create mappings for columns so that a
        // valid mapping can be retrieved later and vice-versa.

        QVector<int> &orthogonal_proxy_to_source = (orient == Qt::Horizontal) ? m->source_rows : m->source_columns;
        QVector<int> &orthogonal_source_to_proxy = (orient == Qt::Horizontal) ? m->proxy_rows : m->proxy_columns;

        if (orthogonal_source_to_proxy.isEmpty()) {
            const int ortho_end = (orient == Qt::Horizontal) ? model->rowCount(source_parent) : model->columnCount(source_parent);

            orthogonal_source_to_proxy.resize(ortho_end);

            for (int ortho_item = 0; ortho_item < ortho_end; ++ortho_item) {
                if ((orient == Qt::Horizontal) ? q->filterAcceptsRow(ortho_item, source_parent)
                        : q->filterAcceptsColumn(ortho_item, source_parent)) {
                    orthogonal_proxy_to_source.append(ortho_item);
                }
            }
            if (orient == Qt::Horizontal) {
                // We're reacting to columnsInserted, but we've just inserted new rows. Sort them.
                sort_source_rows(orthogonal_proxy_to_source, source_parent);
            }
            build_source_to_proxy_mapping(orthogonal_proxy_to_source, orthogonal_source_to_proxy);
        }
    }

    // Sort and insert the items
    if (orient == Qt::Vertical) // Only sort rows
        sort_source_rows(source_items, source_parent);
    insert_source_items(source_to_proxy, proxy_to_source, source_items, source_parent, orient);
}

source_items_removed()

void QSortFilterProxyModelPrivate::source_items_removed	(	const QModelIndex &	source_parent,
		int	start,
		int	end,
		Qt::Orientation	orient
	)

Handles source model items removal (columnsRemoved(), rowsRemoved()).

Warning

This function is not part of the public interface.

Definition at line 878 of file qsortfilterproxymodel.cpp.

{
    if ((start < 0) || (end < 0))
        return;
    IndexMap::const_iterator it = source_index_mapping.constFind(source_parent);
    if (it == source_index_mapping.constEnd()) {
        // Don't care, since we don't have mapping for this index
        return;
    }

    Mapping *m = it.value();
    QVector<int> &source_to_proxy = (orient == Qt::Vertical) ? m->proxy_rows : m->proxy_columns;
    QVector<int> &proxy_to_source = (orient == Qt::Vertical) ? m->source_rows : m->source_columns;

    if (end >= source_to_proxy.size())
        end = source_to_proxy.size() - 1;

    // Shrink the source-to-proxy mapping to reflect the new item count
    int delta_item_count = end - start + 1;
    source_to_proxy.remove(start, delta_item_count);

    int proxy_count = proxy_to_source.size();
    if (proxy_count > source_to_proxy.size()) {
        // mapping is in an inconsistent state -- redo the whole mapping
        qWarning("QSortFilterProxyModel: inconsistent changes reported by source model");
        remove_from_mapping(source_parent);
        Q_Q(QSortFilterProxyModel);
        q->reset();
        return;
    }

    // Adjust "stale" indexes in proxy-to-source mapping
    for (int proxy_item = 0; proxy_item < proxy_count; ++proxy_item) {
        int source_item = proxy_to_source.at(proxy_item);
        if (source_item >= start) {
            Q_ASSERT(source_item - delta_item_count >= 0);
            proxy_to_source.replace(proxy_item, source_item - delta_item_count);
        }
    }
    build_source_to_proxy_mapping(proxy_to_source, source_to_proxy);

    updateChildrenMapping(source_parent, m, orient, start, end, delta_item_count, true);

}

source_to_proxy()

QModelIndex QSortFilterProxyModelPrivate::source_to_proxy

(

const QModelIndex &

sourceIndex

)

const

Definition at line 377 of file qsortfilterproxymodel.cpp.

{
    if (!source_index.isValid())
        return QModelIndex(); // for now; we may want to be able to set a root index later
    if (source_index.model() != model) {
        qWarning() << "QSortFilterProxyModel: index from wrong model passed to mapFromSource";
        Q_ASSERT(!"QSortFilterProxyModel: index from wrong model passed to mapFromSource");
        return QModelIndex();
    }
    QModelIndex source_parent = source_index.parent();
    IndexMap::const_iterator it = create_mapping(source_parent);
    Mapping *m = it.value();
    if ((source_index.row() >= m->proxy_rows.size()) || (source_index.column() >= m->proxy_columns.size()))
        return QModelIndex();
    int proxy_row = m->proxy_rows.at(source_index.row());
    int proxy_column = m->proxy_columns.at(source_index.column());
    if (proxy_row == -1 || proxy_column == -1)
        return QModelIndex();
    return create_index(proxy_row, proxy_column, it);
}

store_persistent_indexes()

QModelIndexPairList QSortFilterProxyModelPrivate::store_persistent_indexes

(

)

Maps the persistent proxy indexes to source indexes and returns the list of source indexes.

Warning

This function is not part of the public interface.

Definition at line 1023 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);
    QModelIndexPairList source_indexes;
    foreach (QPersistentModelIndexData *data, persistent.indexes) {
        QModelIndex proxy_index = data->index;
        QModelIndex source_index = q->mapToSource(proxy_index);
        source_indexes.append(qMakePair(proxy_index, QPersistentModelIndex(source_index)));
    }
    return source_indexes;
}

update_persistent_indexes()

void QSortFilterProxyModelPrivate::update_persistent_indexes

(

const QModelIndexPairList &

source_indexes

)

Maps source_indexes to proxy indexes and stores those as persistent indexes.

Warning

This function is not part of the public interface.

Definition at line 1044 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);
    QModelIndexList from, to;
    for (int i = 0; i < source_indexes.count(); ++i) {
        QModelIndex source_index = source_indexes.at(i).second;
        QModelIndex old_proxy_index = source_indexes.at(i).first;
        create_mapping(source_index.parent());
        QModelIndex proxy_index = q->mapFromSource(source_index);
        from << old_proxy_index;
        to << proxy_index;
    }
    q->changePersistentIndexList(from, to);
}

update_source_sort_column()

bool QSortFilterProxyModelPrivate::update_source_sort_column

(

)

Warning

This function is not part of the public interface.

update the source_sort_column according to the proxy_sort_column return true if the column was changed

Definition at line 447 of file qsortfilterproxymodel.cpp.

{
    Q_Q(QSortFilterProxyModel);
    QModelIndex proxy_index = q->index(0, proxy_sort_column, QModelIndex());
    int old_source_sort_colum = source_sort_column;
    source_sort_column = q->mapToSource(proxy_index).column();
    return old_source_sort_colum != source_sort_column;
}

updateChildrenMapping()

void QSortFilterProxyModelPrivate::updateChildrenMapping	(	const QModelIndex &	source_parent,
		Mapping *	parent_mapping,
		Qt::Orientation	orient,
		int	start,
		int	end,
		int	delta_item_count,
		bool	remove
	)

Warning

This function is not part of the public interface. updates the mapping of the children when inserting or removing items

Definition at line 929 of file qsortfilterproxymodel.cpp.

{
    // see if any mapped children should be (re)moved
    QVector<QPair<QModelIndex, Mapping*> > moved_source_index_mappings;
    QVector<QModelIndex>::iterator it2 = parent_mapping->mapped_children.begin();
    for ( ; it2 != parent_mapping->mapped_children.end();) {
        const QModelIndex source_child_index = *it2;
        const int pos = (orient == Qt::Vertical)
                        ? source_child_index.row()
                        : source_child_index.column();
        if (pos < start) {
            // not affected
            ++it2;
        } else if (remove && pos <= end) {
            // in the removed interval
            it2 = parent_mapping->mapped_children.erase(it2);
            remove_from_mapping(source_child_index);
        } else {
            // below the removed items -- recompute the index
            QModelIndex new_index;
            const int newpos = remove ? pos - delta_item_count : pos + delta_item_count;
            if (orient == Qt::Vertical) {
                new_index = model->index(newpos,
                                         source_child_index.column(),
                                         source_parent);
            } else {
                new_index = model->index(source_child_index.row(),
                                         newpos,
                                         source_parent);
            }
            *it2 = new_index;
            ++it2;

            // update mapping
            Mapping *cm = source_index_mapping.take(source_child_index);
            Q_ASSERT(cm);
        // we do not reinsert right away, because the new index might be identical with another, old index
        moved_source_index_mappings.append(QPair<QModelIndex, Mapping*>(new_index, cm));
        }
    }

    // reinsert moved, mapped indexes
    QVector<QPair<QModelIndex, Mapping*> >::iterator it = moved_source_index_mappings.begin();
    for (; it != moved_source_index_mappings.end(); ++it) {
#ifdef QT_STRICT_ITERATORS
        source_index_mapping.insert((*it).first, (*it).second);
        (*it).second->map_iter = source_index_mapping.constFind((*it).first);
#else
        (*it).second->map_iter = source_index_mapping.insert((*it).first, (*it).second);
#endif
    }
}

Properties

dynamic_sortfilter

bool QSortFilterProxyModelPrivate::dynamic_sortfilter

Definition at line 170 of file qsortfilterproxymodel.cpp.

filter_column

int QSortFilterProxyModelPrivate::filter_column

Definition at line 166 of file qsortfilterproxymodel.cpp.

filter_regexp

QRegExp QSortFilterProxyModelPrivate::filter_regexp

Definition at line 167 of file qsortfilterproxymodel.cpp.

filter_role

int QSortFilterProxyModelPrivate::filter_role

Definition at line 168 of file qsortfilterproxymodel.cpp.

itemsBeingRemoved

QRowsRemoval QSortFilterProxyModelPrivate::itemsBeingRemoved

Definition at line 171 of file qsortfilterproxymodel.cpp.

proxy_sort_column

int QSortFilterProxyModelPrivate::proxy_sort_column

Definition at line 160 of file qsortfilterproxymodel.cpp.

saved_persistent_indexes

QModelIndexPairList QSortFilterProxyModelPrivate::saved_persistent_indexes

Definition at line 173 of file qsortfilterproxymodel.cpp.

sort_casesensitivity

Qt::CaseSensitivity QSortFilterProxyModelPrivate::sort_casesensitivity

Definition at line 162 of file qsortfilterproxymodel.cpp.

sort_localeaware

bool QSortFilterProxyModelPrivate::sort_localeaware

Definition at line 164 of file qsortfilterproxymodel.cpp.

sort_order

Qt::SortOrder QSortFilterProxyModelPrivate::sort_order

Definition at line 161 of file qsortfilterproxymodel.cpp.

sort_role

int QSortFilterProxyModelPrivate::sort_role

Definition at line 163 of file qsortfilterproxymodel.cpp.

source_index_mapping

QHash<QModelIndex, Mapping*> QSortFilterProxyModelPrivate::source_index_mapping

mutable

Definition at line 157 of file qsortfilterproxymodel.cpp.

source_sort_column

int QSortFilterProxyModelPrivate::source_sort_column

Definition at line 159 of file qsortfilterproxymodel.cpp.

---

The documentation for this class was generated from the following file:

• /src/gui/itemviews/qsortfilterproxymodel.cpp