sublime/aggregatemodel.cpp

   1 /***************************************************************************
   2  *   Copyright 2007 Alexander Dymo  <adymo@kdevelop.org>            *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU Library General Public License as       *
   6  *   published by the Free Software Foundation; either version 2 of the    *
   7  *   License, or (at your option) any later version.                       *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU Library General Public     *
  15  *   License along with this program; if not, write to the                 *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  18  ***************************************************************************/
  19 #include "aggregatemodel.h"
  20
  21 #include <QStandardItem>
  22 #include <QStandardItemModel>
  23
  24 #include <kdebug.h>
  25
  26 namespace Sublime {
  27
  28 struct AggregateModelPrivate {
  29
  30     /*Instance of this class is used as an internal pointer to the aggregator items
  31     in the model to differentiate between aggregators and non-aggregators.*/
  32     class AggregateInternalData {
  33     };
  34
  35     AggregateModelPrivate()
  36     {
  37         internal = new AggregateInternalData();
  38     }
  39     ~AggregateModelPrivate()
  40     {
  41         delete internal;
  42     }
  43
  44     QList<QStandardItemModel*> modelList;
  45     QMap<QStandardItemModel*, QString> modelNames;
  46     AggregateInternalData *internal;
  47 };
  48
  49
  50
  51 AggregateModel::AggregateModel(QObject *parent)
  52     :QAbstractItemModel(parent)
  53 {
  54     d = new AggregateModelPrivate();
  55 }
  56
  57 AggregateModel::~AggregateModel()
  58 {
  59     delete d;
  60 }
  61
  62 void AggregateModel::addModel(const QString &name, QStandardItemModel *model)
  63 {
  64     d->modelList << model;
  65     d->modelNames[model] = name;
  66     reset();
  67 }
  68
  69 void AggregateModel::removeModel(QStandardItemModel *model)
  70 {
  71     d->modelList.removeAll(model);
  72     d->modelNames.remove(model);
  73     reset();
  74 }
  75
  76
  77
  78 // reimplemented methods from QAbstractItemModel
  79
  80 Qt::ItemFlags AggregateModel::flags(const QModelIndex &index) const
  81 {
  82     if (!index.isValid())
  83         return 0;
  84     return Qt::ItemIsEnabled & Qt::ItemIsSelectable;
  85 }
  86
  87 QVariant AggregateModel::headerData(int section, Qt::Orientation orientation, int role) const
  88 {
  89     //there's nothing to return here because aggregated models will have different headers
  90     //so we just use empty headers for aggregate model.
  91     return "";
  92 }
  93
  94 int AggregateModel::columnCount(const QModelIndex &parent) const
  95 {
  96     //only 1 column is supported atm
  97     return 1;
  98 }
  99
 100 int AggregateModel::rowCount(const QModelIndex &parent) const
 101 {
 102     if (!parent.isValid())
 103     {
 104         //toplevel items represent aggregated models
 105         return d->modelList.count();
 106     }
 107     else
 108     {
 109         //Qt model guideline - only 1st column has children
 110         if (parent.column() != 0)
 111             return 0;
 112
 113         //find out if the parent is an aggregator
 114         if (parent.internalPointer() == d->internal)
 115         {
 116             //return the number of toplevel rows in the source model
 117             return d->modelList[parent.row()]->rowCount(QModelIndex());
 118         }
 119         else
 120         {
 121             //we have a standard item in the source model - just map it into our model
 122             QStandardItem *item = static_cast<QStandardItem*>(parent.internalPointer());
 123             return item->rowCount();
 124         }
 125     }
 126 }
 127
 128 QVariant AggregateModel::data(const QModelIndex &index, int role) const
 129 {
 130     if (!index.isValid() || (role != Qt::DisplayRole))
 131         return QVariant();
 132
 133     if (!index.parent().isValid())
 134     {
 135         //aggregator item
 136         return d->modelNames[d->modelList[index.row()]];
 137     }
 138     else
 139     {
 140         //we have a standard item in the source model - just map it into our model
 141         QStandardItem *item = static_cast<QStandardItem*>(index.internalPointer());
 142         return item->data(role);
 143     }
 144 }
 145
 146 QModelIndex AggregateModel::parent(const QModelIndex &index) const
 147 {
 148     if (!index.isValid())
 149         return QModelIndex();
 150
 151     if (index.internalPointer() == d->internal)
 152     {
 153         //this is aggregator item, it has no parents
 154         return QModelIndex();
 155     }
 156
 157     //this is just an item from the model
 158     QStandardItem *item = static_cast<QStandardItem*>(index.internalPointer());
 159     QModelIndex parent;
 160     if (!item->parent())
 161     {
 162         //we need to find the aggregator item that owns this index
 163         //first find the model for this index
 164         QStandardItemModel *model = item->model();
 165         //next find the row number of the aggregator item
 166         int row = d->modelList.indexOf(model);
 167         parent = createIndex(row, 0, d->internal);
 168     }
 169     else
 170     {
 171         //we have a standard item in the source model - just map it into our model
 172         parent = createIndex(item->parent()->row(), 0, item->parent());
 173     }
 174     return parent;
 175 }
 176
 177 QModelIndex AggregateModel::index(int row, int column, const QModelIndex &parent) const
 178 {
 179     if (row < 0 || column < 0)
 180         return QModelIndex();
 181
 182     if (!parent.isValid())
 183     {
 184         if (column > 1 || row >= d->modelList.count())
 185             return QModelIndex();
 186         //this is an aggregator item
 187         return createIndex(row, column, d->internal);
 188     }
 189     else if (parent.internalPointer() == d->internal)
 190     {
 191         //the parent is an aggregator
 192         //find the model that holds the items
 193         QStandardItemModel *model = d->modelList[parent.row()];
 194         //this is the first level of items
 195         QStandardItem *item = model->item(row, column);
 196         if (item)
 197             return createIndex(row, column, item);
 198         else
 199             return QModelIndex();
 200     }
 201     else
 202     {
 203         //we have a standard item in the source model - just map it into our model
 204         QStandardItem *parentItem = static_cast<QStandardItem*>(parent.internalPointer());
 205         return createIndex(row, column, parentItem->child(row, column));
 206     }
 207 }
 208
 209 }
 210
 211 #include "aggregatemodel.moc"
 212