path: root/src/qtgroupingproxy.cpp

/****************************************************************************************
 * Copyright (c) 2007-2011 Bart Cerneels <bart.cerneels@kde.org> *
 *                                                                                      *
 * This program is free software; you can redistribute it and/or modify it under * the
 *terms of the GNU General Public License as published by the Free Software        *
 * Foundation; either version 2 of the License, or (at your option) any later * version.
 **
 *                                                                                      *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY *
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A *
 * PARTICULAR PURPOSE. See the GNU General Public License for more details. *
 *                                                                                      *
 * You should have received a copy of the GNU General Public License along with * this
 *program.  If not, see <http://www.gnu.org/licenses/>.                           *
 ****************************************************************************************/

// Modifications 2013-03-27 to 2013-03-29 by Sebastian Herbord

#include "qtgroupingproxy.h"
#include <log.h>

#include <QDebug>
#include <QIcon>
#include <QInputDialog>

using namespace MOBase;

/*!
    \class QtGroupingProxy
    \brief The QtGroupingProxy class will group source model rows by adding a new top
   tree-level. The source model can be flat or tree organized, but only the original top
   level rows are used for determining the grouping. \ingroup model-view
*/

QtGroupingProxy::QtGroupingProxy(QModelIndex rootNode, int groupedColumn,
                                 int groupedRole, unsigned int flags, int aggregateRole)
    : QAbstractProxyModel(), m_rootNode(rootNode), m_groupedColumn(0),
      m_groupedRole(groupedRole), m_aggregateRole(aggregateRole), m_flags(flags)
{
  if (groupedColumn != -1) {
    setGroupedColumn(groupedColumn);
  }
}

QtGroupingProxy::~QtGroupingProxy() {}

void QtGroupingProxy::setSourceModel(QAbstractItemModel* model)
{
  if (sourceModel()) {
    disconnect(sourceModel(), nullptr, this, nullptr);
  }

  QAbstractProxyModel::setSourceModel(model);

  if (sourceModel()) {
    // signal proxies
    connect(sourceModel(), SIGNAL(rowsInserted(const QModelIndex&, int, int)),
            SLOT(modelRowsInserted(const QModelIndex&, int, int)));
    connect(sourceModel(), SIGNAL(rowsAboutToBeInserted(const QModelIndex&, int, int)),
            SLOT(modelRowsAboutToBeInserted(const QModelIndex&, int, int)));
    connect(sourceModel(), SIGNAL(rowsRemoved(const QModelIndex&, int, int)),
            SLOT(modelRowsRemoved(const QModelIndex&, int, int)));
    connect(sourceModel(), SIGNAL(rowsAboutToBeRemoved(const QModelIndex&, int, int)),
            SLOT(modelRowsAboutToBeRemoved(QModelIndex, int, int)));
    connect(sourceModel(), SIGNAL(layoutChanged()), SLOT(buildTree()));
    connect(sourceModel(), SIGNAL(dataChanged(QModelIndex, QModelIndex)),
            SLOT(modelDataChanged(QModelIndex, QModelIndex)));
    connect(sourceModel(), SIGNAL(modelReset()), this, SLOT(resetModel()));

    buildTree();
  }
}

void QtGroupingProxy::setGroupedColumn(int groupedColumn)
{
  m_groupedColumn = groupedColumn;
  buildTree();
}

/** Maps to what groups the source row belongs by returning the data of those groups.
 *
 * @returns a list of data for the rows the argument belongs to. In common cases this
 * list will contain only one entry. An empty list means that the source item will be
 * placed in the root of this proxyModel. There is no support for hiding source items.
 *
 * Group data can be pre-loaded in the return value so it's added to the cache
 * maintained by this class. This is required if you want to have data that is not
 * present in the source model.
 */
QList<RowData> QtGroupingProxy::belongsTo(const QModelIndex& idx)
{
  QList<RowData> rowDataList;

  // get all the data for this index from the model
  ItemData itemData = sourceModel()->itemData(idx);
  if (m_groupedRole != Qt::DisplayRole) {
    itemData[Qt::DisplayRole] = itemData[m_groupedRole];
  }

  // invalid value in grouped role -> ungrouped
  if (!itemData[Qt::DisplayRole].isValid()) {
    return rowDataList;
  }

  QMapIterator<int, QVariant> i(itemData);
  while (i.hasNext()) {
    i.next();
    int role         = i.key();
    QVariant variant = i.value();

    if (variant.type() == QVariant::List) {
      // a list of variants get's expanded to multiple rows
      QVariantList list = variant.toList();
      for (int i = 0; i < list.length(); i++) {
        // take an existing row data or create a new one
        RowData rowData = (rowDataList.count() > i) ? rowDataList.takeAt(i) : RowData();

        // we only gather data for the first column
        ItemData indexData = rowData.contains(0) ? rowData.take(0) : ItemData();
        indexData.insert(role, list.value(i));
        rowData.insert(0, indexData);
        // for the grouped column the data should not be gathered from the children
        // this will allow filtering on the content of this column with a
        // QSortFilterProxyModel
        rowData.insert(m_groupedColumn, indexData);
        rowDataList.insert(i, rowData);
      }
      break;
    } else if (!variant.isNull()) {
      // it's just a normal item. Copy all the data and break this loop.
      RowData rowData;
      rowData.insert(0, itemData);
      rowDataList << rowData;
      break;
    }
  }

  return rowDataList;
}

/* m_groupMap layout
 *  key : index of the group in m_groupMaps
 *  value : a QList of the original rows in sourceModel() for the children of this group
 *
 *  key = -1  contains a QList of the non-grouped indexes
 *
 * TODO: sub-groups
 */
void QtGroupingProxy::buildTree()
{
  if (!sourceModel())
    return;
  beginResetModel();

  m_groupMap.clear();
  // don't clear the data maps since most of it will probably be needed again.
  m_parentCreateList.clear();

  int max = sourceModel()->rowCount(m_rootNode);

  // WARNING: these have to be added in order because the addToGroups function is
  // optimized for modelRowsInserted(). Failure to do so will result in wrong data shown
  // in the view at best.
  for (int row = 0; row < max; row++) {
    QModelIndex idx = sourceModel()->index(row, m_groupedColumn, m_rootNode);
    addSourceRow(idx);
  }
  // dumpGroups();

  if (m_flags & FLAG_NOSINGLE) {
    // awkward: flatten single-item groups as a post-processing steps.

    int currentKey     = 0;
    quint32 quint32max = std::numeric_limits<quint32>::max();
    std::vector<int> rmgroups;

    QMap<quint32, QList<int>> temp;

    for (auto iter = m_groupMap.begin(); iter != m_groupMap.end(); ++iter) {
      if ((iter.key() == quint32max) || (iter->count() < 2)) {
        temp[quint32max].append(iter.value());
        if (iter.key() != quint32max) {
          rmgroups.push_back(iter.key());
        }
      } else {
        temp[currentKey++] = *iter;
      }
    }
    m_groupMap = temp;

    // second loop is necessary because qt containers can't be iterated from end to
    // front and removing by index from begin to end is ugly
    std::sort(rmgroups.begin(), rmgroups.end(), [](int lhs, int rhs) {
      return rhs < lhs;
    });
    for (auto iter = rmgroups.begin(); iter != rmgroups.end(); ++iter) {
      m_groupMaps.removeAt(*iter);
    }
  }

  endResetModel();
}

QList<int> QtGroupingProxy::addSourceRow(const QModelIndex& idx)
{
  QList<int> updatedGroups;
  QList<RowData> groupData = belongsTo(idx);

  // an empty list here means it's supposed to go in root.
  if (groupData.isEmpty()) {
    updatedGroups << -1;
    if (!m_groupMap.keys().contains(std::numeric_limits<quint32>::max()))
      m_groupMap.insert(std::numeric_limits<quint32>::max(),
                        QList<int>());  // add an empty placeholder
  }

  // an item can be in multiple groups
  foreach (RowData data, groupData) {
    int updatedGroup = -1;
    if (!data.isEmpty()) {
      foreach (const RowData& cachedData, m_groupMaps) {
        // when this matches the index belongs to an existing group
        if (data[0][Qt::DisplayRole] == cachedData[0][Qt::DisplayRole]) {
          data = cachedData;
          break;
        }
      }

      updatedGroup = m_groupMaps.indexOf(data);
      //-1 means not found
      if (updatedGroup == -1) {
        // new groups are added to the end of the existing list
        m_groupMaps << data;
        updatedGroup = m_groupMaps.count() - 1;
      }

      if (!m_groupMap.keys().contains(updatedGroup))
        m_groupMap.insert(updatedGroup, QList<int>());  // add an empty placeholder
    }

    if (!updatedGroups.contains(updatedGroup))
      updatedGroups << updatedGroup;
  }

  // update m_groupMap to the new source-model layout (one row added)
  QMutableMapIterator<quint32, QList<int>> i(m_groupMap);
  while (i.hasNext()) {
    i.next();
    QList<int>& groupList = i.value();
    int insertedProxyRow  = groupList.count();
    for (; insertedProxyRow > 0; insertedProxyRow--) {
      int& rowValue = groupList[insertedProxyRow - 1];
      if (idx.row() <= rowValue) {
        // increment the rows that come after the new row since they moved one place up.
        rowValue++;
      } else {
        break;
      }
    }

    if (updatedGroups.contains(i.key())) {
      // the row needs to be added to this group
      groupList.insert(insertedProxyRow, idx.row());
    }
  }

  return updatedGroups;
}

/** Each ModelIndex has in it's internalId a position in the parentCreateList.
 * struct ParentCreate are the instructions to recreate the parent index.
 * It contains the proxy row number of the parent and the postion in this list of the
 * grandfather. This function creates the ParentCreate structs and saves them in a list.
 */
int QtGroupingProxy::indexOfParentCreate(const QModelIndex& parent) const
{
  if (!parent.isValid())
    return -1;

  struct ParentCreate pc;
  for (int i = 0; i < m_parentCreateList.size(); i++) {
    pc = m_parentCreateList[i];
    if (pc.parentCreateIndex == parent.internalId() && pc.row == parent.row())
      return i;
  }
  // there is no parentCreate yet for this index, so let's create one.
  pc.parentCreateIndex = parent.internalId();
  pc.row               = parent.row();
  m_parentCreateList << pc;

  return m_parentCreateList.size() - 1;
}

QModelIndex QtGroupingProxy::index(int row, int column, const QModelIndex& parent) const
{
  if (!hasIndex(row, column, parent)) {
    return QModelIndex();
  }

  if (parent.column() > 0) {
    return QModelIndex();
  }

  /* We save the instructions to make the parent of the index in a struct.
   * The place of the struct in the list is stored in the internalId
   */
  int parentCreateIndex = indexOfParentCreate(parent);

  return createIndex(row, column, parentCreateIndex);
}

QModelIndex QtGroupingProxy::parent(const QModelIndex& index) const
{
  if (!index.isValid())
    return QModelIndex();

  int parentCreateIndex = index.internalId();
  if (parentCreateIndex == -1 || parentCreateIndex >= m_parentCreateList.count())
    return QModelIndex();

  struct ParentCreate pc = m_parentCreateList[parentCreateIndex];

  // only items at column 0 have children
  return createIndex(pc.row, 0, pc.parentCreateIndex);
}

int QtGroupingProxy::rowCount(const QModelIndex& index) const
{
  if (!index.isValid()) {
    // the number of top level groups + the number of non-grouped items
    int rows = m_groupMaps.count() +
               m_groupMap.value(std::numeric_limits<quint32>::max()).count();
    return rows;
  }

  // TODO:group in group support.
  if (isGroup(index)) {
    qint64 groupIndex = index.row();
    int rows          = m_groupMap.value(groupIndex).count();
    return rows;
  } else {
    QModelIndex originalIndex = mapToSource(index);
    int rowCount              = sourceModel()->rowCount(originalIndex);
    return rowCount;
  }
}

int QtGroupingProxy::columnCount(const QModelIndex& index) const
{
  if (!index.isValid())
    return sourceModel()->columnCount(m_rootNode);

  if (index.column() != 0)
    return 0;

  return sourceModel()->columnCount(mapToSource(index));
}

static bool variantLess(const QVariant& LHS, const QVariant& RHS)
{
  if ((LHS.type() == RHS.type()) &&
      ((LHS.type() == QVariant::Int) || (LHS.type() == QVariant::UInt))) {
    return LHS.toInt() < RHS.toInt();
  }

  // this should always work (comparing empty strings in the worst case) but
  // the results may be wrong
  return LHS.toString() < RHS.toString();
}

static QVariant variantMax(const QVariantList& variants)
{
  QVariant result = variants.first();
  foreach (const QVariant& iter, variants) {
    if (variantLess(result, iter)) {
      result = iter;
    }
  }
  return result;
}

static QVariant variantMin(const QVariantList& variants)
{
  QVariant result = variants.first();
  foreach (const QVariant& iter, variants) {
    if (variantLess(iter, result)) {
      result = iter;
    }
  }
  return result;
}

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

  int row    = index.row();
  int column = index.column();
  if (isGroup(index)) {
    if ((role != Qt::DisplayRole) && (role != Qt::EditRole)) {
      switch (role) {
      case Qt::ForegroundRole: {
        return QBrush(Qt::gray);
      } break;
      case Qt::FontRole: {
        QFont font(m_groupMaps[row][column].value(Qt::FontRole).value<QFont>());
        font.setItalic(true);
        return font;
      } break;
      case Qt::TextAlignmentRole: {
        return Qt::AlignHCenter;
      } break;
      case Qt::UserRole: {
        return m_groupMaps[row][column].value(Qt::DisplayRole).toString();
      } break;
      case Qt::CheckStateRole: {
        if (column != 0)
          return QVariant();
        int childCount          = m_groupMap.value(row).count();
        int checked             = 0;
        QModelIndex parentIndex = this->index(row, 0, index.parent());
        for (int childRow = 0; childRow < childCount; ++childRow) {
          QModelIndex childIndex = this->index(childRow, 0, parentIndex);
          QVariant data          = mapToSource(childIndex).data(Qt::CheckStateRole);
          if (data.toInt() == 2)
            ++checked;
        }
        if (checked == childCount)
          return Qt::Checked;
        else if (checked == 0)
          return Qt::Unchecked;
        else
          return Qt::PartiallyChecked;
      } break;
      default: {
        QModelIndex parentIndex = this->index(row, 0, index.parent());
        if (m_groupMap.value(row).count() > 0) {
          return this->index(0, column, parentIndex).data(role);
        } else {
          return QVariant();
        }
        //                return m_groupMaps[row][column].value( role );
      } break;
      }
    }

    // use cached or precalculated data
    if (m_groupMaps[row][column].contains(Qt::DisplayRole)) {
      if ((m_flags & FLAG_NOGROUPNAME) != 0) {
        QModelIndex parentIndex = this->index(row, 0, index.parent());
        QModelIndex childIndex  = this->index(0, column, parentIndex);
        return childIndex.data(role).toString();
      } else {
        return m_groupMaps[row][column].value(role).toString();
      }
    }

    // for column 0 we gather data from the grouped column instead
    if (column == 0)
      column = m_groupedColumn;

    // map all data from children to columns of group to allow grouping one level up
    QVariantList variantsOfChildren;
    int childCount = m_groupMap.value(row).count();
    if (childCount == 0)
      return QVariant();

    int function = AGGR_NONE;
    if (m_aggregateRole >= Qt::UserRole) {
      QModelIndex parentIndex = this->index(row, 0, index.parent());
      QModelIndex childIndex  = this->index(0, column, parentIndex);
      function                = mapToSource(childIndex).data(m_aggregateRole).toInt();
    }

    // Need a parentIndex with column == 0 because only those have children.
    QModelIndex parentIndex = this->index(row, 0, index.parent());
    for (int childRow = 0; childRow < childCount; childRow++) {
      QModelIndex childIndex = this->index(childRow, column, parentIndex);
      QVariant data          = mapToSource(childIndex).data(role);

      if (data.isValid() && !variantsOfChildren.contains(data))
        variantsOfChildren << data;
    }

    // saving in cache
    ItemData roleMap = m_groupMaps[row].value(column);
    foreach (const QVariant& variant, variantsOfChildren) {
      if (roleMap[role] != variant) {
        roleMap.insert(role, variantsOfChildren);
      }
    }

    if (variantsOfChildren.count() == 0)
      return QVariant();

    // only one unique variant? No need to return a list
    switch (function) {
    case AGGR_EMPTY:
      return QVariant();
    case AGGR_FIRST:
      return variantsOfChildren.first();
    case AGGR_MAX:
      return variantMax(variantsOfChildren);
    case AGGR_MIN:
      return variantMin(variantsOfChildren);
    default: {
      if (variantsOfChildren.count() == 1)
        return variantsOfChildren.first();

      return variantsOfChildren;
    } break;
    }
  }

  return mapToSource(index).data(role);
}

bool QtGroupingProxy::setData(const QModelIndex& idx, const QVariant& value, int role)
{
  if (!idx.isValid())
    return false;

  // no need to set data to exactly the same value
  if (idx.data(role) == value)
    return false;

  if (isGroup(idx)) {
    ItemData columnData = m_groupMaps[idx.row()][idx.column()];

    columnData.insert(role, value);
    // QItemDelegate will always use Qt::EditRole
    if (role == Qt::EditRole)
      columnData.insert(Qt::DisplayRole, value);

    // and make sure it's stored in the map
    m_groupMaps[idx.row()].insert(idx.column(), columnData);

    int columnToChange = idx.column() ? idx.column() : m_groupedColumn;
    foreach (int originalRow, m_groupMap.value(idx.row())) {
      QModelIndex childIdx =
          sourceModel()->index(originalRow, columnToChange, m_rootNode);
      if (childIdx.isValid())
        sourceModel()->setData(childIdx, value, role);
    }
    // TODO: we might need to reload the data from the children at this point

    emit dataChanged(idx, idx);
    return true;
  }

  return sourceModel()->setData(mapToSource(idx), value, role);
}

bool QtGroupingProxy::isGroup(const QModelIndex& index) const
{
  int parentCreateIndex = index.internalId();
  if (parentCreateIndex == -1 && index.row() < m_groupMaps.count())
    return true;
  return false;
}

QModelIndex QtGroupingProxy::mapToSource(const QModelIndex& index) const
{
  if (!index.isValid()) {
    return m_rootNode;
  }

  if (isGroup(index)) {
    return m_rootNode;
  }

  QModelIndex proxyParent    = index.parent();
  QModelIndex originalParent = mapToSource(proxyParent);

  int originalRow = index.row();
  if (originalParent == m_rootNode) {
    int indexInGroup = index.row();
    if (!proxyParent.isValid())
      indexInGroup -= m_groupMaps.count();

    QList<int> childRows = m_groupMap.value(proxyParent.row());
    if (childRows.isEmpty() || indexInGroup >= childRows.count() || indexInGroup < 0)
      return QModelIndex();

    originalRow = childRows.at(indexInGroup);
  }
  return sourceModel()->index(originalRow, index.column(), originalParent);
}

QModelIndexList QtGroupingProxy::mapToSource(const QModelIndexList& list) const
{
  QModelIndexList originalList;
  foreach (const QModelIndex& index, list) {
    QModelIndex originalIndex = mapToSource(index);
    if (originalIndex.isValid())
      originalList << originalIndex;
  }
  return originalList;
}

QModelIndex QtGroupingProxy::mapFromSource(const QModelIndex& idx) const
{
  if (!idx.isValid())
    return QModelIndex();

  QModelIndex proxyParent;
  QModelIndex sourceParent = idx.parent();

  int proxyRow  = idx.row();
  int sourceRow = idx.row();

  if (sourceParent.isValid() && (sourceParent != m_rootNode)) {
    // idx is a child of one of the items in the source model
    proxyParent = mapFromSource(sourceParent);
  } else {
    // idx is an item in the top level of the source model (child of the rootnode)
    int groupRow = -1;
    QMapIterator<quint32, QList<int>> iterator(m_groupMap);
    while (iterator.hasNext()) {
      iterator.next();
      if (iterator.value().contains(sourceRow)) {
        groupRow = iterator.key();
        break;
      }
    }

    if (groupRow != -1)  // it's in a group, let's find the correct row.
    {
      proxyParent = this->index(groupRow, 0, QModelIndex());
      proxyRow    = m_groupMap.value(groupRow).indexOf(sourceRow);
    } else {
      proxyParent = QModelIndex();
      // if the proxy item is not in a group it will be below the groups.
      int groupLength = m_groupMaps.count();
      int i = m_groupMap.value(std::numeric_limits<quint32>::max()).indexOf(sourceRow);

      proxyRow = groupLength + i;
    }
  }

  return this->index(proxyRow, idx.column(), proxyParent);
}

Qt::ItemFlags QtGroupingProxy::flags(const QModelIndex& idx) const
{
  if (!idx.isValid()) {
    Qt::ItemFlags rootFlags = sourceModel()->flags(m_rootNode);
    if (rootFlags.testFlag(Qt::ItemIsDropEnabled))
      return Qt::ItemFlags(Qt::ItemIsDropEnabled);

    return Qt::ItemFlags(0);
  }

  // only if the grouped column has the editable flag set allow the
  // actions leading to setData on the source (edit & drop)
  if (isGroup(idx)) {
    //        dumpGroups();
    Qt::ItemFlags defaultFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
    // Qt::ItemFlags defaultFlags(Qt::ItemIsEnabled);
    bool groupIsEditable = true;

    if (idx.column() == 0) {
      bool checkable = true;
      foreach (int originalRow, m_groupMap.value(idx.row())) {
        QModelIndex originalIdx =
            sourceModel()->index(originalRow, 0, m_rootNode.parent());
        if ((originalIdx.flags() & Qt::ItemIsUserCheckable) == 0) {
          checkable = false;
        }
      }

      if (checkable) {
        defaultFlags |= Qt::ItemIsUserCheckable;
      }
    }

    // it's possible to have empty groups
    if (m_groupMap.value(idx.row()).count() == 0) {
      // check the flags of this column with the root node
      QModelIndex originalRootNode =
          sourceModel()->index(m_rootNode.row(), m_groupedColumn, m_rootNode.parent());
      groupIsEditable = originalRootNode.flags().testFlag(Qt::ItemIsEditable);
    } else {
      foreach (int originalRow, m_groupMap.value(idx.row())) {
        QModelIndex originalIdx =
            sourceModel()->index(originalRow, m_groupedColumn, m_rootNode);

        groupIsEditable =
            groupIsEditable ? originalIdx.flags().testFlag(Qt::ItemIsEditable) : false;
        if (!groupIsEditable)  // all children need to have an editable grouped column
          break;
      }
    }
    if (groupIsEditable)
      return (defaultFlags | Qt::ItemIsEditable | Qt::ItemIsDropEnabled);
    return defaultFlags;
  }

  QModelIndex originalIdx         = mapToSource(idx);
  Qt::ItemFlags originalItemFlags = sourceModel()->flags(originalIdx);

  // check the source model to see if the grouped column is editable;
  QModelIndex groupedColumnIndex =
      sourceModel()->index(originalIdx.row(), m_groupedColumn, originalIdx.parent());
  bool groupIsEditable =
      sourceModel()->flags(groupedColumnIndex).testFlag(Qt::ItemIsEditable);

  if (groupIsEditable)
    return originalItemFlags | Qt::ItemIsDragEnabled;
  return originalItemFlags;
}

QVariant QtGroupingProxy::headerData(int section, Qt::Orientation orientation,
                                     int role) const
{
  return sourceModel()->headerData(section, orientation, role);
}

bool QtGroupingProxy::canFetchMore(const QModelIndex& parent) const
{
  if (!parent.isValid())
    return false;

  if (isGroup(parent))
    return false;

  return sourceModel()->canFetchMore(mapToSource(parent));
}

void QtGroupingProxy::fetchMore(const QModelIndex& parent)
{
  if (!parent.isValid())
    return;

  if (isGroup(parent))
    return;

  return sourceModel()->fetchMore(mapToSource(parent));
}

QModelIndex QtGroupingProxy::addEmptyGroup(const RowData& data)
{
  int newRow = m_groupMaps.count();
  beginInsertRows(QModelIndex(), newRow, newRow);
  m_groupMaps << data;
  endInsertRows();
  return index(newRow, 0, QModelIndex());
}

bool QtGroupingProxy::removeGroup(const QModelIndex& idx)
{
  beginRemoveRows(idx.parent(), idx.row(), idx.row());
  m_groupMap.remove(idx.row());
  m_groupMaps.removeAt(idx.row());
  m_parentCreateList.removeAt(idx.internalId());
  endRemoveRows();

  // TODO: only true if all data could be unset.
  return true;
}

bool QtGroupingProxy::hasChildren(const QModelIndex& parent) const
{
  if (!parent.isValid()) {
    return true;
  }

  if (isGroup(parent)) {
    return !m_groupMap.value(parent.row()).isEmpty();
  }

  return sourceModel()->hasChildren(mapToSource(parent));
}

bool QtGroupingProxy::dropMimeData(const QMimeData* data, Qt::DropAction action,
                                   int row, int column, const QModelIndex& parent)
{
  QModelIndex idx = index(row, column, parent);
  if (isGroup(idx)) {
    QList<int> childRows = m_groupMap.value(idx.row());
    int max              = *std::max_element(childRows.begin(), childRows.end());

    QModelIndex newIdx = mapToSource(index(max, column, idx));
    return sourceModel()->dropMimeData(data, action, max, column, newIdx);
  } else {
    if (row == -1) {
      return sourceModel()->dropMimeData(data, action, -1, -1, mapToSource(parent));
    } else {
      QModelIndex idx = mapToSource(index(row, column, parent));
      return sourceModel()->dropMimeData(data, action, idx.row(), idx.column(),
                                         idx.parent());
    }
  }
}

void QtGroupingProxy::modelRowsAboutToBeInserted(const QModelIndex& parent, int start,
                                                 int end)
{
  if (parent != m_rootNode) {
    // an item will be added to an original index, remap and pass it on
    QModelIndex proxyParent = mapFromSource(parent);
    beginInsertRows(proxyParent, start, end);
  }
}

void QtGroupingProxy::modelRowsInserted(const QModelIndex& parent, int start, int end)
{
  if (parent == m_rootNode) {
    // top level of the model changed, these new rows need to be put in groups
    for (int modelRow = start; modelRow <= end; modelRow++) {
      addSourceRow(sourceModel()->index(modelRow, m_groupedColumn, m_rootNode));
    }
  } else {
    // an item was added to an original index, remap and pass it on
    QModelIndex proxyParent = mapFromSource(parent);

    QString s;
    QDebug debug(&s);
    debug << proxyParent;
    log::debug("{}", s);

    // beginInsertRows had to be called in modelRowsAboutToBeInserted()
    endInsertRows();
  }
}

void QtGroupingProxy::modelRowsAboutToBeRemoved(const QModelIndex& parent, int start,
                                                int end)
{
  if (parent == m_rootNode) {
    QMap<quint32, QList<int>>::const_iterator i;
    // HACK, we are going to call beginRemoveRows() multiple times without
    // endRemoveRows() if a source index is in multiple groups.
    // This can be a problem for some views/proxies, but Q*Views can handle it.
    // TODO: investigate a queue for applying proxy model changes in the correct order
    for (i = m_groupMap.constBegin(); i != m_groupMap.constEnd(); ++i) {
      int groupIndex              = i.key();
      const QList<int>& groupList = i.value();
      QModelIndex proxyParent     = index(groupIndex, 0);
      foreach (int originalRow, groupList) {
        if (originalRow >= start && originalRow <= end) {
          int proxyRow = groupList.indexOf(originalRow);
          if (groupIndex == -1)  // adjust for non-grouped (root level) original items
            proxyRow += m_groupMaps.count();
          // TODO: optimize for continues original rows in the same group
          beginRemoveRows(proxyParent, proxyRow, proxyRow);
        }
      }
    }
  } else {
    // child item(s) of an original item will be removed, remap and pass it on
    QModelIndex proxyParent = mapFromSource(parent);
    beginRemoveRows(proxyParent, start, end);
  }
}

void QtGroupingProxy::modelRowsRemoved(const QModelIndex& parent, int start, int end)
{
  if (parent == m_rootNode) {
    // TODO: can be optimised by iterating over m_groupMap and checking start <= r < end

    // rather than increasing i we change the stored sourceRows in-place and reuse
    // argument start X-times (where X = end - start).
    for (int i = start; i <= end; i++) {
      // HACK: we are going to iterate the hash in reverse so calls to endRemoveRows()
      // are matched up with the beginRemoveRows() in modelRowsAboutToBeRemoved()
      // NOTE: easier to do reverse with java style iterator
      QMutableMapIterator<quint32, QList<int>> iter(m_groupMap);
      iter.toBack();
      while (iter.hasPrevious()) {
        iter.previous();
        int groupIndex = iter.key();
        // has to be a modifiable reference for remove and replace operations
        QList<int>& groupList = iter.value();
        int rowIndex          = groupList.indexOf(start);
        if (rowIndex != -1) {
          QModelIndex proxyParent = index(groupIndex, 0);
          groupList.removeAt(rowIndex);
        }
        // Now decrement all source rows that are after the removed row
        for (int j = 0; j < groupList.count(); j++) {
          int sourceRow = groupList.at(j);
          if (sourceRow > start)
            groupList.replace(j, sourceRow - 1);
        }
        if (rowIndex != -1)
          endRemoveRows();  // end remove operation only after group was updated.
      }
    }

    return;
  }

  // beginRemoveRows had to be called in modelRowsAboutToBeRemoved();
  endRemoveRows();
}

void QtGroupingProxy::resetModel()
{
  buildTree();
}

void QtGroupingProxy::modelDataChanged(const QModelIndex& topLeft,
                                       const QModelIndex& bottomRight)
{
  // TODO: need to look in the groupedColumn and see if it changed and changed grouping
  // accordingly
  QModelIndex proxyTopLeft = mapFromSource(topLeft);
  if (!proxyTopLeft.isValid())
    return;

  if (topLeft == bottomRight) {
    emit dataChanged(proxyTopLeft, proxyTopLeft);
  } else {
    QModelIndex proxyBottomRight = mapFromSource(bottomRight);
    emit dataChanged(proxyTopLeft, proxyBottomRight);
  }
}

bool QtGroupingProxy::isAGroupSelected(const QModelIndexList& list) const
{
  foreach (const QModelIndex& index, list) {
    if (isGroup(index))
      return true;
  }
  return false;
}

void QtGroupingProxy::dumpGroups() const
{
  QString s;
  QDebug debug(&s);

  debug << "m_groupMap:\n";
  for (int groupIndex = -1; groupIndex < m_groupMap.keys().count() - 1; groupIndex++) {
    debug << groupIndex << " : " << m_groupMap.value(groupIndex) << "\n";
  }

  debug << "m_groupMaps:\n";
  for (int groupIndex = 0; groupIndex < m_groupMaps.count(); groupIndex++) {
    debug << m_groupMaps[groupIndex] << ": " << m_groupMap.value(groupIndex) << "\n";
  }

  debug << m_groupMap.value(std::numeric_limits<quint32>::max());

  log::debug("{}", s);
}