#include <QtGui>

 #include <iostream>

 using namespace std;

 #include "attributeitem.h"

 #include "branchitem.h"

 #include "imageitem.h"

 #include "treeitem.h"

 #include "treemodel.h"

 #include "xlinkitem.h"

 TreeModel::TreeModel(QObject *parent)

     : QAbstractItemModel(parent)

 {

     QList<QVariant> rootData;

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

     rootItem = new BranchItem(rootData);

 }

 TreeModel::~TreeModel()

 {

     delete rootItem;

 }

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

 {

     if (!index.isValid())

         return QVariant();

     if (role != Qt::DisplayRole)

         return QVariant();

     TreeItem *item = getItem (index);

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

 }

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

 {

     if (!index.isValid())

         return Qt::NoItemFlags;

     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 (TreeItem* ti)

 {

 	if (!ti->parent())

 		return QModelIndex();

 	else	

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

 }

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

             const

 {

 	// Make sure to return invalid index for invalid values (see modeltest)

 	if (row<0 || column<0) return QModelIndex();

 	if (column!=0) return QModelIndex();

     TreeItem *parentItem;

     if (!parent.isValid())

 	{

         parentItem = rootItem;

 		/*

 		cout << "TM::index()  no parent?! xxx\n";

 		cout << "   row="<<row<<"  col="<<column<<endl;

 		cout << "   parent.internal="<< parent.internalPointer()<<endl;

 		*/

 		// Somehow index is requested where parentIndex is invalid.

 		// what's happening here...?

 		// Check if Qt examples also return index of rootIem then...

 	}	

     else

         parentItem = getItem (parent);

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

 	//cout << "TM::index  parentItem="<<parentItem<<"  childItem="<<childItem<<"  row="<<row<<" col="<<column<<endl;

     if (childItem)

         return createIndex(row, column, childItem);

     else

         return QModelIndex();

 }

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

 {

     if (!index.isValid())

         return QModelIndex();

 	//FIXME-3 cout << "TM::parent  ri="<<rootItem<< "  row="<<index.row()<<"  col="<<index.column()<<endl;

     TreeItem *ti= getItem (index);

 	//cout << "            ti="<<ti<<endl;

 	//cout << "               "<<ti->getHeadingStd()<<endl;

     TreeItem *parentItem = ti->parent();

 	//cout << "            pi="<<parentItem<<endl;

 	//cout << "TreeModel::parent  ti="<<ti<<" "<<ti->getHeading().toStdString()<<"  pi="<<parentItem<<"  "<<endl;

     if (parentItem == rootItem)

         return QModelIndex();

 /*

 	if (!parentItem)

         return QModelIndex();	// FIXME-3 do this to avoid segfault, but why?

 		                        // see also my question on qt-interest in march

 */

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

 }

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

 {

     TreeItem *parentItem;

     if (!parent.isValid())

         parentItem = rootItem;

     else

         parentItem = getItem (parent);

     return parentItem->childCount();

 }

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

 {

 	int c;

     if (parent.isValid())

 	{

         c= getItem (parent)->columnCount();

 		//cout << "TM::colCount  c="<<c<<"  parent="<<getItem (parent)<<endl;	

 	}

     else

 	{

         c= rootItem->columnCount();

 		//cout << "TM::colCount  c="<<c<<"  parent=invalid"<<endl;	

 	}

 	return c;

 }

 BranchItem* TreeModel::next(BranchItem* &current, BranchItem* &previous, BranchItem* start)	// FIXME-3 change this to nextBranch and use "next" for all TIs

 {

 /*FIXME-3	cout << "TM::next \n"; 

 	std::string ch="()"; if (current) ch=current->getHeadingStd();

 	std::string ph="()"; if (previous) ph=previous->getHeadingStd();

 	cout << "  cur="<<ch << " prev="<<ph<<endl;

 */

 	// Walk through map beginning at current with previous==0

 	// Start at root, if current==NULL

 	if (!current) current=(BranchItem*)rootItem;

 	// Are we just beginning to walk the map?

 	if (!previous)

 	{

 		if (!start) start=current;

 		previous=current;

 		current=current->getFirstBranch();

 		return current;

 	}

 	// Going up or down (deeper)?

 	if (current->depth() > previous->depth() )

 	{	

 		// Coming from above

 		// Trying  to go down deeper

 //		cout << "  trying to go deeper\n";

 		if (current->branchCount() >0 )

 		{

 //			cout << "  yes, going deeper\n";

 			previous=current;

 			current=current->getFirstBranch();

 			return current;

 		}	

 		// turn around and go up again

 //		cout << "  sorry, turn around\n";

 		BranchItem *bi=current;

 		current=previous;

 		previous=bi;

 	}	

 /*

 	cout << "  coming from below\n";

 	ch="()"; if (current) ch=current->getHeadingStd();

 	ph="()"; if (previous) ph=previous->getHeadingStd();

 	cout << "  cur="<<ch << " prev="<<ph<<endl;

 */	

 	// Coming from below

 	// Trying to go down again to siblings

 	BranchItem *sibling=current->getBranchNum (previous->num()+1);

 //	cout <<"    prev->num()="<<previous->num()<<endl;

 	if (sibling)

 	{	

 		// Found sibling of previous, go there

 //		cout << "  sib=cur="<<sibling->getHeadingStd()<<endl;

 		previous=current;

 		current=sibling;

 		return current;

 	} 

 	// If we only needed to go through subtree, we are done now

 	if (start==current) return NULL;

 	// Go up and try to find siblings of current

 //	cout <<"  going up again...\n";

 	previous=current;

 	current=(BranchItem*)current->parent();

 	// Check if we still can go somewhere

 	if (!current) return current;

 	while (current && current->depth() < previous->depth() )

 		current=next (current,previous,start);

 	return current;

 }

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

 {

 	int last=row+count-1;

     TreeItem *pi= getItem (parent);

 	TreeItem *ti;

 	cout << "TM::removeRows  row="<<row<<"  count="<<count<<endl;

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

 	{

 		ti=pi->getChildNum (row);

 		cout << "   pi="<<pi<<"  ti="<<ti<<endl;

 		pi->removeChild (row);	// does not delete object!

 		delete ti;

 		/* FIXME-3

 		switch (ti->getType()) 

 		{

 			case TreeItem::MapCenter: 

 				delete (BranchItem*)ti; 

 				break;

 			case TreeItem::Branch:

 				delete (BranchItem*)ti; 

 				break;

 			case TreeItem::Image:

 				delete (ImageItem*)ti; 

 				break;

 			case TreeItem::Attribute:

 				delete (AttributeItem*)ti; 

 				break;

 			case TreeItem::XLink:

 				delete (XLinkItem*)ti; 

 				break;

 			default:

 				delete ti;

 				break;

 		}

 		*/

 	}

 	return true;

 }

 TreeItem *TreeModel::getItem(const QModelIndex &index) const

 {

 //FIXME-3	cout << "TM::getItem  "<<index.internalPointer()<<endl;

     if (index.isValid()) {

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

 //		cout << "   item="<<item<<endl;

         if (item) return item;

     }

     return NULL;

 }

 BranchItem *TreeModel::getRootItem()

 {

 	return rootItem;

 }