QSortFilterProxyModel返回人工行

Question

我正在使用QSortFilterProxyModel来过滤QAbstractListModel的结果。但是，我想要返回原始模型中没有的第一个条目，也就是说，它在某种程度上是人为的。

这是我到目前为止所做的：

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

这将返回以下形式的列表：

Account 1
Account 2
...

Id'想在返回的列表f元素的开头返回一个额外的元素：

Extra Element
Account 1
Account 2
...

我尝试重新实现rowCount以返回真正的rowCount（）+ 1，但不知怎的，我需要 shift 所有项目才能在索引0处返回此人工元素，并且我在那里有点迷失。

有任何线索吗？到目前为止，我找不到任何相关的代码示例...谢谢！

Answer 1

因为我在执行此操作时遇到了一点困难，因为我在整个网络中找不到任何其他示例代码，所以我发布了这个示例实现。

我希望这对其他人也有帮助......

/**
 ** 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();
}

此致  斯文

Answer 2

我已经完成了这项工作，只是在工作中，所以我不能给你很多代码。我可以告诉你如何做的一般想法。

如果你继承QAbstractProxyModel，它的设计用于一般操作，而不是排序或过滤，它会更好。您将要覆盖rowCount，还需要覆盖columnCount（尽管这应该只返回源模型中的信息）。您需要覆盖数据函数并返回第一行自己的数据，或再次调用源模型。

您需要覆盖mapFromSource和mapToSource函数，以允许在代理模型索引和源模型索引之间切换。

要执行强大的实现，您需要创建一些插槽并连接到源模型的信号，以便进行数据更改，模型重置以及即将插入/删除的行/列。然后你应该发出你自己的信号，正确地调整它们来计算额外的行。

在我们的课程中，我们将第一行的文本设置为可设置，因此我们可以在不同的情况下使用相同的代理模型。值得为你的调查，因为它增加了很少的努力。

修改

根据评论请求，粗略查看mapToSource和mapFromSource。这大约是你需要考虑的事情。

// 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)

Answer 3

我最近遇到了同样的问题，父母和使用源模型时遇到了很多麻烦。

我的版本必须处理左侧的虚拟列，一些链接到操作，可能还有一个复选框。

希望这也可以帮助别人:)

然而，对明智的一个注释，我是一个QSortFilterProxyModel的子类，通过这样做，我似乎失去了使用sort的能力。我想这是因为我覆盖了索引/数据方法。如果我发生了继承QIdentityProxyModel，然后再添加一个QSortFilterProxyModel，我反而无法检查/取消选中我的复选框列...即使标志设置为Qt :: ItemIsEnabled | Qt :: ItemIsUserCheckable | Qt :: ItemIsEditable ......仍然很棘手：）

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();

}