#include <QtGui>

#include "treeitem.h"

#include "treemodel.h"

TreeItem* TreeModel::itFirst=NULL;

TreeItem* TreeModel::itCur=NULL;

TreeModel::TreeModel(QObject *parent)

    : QAbstractItemModel(parent)

{

    QList<QVariant> rootData;

    rootData << "Heading" << "Type" <<"Note";

    rootItem = new TreeItem(rootData);

}

TreeModel::~TreeModel()

{

    delete rootItem;

}

int TreeModel::columnCount(const QModelIndex &parent) const

{

    if (parent.isValid())

        return static_cast<TreeItem*>(parent.internalPointer())->columnCount();

    else

        return rootItem->columnCount();

}

QVariant TreeModel::data(const QModelIndex &index, int role) const

{

    if (!index.isValid())

        return QVariant();

    if (role != Qt::DisplayRole)

        return QVariant();

    TreeItem *item = static_cast<TreeItem*>(index.internalPointer());

    return item->data(index.column());

}

Qt::ItemFlags TreeModel::flags(const QModelIndex &index) const

{

    if (!index.isValid())

        return Qt::ItemIsEnabled;

    return Qt::ItemIsEnabled | Qt::ItemIsSelectable;

}

QVariant TreeModel::headerData(int section, Qt::Orientation orientation,

                               int role) const

{

    if (orientation == Qt::Horizontal && role == Qt::DisplayRole)

        return rootItem->data(section);

    return QVariant();

}

QModelIndex TreeModel::index(int row, int column, const QModelIndex &parent)

            const

{

    TreeItem *parentItem;

    if (!parent.isValid())

        parentItem = rootItem;

    else

        parentItem = static_cast<TreeItem*>(parent.internalPointer());

    TreeItem *childItem = parentItem->child(row);

    if (childItem)

        return createIndex(row, column, childItem);

    else

        return QModelIndex();

}

QModelIndex TreeModel::parent(const QModelIndex &index) const

{

    if (!index.isValid())

        return QModelIndex();

    TreeItem *childItem = static_cast<TreeItem*>(index.internalPointer());

    TreeItem *parentItem = childItem->parent();

    if (parentItem == rootItem)

        return QModelIndex();

    return createIndex(parentItem->row(), 0, parentItem);

}

int TreeModel::rowCount(const QModelIndex &parent) const

{

    TreeItem *parentItem;

    if (!parent.isValid())

        parentItem = rootItem;

    else

        parentItem = static_cast<TreeItem*>(parent.internalPointer());

    return parentItem->childCount();

}

TreeItem* TreeModel::first()

{

	itCur=NULL;	

	itFirst=rootItem;

	return rootItem; 

}

TreeItem* TreeModel::next()

{

/*

	BranchObj *bo;

	BranchObj *lmo;

	BranchObj *po=(BranchObj*)parObj;

	if (branch.isEmpty())

		bo=NULL;

	else

		bo=branch.first();

	if (!itCur)

	{

		// no itCur, we are just beginning

		if (bo) 

		{

			// we have children, return first one

			itCur=this;

			return bo;

		}	

		else

		{

			// No children, so there is no next

			itCur=this;

			return NULL;

		}	

	}

	// We have an itCur

	if (itCur==po)

	{	// We come from parent

		if (bo)

		{

			// there are children, go there

			itCur=this;

			return bo;

		}	

		else

		{	// no children, try to go up again

			if (po)

			{

				// go back to parent and try to find next there

				itCur=this;

				lmo=po->next();

				itCur=this;

				return lmo;

			}	

			else

			{

				// can't go up, I am mapCenter, no next

				itCur=NULL;

				return NULL;

			}	

		}

	}

	// We don't come from parent, but from brother or children

	// Try to find last child, where we came from, in my own children

	bool searching=true;

	int i=0;

	while (i<branch.size())

	{

		// Try to find itCur in my own children

		if (itCur==branch.at(i))

		{

			// ok, we come from my own children

			if (i<branch.size()-1)

				bo=branch.at(i+1);

			 else

				bo=NULL;

			searching=false;

			i=branch.size();

		} 	

		++i;	

	}

	if (!searching)

	{	// found itCur in my children

		if (bo)

		{

			// found a brother of lastLMO 

			itCur=this;

			return bo;

		}	

		else

		{

			if (po)

			{

				if (this==itFirst) return NULL;	// Stop at starting point

				// go up

				itCur=this;

				lmo=po->next();

				itCur=this;

				return lmo;

			}

			else

			{

				// can't go up, I am mapCenter

				itCur=NULL;

				return NULL;

			}	

		}

	}

	// couldn't find last child, it must be a nephew of mine

	if (branch.size()>0)

	{

		// proceed with my first child

		itCur=this;	

		return branch.first();

	}	

	else

	{

		// or go back to my parents

		if (po)

		{

			// go up

			itCur=this;

			lmo=po->next();

			itCur=this;

			return lmo;

		}	

		else

		{

			// can't go up, I am mapCenter

			itCur=NULL;

			return NULL;

		}	

	}	

	*/

}

#include <iostream>

bool TreeModel::removeRows ( int row, int count, const QModelIndex & parent)

{

	int last=row+count-1;

	beginRemoveRows (parent,row,last);

    TreeItem *pi= static_cast<TreeItem*>(parent.internalPointer());

    TreeItem *ti;

	for (int i=row; i<=last; i++)

	{

		std::cout << "TreeModel::removeRows removing i="<<i<<std::endl;

		pi->removeChild (row);

	}

	endRemoveRows ();

}

QModelIndex TreeModel::index (TreeItem* ti)

{

	return createIndex (ti->row(),ti->column(),ti);

}