#include "mapeditor.h"

 #include <q3filedialog.h>

 #include <iostream>

 #include <cstdlib>

 #include <typeinfo>

 #include "version.h"

 #include "api.h"

 #include "editxlinkdialog.h"

 #include "exports.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 bool clipboardEmpty;

 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;

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

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

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

 MapEditor::MapEditor(

 	QWidget* parent, const char* name, Qt::WFlags f) :

   Q3CanvasView(parent,name,f), urlOperator(0), imageBuffer(0)

 {

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

 	mapNum++;

     viewport()->setAcceptDrops(true);

     mapCanvas = new Q3Canvas(width(),height());

 	mapCanvas->setAdvancePeriod(30);

 	mapCanvas->setBackgroundColor (Qt::white);

     setCanvas (mapCanvas);

 	// Always show scroll bars (automatic would flicker sometimes)

 	setVScrollBarMode ( Q3ScrollView::AlwaysOn );

 	setHScrollBarMode ( Q3ScrollView::AlwaysOn );

     mapCenter = new MapCenterObj(mapCanvas);

     mapCenter->setVisibility (true);

 	mapCenter->setMapEditor (this);

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

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

     printer=NULL;

 	defLinkColor=QColor (0,0,255);

 	defXLinkColor=QColor (180,180,180);

 	linkcolorhint=DefaultColor;

 	linkstyle=StylePolyParabel;

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

     selection=NULL;

     selectionLast=NULL;

     movingObj=NULL;

 	xelection.setMapCenter (mapCenter);

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

 	// Initialize find routine

 	itFind=NULL;				

 	EOFind=false;

 	printFrame=true;

 	printFooter=true;

 	blockReposition=false;

 	blockSaveState=false;

 	hidemode=HideNone;

 	// Create temporary files

 	makeTmpDirs();

 	// Initially set movingCentre

 	updateViewCenter();

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

 }

 MapEditor::~MapEditor()

 {

   if (imageBuffer) delete imageBuffer;

   if (urlOperator) {

     urlOperator->stop();

     delete urlOperator;

   }

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

 }

 MapCenterObj* MapEditor::getMapCenter()

 {

     return mapCenter;

 }

 Q3Canvas* MapEditor::getCanvas()

 {

     return mapCanvas;

 }

 void MapEditor::adjustCanvasSize()

 {

 	// To adjust the canvas to map, viewport size and position, we have to

 	// do some coordinate magic...

 	//

 	// Get rectangle of (scroll-)view. 

 	// We want to be in canvas coords, so

 	// we map. Important if view is zoomed...

 	QRect view = inverseWorldMatrix().mapRect( QRect( contentsX(), contentsY(),

 												visibleWidth(), visibleHeight()) );	

 	// Now we need the bounding box of view AND map to calc the correct canvas size.

 	// Why? Because if the map itself is moved out of view, the view has to be enlarged

 	// to avoid jumping aroung...

 	QRect map=mapCenter->getTotalBBox();

 	// right edge - left edge

 	int cw= max(map.x() + map.width(),  view.x() + view.width())  - min(map.x(), view.x());

 	int ch= max(map.y() + map.height(), view.y() + view.height()) - min(map.y(), view.y());

 	if ( (cw!=mapCanvas->width()) || (ch!=mapCanvas->height()) ||

 		!mapCanvas->onCanvas (map.topLeft()) || !mapCanvas->onCanvas (map.bottomRight())

 	)	

 	{	

 		// move the map on canvas (in order to not move it on screen) this is neccessary

 		// a) if topleft corner of canvas is left or above topleft corner of view and also left of

 		//    above topleft corner of map. E.g. if map is completly inside view, but it would be possible 

 		//    to scroll to an empty area of canvas to the left.

 		// b) if topleft corner of map left of or above topleft of canvas

 		int dx=0;

 		int dy=0;

 		if (cw > mapCanvas->width() )

 		{

 			if (map.x()<0) dx=-map.x();	

 		}

 		if (cw <  mapCanvas->width() )

 			dx=-min (view.x(),map.x());

 		if (ch > mapCanvas->height() )

 		{

 			if (map.y()<0) dy=-map.y();	

 		}

 		if (ch <  mapCanvas->height() )

 		{

 			dy=-min (view.y(),map.y());

 		}

 		// We really have to resize now. Let's go...

 		mapCanvas->resize (cw,ch);

 		if ( (dx!=0) || (dy!=0) ) 

 		{

 			mapCenter->moveAllBy(dx,dy);

 			mapCenter->reposition();

 //			mapCenter->positionBBox();	// To move float

 			// scroll the view (in order to not move map on screen)

 			scrollBy (dx,dy);

 		}	

 	}

 }

 bool MapEditor::isRepositionBlocked()

 {

 	return blockReposition;

 }

 QString MapEditor::getName (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 QPoint &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 canvas. 

 	//				Needed for XML export

 	// Save Header

 	QString ls;

 	switch (linkstyle)

 	{

 		case StyleLine: 

 			ls="StyleLine";

 			break;

 		case StyleParabel:

 			ls="StyleParabel";

 			break;

 		case StylePolyLine:	

 			ls="StylePolyLine";

 			break;

 		default:

 			ls="StylePolyParabel";

 			break;

 	}	

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

 	QString colhint="";

 	if (linkcolorhint==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", mapCanvas->backgroundColor().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 (mapCanvas).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);

 		else if (selection && typeid(*selection)==typeid(BranchObj))

 			// Save selected branch is saved from mainwindow		//FIXME maybe use "subtree" above?

 			// FIXME is this possible at all? BO is already above...

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

 	}

 	// Save local settings

 	s+=settings.getXMLData (destPath);

 	// Save selection

 	if (selection && !saveSel ) 

 		s+=valueElement("select",selection->getSelectString());

 	decIndent();

 	s+=endElement("vymmap");

 	if (writeflags)

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

 	return s;

 }

 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::saveState(const SaveMode &savemode, const QString &undoSelection, const QString &undoCom, const QString &redoSelection, const QString &redoCom, const QString &comment, LinkableMapObj *saveSel)

 {

 	// Main saveState

 	if (blockSaveState) return;

 	/* TODO remove after testing

 	*/

 	cout << "ME::saveState()  "<<endl;

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

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

 	int curStep=undoSet.readNumEntry ("/history/curStep",0);

 	// Find out current undo directory

 	if (undosAvail<stepsTotal) undosAvail++;

 	curStep++;

 	if (curStep>stepsTotal) curStep=1;

 	QString backupXML="";

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

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

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

 	// Create bakMapDir if not available

 	QDir d(bakMapDir);

 	if (!d.exists()) 

 		makeSubDirs (bakMapDir);

 	// Save depending on how much needs to be saved	

 	if (saveSel)

 		backupXML=saveToDir (bakMapDir,mapName+"-",false, QPoint (),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);

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

 	setChanged();

 	mainWindow->updateHistory (undoSet);

 	updateActions();

 }

 void MapEditor::parseAtom(const QString &atom)

 {

 	API api;

 	QString s,t;

 	int x,y;

 	bool b,ok;

 	// Split string s into command and parameters

 	api.parseInput (atom);

 	QString com=api.command();

 	// External commands

 	if (com=="addBranch")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else 

 		{	

 			QList <int> pl;

 			pl << 0 <<1;

 			if (api.checkParamCount(pl))

 			{

 				if (api.paramCount()==0)

 					addNewBranchInt (-2);

 				else

 				{

 					y=api.parInt (ok,0);

 					if (ok ) addNewBranchInt (y);

 				}

 			}

 		}

 	} else if (com=="addBranchBefore")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else 

 		{	

 			if (api.paramCount()==0)

 			{

 				addNewBranchBefore ();

 			}	

 		}

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

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else if (api.checkParamCount(1))

 		{

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

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

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

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

 		}

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

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else 

 		{	

 			if (api.checkParamCount(2))

 			{

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

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

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

 				addMapInsertInt(t,y);	

 			}

 		}

 	} else if (com=="colorItem")

 	{

 		if (!selection)

 		{

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

 		} else if ( typeid(*selection) != typeid(BranchObj) && 

 					typeid(*selection) != typeid(MapCenterObj))

 		{				  

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

 		} else if (api.checkParamCount(1))

 		{	

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

 			if (ok) colorItem (c);

 		}	

 	} else if (com=="colorBranch")

 	{

 		if (!selection)

 		{

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

 		} else if ( typeid(*selection) != typeid(BranchObj) && 

 					typeid(*selection) != typeid(MapCenterObj))

 		{				  

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

 		} else if (api.checkParamCount(1))

 		{	

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

 			if (ok) colorBranch (c);

 		}	

 	} else if (com=="cut")

 	{

 		if (!selection)

 		{

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

 		} else if ( typeid(*selection) != typeid(BranchObj) && 

 					typeid(*selection) != typeid(MapCenterObj) &&

 					typeid(*selection) != typeid(FloatImageObj) )

 		{				  

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

 		} else if (api.checkParamCount(0))

 		{	

 			cut();

 		}	

 	} else if (com=="delete")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else if (api.checkParamCount(0))

 		{	

 			deleteSelection();

 		}	

 	} else if (com=="deleteKeepChilds")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else if (api.checkParamCount(0))

 		{	

 			deleteKeepChilds();

 		}	

 	} else if (com=="deleteChilds")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else if (api.checkParamCount(0))

 		{	

 			deleteChilds();

 		}	

 	} else if (com=="linkBranchToPos")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else if (api.checkParamCount(4))

 		{

 			// 0	selectstring of parent

 			// 1	num in parent (for branches)

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

 			s=api.parString(ok,0);

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

 			if (dst)

 			{	

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

 				{

 					// Get number in parent

 					x=api.parInt (ok,1);

 					if (ok)

 						((BranchObj*)selection)->moveBranchTo ((BranchObj*)(dst),x);

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

 				{

 					((BranchObj*)selection)->moveBranchTo ((BranchObj*)(dst),-1);

 					// Get coordinates of mainbranch

 					x=api.parInt (ok,2);

 					if (ok)

 					{

 						y=api.parInt (ok,3);

 						if (ok) ((BranchObj*)selection)->move (x,y);

 					}

 				}	

 			}	

 		}

 	} else if (com=="moveBranchUp")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else if (api.checkParamCount(0))

 		{

 			moveBranchUp();

 		}	

 	} else if (com=="moveBranchDown")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else if (api.checkParamCount(0))

 		{

 			moveBranchDown();

 		}	

 	} else if (com=="move")

 	{

 		if (!selection)

 		{

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

 		} else if ( typeid(*selection) != typeid(BranchObj) && 

 					typeid(*selection) != typeid(MapCenterObj) &&

 					typeid(*selection) != typeid(FloatImageObj) )

 		{				  

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

 		} else if (api.checkParamCount(2))

 		{	

 			x=api.parInt (ok,0);

 			if (ok)

 			{

 				y=api.parInt (ok,1);

 				if (ok) move (x,y);

 			}

 		}	

 	} else if (com=="moveRel")

 	{

 		if (!selection)

 		{

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

 		} else if ( typeid(*selection) != typeid(BranchObj) && 

 					typeid(*selection) != typeid(MapCenterObj) &&

 					typeid(*selection) != typeid(FloatImageObj) )

 		{				  

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

 		} else if (api.checkParamCount(2))

 		{	

 			x=api.parInt (ok,0);

 			if (ok)

 			{

 				y=api.parInt (ok,1);

 				if (ok) moveRel (x,y);

 			}

 		}	

 	} else if (com=="paste")

 	{

 		if (!selection)

 		{

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

 		} else if ( typeid(*selection) != typeid(BranchObj) && 

 					typeid(*selection) != typeid(MapCenterObj) )

 		{				  

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

 		} else if (api.checkParamCount(0))

 		{	

 			paste();

 		}	

 	} else if (com=="select")

 	{

 		if (api.checkParamCount(1))

 		{

 			s=api.parString(ok,0);

 			if (ok) select (s);

 		}	

 	} else if (com=="setMapAuthor")

 	{

 		if (api.checkParamCount(1))

 		{

 			s=api.parString(ok,0);

 			if (ok) setMapAuthor (s);

 		}	

 	} else if (com=="setMapComment")

 	{

 		if (api.checkParamCount(1))

 		{

 			s=api.parString(ok,0);

 			if (ok) setMapComment(s);

 		}	

 	} else if (com=="setMapBackgroundColor")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else if (api.checkParamCount(1))

 		{

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

 			if (ok) setMapBackgroundColor (c);

 		}	

 	} else if (com=="setMapDefLinkColor")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else if (api.checkParamCount(1))

 		{

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

 			if (ok) setMapDefLinkColor (c);

 		}	

 	} else if (com=="setMapLinkStyle")

 	{

 		if (api.checkParamCount(1))

 		{

 			s=api.parString (ok,0);

 			if (ok) setMapLinkStyle(s);

 		}	

 	} else if (com=="setHeading")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else if (api.checkParamCount(1))

 		{

 			s=api.parString (ok,0);

 			if (ok) 

 				setHeading (s);

 		}	

 	} else if (com=="setHideExport")

 	{

 		if (!selection)

 		{

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

 		} else if ( typeid(*selection) != typeid(BranchObj) && 

 					typeid(*selection) != typeid(FloatImageObj) )

 		{				  

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

 		} else if (api.checkParamCount(1))

 		{

 			b=api.parBool(ok,0);

 			if (ok) setHideExport (b);

 		}

 	} else if (com=="setURL")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else if (api.checkParamCount(1))

 		{

 			s=api.parString (ok,0);

 			if (ok) setURLInt(s);

 		}	

 	} else if (com=="setVymLink")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else if (api.checkParamCount(1))

 		{

 			s=api.parString (ok,0);

 			if (ok) setVymLinkInt(s);

 		}	

 	}

 	else if (com=="setFlag")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else if (api.checkParamCount(1))

 		{

 			s=api.parString(ok,0);

 			if (ok) 

 			{

 				BranchObj* bo=(BranchObj*)selection;

 				bo->activateStandardFlag(s);

 				bo->updateFlagsToolbar();

 			}	

 		}

 	}	

 	else if (com=="unsetFlag")

 	{

 		if (!selection)

 		{

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

 		} else if ( (typeid(*selection) != typeid(BranchObj) && 

 					 typeid(*selection) != typeid(MapCenterObj)) )

 		{				  

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

 		} else if (api.checkParamCount(1))

 		{

 			s=api.parString(ok,0);

 			if (ok) 

 			{

 				BranchObj* bo=(BranchObj*)selection;

 				bo->deactivateStandardFlag(s);

 				bo->updateFlagsToolbar();

 			}	

 		}

 	} else

 	{

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

 	}

 	// Any errors?

 	if (api.errorLevel()==NoError)

 		setChanged();

 	else	

 	{

 		// TODO Error handling

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

 		qWarning(api.errorMessage());

 	} 

 }

 bool MapEditor::isDefault()

 {

     return mapDefault;

 }

 bool MapEditor::isUnsaved()

 {

     return mapUnsaved;

 }

 bool MapEditor::hasChanged()

 {

     return mapChanged;

 }

 void MapEditor::setChanged()

 {

 	mapChanged=true;

 	mapDefault=false;

 	mapUnsaved=true;

 	findReset();

 }

 void MapEditor::closeMap()

 {

 	// Unselect before disabling the toolbar actions

 	if (selection) selection->unselect();

 	selection=NULL;

 	updateActions();

     clear();

 	close();

 }

 void MapEditor::setFilePath(QString fname)

 {

 	setFilePath (fname,fname);

 }

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

 {

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

 	{

 		filePath="";

 		fileName="";

 		destPath="";

 	} else

 	{

 		filePath=fname;		// becomes absolute path

 		fileName=fname;		// gets stripped of path

 		destPath=destname;	// needed for vymlinks

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

 		filePath=QDir(fname).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) );

 	}

 }

 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 (selection) selection->unselect();

 		selection=NULL;

 		mapCenter->clear();

 		mapCenter->setMapEditor(this);

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

 	} else

 	{

 		if (!selection || (typeid(*selection) != typeid(BranchObj) &&

 			typeid(*selection) != typeid (MapCenterObj)))

 			return aborted;

 		BranchObj *bo=(BranchObj*)selection;	

 		if (lmode==ImportAdd)

 			saveStateChangingPart(

 				selection,

 				selection,

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

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

 		else	

 			saveStateChangingPart(

 				selection,

 				selection,

 				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

 	{

 		blockReposition=true;

 		QXmlInputSource source( file);

 		QXmlSimpleReader reader;

 		reader.setContentHandler( &handler );

 		reader.setErrorHandler( &handler );

 		handler.setMapEditor( this );

 		handler.setTmpDir (filePath.left(filePath.findRev("/",-1)));	// needed to load files with rel. path

 		handler.setInputFile (file.name());

 		handler.setLoadMode (lmode);

 		blockSaveState=true;

 		bool ok = reader.parse( source );

 		blockReposition=false;

 		blockSaveState=false;

 		file.close();

 		if ( ok ) 

 		{

 			mapCenter->reposition();

 			adjustCanvasSize();

 			if (lmode==NewMap)

 			{

 				mapDefault=false;

 				mapChanged=false;

 				mapUnsaved=false;

 			}

 		} 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)

 {

 	int returnCode=0;

 	// 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 || selection==NULL)

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

 	else	

 		saveFile=saveToDir (fileDir,mapName+"-",true,QPoint(),selection);

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

 		return 1;

 	if (returnCode==0)

 	{

 		mapChanged=false;

 		mapUnsaved=false;

 		updateActions();

 	}

 	return returnCode;

 }

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

 	}

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

 		// Don't print the visualisation of selection

 		LinkableMapObj *oldselection=NULL;

 		if (selection) 

 		{

 			oldselection=selection;

 			selection->unselect();

 		}

 		// Handle sizes of map and paper:

 		//

 		// setWindow defines which part of the canvas will be transformed 

 		// setViewport defines area on paper in device coordinates (dpi)

 		// e.g. (0,50,700,700) is upper part on A4

 		// see also /usr/lib/qt3/doc/html/coordsys.html

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

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

 		QRect mapRect=totalBBox;

 		Q3CanvasRectangle *frame=NULL;

 		Q3CanvasText *footerFN=NULL;

 		Q3CanvasText *footerDate=NULL;

 		if (printFrame || printFooter)

 		{

 			if (printFrame) 

 			{

 				// Print frame around map

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

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

 				frame=new Q3CanvasRectangle (mapRect,mapCanvas);

 				frame->setBrush (QColor(Qt::white));

 				frame->setPen (QColor(Qt::black));

 				frame->setZ(0);

 				frame->show();    

 			}		

 			/* TODO remove after testing 

 			QCanvasLine *l=new QCanvasLine (mapCanvas);

 			l->setPoints (0,0,mapRect.width(),mapRect.height());

 			l->setPen (QPen(QColor(black), 1));

 			l->setZ (200);

 			l->show();

 			*/

 			if (printFooter) 

 			{

 				// Print footer below map

 				QFont font;		

 				font.setPointSize(10);

 				footerFN=new Q3CanvasText (mapCanvas);

 				footerFN->setText ("VYM - " + fileName);

 				footerFN->setFont(font);

 				footerFN->move (mapRect.x(), mapRect.y() + mapRect.height() );

 				footerFN->setZ(Z_TEXT);

 				footerFN->show();    

 				footerDate=new Q3CanvasText (mapCanvas);

 				footerDate->setText (QDate::currentDate().toString(Qt::TextDate));

 				footerDate->setFont(font);

 				footerDate->move (mapRect.x()+mapRect.width()-footerDate->boundingRect().width(), mapRect.y() + mapRect.height() );

 				footerDate->setZ(Z_TEXT);

 				footerDate->show();    

 			}

 			pp.setWindow (mapRect.x(), mapRect.y(), mapRect.width(), mapRect.height()+20);

 		}	else	

 		{

 			pp.setWindow (mapRect);

 		}	

 		if (mapAspect>=paperAspect)

 		{

 			// Fit horizontally to paper width

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

 		}	else

 		{

 			// Fit vertically to paper height

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

 		}	

 		mapCanvas->drawArea(mapRect, &pp);	// draw Canvas to printer

 		// Delete Frame and footer

 		if (footerFN) 

 		{

 			delete (footerFN);

 			delete (footerDate);

 		}	

 		if (frame)  delete (frame);

 		// Restore selection

 		if (oldselection) 

 		{

 			selection=oldselection;

 			selection->select();

 		}	

 		// Save settings in vymrc

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

 	}

 }

 QPixmap MapEditor::getPixmap()

 {

 	QRect mapRect=mapCenter->getTotalBBox();

 	QPixmap pix (mapRect.size());

 	QPainter pp (&pix);

 	// Don't print the visualisation of selection

 	LinkableMapObj *oldselection=NULL;

 	if (selection) 

 	{

 		oldselection=selection;

 		selection->unselect();

 	}

 	pp.setWindow (mapRect);

 	mapCanvas->drawArea(mapRect, &pp);	// draw Canvas to painter

 	// Restore selection

 	if (oldselection) 

 	{

 		selection=oldselection;

 		selection->select();

 	}	

 	return pix;

 }

 void MapEditor::setHideTmpMode (HideTmpMode mode)

 {

 	hidemode=mode;

 	mapCenter->setHideTmp (hidemode);

 	mapCenter->reposition();

 	adjustCanvasSize();

 	canvas()->update();

 }

 HideTmpMode MapEditor::getHideTmpMode()

 {

 	return hidemode;

 }

 void MapEditor::exportImage(QString fn)

 {

 	setExportMode (true);

 	QPixmap pix (getPixmap());

 	pix.save(fn, "PNG");

 	setExportMode (false);

 }

 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 (HideExport);

 	else	

 		setHideTmpMode (HideNone);

 }

 void MapEditor::exportImage(QString fn, QString format)

 {

 	setExportMode (true);

 	QPixmap pix (getPixmap());

 	pix.save(fn, 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::exportXML(const QString &dir)

 {

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

 	setExportMode (false);

 }

 void MapEditor::clear()

 {

 	if (selection)

 	{

 		selection->unselect();

 		selection=NULL;

 	}	

 	mapCenter->clear();

 }

 void MapEditor::copy()

 {

 	if (selection) 

 	{

 		// write to directory

 		QString clipfile="part";

 		QString saveFile=saveToDir (fileDir,clipfile+"-",true,QPoint(),selection);

 		QFile file;

 		file.setName ( clipboardDir + "/"+clipfile+".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();

 		clipboardEmpty=false;

 		updateActions();

 	}	    

 }

 void MapEditor::redo()

 {

 	blockSaveState=true;

 	// Restore variables

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

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

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

 	// Can we undo at all?

 	if (redosAvail<1) return;

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

 /* TODO remove testing

 */

 	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=false;

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

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

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

 	undoSet.writeSettings(histPath);

 	updateActions();

 	mainWindow->updateHistory (undoSet);

 	/* 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()

 {

 	blockSaveState=true;

 	// Restore variables

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

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

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

 	// Can we undo at all?

 	if (undosAvail<1) return;

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

 /* TODO testing

 */	

 	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=false;

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

 }

 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++) 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)

 {

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

 				      typeid(*selection) == typeid(MapCenterObj))) 

 	{

 		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 (selection!=mapCenter)

 				((BranchObj*)selection)->getLastBranch()->moveBranchTo ((BranchObj*)(selection),pos);

 		} else	

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

 	}		

 }

 void MapEditor::pasteNoSave()

 {

 	load (clipboardDir+"/part.xml",ImportAdd);

 }

 void MapEditor::cutNoSave()

 {

 	copy();

 	deleteSelection();

 }

 void MapEditor::paste()

 {   

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

 				      typeid(*selection) == typeid(MapCenterObj))) 

 	{

 		pasteNoSave();

 		saveStateChangingPart(

 			selection,

 			selection,

 			"paste ()",

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

 		);

 		mapCenter->reposition();

 		adjustCanvasSize();

 	}

 }

 void MapEditor::cut()

 {

 	saveStateChangingPart(

 		selection->getParObj(),

 		selection,

 		"cut ()",

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

 	);

 	copy();

 	cutNoSave();

 	mapCenter->reposition();

 	adjustCanvasSize();

 }

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

 {

 	if (selection)

 	{

 		QString ps=qpointToString (selection->getAbsPos());

 		QString s=selection->getSelectString();

 		saveState(

 			s, "move "+ps, 

 			s, "move "+qpointToString (QPoint (x,y)), 

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

 		selection->move(x,y);

 		mapCenter->reposition();

 		adjustCanvasSize();

 	}

 }

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

 {

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

 				      typeid(*selection) == typeid(MapCenterObj) ||

 					  typeid(*selection) == typeid (FloatImageObj))) 

 	{

 		QString ps=qpointToString (selection->getRelPos());

 		QString s=selection->getSelectString();

 		saveState(

 			s, "moveRel "+ps, 

 			s, "moveRel "+qpointToString (QPoint (x,y)), 

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

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

 		mapCenter->reposition();

 		adjustCanvasSize();

 	}

 }

 void MapEditor::moveBranchUp()

 {

 	BranchObj* bo;

 	BranchObj* par;

 	if (typeid(*selection) == typeid(BranchObj)  ) 

 	{

 		bo=(BranchObj*)selection;

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

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

 		selection->unselect();

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

 		selection->select();

 		saveState (selection,"moveBranchDown ()",bo,"moveBranchUp ()",QString("Move up %1").arg(getName(bo)));

 		mapCenter->reposition();

 		ensureSelectionVisible();

 	}

 }

 void MapEditor::moveBranchDown()

 {

 	BranchObj* bo;

 	BranchObj* par;

 	if (typeid(*selection) == typeid(BranchObj)  ) 

 	{

 		bo=(BranchObj*)selection;

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

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

 		selection->unselect(); 

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

 		selection->select();

 		saveState(selection,"moveBranchUp ()",bo,"moveBranchDown ()",QString("Move down %1").arg(getName(bo)));

 		mapCenter->reposition();

 		ensureSelectionVisible();

 	}	

 }

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

 {

 	if (selection  &&  

 		 (typeid(*selection) == typeid(BranchObj) || 

 		  typeid(*selection) == typeid(MapCenterObj) ) ) 

 	{

 		ok=true;

 		ensureSelectionVisible();

 		p = ((BranchObj*)selection)->getAbsPos();

 		p.setX (p.x() - contentsX());

 		p.setY (p.y() - contentsY() + ((BranchObj*)selection)->height()/2);

 		return ((BranchObj*)selection)->getHeading();

 	}

 	ok=false;

 	return QString();

 }

 void MapEditor::setHeading(const QString &s)

 {

 	if (selection  &&  

 		 (typeid(*selection) == typeid(BranchObj) || 

 		  typeid(*selection) == typeid(MapCenterObj) ) ) 

 	{

 		editingBO=(BranchObj*)selection;

 		saveState(

 			selection,

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

 			selection,

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

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

 		editingBO->setHeading(s );

 		editingBO=NULL;

 		mapCenter->reposition();

 		adjustCanvasSize();

 		ensureSelectionVisible();

 	}

 }

 void MapEditor::setURLInt (const QString &s)

 {

 	// Internal function, no saveState needed

 	if (selection  &&  

 		 (typeid(*selection) == typeid(BranchObj) || 

 		  typeid(*selection) == typeid(MapCenterObj) ) ) 

 	{

 		((BranchObj*)selection)->setURL(s);

 		mapCenter->reposition();

 		adjustCanvasSize();

 		ensureSelectionVisible();

 	}

 }

 void MapEditor::setHeadingInt(const QString &s)

 {

 	if (selection  &&  

 		 (typeid(*selection) == typeid(BranchObj) || 

 		  typeid(*selection) == typeid(MapCenterObj) ) ) 

 	{

 		((BranchObj*)selection)->setHeading(s);

 		mapCenter->reposition();

 		adjustCanvasSize();

 		ensureSelectionVisible();

 	}

 }

 void MapEditor::setVymLinkInt (const QString &s)

 {

 	// Internal function, no saveState needed

 	if (selection  &&  

 		 (typeid(*selection) == typeid(BranchObj) || 

 		  typeid(*selection) == typeid(MapCenterObj) ) ) 

 	{

 		((BranchObj*)selection)->setVymLink(s);

 		mapCenter->reposition();

 		adjustCanvasSize();

 		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;

 	if (selection  &&  

 		 (typeid(*selection) == typeid(BranchObj) || 

 		  typeid(*selection) == typeid(MapCenterObj) ) ) 

 	{

 		BranchObj* bo = (BranchObj*) selection;

 		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 = (BranchObj*) selection;

 	BranchObj *newbo=NULL;

 	if (selection  &&  

 		 (typeid(*selection) == typeid(BranchObj) || 

 		  typeid(*selection) == typeid(MapCenterObj) ) ) 

 	{

 		newbo=addNewBranchInt (pos-2);

 		if (newbo)

 		{

 			saveState(

 				selection,		// FIXME sholdnt newbo be deleted here???

 				"delete ()",

 				selection,

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

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

 			mapCenter->reposition();

 			adjustCanvasSize();

 		}

 	}	

 	return newbo;

 }

 BranchObj* MapEditor::addNewBranchBefore()

 {

 	BranchObj *newbo=NULL;

 	if (selection  &&  

 		 (typeid(*selection) == typeid(BranchObj) ) )

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

 	{

 		BranchObj* bo = (BranchObj*) selection;

 		QPoint p=bo->getRelPos();

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

 		// add below selection

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

 		if (newbo)

 		{

 			newbo->move2RelPos (p);

 			// Move selection to new branch

 			((BranchObj*)selection)->moveBranchTo (newbo,-1);

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

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

 			mapCenter->reposition();

 			adjustCanvasSize();

 		}

 	}	

 	return newbo;

 }

 void MapEditor::deleteSelection()

 {

 	if (selection  && typeid(*selection) ==typeid(BranchObj) ) 

 	{

 		BranchObj* bo=(BranchObj*)selection;

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

 		bo->unselect();

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

 		selection=NULL;

 		par->removeBranch(bo);

 		selection=par;

 		selection->select();

 		ensureSelectionVisible();

 		mapCenter->reposition();

 		adjustCanvasSize();

 	}

 	if (selection  && typeid(*selection) ==typeid(FloatImageObj) ) 

 	{

 		FloatImageObj* fio=(FloatImageObj*)selection;

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

 		saveStateChangingPart(

 			par, 

 			fio,

 			"delete ()",

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

 		);

 		fio->unselect();

 		selection=NULL;

 		par->removeFloatImage(fio);

 		selection=par;

 		selection->select();

 		ensureSelectionVisible();

 		mapCenter->reposition();

 		adjustCanvasSize();

 	}

 }

 LinkableMapObj* MapEditor::getSelection()

 {

 	return selection;

 }

 void MapEditor::unselect()

 {

 	if (selection) 

 	{

 		selectionLast=selection;

 		selection->unselect();

 		selection=NULL;

 	}

 }	

 void MapEditor::reselect()

 {

 	if (selectionLast)

 	{

 		selection=selectionLast;

 		selection->select();

 		selectionLast=NULL;

 	}

 }	

 bool MapEditor::select (const QString &s)

 {

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

 	// Finally select the found object

 	if (lmo)

 	{

 		if (selection) unselect();

 		selection=lmo;

 		selection->select();

 		adjustCanvasSize();

 		ensureSelectionVisible();

 		return true;

 	} 

 	return false;

 }

 QString MapEditor::getSelectString()

 {

 	if (selection) return selection->getSelectString();

 	return QString();

 }

 void MapEditor::selectInt (LinkableMapObj *lmo)

 {

 	if (lmo && selection != lmo)

 	{

 		// select the MapObj

 		if (selection) selection->unselect();

 		selection=lmo;

 		selection->select();

 		adjustCanvasSize();

 	}

 }

 void MapEditor::selectNextBranchInt()

 {

 	// Increase number of branch

 	if (selection)

 	{

 		QString s=selection->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=selection->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 (selection->getOrientation()==OrientRightOfCenter)

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

 					if (b)

 					{	

 						if ( ((BranchObj*)selection)->countBranches()>0)

 							s+=",bo:0";

 						else	

 							break;

 					} else

 						break;

 				}	

 			// try to select the freshly built string

 			found=select(s);

 			d--;

 		}

 		return;

 	}	

 }

 void MapEditor::selectPrevBranchInt()

 {

 	// Decrease number of branch

 	if (selection)

 	{

 		QString s=selection->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 precessor, 

 		// try to decrease the parental number in order to

 		// find a precessor with same depth

 		int d=selection->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)

 			{

 				// decrease 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 (selection->getOrientation()==OrientRightOfCenter)

 					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 last branch for each depth

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

 				{

 					b=select (s);

 					if (b)

 						if ( ((BranchObj*)selection)->countBranches()>0)

 							s+=",bo:"+ QString ("%1").arg( ((BranchObj*)selection)->countBranches()-1 );

 						else	

 							break;

 					else

 						break;

 				}	

 			// try to select the freshly built string

 			found=select(s);

 			d--;

 		}

 		return;

 	}	

 }

 void MapEditor::selectUpperBranch()

 {

 	if (selection) 

 	{

 		if (typeid(*selection) == typeid(BranchObj))

 		{

 			if (selection->getOrientation()==OrientRightOfCenter)

 				selectPrevBranchInt();

 			else

 				if (selection->getDepth()==1)

 					selectNextBranchInt();

 				else

 					selectPrevBranchInt();

 		}		

 	}

 }

 void MapEditor::selectLowerBranch()

 {

 	if (selection) 

 	{

 		if (typeid(*selection) == typeid(BranchObj))

 		{

 			if (selection->getOrientation()==OrientRightOfCenter)

 				selectNextBranchInt();

 			else

 				if (selection->getDepth()==1)

 					selectPrevBranchInt();

 				else

 					selectNextBranchInt();

 		}		

 	}

 }

 void MapEditor::selectLeftBranch()

 {

 	BranchObj* bo;

 	BranchObj* par;

 	if (selection) 

 	{

 		if (typeid(*selection) == typeid(MapCenterObj))

 		{

 			par=  (BranchObj*) selection;

 			bo=par->getLastSelectedBranch();

 			if (bo)

 			{

 				// Workaround for reselecting on left and right side

 				if (bo->getOrientation()==OrientRightOfCenter)

 				{

 					bo=par->getLastBranch();

 				}	

 				if (bo)

 				{

 					par->unselect();

 					selection=bo;

 					selection->select();

 					adjustCanvasSize();

 					ensureSelectionVisible();

 				}

 			}	

 		} else

 		{

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

 			if (selection->getOrientation()==OrientRightOfCenter)

 			{

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

 					typeid(*selection) == typeid(FloatImageObj))

 				{

 					selection->unselect();

 					selection=par;

 					selection->select();

 					adjustCanvasSize();

 					ensureSelectionVisible();

 				}

 			} else

 			{

 				if (typeid(*selection) == typeid(BranchObj) )

 				{

 					bo=((BranchObj*)selection)->getLastSelectedBranch();

 					if (bo) 

 					{

 						selection->unselect();

 						selection=bo;

 						selection->select();

 						adjustCanvasSize();

 						ensureSelectionVisible();

 					}

 				}

 			}

 		}	

 	}

 }

 void MapEditor::selectRightBranch()

 {

 	BranchObj* bo;

 	BranchObj* par;

 	if (selection) 

 	{

 		if (typeid(*selection) == typeid(MapCenterObj))

 		{

 			par=  (BranchObj*) selection;

 			bo=par->getLastSelectedBranch();

 			if (bo)

 			{

 				// Workaround for reselecting on left and right side

 				if (bo->getOrientation()==OrientLeftOfCenter)

 					bo=par->getFirstBranch();

 				if (bo)

 				{

 					par->unselect();

 					selection=bo;

 					selection->select();

 					ensureSelectionVisible();

 				}

 			}

 		} else

 		{

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

 			if (selection->getOrientation()==OrientLeftOfCenter)

 			{

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

 					typeid(*selection) == typeid(FloatImageObj))

 				{

 					selection->unselect();

 					selection=par;

 					selection->select();

 					adjustCanvasSize();

 					ensureSelectionVisible();

 				}

 			} else

 			{

 				if (typeid(*selection) == typeid(BranchObj) )

 				{

 					bo=((BranchObj*)selection)->getLastSelectedBranch();

 					if (bo) 

 					{

 						selection->unselect();

 						selection=bo;

 						selection->select();

 						adjustCanvasSize();

 						ensureSelectionVisible();

 					}

 				}

 			}

 		}

 	}

 }

 void MapEditor::selectFirstBranch()

 {

 	BranchObj *bo1;

 	BranchObj *bo2;

 	BranchObj* par;

 	if (selection) {

 		if (typeid(*selection) == typeid(BranchObj))

 		{

 			bo1=  (BranchObj*) selection;

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

 			bo2=par->getFirstBranch();

 			if (bo2) {

 				bo1->unselect();

 				selection=bo2;

 				selection->select();

 				ensureSelectionVisible();

 			}

 		}		

 		adjustCanvasSize();

 	}

 }

 void MapEditor::selectLastBranch()

 {

 	BranchObj *bo1;

 	BranchObj *bo2;

 	BranchObj* par;

 	if (selection) {

 		if (typeid(*selection) == typeid(BranchObj))

 		{

 			bo1=  (BranchObj*) selection;

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

 			bo2=par->getLastBranch();

 			if (bo2) {

 				bo1->unselect();

 				selection=bo2;

 				selection->select();

 				ensureSelectionVisible();

 			}

 		}		

 		adjustCanvasSize();

 	}

 }

 void MapEditor::selectMapBackgroundColor()

 {

 	QColor col = QColorDialog::getColor( mapCanvas->backgroundColor(), this );

 	if ( !col.isValid() ) return;

 	setBackgroundColor( col );

 }

 void MapEditor::setMapBackgroundColor(QColor col)

 {

 	QColor oldcol=mapCanvas->backgroundColor();

 	saveState(

 		selection,

 		QString ("setMapBackgroundColor (%1)").arg(oldcol.name()),

 		selection,

 		QString ("setMapBackgroundColor (%1)").arg(col.name()),

 		QString("Set background color of map to %1").arg(col.name()));

 	mapCanvas->setBackgroundColor (col);

 }

 QColor MapEditor::getMapBackgroundColor()

 {

     return mapCanvas->backgroundColor();

 }

 QColor MapEditor::getCurrentHeadingColor()

 {

 	if (selection) 

 	{

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

 			typeid(*selection) == typeid(MapCenterObj))

 		{

 			BranchObj *bo=(BranchObj*)selection;

 			return bo->getColor(); 

 		}    

 	}

 	QMessageBox::warning(0,tr("Warning"),tr("Can't get color of heading,\nthere's no branch selected"));

 	return Qt::black;

 }

 void MapEditor::colorItem(QColor c) 

 {

 	if (selection) 

 	{

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

 			typeid(*selection) == typeid(MapCenterObj))

 		{

 			BranchObj *bo=(BranchObj*)selection;

 			saveState(

 				selection, 

 				QString ("colorItem (%1)").arg(bo->getColor().name()),

 				selection,

 				QString ("colorItem (%1)").arg(c.name()),

 				QString("Set color of %1 to %2").arg(getName(bo)).arg(c.name())

 			);	

 			bo->setColor(c); // color branch

 		}    

 	}

 }

 void MapEditor::colorBranch(QColor c)

 {

 	if (selection) 

 	{

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

 			typeid(*selection) == typeid(MapCenterObj))

 		{

 			BranchObj *bo=(BranchObj*)selection;

 			saveStateChangingPart(

 				selection, 

 				selection,

 				QString ("colorBranch (%1)").arg(c.name()),

 				QString ("Set color of %1 and childs to %2").arg(getName(bo)).arg(c.name())

 			);	

 			bo->setColorChilds(c); // color links, color childs

 		}    

 	}

 }

 void MapEditor::toggleStandardFlag(QString f)

 {

 	if (selection)

 	{

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

 			typeid(*selection) == typeid(MapCenterObj))

 		{

 			BranchObj *bo=(BranchObj*)selection;

 			QString u,r;

 			if (bo->isSetStandardFlag(f))

 			{

 				r="unsetFlag";

 				u="setFlag";

 			}	

 			else

 			{

 				u="unsetFlag";

 				r="setFlag";

 			}	

 			saveState(

 				selection,

 				QString("%1 (\"%2\")").arg(u).arg(f), 

 				selection,

 				QString("%1 (\"%2\")").arg(r).arg(f),

 				QString("Toggling standard flag \"%1\" of %2").arg(f).arg(getName(bo)));

 			bo->toggleStandardFlag (f,mainWindow->useFlagGroups());

 			adjustCanvasSize();

 		}

 	}	

 }

 void MapEditor::setViewCenter()

 {

 	// transform to CanvasView Coord:

 	QPoint p=worldMatrix().map(movingCenter);

 	center ( p.x(), p.y());

 }

 BranchObj* MapEditor::findText (QString s, bool cs)

 {

 	QTextDocument::FindFlags flags=0;

 	if (cs) flags=QTextDocument::FindCaseSensitively;

 	if (!itFind) 

 	{	// Nothing found or new find process

 		if (EOFind)

 			// nothing found, start again

 			EOFind=false;

 		itFind=mapCenter->first();

 	}	

 	bool searching=true;

 	bool foundNote=false;

 	while (searching && !EOFind)

 	{

 		if (itFind)

 		{

 			// Searching in Note

 			if (itFind->getNote().contains(s,cs))

 			{

 				if (selection!=itFind) 

 				{

 					if (selection) ((BranchObj*)selection)->unselect();

 					selection=itFind;

 					selection->select();

 					adjustCanvasSize();

 					ensureSelectionVisible();

 				}

 				if (textEditor->findText(s,flags)) 

 				{

 					searching=false;

 					foundNote=true;

 				}	

 			}

 			// Searching in Heading

 			if (searching && itFind->getHeading().contains (s,cs) ) 

 			{

 				if (selection) ((BranchObj*)selection)->unselect();

 				selection=itFind;

 				selection->select();

 				adjustCanvasSize();

 				ensureSelectionVisible();

 				searching=false;

 			}

 		}	

 		if (!foundNote)

 		{

 			itFind=itFind->next();

 			if (!itFind) EOFind=true;

 		}

 	}	

 	if (!searching)

 	{

 		adjustCanvasSize();

 		return (BranchObj*)selection;

 	}	else

 		return NULL;

 }

 void MapEditor::findReset()

 {	// Necessary if text to find changes during a find process

 	itFind=NULL;

 	EOFind=false;

 }

 void MapEditor::setURL(const QString &url)

 {

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

 			typeid(*selection) == typeid(MapCenterObj)) )

 	{		

 		BranchObj *bo=(BranchObj*)selection;

 		QString oldurl=bo->getURL();

 		bo->setURL (url);

 		saveState (

 			selection,

 			QString ("setURL (\"%1\")").arg(oldurl),

 			selection,

 			QString ("setURL (\"%1\")").arg(url),

 			QString ("set URL of %1 to %2").arg(getName(bo)).arg(url)

 		);

 		updateActions();

 	}

 }	

 void MapEditor::editURL()

 {