#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);

 }