I've worked on a QAbstractProxyModel to group source model data into a tree, based upon specifying a column to group by.

It works a charm, and all in all I'm happy.

BUT...

Arrow keys no longer work and I really cannot work out why?

Any hints?

Qt Code: 
  1. // Proxy model for doing groupBy
  2. class GroupByModel : public QAbstractProxyModel
  3. {
  4.     Q_OBJECT
  5.  
  6. private:
  7.     int groupBy;
  8.  
  9.     QList<QString> groups;
  10.     QList<QModelIndex> groupIndexes;
  11.     QMap<QString, QVector<int>*> groupToSourceRow;
  12.     QVector<int> sourceRowToGroupRow;
  13.  
  14. public:
  15.  
  16.     GroupByModel(QObject *parent = NULL) : QAbstractProxyModel(parent), groupBy(-1) {
  17.         setParent(parent);
  18.     }
  19.     ~GroupByModel() {}
  20.  
  21.     void setSourceModel(QAbstractItemModel *model) {
  22.         QAbstractProxyModel::setSourceModel(model);
  23.         setGroupBy(groupBy);
  24.     }
  25.  
  26.     QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const {
  27.         if (parent.isValid()) {
  28.             return createIndex(row,column, (void*)&groupIndexes[parent.row()]);
  29.         } else {
  30.             if (column == 0)
  31.                 return groupIndexes[row];
  32.             else {
  33.                 return createIndex(row,column,NULL);
  34.             }
  35.         }
  36.     }
  37.  
  38.     QModelIndex parent(const QModelIndex &index) const {
  39.         // parent should be encoded in the index if we supplied it, if
  40.         // we didn't then return a duffer
  41.         if (index == QModelIndex() || index.internalPointer() == NULL) {
  42.             return QModelIndex();
  43.         } else if (index.column()) {
  44.             return QModelIndex();
  45.         }  else {
  46.             return *static_cast<QModelIndex*>(index.internalPointer());
  47.         }
  48.     }
  49.  
  50.     QModelIndex mapToSource(const QModelIndex &proxyIndex) const {
  51.  
  52.         if (proxyIndex.internalPointer() != NULL) {
  53.  
  54.             int groupNo = ((QModelIndex*)proxyIndex.internalPointer())->row();
  55.             if (groupNo < 0 || groupNo >= groups.count() || proxyIndex.column() == 0) {
  56.                 return QModelIndex();
  57.             }
  58.  
  59.             return sourceModel()->index(groupToSourceRow.value(groups[groupNo])->at(proxyIndex.row()),
  60.                                         proxyIndex.column()-1, // accomodate virtual column
  62.         } 
  63.         return QModelIndex();
  64.     }
  65.  
  66.     QModelIndex mapFromSource(const QModelIndex &sourceIndex) const {
  67.  
  68.         // which group did we put this row into?
  69.         QString group = whichGroup(sourceIndex.row());
  70.         int groupNo = groups.indexOf(group);
  71.  
  72.         if (groupNo < 0) {
  73.             return QModelIndex();
  74.         } else {
  75.             QModelIndex *p = new QModelIndex(createIndex(groupNo, 0, NULL));
  76.             return createIndex(sourceRowToGroupRow[sourceIndex.row()], sourceIndex.column()+1, &p); // accomodate virtual column
  77.         } 
  78.     }
  79.  
  80.     QVariant data(const QModelIndex &proxyIndex, int role = Qt::DisplayRole) const {
  81.  
  82.         if (!proxyIndex.isValid()) return QVariant();
  83.  
  84.         QVariant returning;
  85.  
  86.         // if we are not at column 0 or we have a parent
  87.         //if (proxyIndex.internalPointer() != NULL || proxyIndex.column() > 0) {
  88.         if (proxyIndex.column() > 0) {
  89.  
  90.             returning = sourceModel()->data(mapToSource(proxyIndex), role);
  91.  
  92.         } else if (proxyIndex.internalPointer() == NULL) {
  93.  
  94.             // its our group by!
  95.             if (proxyIndex.row() < groups.count()) {
  96.  
  97.                 // blank values become "(blank)"
  98.                 QString group = groups[proxyIndex.row()];
  99.                 if (group == "") group = QString("(blank)");
  100.  
  101.                 // format the group by with ride count etc
  102.                 if (groupBy != -1) {
  103.                     QString returnString = QString("%1: %2 (%3 rides)")
  104.                                            .arg(sourceModel()->headerData(groupBy, Qt::Horizontal).toString())
  105.                                            .arg(group)
  106.                                            .arg(groupToSourceRow.value(groups[proxyIndex.row()])->count());
  107.                     returning = QVariant(returnString);
  108.                 } else {
  109.                     QString returnString = QString("All %1 rides")
  110.                                            .arg(groupToSourceRow.value(groups[proxyIndex.row()])->count());
  111.                     returning = QVariant(returnString);
  112.                 }
  113.             }
  114.         }
  115.  
  116.         return returning;
  117.  
  118.     }
  119.  
  120.     QVariant headerData (int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const {
  121.         if (section)
  122.             return sourceModel()->headerData(section-1, orientation, role);
  123.         else
  124.             return QVariant("*");
  125.     }
  126.  
  127.     bool setHeaderData (int section, Qt::Orientation orientation, const QVariant & value, int role = Qt::EditRole) {
  128.         if (section)
  129.             return sourceModel()->setHeaderData(section-1, orientation, value, role);
  130.         else
  131.             return true;
  132.     }
  133.  
  134.     int columnCount(const QModelIndex &/*parent*/ = QModelIndex()) const {
  135.         return sourceModel()->columnCount(QModelIndex())+1; // accomodate virtual group column
  136.     }
  137.  
  138.     int rowCount(const QModelIndex &parent = QModelIndex()) const {
  139.         if (parent == QModelIndex()) {
  140.  
  141.             // top level return count of groups
  142.             return groups.count();
  143.  
  144.         } else if (parent.column() == 0 && parent.internalPointer() == NULL) {
  145.  
  146.             // second level return count of rows for group
  147.             return groupToSourceRow.value(groups[parent.row()])->count();
  148.  
  149.         } else {
  150.  
  151.             // no children any lower
  152.             return 0;
  153.         }
  154.     }
  155.  
  156.     // does this index have children?
  157.     bool hasChildren(const QModelIndex &index) const {
  158.  
  159.         if (index == QModelIndex()) {
  160.  
  161.             // at top
  162.             return (groups.count() > 0);
  163.  
  164.         } else if (index.column() == 0 && index.internalPointer() == NULL) {
  165.  
  166.             // first column - the group bys
  167.             return (groupToSourceRow.value(groups[index.row()])->count() > 0);
  168.  
  169.         } else {
  170.  
  171.             return false;
  172.  
  173.         }
  174.     }
  175.  
  176.     //
  177.     // GroupBy features
  178.     //
  179.     void setGroupBy(int column) {
  180.  
  181.         // shift down
  182.         if (column >= 0) column -= 1;
  183.  
  184.         groupBy = column; // accomodate virtual column
  185.         setGroups();
  186.     }
  187.  
  188.     QString whichGroup(int row) const {
  189.  
  190.         if (groupBy == -1) return tr("All Rides");
  191.         else return groupFromValue(headerData(groupBy+1, Qt::Horizontal).toString(),
  192.                                     sourceModel()->data(sourceModel()->index(row,groupBy)).toString());
  193.  
  194.     }
  195.  
  196.     // implemented in RideNavigator.cpp, to avoid developers
  197.     // from working out how this QAbstractProxy works, or
  198.     // perhaps breaking it by accident ;-)
  199.     QString groupFromValue(QString, QString) const;
  200.  
  201.     void clearGroups() {
  202.         // Wipe current
  203.         QMapIterator<QString, QVector<int>*> i(groupToSourceRow);
  204.         while (i.hasNext()) {
  205.             i.next();
  206.             delete i.value();
  207.         }
  208.         groups.clear();
  209.         groupIndexes.clear();
  210.         groupToSourceRow.clear();
  211.         sourceRowToGroupRow.clear();
  212.     }
  213.  
  214.     int groupCount() {
  215.         return groups.count();
  216.     }
  217.  
  218.     void setGroups() {
  219.  
  220.         // let the views know we're doing this
  221.         beginResetModel();
  222.  
  223.         // wipe whatever is there first
  224.         clearGroups();
  225.  
  226.         if (groupBy >= 0) {
  227.  
  228.             // create a QMap from 'group' string to list of rows in that group
  229.             for (int i=0; i<sourceModel()->rowCount(QModelIndex()); i++) {
  230.                 QString value = whichGroup(i);
  231.  
  232.                 QVector<int> *rows;
  233.                 if ((rows=groupToSourceRow.value(value,NULL)) == NULL) {
  234.                     // add to list of groups
  235.                     rows = new QVector<int>;
  236.                     groupToSourceRow.insert(value, rows);
  237.                 }
  238.  
  239.                 // rowmap is an array corresponding to each row in the
  240.                 // source model, and maps to its row # within the group
  241.                 sourceRowToGroupRow.append(rows->count());
  242.  
  243.                 // add to this groups rows
  244.                 rows->append(i);
  245.             }
  246.  
  247.         } else {
  248.  
  249.             // Just one group by 'All Rides'
  250.             QVector<int> *rows = new QVector<int>;
  251.             for (int i=0; i<sourceModel()->rowCount(QModelIndex()); i++) {
  252.                 rows->append(i);
  253.                 sourceRowToGroupRow.append(i);
  254.             }
  255.             groupToSourceRow.insert("All Rides", rows);
  256.  
  257.         }
  258.  
  259.         // Update list of groups
  260.         int group=0;
  261.         QMapIterator<QString, QVector<int>*> j(groupToSourceRow);
  262.         while (j.hasNext()) {
  263.             j.next();
  264.             groups << j.key();
  265.             groupIndexes << createIndex(group++,0,NULL);
  266.         }
  267.  
  268.         // all done. let the views know everything changed
  269.         endResetModel();
  270.     }
  271. };
To copy to clipboard, switch view to plain text mode 

Many thanks for taking time to look at this! it really is appreciated.

Cheers,
Mark