#include <iostream>

 using namespace std;

 #include <QStringList>

 #include "treeitem.h"

 #include "branchobj.h"

 #include "branchitem.h"

 #include "vymmodel.h"

 TreeItem::TreeItem(const QList<QVariant> &data, TreeItem *parent)

 {

 	init();

     parentItem = parent;

     itemData = data;

 }

 TreeItem::~TreeItem()

 {

 	//cout << "Destructor TreeItem "<<getHeadingStd()<<endl;

 	TreeItem *ti;

 	while (!childItems.isEmpty())

 	{

 		ti=childItems.takeFirst();

 		switch (ti->getType() )

 		{

 			case TreeItem::MapCenter:

 				delete (MapCenterItem*)ti;

 				break;

 			case TreeItem::Branch:

 				delete (BranchItem*)ti;

 				break;

 			default:

 				delete ti;

 				break;

 		}

 	}	

 }

 void TreeItem::init()

 {

 	model=NULL;

     parentItem = NULL;

     itemData.clear();

 	lmo=NULL;	

 	branchOffset=0;

 	branchCounter=0;

 	lastSelectedBranchNum=-1;

 	note.setNote(""); 

 	// note.setFontHint (textEditor->getFontHintDefault() );	//FIXME-2

 	// isNoteInEditor=false;

 	hidden=false;

 	// Reset ID

 	objID="";

 }

 QString TreeItem::saveToDir (const QString &tmpdir,const QString &prefix, const QPointF& offset)

 {

 	cout << "TreeItem::saveToDir called directly for ("<<getHeadingStd()<<"), instead of inherited type...\n";	//FIXME-1 triggered on save

 	return QString();

 }

 /*

 void TreeItem::copy (OrnamentedObj* other)	//FIXME-2	probably need deep copy of branches and data!

 {

 	note.copy (other->note);

 	model=other->model;

 	hideExport=officially 

 	other->hideExport;

 }

 */

 void TreeItem::setModel (VymModel *m)

 {

 	model=m;

 }

 VymModel* TreeItem::getModel ()

 {

 	return model;

 }

 void TreeItem::appendChild(TreeItem *item)

 {

     childItems.append(item);

 	item->parentItem=this;

 	item->setModel (model);

 	if (item->type == Branch || item->type ==MapCenter)

 	{

 		if (branchCounter==0)

 			branchOffset=childItems.count()-1;

 		branchCounter++;

 	}

 }

 void TreeItem::removeChild(int row)

 {

     if (row<0 || row > childItems.size()-1)

 		qWarning ("TreeItem::removeChild tried to remove non existing item?!\n");

 	else

 	{

 		cout << "TI::removeChild this="<<this<<"  row="<<row<<endl;

 		if (childItems.at(row)->isBranchLikeType())

 			branchCounter--;

 		childItems.removeAt (row);

 	}

 }

 TreeItem *TreeItem::child(int row)

 {

     return childItems.value(row);

 }

 int TreeItem::childCount() const

 {

     return childItems.count();

 }

 int TreeItem::childNumber() const

 {

     if (parentItem)

         return parentItem->childItems.indexOf(const_cast<TreeItem*>(this));

     return 0;

 }

 int TreeItem::columnCount() const

 {

     return itemData.count();

 }

 int TreeItem::branchCount() const

 {

     return branchCounter;

 }

 int TreeItem::imageCount() const

 {

 	int imageCounter=0;

     return imageCounter; // FIXME-1 imageCounter needs to be calculated...

 }

 int TreeItem::xlinkCount() const // FIXME-2 check if xlinks are stored in a different way (global to model?)

 {

 	int xlinkCounter=0;

     return xlinkCounter; // FIXME-1 xlinkCounter needs to be calculated...

 }

 int TreeItem::row() const

 {

     if (parentItem)

         return parentItem->childItems.indexOf(const_cast<TreeItem*>(this));

     return 0;

 }

 int TreeItem::column() const

 {

     return 0;

 }

 int TreeItem::depth() 

 {

 	int d=-2;

 	TreeItem *ti=this;

 	while (ti!=NULL)

 	{

 		ti=ti->parent();

 		d++;

 	}

 	return d;

 }

 TreeItem *TreeItem::parent()

 {

     return parentItem;

 }

 int TreeItem::childNum()

 {

 	return parentItem->childItems.indexOf (this);

 }

 int TreeItem::num()

 {

 	switch (type)

 	{

 		case Undefined: return -1;

 		case MapCenter: return parentItem->childItems.indexOf (this) - branchOffset;

 		case Branch: return parentItem->childItems.indexOf (this) - branchOffset;

 		case Image: return -1; // FIXME-2

 		default: return -1;

 	}

 }

 int TreeItem::num (TreeItem *item)

 {

 	if (!item) return -1;

 	switch (item->getType())

 	{

 		case Undefined: return -1;

 		case MapCenter: return childItems.indexOf (this) - branchOffset;

 		case Branch: return childItems.indexOf (this) - branchOffset;

 		case Image: return -1; // FIXME-2

 		default: return -1;

 	}

 }

 QVariant TreeItem::data(int column) const

 {

     return itemData.value(column);

 }

 void TreeItem::setHeading (const QString s)

 {

 	itemData[0]=s;

 }

 QString TreeItem::getHeading () const

 {

 	return itemData[0].toString();

 }

 std::string TreeItem::getHeadingStd () const

 {

 	return itemData[0].toString().toStdString();

 }

 void TreeItem::setNote(const QString s)

 {

 	note.setNote(s);

 	// updateNoteFlag();  FIXME-2 needed?

 	if (model) 

 		model->emitNoteHasChanged (this);

 }

 void TreeItem::setNoteObj(const NoteObj &n, bool updateNoteEditor)

 {

 	note=n;

 	// updateNoteFlag();  FIXME-2 needed?

 	if (model && updateNoteEditor)	

 		model->emitNoteHasChanged (this);

 }

 QString TreeItem::getNote()

 {

 	return note.getNote();

 }

 NoteObj TreeItem::getNoteObj()

 {

 	return note;

 }

 QString TreeItem::getNoteASCII(const QString &indent, const int &width)

 {

     return note.getNoteASCII(indent,width);

 }

 QString TreeItem::getNoteASCII()

 {

     return note.getNoteASCII();

 }

 QString TreeItem::getNoteOpenDoc()

 {

     return note.getNoteOpenDoc();

 }

 void TreeItem::setType(const Type t)

 {

 	type=t;

 	itemData[1]=getTypeName();

 }

 TreeItem::Type TreeItem::getType()

 {

 	return type;

 }

 bool TreeItem::isBranchLikeType() const

 {

 	if (type==Branch ||type==MapCenter) return true;

 	return false;

 }

 QString TreeItem::getTypeName()

 {

 	switch (type)

 	{

 		case Undefined: return QString ("Undefined");

 		case MapCenter: return QString ("MapCenter");

 		case Branch: return QString ("Branch");

 		case Image: return QString ("Image");

 		default: return QString ("TreeItem::getTypeName no typename defined?!");

 	}

 }

 void TreeItem::setID (const QString &s)

 {

 	objID=s;

 }

 QString TreeItem::getID()

 {

 	return objID;

 }

 TreeItem* TreeItem::getChildNum(const int &n)

 {

 	if (n>=0 && n<childItems.count() )

 		return childItems.at(n);

 	else

 		return NULL;

 }

 BranchItem* TreeItem::getFirstBranch()

 {

 	if (branchCounter>0)

 		return getBranchNum (branchOffset);

 	else

 		return NULL;

 }

 BranchItem* TreeItem::getLastBranch()

 {

 	if (branchCounter>0)

 		return getBranchNum (branchOffset + branchCounter-1);

 	else

 		return NULL;

 }

 BranchItem* TreeItem::getBranchNum(const int &n)

 {

 	if (branchCounter>0)

 		return (BranchItem*)getChildNum (branchOffset + n);

 	else

 		return NULL;

 }

 BranchObj* TreeItem::getBranchObjNum(const int &n)

 {

 	if (branchCounter>0)

 	{

 		return (BranchObj*)(getChildNum (branchOffset+n)->lmo);

 	} else

 		return NULL;

 }

 void TreeItem::setLastSelectedBranch()

 {

 	if (parentItem)

 		parentItem->lastSelectedBranchNum=parentItem->childItems.indexOf(this);

 }

 TreeItem* TreeItem::findBySelectString (const QString &s)  //FIXME-1

 {

 /*

 	LinkableMapObj *lmo=this;

 	QString part;

 	QString typ;

 	QString num;

 	while (!s.isEmpty() )

 	{

 		part=s.section(",",0,0);

 		typ=part.left (3);

 		num=part.right(part.length() - 3);

 		if (typ=="mc:")

 		{

 			if (depth>0)

 				return false;	// in a subtree there is no center

 			else

 				break;

 		} else

 			if (typ=="bo:")

 				lmo=lmo->getTreeItem()->getBranchObjNum (num.toInt());

 			else

 				if (typ=="fi:")

 					lmo=((BranchObj*)lmo)->getFloatImageNum (num.toUInt());

 		if (!lmo) break;

 		if (s.contains(","))

 			s=s.right(s.length() - part.length() -1 );

 		else	

 			break;

 	}

 	*/

 	return NULL;

 }

 void TreeItem::setLastSelectedBranch(int i)

 {

 		lastSelectedBranchNum=i;

 }

 TreeItem* TreeItem::getLastSelectedBranch()

 {

 	return getBranchNum (lastSelectedBranchNum);

 }

 void TreeItem::setHideTmp (HideTmpMode mode)

 {

 	if (isBranchLikeType() )

 		((BranchItem*)this)->updateVisibility();

 		/*

 	if (type==Image)

 		//updateVisibility();

 	*/

 /*

 		if (mode==HideExport && (hideExport || hasHiddenExportParent() ) )

 		{

 			// Hide stuff according to hideExport flag and parents

 			//setVisibility (false);

 			updateVisibility();

 			//FIXME-2 hidden=true;

 		}else

 		{

 			// Do not hide, but still take care of scrolled status

 			XXXXXXXX treeItem should be THIS

 			move visible to TreeItem???

 			BranchObj now has updateContents

 			maybe also start "bool TreeItem::branchlikeType"

 			if ( ((BranchItem*)treeItem)->hasScrolledParent((BranchItem*)treeItem))

 				setVisibility (false);

 			else

 				setVisibility (true);

 			//FIXME-2 hidden=false;

 		}	

 */

 		// And take care of my children

 		for (int i=0; i<branchCount(); ++i)

 			getBranchNum(i)->setHideTmp (mode);

 }

 bool TreeItem::hasHiddenExportParent()

 {

 	// Calls parents recursivly to

 	// find out, if we or parents are temp. hidden

 	if (hidden || hideExport) return true;

 	if (parentItem) 

 		return parentItem->hasHiddenExportParent();

 	else

 		return false;

 }

 void TreeItem::setHideInExport(bool b) 

 {

 	if (isBranchLikeType() )

 	{

 		hideExport=b;

 		/* FIXME-1 call setVis and updateContentsSize...

 		if (b)

 			systemFlags->activate("hideInExport");

 		else	

 			systemFlags->deactivate("hideInExport");

 		calcBBoxSize();

 		positionBBox();

 		requestReposition();	

 		*/

 	}

 }	

 bool TreeItem::hideInExport()

 {

 	return hideExport;

 }	

 bool TreeItem::isHidden()

 {

 	return hidden;

 }	

 LinkableMapObj* TreeItem::getLMO()	// FIXME-3  VM should be unnecessary in the end

 {

 	return lmo;

 }

 void TreeItem::setLMO(LinkableMapObj *l)

 {

 	lmo=l;

 }