From d13f6bb870cdda71257f665367be8ef9fca86255 Mon Sep 17 00:00:00 2001 From: Mikaël Capelle Date: Tue, 17 May 2022 11:47:01 +0200 Subject: Apply clang-format. --- src/qtgroupingproxy.cpp | 980 ++++++++++++++++++++++-------------------------- 1 file changed, 445 insertions(+), 535 deletions(-) (limited to 'src/qtgroupingproxy.cpp') diff --git a/src/qtgroupingproxy.cpp b/src/qtgroupingproxy.cpp index bfbf955c..54f8b66e 100644 --- a/src/qtgroupingproxy.cpp +++ b/src/qtgroupingproxy.cpp @@ -1,22 +1,21 @@ /**************************************************************************************** - * Copyright (c) 2007-2011 Bart Cerneels * + * Copyright (c) 2007-2011 Bart Cerneels * * * - * 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 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. * + * 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 . * + * You should have received a copy of the GNU General Public License along with * this + *program. If not, see . * ****************************************************************************************/ // Modifications 2013-03-27 to 2013-03-29 by Sebastian Herbord - #include "qtgroupingproxy.h" #include @@ -28,28 +27,22 @@ 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 + \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) +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() -{ -} +QtGroupingProxy::~QtGroupingProxy() {} void QtGroupingProxy::setSourceModel(QAbstractItemModel* model) { @@ -62,45 +55,44 @@ void QtGroupingProxy::setSourceModel(QAbstractItemModel* model) if (sourceModel()) { // signal proxies connect(sourceModel(), SIGNAL(rowsInserted(const QModelIndex&, int, int)), - SLOT(modelRowsInserted(const QModelIndex&, int, int))); + SLOT(modelRowsInserted(const QModelIndex&, int, int))); connect(sourceModel(), SIGNAL(rowsAboutToBeInserted(const QModelIndex&, int, int)), - SLOT(modelRowsAboutToBeInserted(const QModelIndex&, int, int))); + SLOT(modelRowsAboutToBeInserted(const QModelIndex&, int, int))); connect(sourceModel(), SIGNAL(rowsRemoved(const QModelIndex&, int, int)), - SLOT(modelRowsRemoved(const QModelIndex&, int, int))); + SLOT(modelRowsRemoved(const QModelIndex&, int, int))); connect(sourceModel(), SIGNAL(rowsAboutToBeRemoved(const QModelIndex&, int, int)), - SLOT(modelRowsAboutToBeRemoved(QModelIndex, int, int))); + SLOT(modelRowsAboutToBeRemoved(QModelIndex, int, int))); connect(sourceModel(), SIGNAL(layoutChanged()), SLOT(buildTree())); connect(sourceModel(), SIGNAL(dataChanged(QModelIndex, QModelIndex)), - SLOT(modelDataChanged(QModelIndex, QModelIndex))); + SLOT(modelDataChanged(QModelIndex, QModelIndex))); connect(sourceModel(), SIGNAL(modelReset()), this, SLOT(resetModel())); buildTree(); } } -void -QtGroupingProxy::setGroupedColumn( int groupedColumn ) +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 -QtGroupingProxy::belongsTo( const QModelIndex &idx ) + * + * @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 QtGroupingProxy::belongsTo(const QModelIndex& idx) { QList rowDataList; - //get all the data for this index from the model - ItemData itemData = sourceModel()->itemData( idx ); + // 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]; } @@ -110,40 +102,34 @@ QtGroupingProxy::belongsTo( const QModelIndex &idx ) return rowDataList; } - QMapIterator i( itemData ); - while( i.hasNext() ) - { + QMapIterator i(itemData); + while (i.hasNext()) { i.next(); - int role = i.key(); + int role = i.key(); QVariant variant = i.value(); - if ( variant.type() == QVariant::List ) - { - //a list of variants get's expanded to multiple rows + 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 ); + 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. + } else if (!variant.isNull()) { + // it's just a normal item. Copy all the data and break this loop. RowData rowData; - rowData.insert( 0, itemData ); + rowData.insert(0, itemData); rowDataList << rowData; break; } @@ -153,47 +139,45 @@ QtGroupingProxy::belongsTo( const QModelIndex &idx ) } /* 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() ) + * 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. + // don't clear the data maps since most of it will probably be needed again. m_parentCreateList.clear(); - int max = sourceModel()->rowCount( m_rootNode ); + 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 ); + // 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(); + // dumpGroups(); if (m_flags & FLAG_NOSINGLE) { // awkward: flatten single-item groups as a post-processing steps. - int currentKey = 0; + int currentKey = 0; quint32 quint32max = std::numeric_limits::max(); std::vector rmgroups; - QMap > temp; + QMap> temp; for (auto iter = m_groupMap.begin(); iter != m_groupMap.end(); ++iter) { - if ((iter.key() == quint32max) || - (iter->count() < 2)) { + if ((iter.key() == quint32max) || (iter->count() < 2)) { temp[quint32max].append(iter.value()); if (iter.key() != quint32max) { rmgroups.push_back(iter.key()); @@ -204,9 +188,11 @@ QtGroupingProxy::buildTree() } 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; }); + // 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); } @@ -215,78 +201,66 @@ QtGroupingProxy::buildTree() endResetModel(); } -QList -QtGroupingProxy::addSourceRow( const QModelIndex &idx ) +QList QtGroupingProxy::addSourceRow(const QModelIndex& idx) { QList updatedGroups; - QList groupData = belongsTo( idx ); + QList groupData = belongsTo(idx); - //an empty list here means it's supposed to go in root. - if( groupData.isEmpty() ) - { + // 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::max() ) ) - m_groupMap.insert( std::numeric_limits::max(), QList() ); //add an empty placeholder + if (!m_groupMap.keys().contains(std::numeric_limits::max())) + m_groupMap.insert(std::numeric_limits::max(), + QList()); // add an empty placeholder } - //an item can be in multiple groups - foreach( RowData data, groupData ) - { + // 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] ) - { + 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 ); + updatedGroup = m_groupMaps.indexOf(data); //-1 means not found - if( updatedGroup == -1 ) - { - //new groups are added to the end of the existing list + 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() ); //add an empty placeholder + if (!m_groupMap.keys().contains(updatedGroup)) + m_groupMap.insert(updatedGroup, QList()); // add an empty placeholder } - if( !updatedGroups.contains( updatedGroup ) ) + if (!updatedGroups.contains(updatedGroup)) updatedGroups << updatedGroup; } - //update m_groupMap to the new source-model layout (one row added) - QMutableMapIterator > i( m_groupMap ); - while( i.hasNext() ) - { + // update m_groupMap to the new source-model layout (one row added) + QMutableMapIterator> i(m_groupMap); + while (i.hasNext()) { i.next(); - QList &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. + QList& 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 - { + } else { break; } } - if( updatedGroups.contains( i.key() ) ) - { - //the row needs to be added to this group - groupList.insert( insertedProxyRow, idx.row() ); + if (updatedGroups.contains(i.key())) { + // the row needs to be added to this group + groupList.insert(insertedProxyRow, idx.row()); } } @@ -294,103 +268,95 @@ QtGroupingProxy::addSourceRow( const QModelIndex &idx ) } /** 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 + * 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() ) + if (!parent.isValid()) return -1; struct ParentCreate pc; - for( int i = 0 ; i < m_parentCreateList.size() ; i++ ) - { + for (int i = 0; i < m_parentCreateList.size(); i++) { pc = m_parentCreateList[i]; - if( pc.parentCreateIndex == parent.internalId() && pc.row == parent.row() ) + if (pc.parentCreateIndex == parent.internalId() && pc.row == parent.row()) return i; } - //there is no parentCreate yet for this index, so let's create one. + // there is no parentCreate yet for this index, so let's create one. pc.parentCreateIndex = parent.internalId(); - pc.row = parent.row(); + pc.row = parent.row(); m_parentCreateList << pc; return m_parentCreateList.size() - 1; } -QModelIndex -QtGroupingProxy::index( int row, int column, const QModelIndex &parent ) const +QModelIndex QtGroupingProxy::index(int row, int column, const QModelIndex& parent) const { - if( !hasIndex(row, column, parent) ) { + if (!hasIndex(row, column, parent)) { return QModelIndex(); } - if( parent.column() > 0 ) { + 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 ); + * The place of the struct in the list is stored in the internalId + */ + int parentCreateIndex = indexOfParentCreate(parent); - return createIndex( row, column, parentCreateIndex ); + return createIndex(row, column, parentCreateIndex); } -QModelIndex -QtGroupingProxy::parent( const QModelIndex &index ) const +QModelIndex QtGroupingProxy::parent(const QModelIndex& index) const { - if( !index.isValid() ) + if (!index.isValid()) return QModelIndex(); int parentCreateIndex = index.internalId(); - if( parentCreateIndex == -1 || parentCreateIndex >= m_parentCreateList.count() ) + 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 ); + // only items at column 0 have children + return createIndex(pc.row, 0, pc.parentCreateIndex); } -int -QtGroupingProxy::rowCount( const QModelIndex &index ) const +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::max() ).count(); + 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::max()).count(); return rows; } - //TODO:group in group support. - if( isGroup( index ) ) - { + // TODO:group in group support. + if (isGroup(index)) { qint64 groupIndex = index.row(); - int rows = m_groupMap.value( groupIndex ).count(); + int rows = m_groupMap.value(groupIndex).count(); return rows; } else { - QModelIndex originalIndex = mapToSource( index ); - int rowCount = sourceModel()->rowCount( originalIndex ); + QModelIndex originalIndex = mapToSource(index); + int rowCount = sourceModel()->rowCount(originalIndex); return rowCount; } } -int -QtGroupingProxy::columnCount( const QModelIndex &index ) const +int QtGroupingProxy::columnCount(const QModelIndex& index) const { - if( !index.isValid() ) - return sourceModel()->columnCount( m_rootNode ); + if (!index.isValid()) + return sourceModel()->columnCount(m_rootNode); - if( index.column() != 0 ) + if (index.column() != 0) return 0; - return sourceModel()->columnCount( mapToSource( index ) ); + return sourceModel()->columnCount(mapToSource(index)); } - -static bool variantLess(const QVariant &LHS, const QVariant &RHS) +static bool variantLess(const QVariant& LHS, const QVariant& RHS) { if ((LHS.type() == RHS.type()) && ((LHS.type() == QVariant::Int) || (LHS.type() == QVariant::UInt))) { @@ -402,11 +368,10 @@ static bool variantLess(const QVariant &LHS, const QVariant &RHS) return LHS.toString() < RHS.toString(); } - -static QVariant variantMax(const QVariantList &variants) +static QVariant variantMax(const QVariantList& variants) { QVariant result = variants.first(); - foreach (const QVariant &iter, variants) { + foreach (const QVariant& iter, variants) { if (variantLess(result, iter)) { result = iter; } @@ -414,11 +379,10 @@ static QVariant variantMax(const QVariantList &variants) return result; } - -static QVariant variantMin(const QVariantList &variants) +static QVariant variantMin(const QVariantList& variants) { QVariant result = variants.first(); - foreach (const QVariant &iter, variants) { + foreach (const QVariant& iter, variants) { if (variantLess(iter, result)) { result = iter; } @@ -426,425 +390,396 @@ static QVariant variantMin(const QVariantList &variants) return result; } - -QVariant -QtGroupingProxy::data( const QModelIndex &index, int role ) const +QVariant QtGroupingProxy::data(const QModelIndex& index, int role) const { - if( !index.isValid() ) + if (!index.isValid()) return QVariant(); - int row = index.row(); + int row = index.row(); int column = index.column(); - if( isGroup( index ) ) - { + 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()); - 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; + case Qt::ForegroundRole: { + return QBrush(Qt::gray); + } break; + case Qt::FontRole: { + QFont font(m_groupMaps[row][column].value(Qt::FontRole).value()); + 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 ) ) - { + // 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 ); + 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(); + return m_groupMaps[row][column].value(role).toString(); } } - //for column 0 we gather data from the grouped column instead - if( column == 0 ) + // 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 + // 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 ) + 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(); + 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 ); + // 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 ) ) + 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 ); + // 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 ) + if (variantsOfChildren.count() == 0) return QVariant(); - //only one unique variant? No need to return a list + // 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; + 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 ); + return mapToSource(index).data(role); } -bool -QtGroupingProxy::setData( const QModelIndex &idx, const QVariant &value, int role ) +bool QtGroupingProxy::setData(const QModelIndex& idx, const QVariant& value, int role) { - if( !idx.isValid() ) + if (!idx.isValid()) return false; - //no need to set data to exactly the same value - if( idx.data( role ) == value ) + // no need to set data to exactly the same value + if (idx.data(role) == value) return false; - if( isGroup( idx ) ) - { + 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 ); + 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 ); + // 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 ); + 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 + // TODO: we might need to reload the data from the children at this point - emit dataChanged( idx, idx ); + emit dataChanged(idx, idx); return true; } - return sourceModel()->setData( mapToSource( idx ), value, role ); + return sourceModel()->setData(mapToSource(idx), value, role); } -bool -QtGroupingProxy::isGroup( const QModelIndex &index ) const +bool QtGroupingProxy::isGroup(const QModelIndex& index) const { int parentCreateIndex = index.internalId(); - if( parentCreateIndex == -1 && index.row() < m_groupMaps.count() ) + if (parentCreateIndex == -1 && index.row() < m_groupMaps.count()) return true; return false; } -QModelIndex -QtGroupingProxy::mapToSource( const QModelIndex &index ) const +QModelIndex QtGroupingProxy::mapToSource(const QModelIndex& index) const { - if( !index.isValid() ) { + if (!index.isValid()) { return m_rootNode; } - if( isGroup( index ) ) - { + if (isGroup(index)) { return m_rootNode; } - QModelIndex proxyParent = index.parent(); - QModelIndex originalParent = mapToSource( proxyParent ); + QModelIndex proxyParent = index.parent(); + QModelIndex originalParent = mapToSource(proxyParent); int originalRow = index.row(); - if( originalParent == m_rootNode ) - { + if (originalParent == m_rootNode) { int indexInGroup = index.row(); - if( !proxyParent.isValid() ) + if (!proxyParent.isValid()) indexInGroup -= m_groupMaps.count(); - QList childRows = m_groupMap.value( proxyParent.row() ); - if( childRows.isEmpty() || indexInGroup >= childRows.count() || indexInGroup < 0 ) + QList childRows = m_groupMap.value(proxyParent.row()); + if (childRows.isEmpty() || indexInGroup >= childRows.count() || indexInGroup < 0) return QModelIndex(); - originalRow = childRows.at( indexInGroup ); + originalRow = childRows.at(indexInGroup); } - return sourceModel()->index( originalRow, index.column(), originalParent ); + return sourceModel()->index(originalRow, index.column(), originalParent); } -QModelIndexList -QtGroupingProxy::mapToSource( const QModelIndexList& list ) const +QModelIndexList QtGroupingProxy::mapToSource(const QModelIndexList& list) const { QModelIndexList originalList; - foreach( const QModelIndex &index, list ) - { - QModelIndex originalIndex = mapToSource( index ); - if( originalIndex.isValid() ) + foreach (const QModelIndex& index, list) { + QModelIndex originalIndex = mapToSource(index); + if (originalIndex.isValid()) originalList << originalIndex; } return originalList; } -QModelIndex -QtGroupingProxy::mapFromSource( const QModelIndex &idx ) const +QModelIndex QtGroupingProxy::mapFromSource(const QModelIndex& idx) const { - if( !idx.isValid() ) + if (!idx.isValid()) return QModelIndex(); QModelIndex proxyParent; QModelIndex sourceParent = idx.parent(); - int proxyRow = idx.row(); + 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) + 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 > iterator( m_groupMap ); - while( iterator.hasNext() ) - { + QMapIterator> iterator(m_groupMap); + while (iterator.hasNext()) { iterator.next(); - if( iterator.value().contains( sourceRow ) ) - { + 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 + 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::max() ).indexOf( sourceRow ); + int i = m_groupMap.value(std::numeric_limits::max()).indexOf(sourceRow); proxyRow = groupLength + i; } } - return this->index( proxyRow, idx.column(), proxyParent ); + return this->index(proxyRow, idx.column(), proxyParent); } -Qt::ItemFlags -QtGroupingProxy::flags( const QModelIndex &idx ) const +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 ); + 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 ) ) - { + // 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); + 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 ) - { + 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 ) { + 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 + // 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 ); + if (groupIsEditable) + return (defaultFlags | Qt::ItemIsEditable | Qt::ItemIsDropEnabled); return defaultFlags; } - QModelIndex originalIdx = mapToSource( idx ); - Qt::ItemFlags originalItemFlags = sourceModel()->flags( originalIdx ); + QModelIndex originalIdx = mapToSource(idx); + Qt::ItemFlags originalItemFlags = sourceModel()->flags(originalIdx); - //check the source model to see if the grouped column is editable; + // 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 ); + sourceModel()->index(originalIdx.row(), m_groupedColumn, originalIdx.parent()); + bool groupIsEditable = + sourceModel()->flags(groupedColumnIndex).testFlag(Qt::ItemIsEditable); - if( groupIsEditable ) + if (groupIsEditable) return originalItemFlags | Qt::ItemIsDragEnabled; return originalItemFlags; } -QVariant -QtGroupingProxy::headerData( int section, Qt::Orientation orientation, int role ) const +QVariant QtGroupingProxy::headerData(int section, Qt::Orientation orientation, + int role) const { - return sourceModel()->headerData( section, orientation, role ); + return sourceModel()->headerData(section, orientation, role); } -bool -QtGroupingProxy::canFetchMore( const QModelIndex &parent ) const +bool QtGroupingProxy::canFetchMore(const QModelIndex& parent) const { - if( !parent.isValid() ) + if (!parent.isValid()) return false; - if( isGroup( parent ) ) + if (isGroup(parent)) return false; - return sourceModel()->canFetchMore( mapToSource( parent ) ); + return sourceModel()->canFetchMore(mapToSource(parent)); } -void -QtGroupingProxy::fetchMore ( const QModelIndex & parent ) +void QtGroupingProxy::fetchMore(const QModelIndex& parent) { - if( !parent.isValid() ) + if (!parent.isValid()) return; - if( isGroup( parent ) ) + if (isGroup(parent)) return; - return sourceModel()->fetchMore( mapToSource( parent ) ); + return sourceModel()->fetchMore(mapToSource(parent)); } -QModelIndex -QtGroupingProxy::addEmptyGroup( const RowData &data ) +QModelIndex QtGroupingProxy::addEmptyGroup(const RowData& data) { int newRow = m_groupMaps.count(); - beginInsertRows( QModelIndex(), newRow, newRow ); + beginInsertRows(QModelIndex(), newRow, newRow); m_groupMaps << data; endInsertRows(); - return index( newRow, 0, QModelIndex() ); + return index(newRow, 0, QModelIndex()); } -bool -QtGroupingProxy::removeGroup( const QModelIndex &idx ) +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() ); + 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. + // TODO: only true if all data could be unset. return true; } -bool -QtGroupingProxy::hasChildren( const QModelIndex &parent ) const +bool QtGroupingProxy::hasChildren(const QModelIndex& parent) const { - if( !parent.isValid() ) { + if (!parent.isValid()) { return true; } - if( isGroup( parent ) ) { - return !m_groupMap.value( parent.row() ).isEmpty(); + if (isGroup(parent)) { + return !m_groupMap.value(parent.row()).isEmpty(); } - return sourceModel()->hasChildren( mapToSource( parent ) ); + return sourceModel()->hasChildren(mapToSource(parent)); } -bool -QtGroupingProxy::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &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 childRows = m_groupMap.value(idx.row()); - int max = *std::max_element(childRows.begin(), childRows.end()); + int max = *std::max_element(childRows.begin(), childRows.end()); QModelIndex newIdx = mapToSource(index(max, column, idx)); return sourceModel()->dropMimeData(data, action, max, column, newIdx); @@ -853,186 +788,161 @@ QtGroupingProxy::dropMimeData(const QMimeData *data, Qt::DropAction action, int 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()); + return sourceModel()->dropMimeData(data, action, idx.row(), idx.column(), + idx.parent()); } } } -void -QtGroupingProxy::modelRowsAboutToBeInserted( const QModelIndex &parent, int start, int end ) +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 ); + 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 ) +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 ) ); + 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 ); + } 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() + // beginInsertRows had to be called in modelRowsAboutToBeInserted() endInsertRows(); } } -void -QtGroupingProxy::modelRowsAboutToBeRemoved( const QModelIndex &parent, int start, int end ) +void QtGroupingProxy::modelRowsAboutToBeRemoved(const QModelIndex& parent, int start, + int end) { - if( parent == m_rootNode ) - { - QMap >::const_iterator i; - //HACK, we are going to call beginRemoveRows() multiple times without + if (parent == m_rootNode) { + QMap>::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 &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 + for (i = m_groupMap.constBegin(); i != m_groupMap.constEnd(); ++i) { + int groupIndex = i.key(); + const QList& 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 ); + // 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 ); + } 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 ) +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 + 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() + // 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 > iter( m_groupMap ); + // NOTE: easier to do reverse with java style iterator + QMutableMapIterator> iter(m_groupMap); iter.toBack(); - while( iter.hasPrevious() ) - { + while (iter.hasPrevious()) { iter.previous(); int groupIndex = iter.key(); - //has to be a modifiable reference for remove and replace operations - QList &groupList = iter.value(); - int rowIndex = groupList.indexOf( start ); - if( rowIndex != -1 ) - { - QModelIndex proxyParent = index( groupIndex, 0 ); - groupList.removeAt( rowIndex ); + // has to be a modifiable reference for remove and replace operations + QList& 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 ); + // 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. + if (rowIndex != -1) + endRemoveRows(); // end remove operation only after group was updated. } } return; } - //beginRemoveRows had to be called in modelRowsAboutToBeRemoved(); + // beginRemoveRows had to be called in modelRowsAboutToBeRemoved(); endRemoveRows(); } -void -QtGroupingProxy::resetModel() +void QtGroupingProxy::resetModel() { buildTree(); } -void -QtGroupingProxy::modelDataChanged( const QModelIndex &topLeft, const QModelIndex &bottomRight ) +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() ) + // 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 ); + if (topLeft == bottomRight) { + emit dataChanged(proxyTopLeft, proxyTopLeft); + } else { + QModelIndex proxyBottomRight = mapFromSource(bottomRight); + emit dataChanged(proxyTopLeft, proxyBottomRight); } } -bool -QtGroupingProxy::isAGroupSelected( const QModelIndexList& list ) const +bool QtGroupingProxy::isAGroupSelected(const QModelIndexList& list) const { - foreach( const QModelIndex &index, list ) - { - if( isGroup( index ) ) + foreach (const QModelIndex& index, list) { + if (isGroup(index)) return true; } return false; } -void -QtGroupingProxy::dumpGroups() const +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"; + 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"; + 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::max() ); + debug << m_groupMap.value(std::numeric_limits::max()); log::debug("{}", s); } -- cgit v1.3.1