Question

I’m using a QSortFilterProxyModel to filter results from a QAbstractListModel. However, I’d like to return a first entry which is not present in the original model, that is, it’s somehow artificial.

This is what I have so far:

class ActivedAccountModel(QSortFilterProxyModel):                                                                                                                                  
    def __init__(self, model, parent=None):
        super(ActiveAccountModel, self).__init__(parent)
        self.setSourceModel(model)
        self.setDynamicSortFilter(True)

    def data(self, index, role=Qt.DisplayRole):
        account_info = super(ActiveAccountModel, self).data(index, Qt.UserRole).toPyObject()
        if role == Qt.DisplayRole:
            return account_info.name
        elif role == Qt.UserRole:
            return account_info
        return None

    def filterAcceptsRow(self, source_row, source_parent):
        source_model = self.sourceModel()
        source_index = source_model.index(source_row, 0, source_parent)
        account_info = source_model.data(source_index, Qt.UserRole)
        return isinstance(account_info.account, Account) and account_info.account.enabled

This will return a list in the form of:

Account 1
Account 2
...

Id’ like to return an extra element at the begining of the returned list f elements:

Extra Element
Account 1
Account 2
...

I tried to reimplement rowCount in order to return the real rowCount()+1, but somehow I’d need to shift all the items in order to return this artificial element at index 0, and I’m a bit lost there.

Any clue? I couldn’t find any related code example so far… Thanks!

Answer 1

I’ve done this, only at work, so I can’t give you much code. I can give you the general idea of what to do.

It works better if you subclass QAbstractProxyModel, which is designed for general manipulation, not sorting or filtering. You’ll want to override rowCount, and also need to override columnCount (although that should just return the information from the source model). You’ll need to override the data function and return your own data for the first row, or call the source model once more.

You will want to override the mapFromSource and mapToSource functions, to allow switching between the proxy model indexes and source model indexes.

To do a robust implementation, you’ll need to create some slots and connect to the source model’s signals for data changing, model reset, and rows/columns about to be inserted/removed. You should then emit your own signals, properly adapting them to account for your extra row.

In our class, we made the text for the first row settable, so we could use the same proxy model in different situations. It’s worth investigating for yours, since it adds minimal effort.

Edit

Per commented request, a rough look at mapToSource and mapFromSource. This is approximately what you need to think about.

// Remember that this maps from the proxy's index to the source's index, 
// which is invalid for the extra row the proxy adds.
mapToSource( proxy_index ):
    if proxy_index isn't valid:
        return invalid QModelIndex
    else if proxy_index is for the first row:
        return invalid QModelIndex
    else
        return source model index for (proxy_index.row - 1, proxy_index.column)

mapFromSource( source_index ):
    if source_index isn't valid:
        return invalid QModelIndex
    else if source_index has a parent:
        // This would occur if you are adding an extra top-level 
        // row onto a tree model.
        // You would need to decide how to handle that condition
        return invalid QModelIndex
    else
        return proxy model index for (source_index.row + 1, source_index.column)