#include "mapeditor.h"

 #include <q3filedialog.h>

 #include <iostream>

 #include <cstdlib>

 #include <typeinfo>

 #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-freemind.h"

 #include "xml-vym.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)  

 {

 	setObjectName ("MapEditor");

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

 	model=new VymModel();

 	model->setScene (mapScene);

 	model->setMapEditor (this);

     setScene (mapScene);

     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.setModel (model);

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

 	// Create temporary files

 	makeTmpDirs();

 	curStep=0;

 	redosAvail=0;

 	undosAvail=0;

 	setAcceptDrops (true);	

 	model->reposition();

 	// autosave

 	autosaveTimer=new QTimer (this);

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

 	fileChangedTimer=new QTimer (this);

 	fileChangedTimer->start(3000);

 	connect(fileChangedTimer, SIGNAL(timeout()), this, SLOT(fileChanged()));

 	// Network

 	netstate=Offline;

 	// Attributes	//FIXME testing only...

 	QString k;

 	AttributeDef *ad;

 	attrTable= new AttributeTable();

 	k="A - StringList";

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

 	if (ad)

 	{

 		QStringList sl;

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

 		ad->setValue (QVariant (sl));

 	}

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

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

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

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

 	k="B - FreeString";

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

 	if (ad)

 	{

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

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

 	}

 	k="C - UniqueString";

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

 	if (ad)

 	{

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

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

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

 	}

 }

 MapEditor::~MapEditor()

 {

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

 	autosaveTimer->stop();

 	fileChangedTimer->stop();

 	// tmpMapDir is in tmpVymDir, so it gets removed automagically when vym closes

 	//removeDir(QDir(tmpMapDir));

 	delete (model);

 }

 VymModel* MapEditor::getModel()

 {

     return model;

 }

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

 	}	

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

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

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

 }

 void MapEditor::makeTmpDirs()

 {

 	// Create unique temporary directories

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

 	histPath = 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)

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

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

 			      attribut("date",model->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+=model->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.getDataXML (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(QString("history-%1").arg(curStep));

 	return (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  "<<qPrintable (mapName)<<endl;

 	// Find out current undo directory

 	if (undosAvail<stepsTotal) undosAvail++;

 	curStep++;

 	if (curStep>stepsTotal) curStep=1;

 	QString backupXML="";

 	QString histDir=getHistoryDir();

 	QString bakMapPath=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 (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="<<qPrintable (model->getSelectString(saveSel))<<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=model->getSelectString(undoSel);

 	else

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

 	QString redoSelection="";

 	if (redoSel)

 		redoSelection=model->getSelectString(undoSel);

 	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=model->getSelectString (redoSel->getParObj());

 	QString redoSelection=model->getSelectString(redoSel);

 	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=model->getSelectString(redoSel);

 	QString undoSelection="";

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

 	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 QString &uc, const QString &rc, const QString &comment) 

 {

 	// "Normal" savestate applied to model (no selection needed): 

 	// save commands  and comment

 	saveState (UndoCommand,

 		NULL, uc,

 		NULL, rc, 

 		comment, 

 		NULL);

 }

 void MapEditor::parseAtom(const QString &atom)

 {

 	BranchObj *selb=xelection.getBranch();

 	QString s,t;

 	double x,y;

 	int n;

 	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)

 					addNewBranch (0);

 				else

 				{

 					n=parser.parInt (ok,0);

 					if (ok ) addNewBranch (n);

 				}

 			}

 		}

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

 	} 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("addMapCenter"))

 	{

 		if (parser.checkParCount(2))

 		{

 			x=parser.parDouble (ok,0);

 			if (ok)

 			{

 				y=parser.parDouble (ok,1);

 				if (ok) model->addMapCenter (QPointF(x,y));

 			}

 		}	

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

 	} 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=(tmpMapDir + "/"+t);

 			addMapReplaceInt(model->getSelectString(selb),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

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

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

 				addMapInsertInt(t,n);	

 			}

 		}

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

 	} 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()>=1)

 			// Hey, we even have a filename

 			fname=parser.parString(ok,0); 

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

 		if (!ok)

 		{

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

 		} else

 		{

 			QString format="PNG";

 			if (parser.parCount()>=2)

 			{

 				format=parser.parString(ok,1);

 			}

 			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=model->findObjBySelect (s);

 				if (dst)

 				{	

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

 					{

 						// Get number in parent

 						n=parser.parInt (ok,1);

 						if (ok)

 						{

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

 							xelection.update();

 						}	

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

 					{

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

 						// Get coordinates of mainbranch

 						x=parser.parDouble(ok,2);

 						if (ok)

 						{

 							y=parser.parDouble(ok,3);

 							if (ok) 

 							{

 								selb->move (x,y);

 								xelection.update();

 							}

 						}

 					}	

 				}	

 			}	

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

 		{

 			if (parser.checkParCount(1))

 			{

 				// 0	selectstring of parent

 				s=parser.parString(ok,0);

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

 				if (dst)

 				{	

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

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

 						linkTo (model->getSelectString(dst));

 				} 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.parDouble (ok,0);

 			if (ok)

 			{

 				y=parser.parDouble (ok,1);

 				if (ok) move (x,y);

 			}

 		}	

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

 	} else if (com=="moveRel")

 	{

 		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.parDouble (ok,0);

 			if (ok)

 			{

 				y=parser.parDouble (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))

 		{	

 			n=parser.parInt (ok,0);

 			if (ok) pasteNoSave(n);

 		}	

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

 	} 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: " << qPrintable (c)  << endl;

 										} else

 										{

 											cout << "FAILED: " << qPrintable (c)  << 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=="selectLatestAdded")

 	{

 		if (latestSelection.isEmpty() )

 		{

 			parser.setError (Aborted,"No latest added object");

 		} else

 		{	

 			if (!select (latestSelection))

 				parser.setError (Aborted,"Could not select latest added object "+latestSelection);

 		}	

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

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

 		{

 			n=parser.parInt(ok,0);

 			if (ok) setFramePadding(n);

 		}	

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

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

 		{

 			n=parser.parInt(ok,0);

 			if (ok) setFrameBorderWidth (n);

 		}	

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

 	} 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=="sortChildren")

 	{

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

 		{

 			sortChildren();

 		}

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

 	} 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();  FIXME should not be called e.g. for export?!

 		model->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();  FIXME needed?

 }

 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 and during load to reset fileChangedTime

 		// 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, const LoadMode &lmode, const FileType &ftype)

 {

 	ErrorCode err=success;

 	parseBaseHandler *handler;

 	fileType=ftype;

 	switch (fileType)

 	{

 		case VymMap: handler=new parseVYMHandler; break;

 		case FreemindMap : handler=new parseFreemindHandler; break;

 		default: 

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

 				   "Unknown FileType in MapEditor::load()");

 		return aborted;	

 	}

 	// Save original zip state, important for inserting complete maps

 	bool zipped_org=zipped;

 	if (lmode==NewMap)

 	{

 		xelection.clear();

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

 	}	

 	// Create temporary directory for packing

 	bool ok;

 	QString tmpZipDir=makeTmpDir (ok,"vym-pack");

 	if (!ok)

 	{

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

 		   tr("Couldn't create temporary directory before load\n"));

 		return aborted; 

 	}

 	// Try to unzip file

 	err=unzipDir (tmpZipDir,fname);

 	QString xmlfile;

 	if (err==nozip)

 	{

 		xmlfile=fname;

 		zipped=false;

 	} else

 	{

 		zipped=true;

 		// Look for mapname.xml

 		xmlfile= fname.left(fname.findRev(".",-1,true));

 		xmlfile=xmlfile.section( '/', -1 );

 		QFile mfile( tmpZipDir + "/" + xmlfile + ".xml");

 		if (!mfile.exists() )

 		{

 			// mapname.xml does not exist, well, 

 			// maybe someone renamed the mapname.vym file...

 			// Try to find any .xml in the toplevel 

 			// directory of the .vym file

 			QStringList flist=QDir (tmpZipDir).entryList("*.xml");

 			if (flist.count()==1) 

 			{

 				// Only one entry, take this one

 				xmlfile=tmpZipDir + "/"+flist.first();

 			} else

 			{

 				for ( QStringList::Iterator it = flist.begin(); it != flist.end(); ++it ) 

 					*it=tmpZipDir + "/" + *it;

 				// TODO Multiple entries, load all (but only the first one into this ME)

 				//mainWindow->fileLoadFromTmp (flist);

 				//returnCode=1;	// Silently forget this attempt to load

 				qWarning ("MainWindow::load (fn)  multimap found...");

 			}	

 			if (flist.isEmpty() )

 			{

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

 						   tr("Couldn't find a map (*.xml) in .vym archive.\n"));

 				err=aborted;				   

 			}	

 		} //file doesn't exist	

 		else

 			xmlfile=mfile.name();

 	}

 	QFile file( xmlfile);

 	// I am paranoid: file should exist anyway

 	// according to check in mainwindow.

 	if (!file.exists() )

 	{

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

 				   tr(QString("Couldn't open map %1").arg(file.name())));

 		err=aborted;	

 	} else

 	{

 		bool blockSaveStateOrg=blockSaveState;

 		blockReposition=true;

 		blockSaveState=true;

 		QXmlInputSource source( file);

 		QXmlSimpleReader reader;

 		reader.setContentHandler( handler );

 		reader.setErrorHandler( handler );

 		handler->setModel ( model);

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

 		QString tmpdir;

 		if (zipped)

 			tmpdir=tmpZipDir;

 		else

 			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 ) 

 		{

 			model->reposition();	// FIXME reposition the view instead...

 			xelection.update();

 			if (lmode==NewMap)

 			{

 				mapDefault=false;

 				mapChanged=false;

 				mapUnsaved=false;

 				autosaveTimer->stop();

 			}

 			// Reset timestamp to check for later updates of file

 			fileChangedTime=QFileInfo (destPath).lastModified();

 		} 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

 		}	

 	}	

 	// Delete tmpZipDir

 	removeDir (QDir(tmpZipDir));

 	// Restore original zip state

 	zipped=zipped_org;

 	updateActions();

 	return err;

 }

 ErrorCode MapEditor::save (const SaveMode &savemode)

 {

 	QString tmpZipDir;

 	QString mapFileName;

 	QString safeFilePath;

 	ErrorCode err=success;

 	if (zipped)

 		// save as .xml

 		mapFileName=mapName+".xml";

 	else

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

 		mapFileName=fileName;

 	// Look, if we should zip the data:

 	if (!zipped)

 	{

 		QMessageBox mb( vymName,

 			tr("The map %1\ndid not use the compressed "

 			"vym file format.\nWriting it uncompressed will also write images \n"

 			"and flags and thus may overwrite files in the "

 			"given directory\n\nDo you want to write the map").arg(filePath),

 			QMessageBox::Warning,

 			QMessageBox::Yes | QMessageBox::Default,

 			QMessageBox::No ,

 			QMessageBox::Cancel | QMessageBox::Escape);

 		mb.setButtonText( QMessageBox::Yes, tr("compressed (vym default)") );

 		mb.setButtonText( QMessageBox::No, tr("uncompressed") );

 		mb.setButtonText( QMessageBox::Cancel, tr("Cancel"));

 		switch( mb.exec() ) 

 		{

 			case QMessageBox::Yes:

 				// save compressed (default file format)

 				zipped=true;

 				break;

 			case QMessageBox::No:

 				// save uncompressed

 				zipped=false;

 				break;

 			case QMessageBox::Cancel:

 				// do nothing

 				return aborted;

 				break;

 		}

 	}

 	// First backup existing file, we 

 	// don't want to add to old zip archives

 	QFile f(destPath);

 	if (f.exists())

 	{

 		if ( settings.value ("/mapeditor/writeBackupFile").toBool())

 		{

 			QString backupFileName(destPath + "~");

 			QFile backupFile(backupFileName);

 			if (backupFile.exists() && !backupFile.remove())

 			{

 				QMessageBox::warning(0, tr("Save Error"),

 									 tr("%1\ncould not be removed before saving").arg(backupFileName));

 			}

 			else if (!f.rename(backupFileName))

 			{

 				QMessageBox::warning(0, tr("Save Error"),

 									 tr("%1\ncould not be renamed before saving").arg(destPath));

 			}

 		}

 	}

 	if (zipped)

 	{

 		// Create temporary directory for packing

 		bool ok;

 		tmpZipDir=makeTmpDir (ok,"vym-zip");

 		if (!ok)

 		{

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

 			   tr("Couldn't create temporary directory before save\n"));

 			return aborted; 

 		}

 //	cout <<"ME::save      filePath="<<filePath.toStdString()<<endl;

 		safeFilePath=filePath;

 		setFilePath (tmpZipDir+"/"+ mapName+ ".xml", safeFilePath);

 	} // zipped

 	// Create mapName and fileDir

 	makeSubDirs (fileDir);

 /*

 	// FIXME testing

 	cout <<"ME::save      filePath="<<filePath.toStdString()<<endl;

 	cout <<"ME::save  saveFilePath="<<safeFilePath.toStdString()<<endl;

 	cout <<"ME::save      destPath="<<destPath.toStdString()<<endl;

 	cout <<"ME::save       mapName="<<mapName.toStdString()<<endl;

 	cout <<"ME::save   mapFileName="<<mapFileName.toStdString()<<endl;

 */

 	QString saveFile;

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

 	{

 		// Save complete map

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

 		mapChanged=false;

 		mapUnsaved=false;

 		autosaveTimer->stop();

 	}

 	else	

 	{

 		// Save part of map

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

 			saveFloatImage();

 		else	

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

 		// TODO take care of multiselections

 	}	

 	// FIXME trying to debug save problem

 	if (saveFile.length()<1000)

 		QMessageBox::critical (0,"Critical error in MapEditor::save",QString("saveFile is too small:\n%1").arg(saveFile));

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

 	{

 		err=aborted;

 		QMessageBox::critical (0,"Critical error in MapEditor::save",QString("could not sage %1").arg(fileDir+mapFileName));

 	}

 	if (zipped)

 	{

 		// zip

 		if (err==success) err=zipDir (tmpZipDir,destPath);

 		// Delete tmpDir

 		removeDir (QDir(tmpZipDir));

 		// Restore original filepath outside of tmp zip dir

 		setFilePath (safeFilePath);

 	}

 	updateActions();

 	fileChangedTime=QFileInfo (destPath).lastModified();

 	return err;

 }

 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=model->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=model->getTotalBBox();

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

 	QPainter pp (&pix);

 	pp.setRenderHints(renderHints());

 	// Don't print the visualisation of selection

 	xelection.unselect();

 	mapScene->render (	&pp, 

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

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

 	// Restore selection

 	xelection.reselect();

 	return pix;

 }

 void MapEditor::setHideTmpMode (HideTmpMode mode)

 {

 	hidemode=mode;

 	model->setHideTmp (hidemode);

 	model->reposition();

 	scene()->update();

 }

 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","true")=="true")

 		setHideTmpMode (HideExport);

 	else	

 		setHideTmpMode (HideNone);

 }

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

 {

 	ExportASCII ex;

 	ex.setModel (model);

 	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.setModel (model);

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

 	model->clear();

 }

 void MapEditor::copy()

 {

 	LinkableMapObj *sel=xelection.single();

 	if (sel)

 	{

 		if (redosAvail == 0)

 		{

 			// Copy to history

 			QString s=model->getSelectString(sel);

 			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(QString("history-%1").arg(curStep));

 		QString bakMapDir(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");

 	/* TODO Maybe check for version, if we save the history

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

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

 	/* TODO Maybe check for version, if we save the history

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

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

 		{

 			if (debug) cout << "ME::gotoHistoryStep 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

 		parseVYMHandler handler;

 		QXmlInputSource source( file);

 		QXmlSimpleReader reader;

 		reader.setContentHandler( &handler );

 		reader.setErrorHandler( &handler );

 		handler.setModel ( model);

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

 		if (undoSel.isEmpty())

 		{

 			unselect();

 			model->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

 			parseVYMHandler handler;

 			QXmlInputSource source( file);

 			QXmlSimpleReader reader;

 			reader.setContentHandler( &handler );

 			reader.setErrorHandler( &handler );

 			handler.setModel (model);

 			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->getDepth()>0)

 				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;

 	bool zippedOrg=zipped;

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

 	{

 		// Use the "historical" buffer

 		QString bakMapName(QString("history-%1").arg(n));

 		QString bakMapDir(tmpMapDir +"/"+bakMapName);

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

 	} else

 		// Use the global buffer

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

 	zipped=zippedOrg;

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

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

 		model->reposition();

 	}

 }

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

 {

 	LinkableMapObj *sel=xelection.single();

 	if (sel)

 	{

         QPointF ap(sel->getAbsPos());

         QPointF to(x, y);

         if (ap != to)

         {

             QString ps=qpointfToString(ap);

             QString s=xelection.getSelectString();

             saveState(

                 s, "move "+ps, 

                 s, "move "+qpointfToString(to), 

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

             sel->move(x,y);

             model->reposition();

             xelection.update();

         }

 	}

 }

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

 {

 	LinkableMapObj *sel=xelection.single();

 	if (sel)

 	{

         QPointF rp(sel->getRelPos());

         QPointF to(x, y);

         if (rp != to)

         {

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

             QString s=model->getSelectString(sel);

             saveState(

                 s, "moveRel "+ps, 

                 s, "moveRel "+qpointfToString(to), 

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

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

             model->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 (model->getSelectString(bo),"moveBranchDown ()",model->getSelectString(obo),"moveBranchUp ()",QString("Move up %1").arg(getName(bo)));

 		model->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(model->getSelectString(bo),"moveBranchUp ()",model->getSelectString(obo),"moveBranchDown ()",QString("Move down %1").arg(getName(bo)));

 		model->reposition();

 		scene()->update();

 		xelection.update();

 		ensureSelectionVisible();

 	}	

 }

 void MapEditor::sortChildren()

 {

 	BranchObj* bo=xelection.getBranch();

 	if (bo)

 	{

 		if(bo->countBranches()>1)

 		{

 			saveStateChangingPart(bo,bo, "sortChildren ()",QString("Sort children of %1").arg(getName(bo)));

 			bo->sortChildren();

 			model->reposition();

 			ensureSelectionVisible();

 		}

 	}

 }

 void MapEditor::linkTo(const QString &dstString)	

 {

 	FloatImageObj *fio=xelection.getFloatImage();

 	if (fio)

 	{

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

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

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

 		{			

 			LinkableMapObj *dstPar=dst->getParObj();

 			QString parString=model->getSelectString(dstPar);

 			QString fioPreSelectString=model->getSelectString(fio);

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

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

 			xelection.unselect();

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

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

 			fio->setRelPos();

 			fio->reposition();

 			xelection.select(fio);

 			saveState(

 				model->getSelectString(fio),

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