RootModel.cpp

/***************************************************************************
 *   Copyright (C) 2006 by Graeme Foster                                   *
 *   email    foster.graeme@gmail.com                                      *
 *                                                                         *
 *   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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#include "RootModel.h"

RootModel::RootModel(QObject *parent)
        : QAbstractItemModel(parent)
{
        rootItem = 0;
}

/******************************************************************************
 * Inherited from QAbstractItemModel
 ******************************************************************************/
int RootModel::columnCount(const QModelIndex &index) const
{
        RootItem * item = getRootItem(index);
        if (item == 0)
                return 0;
        else
                return item->columnCount();
}

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

        RootItem * item = getRootItem(index);
        if (role == Qt::TextColorRole)
                return item->textColour(index.column());
        if (role == Qt::BackgroundColorRole)
                return item->bgColour(index.column());
        if (role != Qt::DisplayRole)
                return QVariant();
        return item->data(index.column());
}

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

        if (role != Qt::EditRole)
                return false;

        RootItem *item = getRootItem(index);
        return item->setData(index.column(),value);
        
}

Qt::ItemFlags RootModel::flags(const QModelIndex &index) const
{
        if (!index.isValid())
                return Qt::ItemIsEnabled;

        return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}

QModelIndex RootModel::index(int row, int column, const QModelIndex &parent) const
{
        RootItem *parentItem;

        if (!parent.isValid())
                parentItem = rootItem;
        else
                parentItem = getRootItem(parent);

        RootItem *childItem = parentItem->child(row);
        if (childItem)
                return createIndex(row, column, childItem);
        else
                return QModelIndex();
}

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

        RootItem * childItem = getRootItem(index);
        RootItem * parentItem = childItem->parent();

        if (parentItem == rootItem)
                return QModelIndex();
        if (parentItem == 0)
                return QModelIndex();
        return createIndex(parentItem->row(), 0, parentItem);
}

int RootModel::rowCount(const QModelIndex &parent) const
{
        RootItem *parentItem;

        if (!parent.isValid())
                parentItem = rootItem;
        else
                parentItem = getRootItem(parent);

        return parentItem->childCount();
}

/******************************************************************************
 * Methods used to add or delete objects from the treeView.
 ******************************************************************************/
bool RootModel::insertItem (RootItem * item, QModelIndex & index, int posn)
{
        // The index should be the index of item's parent.
        // However the index passed could be its own index
        // (which will be the case when the Add button is pressed)
        // If that is the case then change the index to the parent
        RootItem * parent = static_cast<RootItem *>(index.internalPointer());
        if (parent != 0)
                if (parent->rtti() == item->rtti())
                        index = index.parent();
        beginInsertRows(index, posn, posn);
        // Insert the item into the model
        if (item->parent() != 0)
                item->parent()->insertChild(item);
        else
                rootItem->insertChild(item);
        endInsertRows();
        return true;
}

bool RootModel::deleteItem (DataClass * dcObj)
{
        RootItem * item = rootItem->findItem(dcObj);
        if (item == 0)
                return false;
        
        beginRemoveRows(QModelIndex(), rowCount(), rowCount());
        if (item->parent() != 0)
                item->parent()->deleteChild(item);
        else
                rootItem->deleteChild(item);
        endRemoveRows();
        return true;
}

void RootModel::sort(CompareRI compare, DataClass * dc)
{
        RootItem * item = rootItem->findItem(dc);
        if (item != 0)
                item->parent()->sort(compare);
}

/******************************************************************************
 * Private Methods
 ******************************************************************************/
void RootModel::clearData(RootItem * item)
{
        if(item == 0)
                rootItem->clearAllChildren();
        else
                item->clearAllChildren();
}

---