QSortFilterProxyModel returning artificial row

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):                                                                                                                               开发者_如何学C   
    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!

Because I struggled a little bit with the implementation of this and because I could not find any other sample code in the whole net, I post this sample implementation.

I hope this helps other people too...

/**
 ** Written by Sven Anders (ANDURAS AG). Public domain code.
 **/

#include <QDebug>
#include <QBrush>
#include <QFont>
#include <QSortFilterProxyModel>

/** Definition **/

class ProxyModelNoneEntry : public QSortFilterProxyModel
{
   Q_OBJECT
 public:
  ProxyModelNoneEntry(QString _entry_text = tr("(None)"), QObject *parent=0);
  int rowCount(const QModelIndex &parent = QModelIndex()) const;
  /* lessThan() is not necessary for this model to work, but can be
     implemented in a derived class if a custom sorting method is required. */
  // bool lessThan(const QModelIndex &left, const QModelIndex &right) const;
  QModelIndex mapFromSource(const QModelIndex &sourceIndex) const;
  QModelIndex mapToSource(const QModelIndex &proxyIndex) const;
  QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
  Qt::ItemFlags flags(const QModelIndex &index) const;
  QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
  QModelIndex parent(const QModelIndex &child) const;

 private:
  QString entry_text;
};

/** Implementation **/

ProxyModelNoneEntry::ProxyModelNoneEntry(QString _entry_text, QObject *parent) : QSortFilterProxyModel(parent)
{
  entry_text = _entry_text;
}

int ProxyModelNoneEntry::rowCount(const QModelIndex &parent) const
{
  Q_UNUSED(parent)
  return QSortFilterProxyModel::rowCount()+1;
}

QModelIndex ProxyModelNoneEntry::mapFromSource(const QModelIndex &sourceIndex) const
{
  if (!sourceIndex.isValid()) return QModelIndex();
  else if (sourceIndex.parent().isValid()) return QModelIndex();
  return createIndex(sourceIndex.row()+1, sourceIndex.column());
}

QModelIndex ProxyModelNoneEntry::mapToSource(const QModelIndex &proxyIndex) const
{
  if (!proxyIndex.isValid()) return QModelIndex();
  else if (proxyIndex.row() == 0) return QModelIndex();
  return sourceModel()->index(proxyIndex.row()-1, proxyIndex.column());
}

QVariant ProxyModelNoneEntry::data(const QModelIndex &index, int role) const
{
  if (!index.isValid()) return QVariant();

  if (index.row() == 0)
  {
    if (role == Qt::DisplayRole)
      return entry_text;
    else if (role == Qt::DecorationRole)
      return QVariant();
    else if (role == Qt::FontRole)
    { QFont font; font.setItalic(true); return font; }
    else
      return QVariant();
  }
  return QSortFilterProxyModel::data(createIndex(index.row(),index.column()), role);
}

Qt::ItemFlags ProxyModelNoneEntry::flags(const QModelIndex &index) const
{
  if (!index.isValid()) return Qt::NoItemFlags;
  if (index.row() == 0) return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
  return QSortFilterProxyModel::flags(createIndex(index.row(),index.column()));
}

QModelIndex ProxyModelNoneEntry::index(int row, int column, const QModelIndex &parent) const
{
  if (row > rowCount()) return QModelIndex();
  return createIndex(row, column);
}

QModelIndex ProxyModelNoneEntry::parent(const QModelIndex &child) const
{
  Q_UNUSED(child)
  return QModelIndex();
}

Regards Sven

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)

I had the same kind of problem recently, and have a lot of trouble with parents and maping with source model.

My version has to handle virtual columns to the left, a few linked to actions, and possibly one that is a checkbox.

Hopes this can help somebody too :)

Yet, a note to the wise, I'm subclassing a QSortFilterProxyModel, and by doing so, I seem to loose the ability to use sort. I guess it's because I override index/data methods. If i happend to subclass QIdentityProxyModel instead and then add a QSortFilterProxyModel afterward, I instead loose the ability to check/uncheck my checkbox column ... even though flags are set to Qt::ItemIsEnabled | Qt::ItemIsUserCheckable | Qt::ItemIsEditable ... tricky still :)

QModelIndex GenericProxy::mapToSource(const QModelIndex & proxy) const {
  if(not proxy.isValid())
    return QModelIndex();

  if((action || checkbox)) {
    int column = proxy.column() - addedCount();
    if(column < 0) // this index is local.
      return QModelIndex();

    QModelIndex idx = sourceModel()->index(proxy.row(), column, mapToSource(proxy.parent()));
    return idx ;
  }

  QModelIndex idx = sourceModel()->index(proxy.row(), proxy.column(), mapToSource(proxy.parent()));
  return idx; 
}

QModelIndex GenericProxy::mapFromSource(const QModelIndex & source) const {
  if(not source.isValid()) 
    return QModelIndex();


  if((action || checkbox)) {
    // simply add appropriate informations ..
    int column = source.column() + addedCount();
    QModelIndex idx = index(source.row(), column, mapFromSource(source.parent()));
    return idx; 
  }
  QModelIndex idx = index(source.row(), source.column(), mapFromSource(source.parent()));
  return idx; 
}

GenericItem * GenericProxy::convert(const QModelIndex & idx) const {
  if(idx.isValid())
    return  _convert(index(idx.row(), firstRealColumn(), idx.parent()));
  else
    return _convert(idx);
}

// _convert doesn't take care of index not really at the rightplace_ness :)
GenericItem * GenericProxy::_convert(const QModelIndex & index) const {
  if(not index.isValid())
    return dynamic_cast<GenericModel *>(sourceModel())->convert(QModelIndex());

  return static_cast<GenericItem*>(index.internalPointer());
}
QModelIndex GenericProxy::parent(const QModelIndex & item) const {
  if(not item.isValid())
    return QModelIndex();

  GenericItem * child = _convert(item);
  if(!child)
    return QModelIndex();
  GenericItem * parent = child->parentItem();
  if(parent == _convert(QModelIndex()))
    return QModelIndex();

  int column = addedCount();
  return sourceModel()->parent(mapToSource(createIndex(item.row(), column, parent )));
}

QModelIndex GenericProxy::index(int row, int column, const QModelIndex & parent) const {
  if( not hasIndex(row,column,parent))
    return QModelIndex();

  GenericItem * pitem = convert(parent);
  GenericItem * pchild = pitem->child(row);

  if(pchild)
    return createIndex(row, column, pchild);
  else
    return QModelIndex();

}