RootItem.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 "RootItem.h"

#include "InstItem.h"
#include "FacItem.h"
#include "DeptItem.h"
#include "StaffItem.h"
#include "ProgItem.h"
#include "ModuItem.h"
#include "RoomItem.h"
#include "MLAllocItem.h"
#include "TimeSlotItem.h"

const int RootItem::UNKNOWN = -1;

bool RootItem::riCompareCI(const RootItem *p1, const RootItem * p2)
{
        return p1->getDescription().toLower() < p2->getDescription().toLower();
}

bool RootItem::riCompareCS(const RootItem *p1, const RootItem * p2)
{
        return p1->getDescription() < p2->getDescription();
}


RootItem::RootItem(RootItem* parent, int cc)
{
        RTTI = ABSTRACT_ITEM;
        itemData = 0;
        col_count = cc;
        parentItem = parent;
        setTextColour(2
                     ,GUIPref::Instance()->getColour(GUIPref::CT_DEFAULT_TEXT,0)
                     ,GUIPref::Instance()->getColour(GUIPref::CT_DEFAULT_TEXT,0));
        setBGColour(2
                   ,GUIPref::Instance()->getColour(GUIPref::CT_DEFAULT_BG,0)
                   ,GUIPref::Instance()->getColour(GUIPref::CT_DEFAULT_BG,1));
}
RootItem::RootItem(RootItem & ri)
{
        RTTI       = ri.RTTI;
        itemData   = ri.itemData;
        col_count  = ri.col_count;
        parentItem = ri.parentItem;
}
// Get Methods
QString RootItem::getClassName()
{
        switch (RTTI)
        {
                case ABSTRACT_ITEM:
                        return "RootItem";
                case INST_ITEM:
                        return "InstItem";
                case PROG_ITEM:
                        return "ProgItem";
                case MODULE_ITEM:
                        return "ModuleItem";
                case FACULTY_ITEM:
                        return "FacItem";
                case DEPT_ITEM:
                        return "DeptItem";
                case STAFF_ITEM:
                        return "StaffItem";
                case ROOM_ITEM:
                        return "RoomItem";
                case ML_ALLOC_ITEM:
                        return "MLAllocItem";
        }       // end of switch on RTTI
        return QString();
}

int RootItem::row() const
{
        if (parentItem)
                return parentItem->childItems.indexOf(const_cast<RootItem*>(this));
        return 0;
}

RootItem * RootItem::findItem(DataClass * dc)
{
        if (itemData == dc)
                return this;
        for (int i = 0; i < childItems.size(); ++i)
        {
                RootItem * item = childItems.at(i)->findItem(dc);
                if (item != 0)
                        return item;
        }
        return 0;
}

int RootItem::findChildPos(int id)
{
        for (int i = 0; i < childItems.size(); ++i)
        {
                if (childItems.at(i)->getID() == id)
                        return i;
        }
        return RootItem::UNKNOWN;
}

// Set Methods
void RootItem::setColumnOrder(int count, ...)
{
        col_order.resize(count);
        setColumnCount(count);
        int i = 0;
        va_list ap;
        va_start(ap,count); /* point to first element after count*/
        while(count > i)
        {
                col_order[i]=va_arg(ap, int);
                i++;
        }
        va_end(ap);
}

void RootItem::setTextColour(int count, ...)
{
        txtColour.resize(count);
        int i = 0;
        va_list ap;
        va_start(ap,count); /* point to first element after count*/
        while(count > i)
        {
                txtColour[i]=(QColor)(* va_arg(ap, QColor *));
                i++;
        }
        va_end(ap);
}

void RootItem::setBGColour(int count, ...)
{
        backgroundColour.resize(count);
        int i = 0;
        va_list ap;
        va_start(ap,count); /* point to first element after count*/
        while(count > i)
        {
                backgroundColour[i]=(QColor)(* va_arg(ap, QColor *));
                i++;
        }
        va_end(ap);
}

void RootItem::insertChild(RootItem *item)
{
        int i = 0;
        while (i < childItems.size())
        {
                if (childItems[i]->data(0).toString() > item->data(0).toString())
                        break;
                i++;
        }
        childItems.insert(i,item);
}

void RootItem::appendChild(RootItem *item)
{
        childItems.insert(childItems.size(),item);
}

void RootItem::deleteChild(RootItem *child)
{
        if (child != 0)
        {
                int pos = findChildPos(child->getID());
                if (pos != RootItem::UNKNOWN)
                {
                        childItems.takeAt(pos);
                }
        }
}

RootItem * RootItem::clone()
{
        switch (RTTI)
        {
                case ABSTRACT_ITEM:
                        return 0;
                case INST_ITEM:
                        return new InstItem(*static_cast<InstItem *>(this));
                case PROG_ITEM:
                        return new ProgItem(*static_cast<ProgItem *>(this));
                case MODULE_ITEM:
                        return new ModuleItem(*static_cast<ModuleItem*>(this));
                case FACULTY_ITEM:
                        return new FacItem(*static_cast<FacItem*>(this));
                case DEPT_ITEM:
                        return new DeptItem(*static_cast<DeptItem*>(this));
                case STAFF_ITEM:
                        return new StaffItem(*static_cast<StaffItem*>(this));
                case ROOM_ITEM:
                        return new RoomItem(*static_cast<RoomItem*>(this));
                case ML_ALLOC_ITEM:
                        return new MLAllocItem(*static_cast<MLAllocItem*>(this));
        }       // end of switch on RTTI
        return 0;
}

void RootItem::dump()
{
        std::cout << "Start of RootItem dump\n";
        for (int i = 0; i<childItems.size(); i++)
                std::cout << i << ": " << childItems.at(i)->getDescription().toStdString() << " Child Count" << childItems.at(i)->childCount() << std::endl;
        std::cout << "End of RootItem dump\n\n";
}

---