include/NodeBasedModel.h

   1 /***************************************************************************
   2  *   This file is part of KWorship.                                        *
   3  *   Copyright 2008 James Hogan <james@albanarts.com>                      *
   4  *                                                                         *
   5  *   KWorship is free software: you can redistribute it and/or modify      *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation, either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   KWorship is distributed in the hope that it will be useful,           *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with KWorship.  If not, write to the Free Software Foundation,  *
  17  *   Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.   *
  18  ***************************************************************************/
  19
  20 #ifndef _NodeBasedModel_h_
  21 #define _NodeBasedModel_h_
  22
  23 /**
  24  * @file NodeBasedModel.h
  25  * @brief A Qt model based on nodes.
  26  * @author James Hogan <james@albanarts.com>
  27  */
  28
  29 #include "compiler.h"
  30
  31 #include <QAbstractItemModel>
  32 #include <QVector>
  33 #include <QVariant>
  34
  35 #include <cassert>
  36
  37 /// A node in the model.
  38 class DefaultModelNode
  39 {
  40   public:
  41
  42     /*
  43      * Constructors + destructor.
  44      */
  45
  46     /// Primary constructor.
  47     DefaultModelNode(DefaultModelNode* parent)
  48     : m_parent(parent)
  49     , m_children()
  50     {
  51     }
  52
  53     /// Destructor.
  54     virtual ~DefaultModelNode()
  55     {
  56     }
  57
  58     /*
  59      * Main interface
  60      */
  61
  62     /// Get the parent.
  63     DefaultModelNode* getParent()
  64     {
  65       return m_parent;
  66     }
  67
  68     /// Get a child node by index.
  69     DefaultModelNode* getChild(int index)
  70     {
  71       if (unlikely(index < 0 || index >= getChildCount()))
  72       {
  73         return 0;
  74       }
  75
  76       if (index >= m_children.size())
  77       {
  78         int prevSize = m_children.size();
  79         int newSize = getChildCount();
  80         m_children.resize(newSize);
  81         for (int i = prevSize; i < newSize; ++i)
  82         {
  83           m_children[i] = 0;
  84         }
  85       }
  86       if (0 == m_children[index])
  87       {
  88         m_children[index] = _getChild(index);
  89       }
  90       return m_children[index];
  91     }
  92
  93     /// Get the number of cached children.
  94     int getNumCachedChildren() const
  95     {
  96       return m_children.size();
  97     }
  98
  99     /// Get a cached child node by index (even if it is 0).
 100     DefaultModelNode* getCachedChild(int index)
 101     {
 102       if (index >= 0 && index < m_children.size())
 103       {
 104         return m_children[index];
 105       }
 106       else
 107       {
 108         return 0;
 109       }
 110     }
 111
 112     /// Notify that children have been added.
 113     void childrenAdded(int first, int last)
 114     {
 115       if (first > m_children.size())
 116       {
 117         first = m_children.size();
 118       }
 119       m_children.insert(first, last - first + 1, 0);
 120     }
 121
 122     /// Notify that children have been removed.
 123     void childrenRemoved(int first, int last)
 124     {
 125       int cacheSize = m_children.size();
 126       if (first < cacheSize)
 127       {
 128         if (last >= cacheSize)
 129         {
 130           last = cacheSize - 1;
 131         }
 132         for (int i = first; i <= last; ++i)
 133         {
 134           delete m_children[i];
 135         }
 136         m_children.remove(first, last - first + 1);
 137       }
 138     }
 139
 140     /// Clear the cache of child nodes.
 141     void clearChildCache()
 142     {
 143       foreach (DefaultModelNode* node, m_children)
 144       {
 145         delete node;
 146       }
 147       m_children.clear();
 148     }
 149
 150     /// Get the index of a certain child.
 151     int getChildIndex(DefaultModelNode* node) const
 152     {
 153       for (int i = 0; i < m_children.size(); ++i)
 154       {
 155         if (m_children[i] == node)
 156         {
 157           return i;
 158         }
 159       }
 160       return -1;
 161     }
 162
 163     /// Get data associated with the node.
 164     virtual QVariant getData(int role, int column)
 165     {
 166       Q_UNUSED(role)
 167       Q_UNUSED(column)
 168       return QVariant();
 169     }
 170
 171     /// Get the number of children.
 172     virtual int getChildCount() const
 173     {
 174       return 0;
 175     }
 176
 177   protected:
 178
 179     /// Get a child node by index.
 180     virtual DefaultModelNode* _getChild(int index)
 181     {
 182       Q_UNUSED(index)
 183       return 0;
 184     }
 185
 186   private:
 187
 188     /*
 189      * Variables
 190      */
 191
 192     /// Parent node.
 193     DefaultModelNode* m_parent;
 194
 195     /// Child nodes.
 196     QVector<DefaultModelNode*> m_children;
 197
 198 };
 199
 200
 201 /// A Qt model based on nodes.
 202 template <class NODE = DefaultModelNode>
 203 class NodeBasedModel : public QAbstractItemModel
 204 {
 205   public:
 206
 207     /*
 208      * Types
 209      */
 210
 211     /// Node type.
 212     typedef NODE Node;
 213
 214     /*
 215      * Constructors + destructor.
 216      */
 217
 218     /// Default constructor.
 219     NodeBasedModel(QObject* parent = 0)
 220     : QAbstractItemModel(parent)
 221     , m_root(0)
 222     {
 223     }
 224
 225     /// Destructor.
 226     virtual ~NodeBasedModel()
 227     {
 228       delete m_root;
 229     }
 230
 231     /*
 232      * Main interface
 233      */
 234
 235     /// Get the root node.
 236     Node* getRootNode()
 237     {
 238       return m_root;
 239     }
 240
 241     /// Set the root node.
 242     void setRootNode(Node* root)
 243     {
 244       delete m_root;
 245       m_root = root;
 246       reset();
 247     }
 248     Node* itemFromIndex(const QModelIndex &index) const
 249     {
 250       if (index.isValid())
 251       {
 252         return reinterpret_cast<Node*>(index.internalPointer());
 253       }
 254       else
 255       {
 256         return m_root;
 257       }
 258     }
 259
 260     QModelIndex index(int row, int column, const QModelIndex& parent) const
 261     {
 262       if (0 == m_root)
 263       {
 264         return QModelIndex();
 265       }
 266       Node* parentNode = itemFromIndex(parent);
 267       assert(0 != parentNode);
 268       return createIndex(row, column, parentNode->getChild(row));
 269     }
 270
 271     QModelIndex parent(const QModelIndex &child) const
 272     {
 273       Node* node = itemFromIndex(child);
 274       if (0 == node)
 275       {
 276         return QModelIndex();
 277       }
 278       DefaultModelNode* parentNode = node->getParent();
 279       if (0 == parentNode)
 280       {
 281         return QModelIndex();
 282       }
 283       DefaultModelNode* grandParentNode = parentNode->getParent();
 284       if (0 == grandParentNode)
 285       {
 286         return QModelIndex();
 287       }
 288       int row = grandParentNode->getChildIndex(parentNode);
 289       assert(row != -1);
 290       return createIndex(row, child.column(), parentNode);
 291     }
 292     int rowCount(const QModelIndex &parent) const
 293     {
 294       Node* parentNode = itemFromIndex(parent);
 295       if (0 == parentNode)
 296       {
 297         return 0;
 298       }
 299       return parentNode->getChildCount();
 300     }
 301     virtual int columnCount(const QModelIndex &parent) const
 302     {
 303       Q_UNUSED(parent)
 304       return 1;
 305     }
 306     QVariant data(const QModelIndex &index, int role) const
 307     {
 308       Node* item = itemFromIndex(index);
 309       if (0 == item)
 310       {
 311         return QVariant();
 312       }
 313       return item->getData(role, index.column());
 314     }
 315     virtual QVariant headerData(int section, Qt::Orientation orientation, int role) const
 316     {
 317       Q_UNUSED(section)
 318       Q_UNUSED(orientation)
 319       Q_UNUSED(role)
 320       return QVariant();
 321     }
 322
 323   private:
 324
 325     /*
 326      * Variables
 327      */
 328
 329     /// Root item.
 330     Node* m_root;
 331 };
 332
 333 #endif // _NodeBasedModel_h_
 334