#include "mapeditor.h"

 #include <q3filedialog.h>

 #include <iostream>

 #include <cstdlib>

 #include <typeinfo>

 #include "version.h"

 #include "parser.h"

 #include "editxlinkdialog.h"

 #include "exports.h"

 #include "exportxhtmldialog.h"

 #include "extrainfodialog.h"

 #include "file.h"

 #include "linkablemapobj.h"

 #include "mainwindow.h"

 #include "misc.h"

 #include "texteditor.h"

 #include "warningdialog.h"

 #include "xml.h"

 extern TextEditor *textEditor;

 extern int statusbarTime;

 extern Main *mainWindow;

 extern QString tmpVymDir;

 extern QString clipboardDir;

 extern QString clipboardFile;

 extern bool clipboardEmpty;

 extern bool debug;

 extern FlagRowObj *standardFlagsDefault;

 extern QMenu* branchContextMenu;

 extern QMenu* branchAddContextMenu;

 extern QMenu* branchRemoveContextMenu;

 extern QMenu* branchLinksContextMenu;

 extern QMenu* branchXLinksContextMenuEdit;

 extern QMenu* branchXLinksContextMenuFollow;

 extern QMenu* floatimageContextMenu;

 extern QMenu* canvasContextMenu;

 extern Settings settings;

 extern ImageIO imageIO;

 extern QString vymName;

 extern QString vymVersion;

 extern QString iconPath;

 extern QDir vymBaseDir;

 extern QDir lastImageDir;

 extern QDir lastFileDir;

 int MapEditor::mapNum=0;	// make instance

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

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

 MapEditor::MapEditor( QWidget* parent) :

   QGraphicsView(parent)  

 {

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

 	mapNum++;

 	mapScene= new QGraphicsScene(parent);

 	//mapScene= new QGraphicsScene(QRectF(0,0,width(),height()), parent);

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

     setScene (mapScene);

     mapCenter = new MapCenterObj(mapScene);

     mapCenter->setVisibility (true);

 	mapCenter->setMapEditor (this);

 	mapCenter->setHeading (tr("New Map","Heading of mapcenter in new map"));

 	//mapCenter->move(mapScene->width()/2-mapCenter->width()/2,mapScene->height()/2-mapCenter->height()/2);

 	mapCenter->move(0,0);

     printer=NULL;

 	defLinkColor=QColor (0,0,255);

 	defXLinkColor=QColor (180,180,180);

 	linkcolorhint=LinkableMapObj::DefaultColor;

 	linkstyle=LinkableMapObj::PolyParabel;

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

 	pickingColor=false;

 	drawingLink=false;

 	copyingObj=false;

     editingBO=NULL;

     movingObj=NULL;

 	xelection.setMapEditor (this);

 	xelection.unselect();

 	defXLinkWidth=1;

 	defXLinkColor=QColor (230,230,230);

     mapChanged=false;

 	mapDefault=true;

 	mapUnsaved=false;

 	zipped=true;

 	filePath="";

 	fileName=tr("unnamed");

 	mapName="";

 	stepsTotal=settings.readNumEntry("/mapeditor/stepsTotal",100);

 	undoSet.setEntry ("/history/stepsTotal",QString::number(stepsTotal));

 	mainWindow->updateHistory (undoSet);

 	// Initialize find routine

 	itFind=NULL;				

 	EOFind=false;

 	printFrame=true;

 	printFooter=true;

 	blockReposition=false;

 	blockSaveState=false;

 	hidemode=BranchObj::HideNone;

 	// Create temporary files

 	makeTmpDirs();

 	curStep=0;

 	redosAvail=0;

 	undosAvail=0;

 	setAcceptDrops (true);	

 	mapCenter->reposition();	//	for positioning heading

 	// TODO animations

 	animObjList.clear();

 	//timerId = startTimer(100);  

 	// autosave

 	autosaveTimer=new QTimer (this);

 	connect(autosaveTimer, SIGNAL(timeout()), this, SLOT(autosave()));

 	// Network

 	netstate=Offline;

 }

 MapEditor::~MapEditor()

 {

 	//cout <<"Destructor MapEditor\n";

 	autosaveTimer->stop();

 }

 MapCenterObj* MapEditor::getMapCenter()

 {

     return mapCenter;

 }

 QGraphicsScene * MapEditor::getScene()

 {

     return mapScene;

 }

 MapEditor::State MapEditor::getState()

 {

     return state;

 }

 void MapEditor::setStateEditHeading(bool s)

 {

 	if (s)

 	{

 		if (state==Idle) state=EditHeading;

 	}

 	else	

 		state=Idle;

 }

 bool MapEditor::isRepositionBlocked()

 {

 	return blockReposition;

 }

 void MapEditor::setSaveStateBlocked(bool b)

 {

 	blockSaveState=b;

 }

 bool MapEditor::isSelectBlocked()

 {

 	if (state==EditHeading)

 		return true;

 	else

 		return false; 

 }

 QString MapEditor::getName (const LinkableMapObj *lmo)

 {

 	QString s;

 	if (!lmo) return QString("Error: NULL has no name!");

 	if ((typeid(*lmo) == typeid(BranchObj) ||

 				      typeid(*lmo) == typeid(MapCenterObj))) 

 	{

 		s=(((BranchObj*)lmo)->getHeading());

 		if (s=="") s="unnamed";

 		return QString("branch (%1)").arg(s);

 		//return QString("branch (<font color=\"#0000ff\">%1</font>)").arg(s);

 	}	

 	if ((typeid(*lmo) == typeid(FloatImageObj) ))

 		return QString ("floatimage [%1]").arg(((FloatImageObj*)lmo)->getOriginalFilename());

 		//return QString ("floatimage [<font color=\"#0000ff\">%1</font>]").arg(((FloatImageObj*)lmo)->getOriginalFilename());

 	return QString("Unknown type has no name!");

 }

 void MapEditor::makeTmpDirs()

 {

 	// Create unique temporary directories

 	tmpMapDir=QDir::convertSeparators (tmpVymDir+QString("/mapeditor-%1").arg(mapNum));

 	histPath=QDir::convertSeparators (tmpMapDir+"/history");

 	QDir d;

 	d.mkdir (tmpMapDir);

 }

 QString MapEditor::saveToDir(const QString &tmpdir, const QString &prefix, bool writeflags, const QPointF &offset, LinkableMapObj *saveSel)

 {

 	// tmpdir		temporary directory to which data will be written

 	// prefix		mapname, which will be appended to images etc.

 	// writeflags	Only write flags for "real" save of map, not undo

 	// offset		offset of bbox of whole map in scene. 

 	//				Needed for XML export

 	// Save Header

 	QString ls;

 	switch (linkstyle)

 	{

 		case LinkableMapObj::Line: 

 			ls="StyleLine";

 			break;

 		case LinkableMapObj::Parabel:

 			ls="StyleParabel";

 			break;

 		case LinkableMapObj::PolyLine:	

 			ls="StylePolyLine";

 			break;

 		default:

 			ls="StylePolyParabel";

 			break;

 	}	

 	QString s="<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE vymmap>\n";

 	QString colhint="";

 	if (linkcolorhint==LinkableMapObj::HeadingColor) 

 		colhint=attribut("linkColorHint","HeadingColor");

 	QString mapAttr=attribut("version",vymVersion);

 	if (!saveSel || saveSel==mapCenter)

 		mapAttr+= attribut("author",mapCenter->getAuthor()) +

 				  attribut("comment",mapCenter->getComment()) +

 			      attribut("date",mapCenter->getDate()) +

 		          attribut("backgroundColor", mapScene->backgroundBrush().color().name() ) +

 		          attribut("selectionColor", xelection.getColor().name() ) +

 		          attribut("linkStyle", ls ) +

 		          attribut("linkColor", defLinkColor.name() ) +

 		          attribut("defXLinkColor", defXLinkColor.name() ) +

 		          attribut("defXLinkWidth", QString().setNum(defXLinkWidth,10) ) +

 		          colhint; 

 	s+=beginElement("vymmap",mapAttr);

 	incIndent();

 	// Find the used flags while traversing the tree

 	standardFlagsDefault->resetUsedCounter();

 	// Reset the counters before saving

 	// TODO constr. of FIO creates lots of objects, better do this in some other way...

 	FloatImageObj (mapScene).resetSaveCounter();

 	// Build xml recursivly

 	if (!saveSel || typeid (*saveSel) == typeid (MapCenterObj))

 		// Save complete map, if saveSel not set

 		s+=mapCenter->saveToDir(tmpdir,prefix,writeflags,offset);

 	else

 	{

 		if ( typeid(*saveSel) == typeid(BranchObj) )

 			// Save Subtree

 			s+=((BranchObj*)(saveSel))->saveToDir(tmpdir,prefix,offset);

 		else if ( typeid(*saveSel) == typeid(FloatImageObj) )

 			// Save image

 			s+=((FloatImageObj*)(saveSel))->saveToDir(tmpdir,prefix);

 	}

 	// Save local settings

 	s+=settings.getXMLData (destPath);

 	// Save selection

 	if (!xelection.isEmpty() && !saveSel ) 

 		s+=valueElement("select",xelection.getSelectString());

 	decIndent();

 	s+=endElement("vymmap");

 	if (writeflags)

 		standardFlagsDefault->saveToDir (tmpdir+"/flags/","",writeflags);

 	return s;

 }

 QString MapEditor::getHistoryDir()

 {

 	QString histName=QDir::convertSeparators (QString("history-%1").arg(curStep));

 	return QDir::convertSeparators (tmpMapDir +"/"+histName);

 }

 void MapEditor::saveState(const SaveMode &savemode, const QString &undoSelection, const QString &undoCom, const QString &redoSelection, const QString &redoCom, const QString &comment, LinkableMapObj *saveSel)

 {

 	sendData(redoCom);	//FIXME testing

 	// Main saveState

 	if (blockSaveState) return;

 	if (debug) cout << "ME::saveState() for  "<<mapName.ascii()<<endl;

 	// Find out current undo directory

 	if (undosAvail<stepsTotal) undosAvail++;

 	curStep++;

 	if (curStep>stepsTotal) curStep=1;

 	QString backupXML="";

 	QString histDir=getHistoryDir();

 	QString bakMapPath=QDir::convertSeparators(histDir+"/map.xml");

 	// Create histDir if not available

 	QDir d(histDir);

 	if (!d.exists()) 

 		makeSubDirs (histDir);

 	// Save depending on how much needs to be saved	

 	if (saveSel)

 		backupXML=saveToDir (histDir,mapName+"-",false, QPointF (),saveSel);

 	QString undoCommand="";

 	if (savemode==UndoCommand)

 	{

 		undoCommand=undoCom;

 	}	

 	else if (savemode==PartOfMap )

 	{

 		undoCommand=undoCom;

 		undoCommand.replace ("PATH",bakMapPath);

 	}

 	if (!backupXML.isEmpty())

 		// Write XML Data to disk

 		saveStringToDisk (QString(bakMapPath),backupXML);

 	// We would have to save all actions in a tree, to keep track of 

 	// possible redos after a action. Possible, but we are too lazy: forget about redos.

 	redosAvail=0;

 	// Write the current state to disk

 	undoSet.setEntry ("/history/undosAvail",QString::number(undosAvail));

 	undoSet.setEntry ("/history/redosAvail",QString::number(redosAvail));

 	undoSet.setEntry ("/history/curStep",QString::number(curStep));

 	undoSet.setEntry (QString("/history/step-%1/undoCommand").arg(curStep),undoCommand);

 	undoSet.setEntry (QString("/history/step-%1/undoSelection").arg(curStep),undoSelection);

 	undoSet.setEntry (QString("/history/step-%1/redoCommand").arg(curStep),redoCom);

 	undoSet.setEntry (QString("/history/step-%1/redoSelection").arg(curStep),redoSelection);

 	undoSet.setEntry (QString("/history/step-%1/comment").arg(curStep),comment);

 	undoSet.setEntry (QString("/history/version"),vymVersion);

 	undoSet.writeSettings(histPath);

 	if (debug)

 	{

 		// TODO remove after testing

 		//cout << "          into="<< histPath.toStdString()<<endl;

 		cout << "    stepsTotal="<<stepsTotal<<

 		", undosAvail="<<undosAvail<<

 		", redosAvail="<<redosAvail<<

 		", curStep="<<curStep<<endl;

 		cout << "    ---------------------------"<<endl;

 		cout << "    comment="<<comment.toStdString()<<endl;

 		cout << "    undoCom="<<undoCommand.toStdString()<<endl;

 		cout << "    undoSel="<<undoSelection.toStdString()<<endl;

 		cout << "    redoCom="<<redoCom.toStdString()<<endl;

 		cout << "    redoSel="<<redoSelection.toStdString()<<endl;

 		if (saveSel) cout << "    saveSel="<<saveSel->getSelectString().ascii()<<endl;

 		cout << "    ---------------------------"<<endl;

 	}

 	mainWindow->updateHistory (undoSet);

 	setChanged();

 	updateActions();

 }

 void MapEditor::saveStateChangingPart(LinkableMapObj *undoSel, LinkableMapObj* redoSel, const QString &rc, const QString &comment)

 {

 	// save the selected part of the map, Undo will replace part of map 

 	QString undoSelection="";

 	if (undoSel)

 		undoSelection=undoSel->getSelectString();

 	else

 		qWarning ("MapEditor::saveStateChangingPart  no undoSel given!");

 	QString redoSelection="";

 	if (redoSel)

 		redoSelection=undoSel->getSelectString();

 	else

 		qWarning ("MapEditor::saveStateChangingPart  no redoSel given!");

 	saveState (PartOfMap,

 		undoSelection, "addMapReplace (\"PATH\")",

 		redoSelection, rc, 

 		comment, 

 		undoSel);

 }

 void MapEditor::saveStateRemovingPart(LinkableMapObj *redoSel, const QString &comment)

 {

 	if (!redoSel)

 	{

 		qWarning ("MapEditor::saveStateRemovingPart  no redoSel given!");

 		return;

 	}

 	QString undoSelection=redoSel->getParObj()->getSelectString();

 	QString redoSelection=redoSel->getSelectString();

 	if (typeid(*redoSel) == typeid(BranchObj)  ) 

 	{

 		// save the selected branch of the map, Undo will insert part of map 

 		saveState (PartOfMap,

 			undoSelection, QString("addMapInsert (\"PATH\",%1)").arg(((BranchObj*)redoSel)->getNum()),

 			redoSelection, "delete ()", 

 			comment, 

 			redoSel);

 	}

 }

 void MapEditor::saveState(LinkableMapObj *undoSel, const QString &uc, LinkableMapObj *redoSel, const QString &rc, const QString &comment) 

 {

 	// "Normal" savestate: save commands, selections and comment

 	// so just save commands for undo and redo

 	// and use current selection

 	QString redoSelection="";

 	if (redoSel) redoSelection=redoSel->getSelectString();

 	QString undoSelection="";

 	if (undoSel) undoSelection=undoSel->getSelectString();

 	saveState (UndoCommand,

 		undoSelection, uc,

 		redoSelection, rc, 

 		comment, 

 		NULL);

 }

 void MapEditor::saveState(const QString &undoSel, const QString &uc, const QString &redoSel, const QString &rc, const QString &comment) 

 {

 	// "Normal" savestate: save commands, selections and comment

 	// so just save commands for undo and redo

 	// and use current selection

 	saveState (UndoCommand,

 		undoSel, uc,

 		redoSel, rc, 

 		comment, 

 		NULL);

 }

 void MapEditor::parseAtom(const QString &atom)

 {

 	BranchObj *selb=xelection.getBranch();

 	QString s,t;

 	int x,y;

 	bool b,ok;

 	// Split string s into command and parameters

 	parser.parseAtom (atom);

 	QString com=parser.getCommand();

 	// External commands

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

 	if (com=="addBranch")

 	{

 		if (xelection.isEmpty())

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else 

 		{	

 			QList <int> pl;

 			pl << 0 <<1;

 			if (parser.checkParCount(pl))

 			{

 				if (parser.parCount()==0)

 					addNewBranchInt (-2);

 				else

 				{

 					y=parser.parInt (ok,0);

 					if (ok ) addNewBranchInt (y);

 				}

 			}

 		}

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

 	} else if (com=="addBranchBefore")

 	{

 		if (xelection.isEmpty())

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else 

 		{	

 			if (parser.parCount()==0)

 			{

 				addNewBranchBefore ();

 			}	

 		}

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

 	} else if (com==QString("addMapReplace"))

 	{

 		if (xelection.isEmpty())

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{

 			//s=parser.parString (ok,0);	// selection

 			t=parser.parString (ok,0);	// path to map

 			if (QDir::isRelativePath(t)) t=QDir::convertSeparators (tmpMapDir + "/"+t);

 			addMapReplaceInt(selb->getSelectString(),t);	

 		}

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

 	} else if (com==QString("addMapInsert"))

 	{

 		if (xelection.isEmpty())

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else 

 		{	

 			if (parser.checkParCount(2))

 			{

 				t=parser.parString (ok,0);	// path to map

 				y=parser.parInt(ok,1);		// position

 				if (QDir::isRelativePath(t)) t=QDir::convertSeparators (tmpMapDir + "/"+t);

 				addMapInsertInt(t,y);	

 			}

 		}

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

 	} else if (com=="clearFlags")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(0))

 		{

 			selb->clearStandardFlags();	

 			selb->updateFlagsToolbar();

 		}

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

 	} else if (com=="colorBranch")

 	{

 		if (xelection.isEmpty())

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{	

 			QColor c=parser.parColor (ok,0);

 			if (ok) colorBranch (c);

 		}	

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

 	} else if (com=="colorSubtree")

 	{

 		if (xelection.isEmpty())

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{	

 			QColor c=parser.parColor (ok,0);

 			if (ok) colorSubtree (c);

 		}	

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

 	} else if (com=="copy")

 	{

 		if (xelection.isEmpty())

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(0))

 		{	

 			//FIXME missing action for copy

 		}	

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

 	} else if (com=="cut")

 	{

 		if (xelection.isEmpty())

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if ( xelection.type()!=Selection::Branch  && 

 					xelection.type()!=Selection::MapCenter  &&

 					xelection.type()!=Selection::FloatImage )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch or floatimage");

 		} else if (parser.checkParCount(0))

 		{	

 			cut();

 		}	

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

 	} else if (com=="delete")

 	{

 		if (xelection.isEmpty())

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (xelection.type() != Selection::Branch && xelection.type() != Selection::FloatImage )

 		{

 			parser.setError (Aborted,"Type of selection is wrong.");

 		} else if (parser.checkParCount(0))

 		{	

 			deleteSelection();

 		}	

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

 	} else if (com=="deleteKeepChilds")

 	{

 		if (xelection.isEmpty())

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(0))

 		{	

 			deleteKeepChilds();

 		}	

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

 	} else if (com=="deleteChilds")

 	{

 		if (xelection.isEmpty())

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb)

 		{

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(0))

 		{	

 			deleteChilds();

 		}	

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

 	} else if (com=="exportASCII")

 	{

 		QString fname="";

 		ok=true;

 		if (parser.parCount()>=2)

 			// Hey, we even have a filename

 			fname=parser.parString(ok,1); 

 		if (!ok)

 		{

 			parser.setError (Aborted,"Could not read filename");

 		} else

 		{

 				exportASCII (fname,false);

 		}

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

 	} else if (com=="exportImage")

 	{

 		QString fname="";

 		ok=true;

 		if (parser.parCount()>=2)

 			// Hey, we even have a filename

 			fname=parser.parString(ok,1); 

 		if (!ok)

 		{

 			parser.setError (Aborted,"Could not read filename");

 		} else

 		{

 			QString format="PNG";

 			if (parser.parCount()>2)

 			{

 				format=parser.parString(ok,2);

 			}

 			exportImage (fname,false,format);

 		}

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

 	} else if (com=="exportXHTML")

 	{

 		QString fname="";

 		ok=true;

 		if (parser.parCount()>=2)

 			// Hey, we even have a filename

 			fname=parser.parString(ok,1); 

 		if (!ok)

 		{

 			parser.setError (Aborted,"Could not read filename");

 		} else

 		{

 			exportXHTML (fname,false);

 		}

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

 	} else if (com=="exportXML")

 	{

 		QString fname="";

 		ok=true;

 		if (parser.parCount()>=2)

 			// Hey, we even have a filename

 			fname=parser.parString(ok,1); 

 		if (!ok)

 		{

 			parser.setError (Aborted,"Could not read filename");

 		} else

 		{

 			exportXML (fname,false);

 		}

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

 	} else if (com=="importDir")

 	{

 		if (xelection.isEmpty())

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{

 			s=parser.parString(ok,0);

 			if (ok) importDirInt(s);

 		}	

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

 	} else if (com=="linkTo")

 	{

 		if (xelection.isEmpty())

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if ( selb)

 		{

 			if (parser.checkParCount(4))

 			{

 				// 0	selectstring of parent

 				// 1	num in parent (for branches)

 				// 2,3	x,y of mainbranch or mapcenter

 				s=parser.parString(ok,0);

 				LinkableMapObj *dst=mapCenter->findObjBySelect (s);

 				if (dst)

 				{	

 					if (typeid(*dst) == typeid(BranchObj) ) 

 					{

 						// Get number in parent

 						x=parser.parInt (ok,1);

 						if (ok)

 							selb->linkTo ((BranchObj*)(dst),x);

 					} else if (typeid(*dst) == typeid(MapCenterObj) ) 

 					{

 						selb->linkTo ((BranchObj*)(dst),-1);

 						// Get coordinates of mainbranch

 						x=parser.parInt (ok,2);

 						if (ok)

 						{

 							y=parser.parInt (ok,3);

 							if (ok) selb->move (x,y);

 						}

 					}	

 				}	

 			}	

 		} else if ( xelection.type() == Selection::FloatImage) 

 		{

 			if (parser.checkParCount(1))

 			{

 				// 0	selectstring of parent

 				s=parser.parString(ok,0);

 				LinkableMapObj *dst=mapCenter->findObjBySelect (s);

 				if (dst)

 				{	

 					if (typeid(*dst) == typeid(BranchObj) ||

 						typeid(*dst) == typeid(MapCenterObj)) 

 						linkTo (dst->getSelectString());

 				} else	

 					parser.setError (Aborted,"Destination is not a branch");

 			}		

 		} else

 			parser.setError (Aborted,"Type of selection is not a floatimage or branch");

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

 	} else if (com=="loadImage")

 	{

 		if (xelection.isEmpty())

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{

 			s=parser.parString(ok,0);

 			if (ok) loadFloatImageInt (s);

 		}	

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

 	} else if (com=="moveBranchUp")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(0))

 		{

 			moveBranchUp();

 		}	

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

 	} else if (com=="moveBranchDown")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(0))

 		{

 			moveBranchDown();

 		}	

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

 	} else if (com=="move")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if ( xelection.type()!=Selection::Branch  && 

 					xelection.type()!=Selection::MapCenter  &&

 					xelection.type()!=Selection::FloatImage )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch or floatimage");

 		} else if (parser.checkParCount(2))

 		{	

 			x=parser.parInt (ok,0);

 			if (ok)

 			{

 				y=parser.parInt (ok,1);

 				if (ok) move (x,y);

 			}

 		}	

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

 	} else if (com=="moveRel")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if ( xelection.type()!=Selection::Selection::Branch  && 

 					xelection.type()!=Selection::Selection::MapCenter  &&

 					xelection.type()!=Selection::Selection::FloatImage )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch or floatimage");

 		} else if (parser.checkParCount(2))

 		{	

 			x=parser.parInt (ok,0);

 			if (ok)

 			{

 				y=parser.parInt (ok,1);

 				if (ok) moveRel (x,y);

 			}

 		}	

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

 	} else if (com=="nop")

 	{

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

 	} else if (com=="paste")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{	

 			x=parser.parInt (ok,0);

 			if (ok) pasteNoSave(x);

 		}	

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

 	} else if (com=="qa")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(4))

 		{	

 			QString c,u;

 			c=parser.parString (ok,0);

 			if (!ok)

 			{

 				parser.setError (Aborted,"No comment given");

 			} else

 			{

 				s=parser.parString (ok,1);

 				if (!ok)

 				{

 					parser.setError (Aborted,"First parameter is not a string");

 				} else

 				{

 					t=parser.parString (ok,2);

 					if (!ok)

 					{

 						parser.setError (Aborted,"Condition is not a string");

 					} else

 					{

 						u=parser.parString (ok,3);

 						if (!ok)

 						{

 							parser.setError (Aborted,"Third parameter is not a string");

 						} else

 						{

 							if (s!="heading")

 							{

 								parser.setError (Aborted,"Unknown type: "+s);

 							} else

 							{

 								if (! (t=="eq") ) 

 								{

 									parser.setError (Aborted,"Unknown operator: "+t);

 								} else

 								{

 									if (! selb    )

 									{

 										parser.setError (Aborted,"Type of selection is not a branch");

 									} else

 									{

 										if (selb->getHeading() == u)

 										{

 											cout << "PASSED: " << c.ascii() << endl;

 										} else

 										{

 											cout << "FAILED: " << c.ascii() << endl;

 										}

 									}

 								}

 							}

 						} 

 					} 

 				} 

 			}

 		}	

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

 	} else if (com=="saveImage")

 	{

 		FloatImageObj *fio=xelection.getFloatImage();

 		if (!fio)

 		{

 			parser.setError (Aborted,"Type of selection is not an image");

 		} else if (parser.checkParCount(2))

 		{

 			s=parser.parString(ok,0);

 			if (ok)

 			{

 				t=parser.parString(ok,1);

 				if (ok) saveFloatImageInt (fio,t,s);

 			}

 		}	

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

 	} else if (com=="scroll")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(0))

 		{	

 			if (!scrollBranch (selb))	

 				parser.setError (Aborted,"Could not scroll branch");

 		}	

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

 	} else if (com=="select")

 	{

 		if (parser.checkParCount(1))

 		{

 			s=parser.parString(ok,0);

 			if (ok) select (s);

 		}	

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

 	} else if (com=="selectLastBranch")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(0))

 		{	

 			BranchObj *bo=selb->getLastBranch();

 			if (!bo)

 				parser.setError (Aborted,"Could not select last branch");

 			selectInt (bo);	

 		}	

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

 	} else if (com=="selectLastImage")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(0))

 		{	

 			FloatImageObj *fio=selb->getLastFloatImage();

 			if (!fio)

 				parser.setError (Aborted,"Could not select last image");

 			selectInt (fio);	

 		}	

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

 	} else if (com=="setFrameType")

 	{

 		if ( xelection.type()!=Selection::Branch && xelection.type()!= Selection::MapCenter && xelection.type()!=Selection::FloatImage)

 		{

 			parser.setError (Aborted,"Type of selection does not allow setting frame type");

 		}

 		else if (parser.checkParCount(1))

 		{

 			s=parser.parString(ok,0);

 			if (ok) setFrameType (s);

 		}	

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

 	} else if (com=="setFramePenColor")

 	{

 		if ( xelection.type()!=Selection::Branch && xelection.type()!= Selection::MapCenter && xelection.type()!=Selection::FloatImage)

 		{

 			parser.setError (Aborted,"Type of selection does not allow setting of pen color");

 		}

 		else if (parser.checkParCount(1))

 		{

 			QColor c=parser.parColor(ok,0);

 			if (ok) setFramePenColor (c);

 		}	

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

 	} else if (com=="setFrameBrushColor")

 	{

 		if ( xelection.type()!=Selection::Branch && xelection.type()!= Selection::MapCenter && xelection.type()!=Selection::FloatImage)

 		{

 			parser.setError (Aborted,"Type of selection does not allow setting brush color");

 		}

 		else if (parser.checkParCount(1))

 		{

 			QColor c=parser.parColor(ok,0);

 			if (ok) setFrameBrushColor (c);

 		}	

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

 	} else if (com=="setFramePadding")

 	{

 		if ( xelection.type()!=Selection::Branch && xelection.type()!= Selection::MapCenter && xelection.type()!=Selection::FloatImage)

 		{

 			parser.setError (Aborted,"Type of selection does not allow setting frame padding");

 		}

 		else if (parser.checkParCount(1))

 		{

 			x=parser.parInt(ok,0);

 			if (ok) setFramePadding(x);

 		}	

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

 	} else if (com=="setFrameBorderWidth")

 	{

 		if ( xelection.type()!=Selection::Branch && xelection.type()!= Selection::MapCenter && xelection.type()!=Selection::FloatImage)

 		{

 			parser.setError (Aborted,"Type of selection does not allow setting frame border width");

 		}

 		else if (parser.checkParCount(1))

 		{

 			x=parser.parInt(ok,0);

 			if (ok) setFrameBorderWidth (x);

 		}	

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

 	} else if (com=="setMapAuthor")

 	{

 		if (parser.checkParCount(1))

 		{

 			s=parser.parString(ok,0);

 			if (ok) setMapAuthor (s);

 		}	

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

 	} else if (com=="setMapComment")

 	{

 		if (parser.checkParCount(1))

 		{

 			s=parser.parString(ok,0);

 			if (ok) setMapComment(s);

 		}	

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

 	} else if (com=="setMapBackgroundColor")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! xelection.getBranch() )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{

 			QColor c=parser.parColor (ok,0);

 			if (ok) setMapBackgroundColor (c);

 		}	

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

 	} else if (com=="setMapDefLinkColor")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{

 			QColor c=parser.parColor (ok,0);

 			if (ok) setMapDefLinkColor (c);

 		}	

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

 	} else if (com=="setMapLinkStyle")

 	{

 		if (parser.checkParCount(1))

 		{

 			s=parser.parString (ok,0);

 			if (ok) setMapLinkStyle(s);

 		}	

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

 	} else if (com=="setHeading")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{

 			s=parser.parString (ok,0);

 			if (ok) 

 				setHeading (s);

 		}	

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

 	} else if (com=="setHideExport")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (xelection.type()!=Selection::Branch && xelection.type() != Selection::MapCenter &&xelection.type()!=Selection::FloatImage)

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch or floatimage");

 		} else if (parser.checkParCount(1))

 		{

 			b=parser.parBool(ok,0);

 			if (ok) setHideExport (b);

 		}

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

 	} else if (com=="setIncludeImagesHorizontally")

 	{ 

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb)

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{

 			b=parser.parBool(ok,0);

 			if (ok) setIncludeImagesHor(b);

 		}

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

 	} else if (com=="setIncludeImagesVertically")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb)

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{

 			b=parser.parBool(ok,0);

 			if (ok) setIncludeImagesVer(b);

 		}

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

 	} else if (com=="setHideLinkUnselected")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if ( xelection.type()!=Selection::Branch && xelection.type()!= Selection::MapCenter && xelection.type()!=Selection::FloatImage)

 		{				  

 			parser.setError (Aborted,"Type of selection does not allow hiding the link");

 		} else if (parser.checkParCount(1))

 		{

 			b=parser.parBool(ok,0);

 			if (ok) setHideLinkUnselected(b);

 		}

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

 	} else if (com=="setSelectionColor")

 	{

 		if (parser.checkParCount(1))

 		{

 			QColor c=parser.parColor (ok,0);

 			if (ok) setSelectionColorInt (c);

 		}	

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

 	} else if (com=="setURL")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{

 			s=parser.parString (ok,0);

 			if (ok) setURL(s);

 		}	

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

 	} else if (com=="setVymLink")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{

 			s=parser.parString (ok,0);

 			if (ok) setVymLinkInt(s);

 		}	

 	}

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

 	else if (com=="setFlag")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{

 			s=parser.parString(ok,0);

 			if (ok) 

 			{

 				selb->activateStandardFlag(s);

 				selb->updateFlagsToolbar();

 			}	

 		}

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

 	} else if (com=="setFrameType")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{

 			s=parser.parString(ok,0);

 			if (ok) 

 				setFrameType (s);

 		}

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

 	} else if (com=="toggleFlag")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{

 			s=parser.parString(ok,0);

 			if (ok) 

 			{

 				selb->toggleStandardFlag(s);	

 				selb->updateFlagsToolbar();

 			}	

 		}

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

 	} else if (com=="unscroll")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(0))

 		{	

 			if (!unscrollBranch (selb))	

 				parser.setError (Aborted,"Could not unscroll branch");

 		}	

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

 	} else if (com=="unscrollChilds")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(0))

 		{	

 			unscrollChilds ();

 		}	

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

 	} else if (com=="unsetFlag")

 	{

 		if (xelection.isEmpty() )

 		{

 			parser.setError (Aborted,"Nothing selected");

 		} else if (! selb )

 		{				  

 			parser.setError (Aborted,"Type of selection is not a branch");

 		} else if (parser.checkParCount(1))

 		{

 			s=parser.parString(ok,0);

 			if (ok) 

 			{

 				selb->deactivateStandardFlag(s);

 				selb->updateFlagsToolbar();

 			}	

 		}

 	} else

 		parser.setError (Aborted,"Unknown command");

 	// Any errors?

 	if (parser.errorLevel()==NoError)

 	{

 		setChanged();

 		mapCenter->reposition();

 	}	

 	else	

 	{

 		// TODO Error handling

 		qWarning("MapEditor::parseAtom: Error!");

 		qWarning(parser.errorMessage());

 	} 

 }

 void MapEditor::runScript (QString script)

 {

 	parser.setScript (script);

 	parser.runScript();

 	while (parser.next() ) 

 		parseAtom(parser.getAtom());

 }

 bool MapEditor::isDefault()

 {

     return mapDefault;

 }

 bool MapEditor::hasChanged()

 {

     return mapChanged;

 }

 void MapEditor::setChanged()

 {

 	if (!mapChanged)

 		autosaveTimer->start(settings.value("/mapeditor/autosave/ms/",300000).toInt());

 	mapChanged=true;

 	mapDefault=false;

 	mapUnsaved=true;

 	findReset();

 }

 void MapEditor::closeMap()

 {

 	// Unselect before disabling the toolbar actions

 	if (!xelection.isEmpty() ) xelection.unselect();

 	xelection.clear();

 	updateActions();

     clear();

 	close();

 }

 void MapEditor::setFilePath(QString fpath, QString destname)

 {

 	if (fpath.isEmpty() || fpath=="")

 	{

 		filePath="";

 		fileName="";

 		destPath="";

 	} else

 	{

 		filePath=fpath;		// becomes absolute path

 		fileName=fpath;		// gets stripped of path

 		destPath=destname;	// needed for vymlinks

 		// If fpath is not an absolute path, complete it

 		filePath=QDir(fpath).absPath();

 		fileDir=filePath.left (1+filePath.findRev ("/"));

 		// Set short name, too. Search from behind:

 		int i=fileName.findRev("/");

 		if (i>=0) fileName=fileName.remove (0,i+1);

 		// Forget the .vym (or .xml) for name of map

 		mapName=fileName.left(fileName.findRev(".",-1,true) );

 	}

 }

 void MapEditor::setFilePath(QString fpath)

 {

 	setFilePath (fpath,fpath);

 }

 QString MapEditor::getFilePath()

 {

 	return filePath;

 }

 QString MapEditor::getFileName()

 {

 	return fileName;

 }

 QString MapEditor::getMapName()

 {

 	return mapName;

 }

 QString MapEditor::getDestPath()

 {

 	return destPath;

 }

 ErrorCode MapEditor::load (QString fname, LoadMode lmode)

 {

 	ErrorCode err=success;

 	if (lmode==NewMap)

 	{

 		if (xelection.isEmpty() ) xelection.unselect();

 		xelection.clear();

 		mapCenter->clear();

 		mapCenter->setMapEditor(this);

 		// (map state is set later at end of load...)

 	} else

 	{

 		BranchObj *bo=xelection.getBranch();

 		if (!bo) return aborted;

 		if (lmode==ImportAdd)

 			saveStateChangingPart(

 				bo,

 				bo,

 				QString("addMapInsert (%1)").arg(fname),

 				QString("Add map %1 to %2").arg(fname).arg(getName(bo)));

 		else	

 			saveStateChangingPart(

 				bo,

 				bo,

 				QString("addMapReplace(%1)").arg(fname),

 				QString("Add map %1 to %2").arg(fname).arg(getName(bo)));

 	}	

     mapBuilderHandler handler;

 	QFile file( fname );

 	// I am paranoid: file should exist anyway

 	// according to check in mainwindow.

 	if (!file.exists() )

 	{

 		QMessageBox::critical( 0, tr( "Critical Parse Error" ),

 				   tr("Couldn't open map " +fname)+".");

 		err=aborted;	

 	} else

 	{

 		bool blockSaveStateOrg=blockSaveState;

 		blockReposition=true;

 		blockSaveState=true;

 		QXmlInputSource source( file);

 		QXmlSimpleReader reader;

 		reader.setContentHandler( &handler );

 		reader.setErrorHandler( &handler );

 		handler.setMapEditor( this );

 		// We need to set the tmpDir in order  to load files with rel. path

 		QString tmpdir= fname.left(fname.findRev("/",-1));	

 		handler.setTmpDir (tmpdir);

 		handler.setInputFile (file.name());

 		handler.setLoadMode (lmode);

 		bool ok = reader.parse( source );

 		blockReposition=false;

 		blockSaveState=blockSaveStateOrg;

 		file.close();

 		if ( ok ) 

 		{

 			mapCenter->reposition();

 			xelection.update();

 			if (lmode==NewMap)

 			{

 				mapDefault=false;

 				mapChanged=false;

 				mapUnsaved=false;

 				autosaveTimer->stop();

 			}

 		} else 

 		{

 			QMessageBox::critical( 0, tr( "Critical Parse Error" ),

 					   tr( handler.errorProtocol() ) );

 			// returnCode=1;	

 			// Still return "success": the map maybe at least

 			// partially read by the parser

 		}	

 	}	

 	updateActions();

 	return err;

 }

 int MapEditor::save (const SaveMode &savemode)

 {

 	// Create mapName and fileDir

 	makeSubDirs (fileDir);

 	QString fname;

 	if (saveZipped())

 		// save as .xml

 		fname=mapName+".xml";

 	else

 		// use name given by user, even if he chooses .doc

 		fname=fileName;

 	QString saveFile;

 	if (savemode==CompleteMap || xelection.isEmpty())

 		saveFile=saveToDir (fileDir,mapName+"-",true,QPointF(),NULL);

 	else	

 	{

 		// TODO take care of multiselections

 		if (xelection.type()==Selection::FloatImage)

 			saveFloatImage();

 		else	

 			saveFile=saveToDir (fileDir,mapName+"-",true,QPointF(),xelection.getBranch());	

 		return 0;	

 	}	

 	if (!saveStringToDisk(fileDir+fname,saveFile))

 		return 1;

 	mapChanged=false;

 	mapUnsaved=false;

 	autosaveTimer->stop();

 	updateActions();

 	return 0;

 }

 void MapEditor::setZipped (bool z)

 {

 	zipped=z;

 }

 bool MapEditor::saveZipped ()

 {

 	return zipped;

 }

 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=mapCenter->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

 		xelection.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);

 			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

 		xelection.reselect();

 		// Save settings in vymrc

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

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

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

 	}

 }

 void MapEditor::setAntiAlias (bool b)

 {

 	setRenderHint(QPainter::Antialiasing,b);

 }

 void MapEditor::setSmoothPixmap(bool b)

 {

 	setRenderHint(QPainter::SmoothPixmapTransform,b);

 }

 QPixmap MapEditor::getPixmap()

 {

 	QRectF mapRect=mapCenter->getTotalBBox();

 	QPixmap pix((int)mapRect.width()+2,(int)mapRect.height()+2);

 	QPainter pp (&pix);

 	pp.setRenderHints(renderHints());

 	// Don't print the visualisation of selection

 	xelection.unselect();

 	mapScene->render (	&pp, 

 		QRectF(0,0,mapRect.width()+2,mapRect.height()+2),

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

 	// Restore selection

 	xelection.reselect();

 	return pix;

 }

 void MapEditor::setHideTmpMode (BranchObj::HideTmpMode mode)

 {

 	hidemode=mode;

 	mapCenter->setHideTmp (hidemode);

 	mapCenter->reposition();

 	scene()->update();

 }

 BranchObj::HideTmpMode MapEditor::getHideTmpMode()

 {

 	return hidemode;

 }

 void MapEditor::setExportMode (bool b)

 {

 	// should be called before and after exports

 	// depending on the settings

 	if (b && settings.value("/export/useHideExport","yes")=="yes")

 		setHideTmpMode (BranchObj::HideExport);

 	else	

 		setHideTmpMode (BranchObj::HideNone);

 }

 void MapEditor::exportASCII(QString fname,bool askName)

 {

 	ExportASCII ex;

 	ex.setMapCenter(mapCenter);

 	if (fname=="") 

 		ex.setFile (mapName+".txt");	

 	else

 		ex.setFile (fname);

 	if (askName)

 	{

 		//ex.addFilter ("TXT (*.txt)");

 		ex.setDir(lastImageDir);

 		//ex.setCaption(vymName+ " -" +tr("Export as ASCII")+" "+tr("(still experimental)"));

 		ex.execDialog() ; 

 	} 

 	if (!ex.canceled())

 	{

 		setExportMode(true);

 		ex.doExport();

 		setExportMode(false);

 	}

 }

 void MapEditor::exportImage(QString fname, bool askName, QString format)

 {

 	if (fname=="")

 	{

 		fname=mapName+".png";

 		format="PNG";

 	} 	

 	if (askName)

 	{

 		QStringList fl;

 		QFileDialog *fd=new QFileDialog (this);

 		fd->setCaption (tr("Export map as image"));

 		fd->setDirectory (lastImageDir);

 		fd->setFileMode(QFileDialog::AnyFile);

 		fd->setFilters  (imageIO.getFilters() );

 		if (fd->exec())

 		{

 			fl=fd->selectedFiles();

 			fname=fl.first();

 			format=imageIO.getType(fd->selectedFilter());

 		} 

 	}

 	setExportMode (true);

 	QPixmap pix (getPixmap());

 	pix.save(fname, format);

 	setExportMode (false);

 }

 void MapEditor::exportOOPresentation(const QString &fn, const QString &cf)

 {

 	ExportOO ex;

 	ex.setFile (fn);

 	ex.setMapCenter(mapCenter);

 	if (ex.setConfigFile(cf)) 

 	{

 		setExportMode (true);

 		ex.exportPresentation();

 		setExportMode (false);

 	}

 }

 void MapEditor::exportXHTML (const QString &dir, bool askForName)

 {

 			ExportXHTMLDialog dia(this);

 			dia.setFilePath (filePath );

 			dia.setMapName (mapName );

 			dia.readSettings();

 			if (dir!="") dia.setDir (dir);

 			bool ok=true;

 			if (askForName)

 			{

 				if (dia.exec()!=QDialog::Accepted) 

 					ok=false;

 				else	

 				{

 					QDir d (dia.getDir());

 					// Check, if warnings should be used before overwriting

 					// the output directory

 					if (d.exists() && d.count()>0)

 					{

 						WarningDialog warn;

 						warn.showCancelButton (true);

 						warn.setText(QString(

 							"The directory %1 is not empty.\n"

 							"Do you risk to overwrite some of its contents?").arg(d.path() ));

 						warn.setCaption("Warning: Directory not empty");

 						warn.setShowAgainName("mainwindow/overwrite-dir-xhtml");

 						if (warn.exec()!=QDialog::Accepted) ok=false;

 					}

 				}	

 			}

 			if (ok)

 			{

 				exportXML (dia.getDir(),false );

 				dia.doExport(mapName );

 				//if (dia.hasChanged()) setChanged();

 			}

 }

 void MapEditor::exportXML(QString dir, bool askForName)

 {

 	if (askForName)

 	{

 		dir=browseDirectory(this,tr("Export XML to directory"));

 		if (dir =="" && !reallyWriteDirectory(dir) )

 		return;

 	}

 	// Hide stuff during export, if settings want this

 	setExportMode (true);

 	// Create subdirectories

 	makeSubDirs (dir);

 	// write to directory

 	QString saveFile=saveToDir (dir,mapName+"-",true,mapCenter->getTotalBBox().topLeft() ,NULL);

 	QFile file;

 	file.setName ( dir + "/"+mapName+".xml");

 	if ( !file.open( QIODevice::WriteOnly ) )

 	{

 		// This should neverever happen

 		QMessageBox::critical (0,tr("Critical Export Error"),tr("MapEditor::exportXML couldn't open %1").arg(file.name()));

 		return;

 	}	

 	// Write it finally, and write in UTF8, no matter what 

 	QTextStream ts( &file );

 	ts.setEncoding (QTextStream::UnicodeUTF8);

 	ts << saveFile;

 	file.close();

 	// Now write image, too

 	exportImage (dir+"/images/"+mapName+".png",false,"PNG");

 	setExportMode (false);

 }

 void MapEditor::clear()

 {

 	xelection.unselect();

 	mapCenter->clear();

 }

 void MapEditor::copy()

 {

 	LinkableMapObj *sel=xelection.single();

 	if (sel)

 	{

 		if (redosAvail == 0)

 		{

 			// Copy to history

 			QString s=sel->getSelectString();

 			saveState (PartOfMap, s, "nop ()", s, "copy ()","Copy selection to clipboard",sel  );

 			curClipboard=curStep;

 		}

 		// Copy also to global clipboard, because we are at last step in history

 		QString bakMapName=QDir::convertSeparators (QString("history-%1").arg(curStep));

 		QString bakMapDir=QDir::convertSeparators (tmpMapDir +"/"+bakMapName);

 		copyDir (bakMapDir,clipboardDir );

 		clipboardEmpty=false;

 		updateActions();

 	}	    

 }

 void MapEditor::redo()

 {

 	// Can we undo at all?

 	if (redosAvail<1) return;

 	bool blockSaveStateOrg=blockSaveState;

 	blockSaveState=true;

 	redosAvail--;

 	if (undosAvail<stepsTotal) undosAvail++;

 	curStep++;

 	if (curStep>stepsTotal) curStep=1;

 	QString undoCommand=  undoSet.readEntry (QString("/history/step-%1/undoCommand").arg(curStep));

 	QString undoSelection=undoSet.readEntry (QString("/history/step-%1/undoSelection").arg(curStep));

 	QString redoCommand=  undoSet.readEntry (QString("/history/step-%1/redoCommand").arg(curStep));

 	QString redoSelection=undoSet.readEntry (QString("/history/step-%1/redoSelection").arg(curStep));

 	QString comment=undoSet.readEntry (QString("/history/step-%1/comment").arg(curStep));

 	QString version=undoSet.readEntry ("/history/version");

 	if (!checkVersion(version))

 		QMessageBox::warning(0,tr("Warning"),

 			tr("Version %1 of saved undo/redo data\ndoes not match current vym version %2.").arg(version).arg(vymVersion));

 	// Find out current undo directory

 	QString bakMapDir=QDir::convertSeparators (QString(tmpMapDir+"/undo-%1").arg(curStep));

 	if (debug)

 	{

 		cout << "ME::redo() begin\n";

 		cout << "    undosAvail="<<undosAvail<<endl;

 		cout << "    redosAvail="<<redosAvail<<endl;

 		cout << "       curStep="<<curStep<<endl;

 		cout << "    ---------------------------"<<endl;

 		cout << "    comment="<<comment.toStdString()<<endl;

 		cout << "    undoCom="<<undoCommand.toStdString()<<endl;

 		cout << "    undoSel="<<undoSelection.toStdString()<<endl;

 		cout << "    redoCom="<<redoCommand.toStdString()<<endl;

 		cout << "    redoSel="<<redoSelection.toStdString()<<endl;

 		cout << "    ---------------------------"<<endl<<endl;

 	}

 	// select  object before redo

 	if (!redoSelection.isEmpty())

 		select (redoSelection);

 	parseAtom (redoCommand);

 	mapCenter->reposition();

 	blockSaveState=blockSaveStateOrg;

 	undoSet.setEntry ("/history/undosAvail",QString::number(undosAvail));

 	undoSet.setEntry ("/history/redosAvail",QString::number(redosAvail));

 	undoSet.setEntry ("/history/curStep",QString::number(curStep));

 	undoSet.writeSettings(histPath);

 	mainWindow->updateHistory (undoSet);

 	updateActions();

 	/* TODO remove testing

 	cout << "ME::redo() end\n";

 	cout << "    undosAvail="<<undosAvail<<endl;

 	cout << "    redosAvail="<<redosAvail<<endl;

 	cout << "       curStep="<<curStep<<endl;

 	cout << "    ---------------------------"<<endl<<endl;

 	*/

 }

 bool MapEditor::isRedoAvailable()

 {

 	if (undoSet.readNumEntry("/history/redosAvail",0)>0)

 		return true;

 	else	

 		return false;

 }

 void MapEditor::undo()

 {

 	// Can we undo at all?

 	if (undosAvail<1) return;

 	mainWindow->statusMessage (tr("Autosave disabled during undo."));

 	bool blockSaveStateOrg=blockSaveState;

 	blockSaveState=true;

 	QString undoCommand=  undoSet.readEntry (QString("/history/step-%1/undoCommand").arg(curStep));

 	QString undoSelection=undoSet.readEntry (QString("/history/step-%1/undoSelection").arg(curStep));

 	QString redoCommand=  undoSet.readEntry (QString("/history/step-%1/redoCommand").arg(curStep));

 	QString redoSelection=undoSet.readEntry (QString("/history/step-%1/redoSelection").arg(curStep));

 	QString comment=undoSet.readEntry (QString("/history/step-%1/comment").arg(curStep));

 	QString version=undoSet.readEntry ("/history/version");

 	if (!checkVersion(version))

 		QMessageBox::warning(0,tr("Warning"),

 			tr("Version %1 of saved undo/redo data\ndoes not match current vym version %2.").arg(version).arg(vymVersion));

 	// Find out current undo directory

 	QString bakMapDir=QDir::convertSeparators (QString(tmpMapDir+"/undo-%1").arg(curStep));

 	// select  object before undo

 	if (!undoSelection.isEmpty())

 		select (undoSelection);

 	if (debug)

 	{

 		cout << "ME::undo() begin\n";

 		cout << "    undosAvail="<<undosAvail<<endl;

 		cout << "    redosAvail="<<redosAvail<<endl;

 		cout << "       curStep="<<curStep<<endl;

 		cout << "    ---------------------------"<<endl;

 		cout << "    comment="<<comment.toStdString()<<endl;

 		cout << "    undoCom="<<undoCommand.toStdString()<<endl;

 		cout << "    undoSel="<<undoSelection.toStdString()<<endl;

 		cout << "    redoCom="<<redoCommand.toStdString()<<endl;

 		cout << "    redoSel="<<redoSelection.toStdString()<<endl;

 		cout << "    ---------------------------"<<endl<<endl;

 	}	

 	parseAtom (undoCommand);

 	mapCenter->reposition();

 	undosAvail--;

 	curStep--; 

 	if (curStep<1) curStep=stepsTotal;

 	redosAvail++;

 	blockSaveState=blockSaveStateOrg;

 /* TODO remove testing

 	cout << "ME::undo() end\n";

 	cout << "    undosAvail="<<undosAvail<<endl;

 	cout << "    redosAvail="<<redosAvail<<endl;

 	cout << "       curStep="<<curStep<<endl;

 	cout << "    ---------------------------"<<endl<<endl;

 */

 	undoSet.setEntry ("/history/undosAvail",QString::number(undosAvail));

 	undoSet.setEntry ("/history/redosAvail",QString::number(redosAvail));

 	undoSet.setEntry ("/history/curStep",QString::number(curStep));

 	undoSet.writeSettings(histPath);

 	mainWindow->updateHistory (undoSet);

 	updateActions();

 	xelection.update();

 	ensureSelectionVisible();

 }

 bool MapEditor::isUndoAvailable()

 {

 	if (undoSet.readNumEntry("/history/undosAvail",0)>0)

 		return true;

 	else	

 		return false;

 }

 void MapEditor::gotoHistoryStep (int i)

 {

 	// Restore variables

 	int undosAvail=undoSet.readNumEntry (QString("/history/undosAvail"));

 	int redosAvail=undoSet.readNumEntry (QString("/history/redosAvail"));

 	if (i<0) i=undosAvail+redosAvail;

 	// Clicking above current step makes us undo things

 	if (i<undosAvail) 

 	{	

 		for (int j=0; j<undosAvail-i; j++) undo();

 		return;

 	}	

 	// Clicking below current step makes us redo things

 	if (i>undosAvail) 

 		for (int j=undosAvail; j<i; j++) 

 		{

 		cout << "redo "<<j<<"/"<<undosAvail<<" i="<<i<<endl;

 		redo();

 		}

 	// And ignore clicking the current row ;-)	

 }

 void MapEditor::addMapReplaceInt(const QString &undoSel, const QString &path)

 {

 	QString pathDir=path.left(path.findRev("/"));

 	QDir d(pathDir);

 	QFile file (path);

 	if (d.exists() )

 	{

 		// We need to parse saved XML data

 		mapBuilderHandler handler;

 		QXmlInputSource source( file);

 		QXmlSimpleReader reader;

 		reader.setContentHandler( &handler );

 		reader.setErrorHandler( &handler );

 		handler.setMapEditor( this );

 		handler.setTmpDir ( pathDir );	// needed to load files with rel. path

 		if (undoSel.isEmpty())

 		{

 			unselect();

 			mapCenter->clear();

 			handler.setLoadMode (NewMap);

 		} else	

 		{

 			select (undoSel);

 			handler.setLoadMode (ImportReplace);

 		}	

 		blockReposition=true;

 		bool ok = reader.parse( source );

 		blockReposition=false;

 		if (! ok ) 

 		{	

 			// This should never ever happen

 			QMessageBox::critical( 0, tr( "Critical Parse Error while reading %1").arg(path),

 								    handler.errorProtocol());

 		}

 	} else	

 		QMessageBox::critical( 0, tr( "Critical Error" ), tr("Could not read %1").arg(path));

 }

 void MapEditor::addMapInsertInt (const QString &path, int pos)

 {

 	BranchObj *sel=xelection.getBranch();

 	if (sel);

 	{

 		QString pathDir=path.left(path.findRev("/"));

 		QDir d(pathDir);

 		QFile file (path);

 		if (d.exists() )

 		{

 			// We need to parse saved XML data

 			mapBuilderHandler handler;

 			QXmlInputSource source( file);

 			QXmlSimpleReader reader;

 			reader.setContentHandler( &handler );

 			reader.setErrorHandler( &handler );

 			handler.setMapEditor( this );

 			handler.setTmpDir ( pathDir );	// needed to load files with rel. path

 			handler.setLoadMode (ImportAdd);

 			blockReposition=true;

 			bool ok = reader.parse( source );

 			blockReposition=false;

 			if (! ok ) 

 			{	

 				// This should never ever happen

 				QMessageBox::critical( 0, tr( "Critical Parse Error while reading %1").arg(path),

 										handler.errorProtocol());

 			}

 			if (sel!=mapCenter)

 				sel->getLastBranch()->linkTo (sel,pos);

 		} else	

 			QMessageBox::critical( 0, tr( "Critical Error" ), tr("Could not read %1").arg(path));

 	}		

 }

 void MapEditor::pasteNoSave(const int &n)

 {

 	bool old=blockSaveState;

 	blockSaveState=true;

 	if (redosAvail > 0 || n!=0)

 	{

 		// Use the "historical" buffer

 		QString bakMapName=QDir::convertSeparators (QString("history-%1").arg(n));

 		QString bakMapDir=QDir::convertSeparators (tmpMapDir +"/"+bakMapName);

 		load (bakMapDir+"/"+clipboardFile,ImportAdd);

 	} else

 		// Use the global buffer

 		load (clipboardDir+"/"+clipboardFile,ImportAdd);

 	blockSaveState=old;

 }

 void MapEditor::paste()		

 {   

 	BranchObj *sel=xelection.getBranch();

 	if (sel)

 	{

 		saveStateChangingPart(

 			sel,

 			sel,

 			QString ("paste (%1)").arg(curClipboard),

 			QString("Paste to %1").arg( getName(sel))

 		);

 		pasteNoSave(0);

 		mapCenter->reposition();

 	}

 }

 void MapEditor::cut()

 {

 	LinkableMapObj *sel=xelection.single();

 	if ( sel && (xelection.type() == Selection::Branch ||

 		xelection.type()==Selection::MapCenter ||

 		xelection.type()==Selection::FloatImage))

 	{

 	/* No savestate! savestate is called in cutNoSave

 		saveStateChangingPart(

 			sel->getParObj(),

 			sel,

 			"cut ()",

 			QString("Cut %1").arg(getName(sel ))

 		);

 	*/	

 		copy();

 		deleteSelection();

 		mapCenter->reposition();

 	}

 }

 void MapEditor::move(const int &x, const int &y)

 {

 	LinkableMapObj *sel=xelection.single();

 	if (sel)

 	{

 		QString ps=qpointfToString (sel->getAbsPos());

 		QString s=xelection.single()->getSelectString();

 		saveState(

 			s, "move "+ps, 

 			s, "move "+qpointfToString (QPointF (x,y)), 

 			QString("Move %1 to  %2").arg(getName(sel)).arg(ps));

 		sel->move(x,y);

 		mapCenter->reposition();

 		xelection.update();

 	}

 }

 void MapEditor::moveRel (const int &x, const int &y)

 {

 	LinkableMapObj *sel=xelection.single();

 	if (sel)

 	{

 		QString ps=qpointfToString (sel->getRelPos());

 		QString s=sel->getSelectString();

 		saveState(

 			s, "moveRel "+ps, 

 			s, "moveRel "+qpointfToString (QPointF (x,y)), 

 			QString("Move %1 to relativ position %2").arg(getName(sel)).arg(ps));

 		((OrnamentedObj*)sel)->move2RelPos (x,y);

 		mapCenter->reposition();

 		sel->updateLink();

 		xelection.update();

 	}

 }

 void MapEditor::moveBranchUp()

 {

 	BranchObj* bo=xelection.getBranch();

 	BranchObj* par;

 	if (bo)

 	{

 		if (!bo->canMoveBranchUp()) return;

 		par=(BranchObj*)(bo->getParObj());

 		BranchObj *obo=par->moveBranchUp (bo);	// bo will be the one below selection

 		saveState (bo->getSelectString(),"moveBranchDown ()",obo->getSelectString(),"moveBranchUp ()",QString("Move up %1").arg(getName(bo)));

 		mapCenter->reposition();

 		scene()->update();

 		xelection.update();

 		ensureSelectionVisible();

 	}

 }

 void MapEditor::moveBranchDown()

 {

 	BranchObj* bo=xelection.getBranch();

 	BranchObj* par;

 	if (bo)

 	{

 		if (!bo->canMoveBranchDown()) return;

 		par=(BranchObj*)(bo->getParObj());

 		BranchObj *obo=par->moveBranchDown(bo);	// bo will be the one above selection

 		saveState(bo->getSelectString(),"moveBranchUp ()",obo->getSelectString(),"moveBranchDown ()",QString("Move down %1").arg(getName(bo)));

 		mapCenter->reposition();

 		scene()->update();

 		xelection.update();

 		ensureSelectionVisible();

 	}	

 }

 void MapEditor::linkTo(const QString &dstString)	

 {

 	FloatImageObj *fio=xelection.getFloatImage();

 	if (fio)

 	{

 		BranchObj *dst=(BranchObj*)(mapCenter->findObjBySelect(dstString));

 		if (dst && (typeid(*dst)==typeid (BranchObj) || 

 					typeid(*dst)==typeid (MapCenterObj)))

 		{			

 			LinkableMapObj *dstPar=dst->getParObj();

 			QString parString=dstPar->getSelectString();

 			QString fioPreSelectString=fio->getSelectString();

 			QString fioPreParentSelectString=fio->getParObj()->getSelectString();

 			((BranchObj*)(dst))->addFloatImage (fio);

 			xelection.unselect();

 			((BranchObj*)(fio->getParObj()))->removeFloatImage (fio);

 			fio=((BranchObj*)(dst))->getLastFloatImage();

 			fio->setRelPos();

 			fio->reposition();

 			xelection.select(fio);

 			saveState(

 				fio->getSelectString(),

 				QString("linkTo (\"%1\")").arg(fioPreParentSelectString), 

 				fioPreSelectString, 

 				QString ("linkTo (\"%1\")").arg(dstString),

 				QString ("Link floatimage to %1").arg(getName(dst)));

 		}

 	}

 }

 QString MapEditor::getHeading(bool &ok, QPoint &p)

 {

 	BranchObj *bo=xelection.getBranch();

 	if (bo)

 	{

 		ok=true;

 		p=mapFromScene(bo->getAbsPos());

 		return bo->getHeading();

 	}

 	ok=false;

 	return QString();

 }

 void MapEditor::setHeading(const QString &s)

 {

 	BranchObj *sel=xelection.getBranch();

 	if (sel)

 	{

 		saveState(

 			sel,

 			"setHeading (\""+sel->getHeading()+"\")", 

 			sel,

 			"setHeading (\""+s+"\")", 

 			QString("Set heading of %1 to \"%2\"").arg(getName(sel)).arg(s) );

 		sel->setHeading(s );

 		mapCenter->reposition();

 		xelection.update();

 		ensureSelectionVisible();

 	}

 }

 void MapEditor::setHeadingInt(const QString &s)

 {

 	BranchObj *bo=xelection.getBranch();

 	if (bo)

 	{

 		bo->setHeading(s);

 		mapCenter->reposition();

 		xelection.update();

 		ensureSelectionVisible();

 	}

 }

 void MapEditor::setVymLinkInt (const QString &s)

 {

 	// Internal function, no saveState needed

 	BranchObj *bo=xelection.getBranch();

 	if (bo)

 	{

 		bo->setVymLink(s);

 		mapCenter->reposition();

 		updateActions();

 		xelection.update();

 		ensureSelectionVisible();

 	}

 }

 BranchObj* MapEditor::addNewBranchInt(int num)

 {

 	// Depending on pos:

 	// -3		insert in childs of parent  above selection 

 	// -2		add branch to selection 

 	// -1		insert in childs of parent below selection 

 	// 0..n		insert in childs of parent at pos

 	BranchObj *newbo=NULL;

 	BranchObj *bo=xelection.getBranch();

 	if (bo)

 	{

 		if (num==-2)

 		{

 			// save scroll state. If scrolled, automatically select

 			// new branch in order to tmp unscroll parent...

 			return bo->addBranch();

 		}else if (num==-1)

 		{

 			num=bo->getNum()+1;

 			bo=(BranchObj*)bo->getParObj();

 		}else if (num==-3)

 		{

 			num=bo->getNum();

 			bo=(BranchObj*)bo->getParObj();

 		}

 		if (!bo) return bo;

 		newbo=bo->insertBranch(num);

 	}	

 	return newbo;

 }	

 BranchObj* MapEditor::addNewBranch(int pos)

 {

 	// Different meaning than num in addNewBranchInt!

 	// -1	add above

 	//  0	add as child

 	// +1	add below

 	BranchObj *bo = xelection.getBranch();

 	BranchObj *newbo=NULL;

 	if (bo)

 	{

 		setCursor (Qt::ArrowCursor);

 		newbo=addNewBranchInt (pos-2);

 		if (newbo)

 		{

 			saveState(

 				newbo,		

 				"delete ()",

 				bo,

 				QString ("addBranch (%1)").arg(pos-2),

 				QString ("Add new branch to %1").arg(getName(bo)));	

 			mapCenter->reposition();

 			// In Network mode, the client needs to know where the new branch is,

 			// so we have to pass on this information via saveState.

 			// TODO: Get rid of this positioning workaround

 			QString ps=qpointfToString (newbo->getAbsPos());

 			saveState(

 				newbo, "move "+ps, 

 				newbo, "move "+ps, 

 				QString("Move %1 to  %2").arg(getName(newbo)).arg(ps));

 			xelection.update();

 		}

 	}	

 	return newbo;

 }

 BranchObj* MapEditor::addNewBranchBefore()

 {

 	BranchObj *newbo=NULL;

 	BranchObj *bo = xelection.getBranch();

 	if (bo && xelection.type()==Selection::Branch)

 		 // We accept no MapCenterObj here, so we _have_ a parent

 	{

 		QPointF p=bo->getRelPos();

 		BranchObj *parbo=(BranchObj*)(bo->getParObj());

 		// add below selection

 		newbo=parbo->insertBranch(bo->getNum()+1);

 		if (newbo)

 		{

 			newbo->move2RelPos (p);

 			// Move selection to new branch

 			bo->linkTo (newbo,-1);

 			saveState (newbo, "deleteKeepChilds ()", newbo, "addBranchBefore ()", 

 				QString ("Add branch before %1").arg(getName(bo)));

 			mapCenter->reposition();

 			xelection.update();

 		}

 	}	

 	return newbo;

 }

 void MapEditor::deleteSelection()

 {

 	BranchObj *bo = xelection.getBranch();

 	if (bo && xelection.type()==Selection::Branch)

 	{

 		BranchObj* par=(BranchObj*)(bo->getParObj());

 		xelection.unselect();

 		saveStateRemovingPart (bo, QString ("Delete %1").arg(getName(bo)));

 		par->removeBranch(bo);

 		xelection.select (par);

 		ensureSelectionVisible();

 		mapCenter->reposition();

 		xelection.update();

 		xelection.update();

 		return;

 	}

 	FloatImageObj *fio=xelection.getFloatImage();

 	if (fio)

 	{

 		BranchObj* par=(BranchObj*)(fio->getParObj());

 		saveStateChangingPart(

 			par, 

 			fio,

 			"delete ()",

 			QString("Delete %1").arg(getName(fio))

 		);

 		xelection.unselect();

 		par->removeFloatImage(fio);

 		xelection.select (par);

 		mapCenter->reposition();

 		xelection.update();

 		ensureSelectionVisible();

 		return;

 	}

 }

 LinkableMapObj* MapEditor::getSelection()

 {

 	return xelection.single();

 }

 BranchObj* MapEditor::getSelectedBranch()

 {

 	return xelection.getBranch();

 }

 FloatImageObj* MapEditor::getSelectedFloatImage()

 {

 	return xelection.getFloatImage();

 }

 void MapEditor::unselect()

 {

 	xelection.unselect();

 }	

 void MapEditor::reselect()

 {

 	xelection.reselect();

 }	

 bool MapEditor::select (const QString &s)

 {

 	LinkableMapObj *lmo=mapCenter->findObjBySelect(s);

 	// Finally select the found object

 	if (lmo)

 	{

 		xelection.unselect();

 		xelection.select(lmo);

 		xelection.update();

 		ensureSelectionVisible();

 		sendSelection ();

 		return true;

 	} 

 	return false;

 }

 QString MapEditor::getSelectString()

 {

 	return xelection.getSelectString();

 }

 void MapEditor::selectInt (LinkableMapObj *lmo)

 {

 	if (lmo && xelection.single()!= lmo && isSelectBlocked()==false )

 	{

 		xelection.select(lmo);

 		xelection.update();

 		sendSelection ();

 	}	

 }

 void MapEditor::selectNextBranchInt()

 {

 	// Increase number of branch

 	LinkableMapObj *sel=xelection.single();

 	if (sel)

 	{

 		QString s=sel->getSelectString();

 		QString part;

 		QString typ;

 		QString num;

 		// Where am I? 

 		part=s.section(",",-1);

 		typ=part.left (3);

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

 		s=s.left (s.length() -num.length());

 		// Go to next lmo

 		num=QString ("%1").arg(num.toUInt()+1);

 		s=s+num;

 		// Try to select this one

 		if (select (s)) return;

 		// We have no direct successor, 

 		// try to increase the parental number in order to

 		// find a successor with same depth

 		int d=xelection.single()->getDepth();

 		int oldDepth=d;

 		int i;

 		bool found=false;

 		bool b;

 		while (!found && d>0)

 		{

 			s=s.section (",",0,d-1);

 			// replace substring of current depth in s with "1"

 			part=s.section(",",-1);

 			typ=part.left (3);

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

 			if (d>1)

 			{	

 				// increase number of parent

 				num=QString ("%1").arg(num.toUInt()+1);

 				s=s.section (",",0,d-2) + ","+ typ+num;

 			} else

 			{

 				// Special case, look at orientation

 				if (xelection.single()->getOrientation()==LinkableMapObj::RightOfCenter)

 					num=QString ("%1").arg(num.toUInt()+1);

 				else	

 					num=QString ("%1").arg(num.toUInt()-1);

 				s=typ+num;

 			}	

 			if (select (s))

 				// pad to oldDepth, select the first branch for each depth

 				for (i=d;i<oldDepth;i++)

 				{

 					b=select (s);