#include "mapeditor.h"

#include <iostream>

#include <cstdlib>

#include <typeinfo>

#include <QObject>

#include "branchitem.h"

#include "geometry.h"

#include "mainwindow.h"

#include "misc.h"

#include "warningdialog.h"

#include "xlinkitem.h"

extern int statusbarTime;

extern Main *mainWindow;

extern QString tmpVymDir;

extern QString clipboardDir;

extern QString clipboardFile;

extern bool clipboardEmpty;

extern bool debug;

extern QMenu* branchContextMenu;

extern QMenu* floatimageContextMenu;

extern QMenu* canvasContextMenu;

extern Settings settings;

extern QString iconPath;

///////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////

MapEditor::MapEditor( VymModel *vm) 

{

	//cout << "Constructor ME "<<this<<endl;

	mapScene= new QGraphicsScene(NULL);

	mapScene->setBackgroundBrush (QBrush(Qt::white, Qt::SolidPattern));

	zoomFactor=zoomFactorTarget=1;

	model=vm;

	model->setScene (mapScene);

	model->registerEditor(this);

	model->makeDefault();	// No changes in model so far

    setScene (mapScene);

    printer=NULL;

	// Create bitmap cursors, platform dependant

	HandOpenCursor=QCursor (QPixmap(iconPath+"cursorhandopen.png"),1,1);		

	PickColorCursor=QCursor ( QPixmap(iconPath+"cursorcolorpicker.png"), 5,27 ); 

	CopyCursor=QCursor ( QPixmap(iconPath+"cursorcopy.png"), 1,1 ); 

	XLinkCursor=QCursor ( QPixmap(iconPath+"cursorxlink.png"), 1,7 ); 

	//setFocusPolicy (Qt::StrongFocus);	//FIXME-3

	pickingColor=false;

	drawingLink=false;

	copyingObj=false;

	objectMoved=false;

    editingBO=NULL;

    movingObj=NULL;

	printFrame=true;

	printFooter=true;

	setAcceptDrops (true);	

	//model->reposition();	//FIXME-3 really still needed?

	// Shortcuts and actions

	QAction *a;

    a = new QAction("Select upper branch", this);

	a->setShortcut (Qt::Key_Up );

	a->setShortcutContext (Qt::WidgetShortcut);

	addAction (a);

    connect( a, SIGNAL( triggered() ), this, SLOT( cursorUp() ) );

    a = new QAction( "Select lower branch",this);

	a->setShortcut ( Qt::Key_Down );

	a->setShortcutContext (Qt::WidgetShortcut);

	addAction (a);

    connect( a, SIGNAL( triggered() ), this, SLOT( cursorDown() ) );

    a = new QAction( "Select left branch", this);

	a->setShortcut (Qt::Key_Left );

//	a->setShortcutContext (Qt::WindowShortcut);

	a->setShortcutContext (Qt::WidgetWithChildrenShortcut);

	addAction (a);

    connect( a, SIGNAL( triggered() ), this, SLOT( cursorLeft() ) );

    a = new QAction( "Select child branch", this);

	a->setShortcut (Qt::Key_Right);

	a->setShortcutContext (Qt::WidgetWithChildrenShortcut);

	addAction (a);

    connect( a, SIGNAL( triggered() ), this, SLOT( cursorRight() ) );

    a = new QAction(  "Select first branch", this);

	a->setShortcut (Qt::Key_Home );

	a->setShortcutContext (Qt::WidgetWithChildrenShortcut);

	addAction (a);

    connect( a, SIGNAL( triggered() ), this, SLOT( cursorFirst() ) );

    a = new QAction( "Select last branch",this);

	a->setShortcut ( Qt::Key_End );

	a->setShortcutContext (Qt::WidgetWithChildrenShortcut);

	addAction (a);

    connect( a, SIGNAL( triggered() ), this, SLOT( cursorLast() ) );

	// Action to embed LineEdit for heading in Scene

	editingHeading=false;

	lineEdit=NULL;

	a = new QAction( tr( "Edit heading","MapEditor" ), this);

	a->setShortcut ( Qt::Key_Return );					//Edit heading

	a->setShortcutContext (Qt::WidgetShortcut);

	addAction (a);

    connect( a, SIGNAL( triggered() ), this, SLOT( editHeading() ) );

	a = new QAction( tr( "Edit heading","MapEditor" ), this);

	a->setShortcut ( Qt::Key_Enter);					//Edit heading

	addAction (a);

    connect( a, SIGNAL( triggered() ), this, SLOT( editHeading() ) );

	// Selections

	selectionColor =QColor (255,255,0);

	// Attributes	//FIXME-2 testing only...

	QString k;

	AttributeDef *ad;

	attrTable= new AttributeTable();

	k="A - StringList";

	ad=attrTable->addKey (k,StringList);

	if (ad)

	{

		QStringList sl;

		sl <<"val 1"<<"val 2"<< "val 3";

		ad->setValue (QVariant (sl));

	}

	//attrTable->addValue ("Key A","P 1");

	//attrTable->addValue ("Key A","P 2");

	//attrTable->addValue ("Key A","P 3");

	//attrTable->addValue ("Key A","P 4");

	k="B - FreeString";

	ad=attrTable->addKey (k,FreeString);

	if (ad)

	{

		//attrTable->addValue ("Key B","w1");

		//attrTable->addValue ("Key B","w2");

	}

	k="C - UniqueString";

	ad=attrTable->addKey (k,UniqueString);

	if (ad)

	{

	//attrTable->addKey ("Key Prio");

	//attrTable->addValue ("Key Prio","Prio 1");

	//attrTable->addValue ("Key Prio","Prio 2");

	}

}

MapEditor::~MapEditor()

{

	//cout <<"Destructor MapEditor for "<<model->getMapName().toStdString()<<endl;

	model->unregisterEditor(this);

}

VymModel* MapEditor::getModel()

{

    return model;

}

QGraphicsScene * MapEditor::getScene()

{

    return mapScene;

}

void MapEditor::scrollTo (const QModelIndex &index)	

{

	if (index.isValid())

	{

		LinkableMapObj* lmo=NULL;

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

		if (ti->getType()==TreeItem::Image ||ti->isBranchLikeType() )

			lmo=((MapItem*)ti)->getLMO();

		if (lmo) 

		{

			QRectF r=lmo->getBBox();

			setScrollBarPosTarget (r);

		}	

	}

}

void MapEditor::setScrollBarPosTarget (const QRectF &rect)

{

	// Code copied from Qt sources

	int xmargin=50;

	int ymargin=50;

    qreal width = viewport()->width();

    qreal height = viewport()->height();

    QRectF viewRect = matrix().mapRect(rect);

    qreal left = horizontalScrollBar()->value();

    qreal right = left + width;

    qreal top = verticalScrollBar()->value();

    qreal bottom = top + height;

	scrollBarPosTarget=getScrollBarPos();

    if (viewRect.left() <= left + xmargin) {

        // need to scroll from the left

  //      if (!d->leftIndent)

            scrollBarPosTarget.setX(int(viewRect.left() - xmargin - 0.5));

    }

    if (viewRect.right() >= right - xmargin) {

        // need to scroll from the right

//        if (!d->leftIndent)

            scrollBarPosTarget.setX(int(viewRect.right() - width + xmargin + 0.5));

    }

    if (viewRect.top() <= top + ymargin) {

        // need to scroll from the top

   //     if (!d->topIndent)

            scrollBarPosTarget.setY(int(viewRect.top() - ymargin - 0.5));

    }

    if (viewRect.bottom() >= bottom - ymargin) {

        // need to scroll from the bottom

//        if (!d->topIndent)

            scrollBarPosTarget.setY(int(viewRect.bottom() - height + ymargin + 0.5));

    }

	if (scrollBarPosTarget==getScrollBarPos()) return;

	if (scrollBarPosAnimation.state()==QtAbstractAnimation::Running)

		scrollBarPosAnimation.stop();

	if (settings.value ("/animation/use/",true).toBool() )

	{

		scrollBarPosAnimation.setTargetObject (this);

		scrollBarPosAnimation.setPropertyName ("scrollBarPos");

		scrollBarPosAnimation.setDuration(1000);

		scrollBarPosAnimation.setEasingCurve ( QtEasingCurve::OutQuint);

		scrollBarPosAnimation.setStartValue(

			QPointF (horizontalScrollBar()->value() ,

					 verticalScrollBar()->value() ) );

		scrollBarPosAnimation.setEndValue(scrollBarPosTarget);

		scrollBarPosAnimation.start();

	} else

		setScrollBarPos (scrollBarPosTarget);

}

QPointF MapEditor::getScrollBarPosTarget()

{

    return scrollBarPosTarget;

}

void MapEditor::setScrollBarPos(const QPointF &p)

{

    scrollBarPos=p;

	horizontalScrollBar()->setValue(int(p.x()));

	verticalScrollBar()->setValue(int(p.y()));

}

QPointF MapEditor::getScrollBarPos()

{

	return QPointF (horizontalScrollBar()->value(),verticalScrollBar()->value());

    //return scrollBarPos;

}

void MapEditor::setZoomFactorTarget (const qreal &zft)

{

	zoomFactorTarget=zft;

	if (zoomAnimation.state()==QtAbstractAnimation::Running)

		zoomAnimation.stop();

	if (settings.value ("/animation/use/",true).toBool() )

	{

		//zoomAnimation=QPropertyAnimation(this, "zoomFactor");

		zoomAnimation.setTargetObject (this);

		zoomAnimation.setPropertyName ("zoomFactor");

		zoomAnimation.setDuration(1000);

		zoomAnimation.setEasingCurve ( QtEasingCurve::OutQuint);

		zoomAnimation.setStartValue(zoomFactor);

		zoomAnimation.setEndValue(zft);

		zoomAnimation.start();

	} else

		setZoomFactor (zft);

}

qreal MapEditor::getZoomFactorTarget()

{

    return zoomFactorTarget;

}

void MapEditor::setZoomFactor(const qreal &zf)

{

    zoomFactor=zf;

	setMatrix (QMatrix(zf, 0, 0, zf, 0, 0),false );

}

qreal MapEditor::getZoomFactor()

{

    return zoomFactor;

}

void MapEditor::print()

{

	if ( !printer ) 

	{

		printer = new QPrinter;

		printer->setColorMode (QPrinter::Color);

		printer->setPrinterName (settings.value("/mainwindow/printerName",printer->printerName()).toString());

		printer->setOutputFormat((QPrinter::OutputFormat)settings.value("/mainwindow/printerFormat",printer->outputFormat()).toInt());

		printer->setOutputFileName(settings.value("/mainwindow/printerFileName",printer->outputFileName()).toString());

	}

	QRectF totalBBox=getTotalBBox();

	// Try to set orientation automagically

	// Note: Interpretation of generated postscript is amibiguous, if 

	// there are problems with landscape mode, see

	// http://sdb.suse.de/de/sdb/html/jsmeix_print-cups-landscape-81.html

	if (totalBBox.width()>totalBBox.height())

		// recommend landscape

		printer->setOrientation (QPrinter::Landscape);

	else	

		// recommend portrait

		printer->setOrientation (QPrinter::Portrait);

	if ( printer->setup(this) ) 

	// returns false, if printing is canceled

	{

		QPainter pp(printer);

		pp.setRenderHint(QPainter::Antialiasing,true);

		// Don't print the visualisation of selection

		model->unselect();

		QRectF mapRect=totalBBox;

		QGraphicsRectItem *frame=NULL;

		if (printFrame) 

		{

			// Print frame around map

			mapRect.setRect (totalBBox.x()-10, totalBBox.y()-10, 

				totalBBox.width()+20, totalBBox.height()+20);

			frame=mapScene->addRect (mapRect, QPen(Qt::black),QBrush(Qt::NoBrush));

			frame->setZValue(0);

			frame->show();    

		}		

		double paperAspect = (double)printer->width()   / (double)printer->height();

		double   mapAspect = (double)mapRect.width() / (double)mapRect.height();

		int viewBottom;

		if (mapAspect>=paperAspect)

		{

			// Fit horizontally to paper width

			//pp.setViewport(0,0, printer->width(),(int)(printer->width()/mapAspect) );	

			viewBottom=(int)(printer->width()/mapAspect);	

		}	else

		{

			// Fit vertically to paper height

			//pp.setViewport(0,0,(int)(printer->height()*mapAspect),printer->height());	

			viewBottom=printer->height();	

		}	

		if (printFooter) 

		{

			// Print footer below map

			QFont font;		

			font.setPointSize(10);

			pp.setFont (font);

			QRectF footerBox(0,viewBottom,printer->width(),15);

			// FIXME-3 fileName not any longer available here: pp.drawText ( footerBox,Qt::AlignLeft,"VYM - " +fileName);

			pp.drawText ( footerBox, Qt::AlignRight, QDate::currentDate().toString(Qt::TextDate));

		}

		mapScene->render (

			&pp, 

			QRectF (0,0,printer->width(),printer->height()-15),

			QRectF(mapRect.x(),mapRect.y(),mapRect.width(),mapRect.height())

		);

		// Viewport has paper dimension

		if (frame)  delete (frame);

		// Restore selection

		model->reselect();

		// Save settings in vymrc

		settings.writeEntry("/mainwindow/printerName",printer->printerName());

		settings.writeEntry("/mainwindow/printerFormat",printer->outputFormat());

		settings.writeEntry("/mainwindow/printerFileName",printer->outputFileName());

	}

}

QRectF MapEditor::getTotalBBox()	

{

	QPen pen;

	pen.setWidth (1);

	pen.setCapStyle ( Qt::RoundCap );

	QRectF rt;

	BranchObj *bo;

	BranchItem *cur=NULL;

	BranchItem *prev=NULL;

	model->nextBranch(cur,prev);

	while (cur) 

	{

		if (!cur->hasHiddenExportParent())

		{

			bo=(BranchObj*)(cur->getLMO());

			if (bo && bo->isVisibleObj())

			{

				bo->calcBBoxSizeWithChildren();

				// FIXME-3 testing

				//QRectF r1=bo->getBBoxSizeWithChildren();

				QRectF r1=bo->getBBox();

				//pen.setColor ( QColor(qrand()%32*8,qrand()%32*8,qrand()%32*8));

				//mapScene->addRect (r1,pen);

				if (rt.isNull()) rt=r1;

				rt=addBBox (r1, rt);

				//FIXME-2 cout <<"ME: r1="<<r1<<"  "<<cur->getHeadingStd()<<endl;

				//cout <<"    rt="<<rt<<endl;

			}

		}

		model->nextBranch(cur,prev);

	}

	return rt;	

}

QImage MapEditor::getImage()

{

	QRectF mapRect=getTotalBBox();

	int w=mapRect.width()+2;

	int h=mapRect.height()+2;

	QImage pix (w,h,QImage::Format_RGB32);

	QPainter pp (&pix);

	pp.setRenderHints(renderHints());

	mapScene->render (	&pp, 

		QRectF(0,0,w,h),

		QRectF(mapRect.x(),mapRect.y(),mapRect.width(),mapRect.height() ));

	return pix;

}

void MapEditor::setAntiAlias (bool b)

{

	setRenderHint(QPainter::Antialiasing,b);

}

void MapEditor::setSmoothPixmap(bool b)

{

	setRenderHint(QPainter::SmoothPixmapTransform,b);

}

void MapEditor::setHideTmp (bool b)	// FIXME-4 better use signals

{

/*

	if (b)

	{

		setHideTmpMode (HideExport);

		mapCenter->calcBBoxSizeWithChilds();

		QRectF totalBBox=mapCenter->getTotalBBox();

		//QRectF mapRect=totalBBox;

		cout << "  map has =("<<totalBBox.x()<<","<<totalBBox.y()<<","<<totalBBox.width()<<","<<totalBBox.height()<<")\n";

		mapRect.setRect (totalBBox.x(), totalBBox.y(), 

			totalBBox.width(), totalBBox.height());

		QCanvasRectangle *frame=new QCanvasRectangle (mapRect,mapScene);

		frame->setBrush (QColor(white));

		frame->setPen (QColor(black));

		frame->setZValue(0);

		frame->show();    

	}	

	else	

	{

		setHideTmpMode (HideNone);

	}	

	cout <<"  hidemode="<<hidemode<<endl;

*/

/*

	// Toggle hidemode

	if (hidemode==HideExport)

		setHideTmpMode (HideNone);

	else	

		setHideTmpMode (HideExport);

*/		

}

TreeItem* MapEditor::findMapItem (QPointF p,TreeItem *exclude)

{

	// Start with mapcenter, no images allowed at rootItem

	int i=0;

	BranchItem *bi=model->getRootItem()->getFirstBranch();

	TreeItem *found=NULL;

	while (bi)

	{

		found=bi->findMapItem (p, exclude);

		if (found) return found;

		i++;

		bi=model->getRootItem()->getBranchNum(i);

	}

	return NULL;

}

AttributeTable* MapEditor::attributeTable()

{

	return attrTable;

}

void MapEditor::testFunction1()

{

	cout << "ME::test1  selected TI="<<model->getSelectedItem()<<endl;

	model->setExportMode (true);

	/*

	// Code copied from Qt sources

	QRectF rect=model->getSelectedBranchObj()->getBBox();

	int xmargin=50;

	int ymargin=50;

    qreal width = viewport()->width();

    qreal height = viewport()->height();

    QRectF viewRect = matrix().mapRect(rect);

    qreal left = horizontalScrollBar()->value();

    qreal right = left + width;

    qreal top = verticalScrollBar()->value();

    qreal bottom = top + height;

    if (viewRect.left() <= left + xmargin) {

        // need to scroll from the left

  //      if (!d->leftIndent)

            horizontalScrollBar()->setValue(int(viewRect.left() - xmargin - 0.5));

    }

    if (viewRect.right() >= right - xmargin) {

        // need to scroll from the right

//        if (!d->leftIndent)

            horizontalScrollBar()->setValue(int(viewRect.right() - width + xmargin + 0.5));

    }

    if (viewRect.top() <= top + ymargin) {

        // need to scroll from the top

   //     if (!d->topIndent)

            verticalScrollBar()->setValue(int(viewRect.top() - ymargin - 0.5));

    }

    if (viewRect.bottom() >= bottom - ymargin) {

        // need to scroll from the bottom

//        if (!d->topIndent)

            verticalScrollBar()->setValue(int(viewRect.bottom() - height + ymargin + 0.5));

    }

	cout << "test1:  hor="<<horizontalScrollBar()->value()<<endl;

	cout << "test1:  ver="<<verticalScrollBar()->value()<<endl;

}

*/

/*

	 QtPropertyAnimation *animation=new QtPropertyAnimation(this, "sceneRect");

	 animation->setDuration(5000);

	 //animation->setEasingCurve ( QtEasingCurve::OutElastic);

	 animation->setEasingCurve ( QtEasingCurve::OutQuint);

	 animation->setStartValue(sceneRect() );

	 animation->setEndValue(QRectF(50, 50, 1000, 1000));

	 animation->start();

*/	 

/*

	QDialog *dia= new QDialog (this);

	dia->setGeometry (50,50,10,10);

     dia->show();

     dia ->raise();

	 QtPropertyAnimation *animation=new QtPropertyAnimation(dia, "geometry");

	 animation->setDuration(1000);

	 //animation->setEasingCurve ( QtEasingCurve::OutElastic);

	 animation->setEasingCurve ( QtEasingCurve::OutQuint);

	 animation->setStartValue(QRect(50, 50, 10, 10));

	 animation->setEndValue(QRect(250, 250, 100, 100));

	 animation->start();

 */

}

void MapEditor::testFunction2()

{

	model->setExportMode (false);

	return;

	// Create list with all bounding polygons

	QList <LinkableMapObj*> mapobjects;

	QList <ConvexPolygon> polys; 

	ConvexPolygon p;

	QList <Vector> vectors;

	QList <Vector> orgpos;

	QStringList headings;	//FIXME-3 testing only

	Vector v;

	BranchItem *bi;

	BranchItem *bi2;

	BranchObj *bo;

	// Outer loop: Iterate until we no more changes in orientation 

	bool orientationChanged=true;

	while (orientationChanged)

	{

		BranchItem *ri=model->getRootItem();

		for (int i=0;i<ri->branchCount();++i)

		{

			bi=ri->getBranchNum (i);

			bo=(BranchObj*)bi->getLMO();

			if (bo)

			{

				mapobjects.append (bo);

				p=bo->getBoundingPolygon();

				p.calcCentroid();

				polys.append(p);

				vectors.append (QPointF(0,0));

				orgpos.append (p.at(0));

				headings.append (bi->getHeading());

			}

			for (int j=0;j<bi->branchCount();++j)

			{

				bi2=bi->getBranchNum (j);

				bo=(BranchObj*)bi2->getLMO();

				if (bo)

				{

					mapobjects.append (bo);

					p=bo->getBoundingPolygon();

					p.calcCentroid();

					polys.append(p);

					vectors.append (QPointF(0,0));

					orgpos.append (p.at(0));

					headings.append (bi2->getHeading());

				}	

			}

		}

		// Iterate moving bounding polygons until we have no more collisions

		int collisions=1;

		while (collisions>0)

		{

			collisions=0;

			for (int i=0; i<polys.size()-1; ++i)

			{

				for (int j=i+1; j<polys.size();++j)

				{

					if (polygonCollision (polys.at(i),polys.at(j), QPointF(0,0)).intersect )

					{

						collisions++;

						//cout << "Collision: "<<headings[i].toStdString()<<" - "<<headings[j].toStdString()<<endl;

						v=polys.at(j).centroid()-polys.at(i).centroid();

						// Move also away if centroids are identical

						if (v.isNull()) 

						{

							//cout << "v==0="<<polys[i].centroid()<<polys[j].centroid()<<" "<<v<<endl;

							v.setX (rand()%200 -100);

							v.setY (rand()%200 -100);

							//cout << v;

						}

						v.normalize();

						v.scale (2);

						//cout <<  "  v="<<v<<endl;

						vectors[j]=v;

						vectors[i]=v;

						vectors[i].invert();

					}  

				}

			}

			for (int i=0;i<vectors.size();i++)

			{

				//cout << " v="<<vectors[i]<<" "<<headings[i].toStdString()<<endl;

				polys[i].translate (vectors[i]);

			}

			cout << "Collisions: "<<collisions<<endl;

			//collisions=0;

		}	

		// Finally move the real objects and update 

		QList <LinkableMapObj::Orientation> orients;

		for (int i=0;i<polys.size();i++)

		{

			Vector v=polys[i].at(0)-orgpos[i];

			orients.append (mapobjects[i]->getOrientation());

			mapobjects[i]->moveBy(v.x(),v.y() );

			mapobjects[i]->setRelPos();

		}	

		model->reposition();	

		orientationChanged=false;

		for (int i=0;i<polys.size();i++)

			if (orients[i]!=mapobjects[i]->getOrientation())

			{

				orientationChanged=true;

				break;

			}

		cout << "Final: orientChanged="<<orientationChanged<<endl;

		break;

		//orientationChanged=false;

	} // loop if orientation has changed

	model->emitSelectionChanged();

}

BranchItem* MapEditor::getBranchDirectAbove (BranchItem *bi)

{

	if (bi)

	{

		int i=bi->num();

		if (i>0) return bi->parent()->getBranchNum(i-1);

	}

	return NULL;

}

BranchItem* MapEditor::getBranchAbove (BranchItem *selbi)

{

	if (selbi)

	{

		int dz=selbi->depth();	// original depth

		bool invert=false;

		if (selbi->getLMO()->getOrientation()==LinkableMapObj::LeftOfCenter)

			invert=true;

		BranchItem *bi;

		// Look for branch with same parent but directly above

		if (dz==1 && invert)

			bi=getBranchDirectBelow(selbi);

		else

			bi=getBranchDirectAbove (selbi);

		if (bi) 

			// direct predecessor

			return bi;

		// Go towards center and look for predecessor

		while (selbi->depth()>0)

		{

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

			if (selbi->depth()==1 && invert)

				bi=getBranchDirectBelow (selbi);

			else

				bi=getBranchDirectAbove (selbi);

			if (bi)

			{

				// turn 

				selbi=bi;

				while (selbi->depth()<dz)

				{

					// try to get back to original depth dz

					bi=selbi->getLastBranch();

					if (!bi) 

					{

						return selbi;

					}

					selbi=bi;

				}

				return selbi;

			}

		}

	}

	return NULL;

}

BranchItem* MapEditor::getBranchDirectBelow(BranchItem *bi)

{

	if (bi)

	{

		int i=bi->num();

		if (i+1<bi->parent()->branchCount()) return bi->parent()->getBranchNum(i+1);

	}

	return NULL;

}

BranchItem* MapEditor::getBranchBelow (BranchItem *selbi)

{

	if (selbi)

	{

		BranchItem *bi;

		int dz=selbi->depth();	// original depth

		bool invert=false;

		if (selbi->getLMO()->getOrientation()==LinkableMapObj::LeftOfCenter)

			invert=true;

		// Look for branch with same parent but directly below

		if (dz==1 && invert)

			bi=getBranchDirectAbove (selbi);

		else

			bi=getBranchDirectBelow (selbi);

		if (bi) 

			// direct successor

			return bi;

		// Go towards center and look for neighbour

		while (selbi->depth()>0)

		{

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

			if (selbi->depth()==1 && invert)

				bi=getBranchDirectAbove (selbi);

			else

				bi=getBranchDirectBelow (selbi);

			if (bi)

			{

				// turn 

				selbi=bi;

				while (selbi->depth()<dz)

				{

					// try to get back to original depth dz

					bi=selbi->getFirstBranch();

					if (!bi) 

					{

						return selbi;

					}

					selbi=bi;

				}

				return selbi;

			}

		}

	}

	return NULL;

}

BranchItem* MapEditor::getLeftBranch (BranchItem *bi)

{

	if (bi)

	{

		if (bi->depth()==0)

			// Special case: use alternative selection index

			return bi->getLastSelectedBranchAlt();	

		if (bi->getBranchObj()->getOrientation()==LinkableMapObj::RightOfCenter)	

			// right of center

			return (BranchItem*)(bi->parent());

		else

			// left of center

			if (bi->getType()== TreeItem::Branch )

				return bi->getLastSelectedBranch();

	}

	return NULL;

}

BranchItem* MapEditor::getRightBranch(BranchItem *bi)

{

	if (bi)

	{

		if (bi->depth()==0) return bi->getLastSelectedBranch();	

		if (bi->getBranchObj()->getOrientation()==LinkableMapObj::LeftOfCenter)	

			// left of center

			return (BranchItem*)(bi->parent());

		else

			// right of center

			if (bi->getType()== TreeItem::Branch )

				return (BranchItem*)bi->getLastSelectedBranch();

	}

	return NULL;

}

void MapEditor::cursorUp()

{

	BranchItem *bi=model->getSelectedBranch();

	if (bi) model->select (getBranchAbove(bi));

}

void MapEditor::cursorDown()	

{

	BranchItem *bi=model->getSelectedBranch();

	if (bi) model->select (getBranchBelow(bi));

}

void MapEditor::cursorLeft()

{

	BranchItem *bi=getLeftBranch (model->getSelectedBranch());

	if (bi) model->select (bi);

}

void MapEditor::cursorRight()	

{

	BranchItem *bi=getRightBranch (model->getSelectedBranch());

	if (bi) model->select (bi);

}

void MapEditor::cursorFirst()	

{

	model->selectFirstBranch();

}

void MapEditor::cursorLast()	

{

	model->selectLastBranch();

}

void MapEditor::editHeading()

{

	if (editingHeading)

	{

		editHeadingFinished();

		return;

	}

	BranchObj *bo=model->getSelectedBranchObj();

	BranchItem *bi=model->getSelectedBranch();

	if (bo)	

	{

		model->setSelectionBlocked(true);

		lineEdit=new QLineEdit;

		QGraphicsProxyWidget *pw=scene()->addWidget (lineEdit);

		pw->setZValue (Z_LINEEDIT);

		lineEdit->setText (bi->getHeading());

		QPoint p = mapTo (this,bo->getAbsPos().toPoint() );

		lineEdit->setGeometry(p.x(),p.y(),230,25);

		//lineEdit->selectAll();

		//lineEdit->setCursorPosition (1);

		lineEdit->show();

		lineEdit->setFocus();

		lineEdit->grabKeyboard();

		editingHeading=true;

	}

}

void MapEditor::editHeadingFinished()

{

	editingHeading=false;

	lineEdit->releaseKeyboard();

	lineEdit->clearFocus();

	model->setHeading (lineEdit->text() );

	model->setSelectionBlocked(false);

	delete (lineEdit);

	// Maybe reselect previous branch 

	mainWindow->editHeadingFinished (model);

}

void MapEditor::contextMenuEvent ( QContextMenuEvent * e )

{

	// Lineedits are already closed by preceding

	// mouseEvent, we don't need to close here.

    QPointF p = mapToScene(e->pos());

    TreeItem *ti=findMapItem (p, NULL);

    LinkableMapObj* lmo=NULL;

	if (ti) lmo=((MapItem*)ti)->getLMO();

    if (lmo) 

	{	// MapObj was found

		if (model->getSelectedLMO() != lmo)

		{

			// select the MapObj

			model->select(lmo);

		}

		// Context Menu 

		if (model->getSelectedBranchObj() ) 

		{

			// Context Menu on branch or mapcenter

			branchContextMenu->popup(e->globalPos() );

		} else

		{

			if (model->getSelectedImage() )

			{

				// Context Menu on floatimage

				floatimageContextMenu->popup(e->globalPos() );

			}	

		}	

	} else 

	{ // No MapObj found, we are on the Canvas itself

		// Context Menu on scene

		// Open context menu synchronously to position new mapcenter

		model->setContextPos (p);

		canvasContextMenu->exec(e->globalPos() );

		model->unsetContextPos ();

    } 

	e->accept();

}