#include <QApplication>

 #include <typeinfo>

 #include "vymmodel.h"

 #include "branchitem.h"

 #include "mapcenteritem.h"

 #include "editxlinkdialog.h"

 #include "exports.h"

 #include "exportxhtmldialog.h"

 #include "file.h"

 #include "geometry.h"		// for addBBox

 #include "mainwindow.h"

 #include "mapcenterobj.h"

 #include "misc.h"

 #include "parser.h"

 #include "selection.h"

 #include "warningdialog.h"

 #include "xml-freemind.h"

 #include "xmlobj.h"

 #include "xml-vym.h"

 extern bool debug;

 extern Main *mainWindow;

 extern Settings settings;

 extern QString tmpVymDir;

 extern TextEditor *textEditor;

 extern QString clipboardDir;

 extern QString clipboardFile;

 extern bool clipboardEmpty;

 extern ImageIO imageIO;

 extern QString vymName;

 extern QString vymVersion;

 extern QDir vymBaseDir;

 extern QDir lastImageDir;

 extern QDir lastFileDir;

 extern FlagRowObj *standardFlagsDefault;

 extern Settings settings;

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

 VymModel::VymModel() 

 {

 //    cout << "Const VymModel\n";

 	init();

 	rootItem->setModel (this);

 }

 VymModel::~VymModel() 

 {

 //    cout << "Destr VymModel\n";

 	autosaveTimer->stop();

 	fileChangedTimer->stop();

 	clear();

 }	

 void VymModel::clear() 

 {

 	selModel->clearSelection();

 	// Remove stuff    

 	while (!mapCenters.isEmpty())			// FIXME-2 VM needs to be in treemodel only...

 		delete mapCenters.takeFirst();

 	QModelIndex ri=index(rootItem);

 	//removeRows (0, rowCount(ri),ri);		// FIXME-2 here should be at least a beginRemoveRows...

 }

 void VymModel::init () 

 {

 	// We should have at least one map center to start with

 	// addMapCenter();  FIXME-2 VM create this in MapEditor as long as model is part of that

 	// No MapEditor yet

 	mapEditor=NULL;

 	// Also no scene yet (should not be needed anyway)  FIXME-3 VM

 	mapScene=NULL;

 	// History 

 	mapNum++;

     mapChanged=false;

 	mapDefault=true;

 	mapUnsaved=false;

 	curStep=0;

 	redosAvail=0;

 	undosAvail=0;

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

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

 	mainWindow->updateHistory (undoSet);

 	// Create tmp dirs

 	makeTmpDirectories();

 	// Files

 	zipped=true;

 	filePath="";

 	fileName=tr("unnamed");

 	mapName="";

 	blockReposition=false;

 	blockSaveState=false;

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

 	// selections

 	selModel=NULL;

 	// find routine

 	findCurrent=NULL;				

 	findPrevious=NULL;				

 	EOFind=false;

 	// animations

 	animationUse=settings.readBoolEntry("/animation/use",false);

 	animationTicks=settings.readNumEntry("/animation/ticks",10);

 	animationInterval=settings.readNumEntry("/animation/interval",50);

 	animObjList.clear();

 	animationTimer=new QTimer (this);

 	connect(animationTimer, SIGNAL(timeout()), this, SLOT(animate()));

 	// View - map

 	defLinkColor=QColor (0,0,255);

 	defXLinkColor=QColor (180,180,180);

 	linkcolorhint=LinkableMapObj::DefaultColor;

 	linkstyle=LinkableMapObj::PolyParabel;

 	defXLinkWidth=1;

 	defXLinkColor=QColor (230,230,230);

 	hidemode=HideNone;

 	// Network

 	netstate=Offline;

 	// Create MapCenter

 	//  addMapCenter();  FIXME-2 VM create this in MapEditor until BO and MCO are independent of scene

 }

 void VymModel::makeTmpDirectories()

 {

 	// Create unique temporary directories

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

 	histPath = tmpMapDir+"/history";

 	QDir d;

 	d.mkdir (tmpMapDir);

 }

 MapEditor* VymModel::getMapEditor()	// FIXME-2 VM better return favourite editor here

 {

 	return mapEditor;

 }

 bool VymModel::isRepositionBlocked()

 {

 	return blockReposition;

 }

 void VymModel::updateActions()	// FIXME-2  maybe don't update if blockReposition is set

 {

 	cout << "VymModel::updateActions \n";

 	// Tell mainwindow to update states of actions

 	mainWindow->updateActions();

 }

 QString VymModel::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

 	XMLObj xml;

 	// 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=xml.attribut("linkColorHint","HeadingColor");

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

 	if (!saveSel)

 		mapAttr+= xml.attribut("author",author) +

 				  xml.attribut("comment",comment) +

 			      xml.attribut("date",getDate()) +

 				  xml.attribut("branchCount", QString().number(branchCount())) +

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

 		          xml.attribut("selectionColor", mapEditor->getSelectionColor().name() ) +

 		          xml.attribut("linkStyle", ls ) +

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

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

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

 		          colhint; 

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

 	xml.incIndent();

 	// Find the used flags while traversing the tree	// FIXME-2 this can be done local to vymmodel maybe...

 	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();// FIXME-2 this can be done local to vymmodel maybe...

 	// Build xml recursivly

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

 		// Save all mapcenters as complete map, if saveSel not set

 		s+=saveTreeToDir(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 (!selection.isEmpty() && !saveSel ) 

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

 	xml.decIndent();

 	s+=xml.endElement("vymmap");

 	if (writeflags)

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

 	return s;

 }

 QString VymModel::saveTreeToDir (const QString &tmpdir,const QString &prefix, int verbose, const QPointF &offset)

 {

     QString s;

 	for (int i=0; i<mapCenters.count(); i++)

 		s+=mapCenters.at(i)->saveToDir (tmpdir,prefix,verbose,offset);

     return s;

 }

 void VymModel::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 VymModel::setFilePath(QString fpath)

 {

 	setFilePath (fpath,fpath);

 }

 QString VymModel::getFilePath()

 {

 	return filePath;

 }

 QString VymModel::getFileName()

 {

 	return fileName;

 }

 QString VymModel::getMapName()

 {

 	return mapName;

 }

 QString VymModel::getDestPath()

 {

 	return destPath;

 }

 ErrorCode VymModel::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 VymModel::load()");

 		return aborted;	

 	}

 	bool zipped_org=zipped;

 	if (lmode==NewMap)

 	{

 		selModel->clearSelection();

 		// FIXME-2 VM not needed??? model->setMapEditor(this);

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

 	} else

 	{

 		BranchObj *bo=getSelectedBranch();

 		if (!bo) return aborted;

 		if (lmode==ImportAdd)

 			saveStateChangingPart(

 				bo,

 				bo,

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

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

 		else	

 			saveStateChangingPart(

 				bo,

 				bo,

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

 				QString("Add map %1 to %2").arg(fname).arg(getObjectName(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 ( this);

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

 		{

 			reposition();	// FIXME-2 VM reposition the view instead...

 			selection.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 VymModel::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; 

 		}

 		safeFilePath=filePath;

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

 	} // zipped

 	// Create mapName and fileDir

 	makeSubDirs (fileDir);

 	QString saveFile;

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

 	{

 		// Save complete map

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

 		mapChanged=false;

 		mapUnsaved=false;

 		autosaveTimer->stop();

 	}

 	else	

 	{

 		// Save part of map

 		if (selectionType()==TreeItem::Image)

 			saveFloatImage();

 		else	

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

 		// TODO take care of multiselections

 	}	

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

 	{

 		err=aborted;

 		qWarning ("ME::saveStringToDisk failed!");

 	}

 	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 VymModel::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 ( this);

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

 		if (undoSel.isEmpty())

 		{

 			unselect();

 			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 VymModel::addMapInsertInt (const QString &path, int pos)

 {

 /* FIXME-2  addMapInsertInt not ported yet

 	BranchObj *sel=getSelectedBranch();

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

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

 			handler.setLoadMode (ImportAdd);

 			blockReposition=true;

 			bool ok = reader.parse( source );

 			blockReposition=false;

 			if (! ok ) 

 			{	

 				// This should never ever happen

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

 										handler.errorProtocol());

 			}

 			if (sel->getDepth()>0)

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

 		} else	

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

 	}		

 */

 }

 FloatImageObj* VymModel::loadFloatImageInt (QString fn)

 {

 	TreeItem *fi=createImage();

 	if (fi)

 	{

 		FloatImageObj *fio= ((FloatImageObj*)fi->getLMO());

 		fio->load (fn);

 		reposition();

 		return fio;

 	}

 	return NULL;

 }	

 void VymModel::loadFloatImage ()

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		Q3FileDialog *fd=new Q3FileDialog( NULL);

 		fd->setMode (Q3FileDialog::ExistingFiles);

 		fd->addFilter (QString (tr("Images") + " (*.png *.bmp *.xbm *.jpg *.png *.xpm *.gif *.pnm)"));

 		ImagePreview *p =new ImagePreview (fd);

 		fd->setContentsPreviewEnabled( TRUE );

 		fd->setContentsPreview( p, p );

 		fd->setPreviewMode( Q3FileDialog::Contents );

 		fd->setCaption(vymName+" - " +tr("Load image"));

 		fd->setDir (lastImageDir);

 		fd->show();

 		if ( fd->exec() == QDialog::Accepted )

 		{

 			// TODO loadFIO in QT4 use:	lastImageDir=fd->directory();

 			lastImageDir=QDir (fd->dirPath());

 			QString s;

 			FloatImageObj *fio;

 			for (int j=0; j<fd->selectedFiles().count(); j++)

 			{

 				s=fd->selectedFiles().at(j);

 				fio=loadFloatImageInt (s);

 				if (fio)

 					saveState(

 						(LinkableMapObj*)fio,

 						"delete ()",

 						bo, 

 						QString ("loadImage (%1)").arg(s ),

 						QString("Add image %1 to %2").arg(s).arg(getObjectName(bo))

 					);

 				else

 					// TODO loadFIO error handling

 					qWarning ("Failed to load "+s);

 			}

 		}

 		delete (p);

 		delete (fd);

 	}

 }

 void VymModel::saveFloatImageInt  (FloatImageObj *fio, const QString &type, const QString &fn)

 {

 	fio->save (fn,type);

 }

 void VymModel::saveFloatImage ()

 {

 	FloatImageObj *fio=selection.getFloatImage();

 	if (fio)

 	{

 		QFileDialog *fd=new QFileDialog( NULL);

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

 		fd->setCaption(vymName+" - " +tr("Save image"));

 		fd->setFileMode( QFileDialog::AnyFile );

 		fd->setDirectory (lastImageDir);

 //		fd->setSelection (fio->getOriginalFilename());

 		fd->show();

 		QString fn;

 		if ( fd->exec() == QDialog::Accepted && fd->selectedFiles().count()==1)

 		{

 			fn=fd->selectedFiles().at(0);

 			if (QFile (fn).exists() )

 			{

 				QMessageBox mb( vymName,

 					tr("The file %1 exists already.\n"

 					"Do you want to overwrite it?").arg(fn),

 				QMessageBox::Warning,

 				QMessageBox::Yes | QMessageBox::Default,

 				QMessageBox::Cancel | QMessageBox::Escape,

 				QMessageBox::NoButton );

 				mb.setButtonText( QMessageBox::Yes, tr("Overwrite") );

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

 				switch( mb.exec() ) 

 				{

 					case QMessageBox::Yes:

 						// save 

 						break;

 					case QMessageBox::Cancel:

 						// do nothing

 						delete (fd);

 						return;

 						break;

 				}

 			}

 			saveFloatImageInt (fio,fd->selectedFilter(),fn );

 		}

 		delete (fd);

 	}

 }

 void VymModel::importDirInt(BranchObj *dst, QDir d)

 {

 /* FIXME-2 importDirInt not ported yet

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		// Traverse directories

 		d.setFilter( QDir::Dirs| QDir::Hidden | QDir::NoSymLinks );

 		QFileInfoList list = d.entryInfoList();

 		QFileInfo fi;

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

 		{

 			fi=list.at(i);

 			if (fi.fileName() != "." && fi.fileName() != ".." )

 			{

 				dst->addBranch();

 				bo=dst->getLastBranch();

 				BranchItem *bi=(BranchItem*)(bo->getTreeItem());

 				bi->setHeading (fi.fileName() );	// FIXME-3 check this

 				bo->setColor (QColor("blue"));

 				bi->toggleScroll();

 				if ( !d.cd(fi.fileName()) ) 

 					QMessageBox::critical (0,tr("Critical Import Error"),tr("Cannot find the directory %1").arg(fi.fileName()));

 				else 

 				{

 					// Recursively add subdirs

 					importDirInt (bo,d);

 					d.cdUp();

 				}

 			}	

 		}		

 		// Traverse files

 		d.setFilter( QDir::Files| QDir::Hidden | QDir::NoSymLinks );

 		list = d.entryInfoList();

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

 		{

 			fi=list.at(i);

 			dst->addBranch();

 			bo=dst->getLastBranch();

 			bo->setHeading (fi.fileName() );

 			bo->setColor (QColor("black"));

 			if (fi.fileName().right(4) == ".vym" )

 				bo->setVymLink (fi.filePath());

 		}	

 	}		

 */

 }

 void VymModel::importDirInt (const QString &s)

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		saveStateChangingPart (bo,bo,QString ("importDir (\"%1\")").arg(s),QString("Import directory structure from %1").arg(s));

 		QDir d(s);

 		importDirInt (bo,d);

 	}

 }	

 void VymModel::importDir()

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		QStringList filters;

 		filters <<"VYM map (*.vym)";

 		QFileDialog *fd=new QFileDialog( NULL,vymName+ " - " +tr("Choose directory structure to import"));

 		fd->setMode (QFileDialog::DirectoryOnly);

 		fd->setFilters (filters);

 		fd->setCaption(vymName+" - " +tr("Choose directory structure to import"));

 		fd->show();

 		QString fn;

 		if ( fd->exec() == QDialog::Accepted )

 		{

 			importDirInt (fd->selectedFile() );

 			reposition();

 			//FIXME-3 VM needed? scene()->update();

 		}

 	}	

 }

 void VymModel::autosave()

 {

 	if (filePath=="") 

 	{

 		if (debug)

 			cout << "VymModel::autosave rejected due to missing filePath\n";

 	}

 	QDateTime now=QDateTime().currentDateTime();

 	// Disable autosave, while we have gone back in history

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

 	if (redosAvail>0) return;

 	// Also disable autosave for new map without filename

 	if (filePath.isEmpty()) return;

 	if (mapUnsaved &&mapChanged && settings.value ("/mainwindow/autosave/use",true).toBool() )

 	{

 		if (QFileInfo(filePath).lastModified()<=fileChangedTime) 

 			mainWindow->fileSave (this);

 		else

 			if (debug)

 				cout <<"  ME::autosave  rejected, file on disk is newer than last save.\n"; 

 	}	

 }

 void VymModel::fileChanged()

 {

 	// Check if file on disk has changed meanwhile

 	if (!filePath.isEmpty())

 	{

 		QDateTime tmod=QFileInfo (filePath).lastModified();

 		if (tmod>fileChangedTime)

 		{

 			// FIXME-2 VM switch to current mapeditor and finish lineedits...

 			QMessageBox mb( vymName,

 				tr("The file of the map  on disk has changed:\n\n"  

 				   "   %1\n\nDo you want to reload that map with the new file?").arg(filePath),

 				QMessageBox::Question,

 				QMessageBox::Yes ,

 				QMessageBox::Cancel | QMessageBox::Default,

 				QMessageBox::NoButton );

 			mb.setButtonText( QMessageBox::Yes, tr("Reload"));

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

 			switch( mb.exec() ) 

 			{

 				case QMessageBox::Yes:

 					// Reload map

 					load (filePath,NewMap,fileType);

 		        case QMessageBox::Cancel:

 					fileChangedTime=tmod; // allow autosave to overwrite newer file!

 			}

 		}

 	}	

 }

 bool VymModel::isDefault()

 {

     return mapDefault;

 }

 void VymModel::makeDefault()

 {

 	mapChanged=false;

 	mapDefault=true;

 }

 bool VymModel::hasChanged()

 {

     return mapChanged;

 }

 void VymModel::setChanged()

 {

 	cout << "VM::setChanged()\n";

 	if (!mapChanged)

 	{

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

 		cout <<"   timer started with "<<settings.value("/mainwindow/autosave/ms/",300000).toInt()<<endl;

 	}	

 	mapChanged=true;

 	mapDefault=false;

 	mapUnsaved=true;

 	findReset();

 }

 QString VymModel::getObjectName (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 VymModel::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 << "VymModel::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);

 	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 VymModel::isRedoAvailable()

 {

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

 		return true;

 	else	

 		return false;

 }

 void VymModel::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 << "VymModel::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);

 	reposition();

 	undosAvail--;

 	curStep--; 

 	if (curStep<1) curStep=stepsTotal;

 	redosAvail++;

 	blockSaveState=blockSaveStateOrg;

 /* TODO remove testing

 	cout << "VymModel::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();

 	selection.update();

 	ensureSelectionVisible();

 }

 bool VymModel::isUndoAvailable()

 {

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

 		return true;

 	else	

 		return false;

 }

 void VymModel::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 << "VymModel::gotoHistoryStep redo "<<j<<"/"<<undosAvail<<" i="<<i<<endl;

 			redo();

 		}

 	// And ignore clicking the current row ;-)	

 }

 QString VymModel::getHistoryPath()

 {

 	QString histName(QString("history-%1").arg(curStep));

 	return (tmpMapDir+"/"+histName);

 }

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

 {

 	sendData(redoCom);	//FIXME-3 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=getHistoryPath();

 	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 (getSelectString(saveSel))<<endl;

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

 	}

 	mainWindow->updateHistory (undoSet);

 	setChanged();

 	updateActions();

 }

 void VymModel::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=getSelectString(undoSel);

 	else

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

 	QString redoSelection="";

 	if (redoSel)

 		redoSelection=getSelectString(undoSel);

 	else

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

 	saveState (PartOfMap,

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

 		redoSelection, rc, 

 		comment, 

 		undoSel);

 }

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

 {

 	if (!redoSel)

 	{

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

 		return;

 	}

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

 	QString redoSelection=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(redoSel->getTreeItem()->num()),

 			redoSelection, "delete ()", 

 			comment, 

 			redoSel);

 	}

 }

 void VymModel::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=getSelectString(redoSel);

 	QString undoSelection="";

 	if (undoSel) undoSelection=getSelectString(undoSel);

 	saveState (UndoCommand,

 		undoSelection, uc,

 		redoSelection, rc, 

 		comment, 

 		NULL);

 }

 void VymModel::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 VymModel::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);

 }

 QGraphicsScene* VymModel::getScene ()

 {

 	return mapScene;

 }

 LinkableMapObj* VymModel::findMapObj(QPointF p, LinkableMapObj *excludeLMO)

 {

 	LinkableMapObj *lmo;

 	for (int i=0;i<mapCenters.count(); i++)

 	{

 		lmo=mapCenters.at(i)->findMapObj (p,excludeLMO);

 		if (lmo) return lmo;

 	}

 	return NULL;

 }

 LinkableMapObj* VymModel::findObjBySelect(const QString &s)

 {

 	LinkableMapObj *lmo;

 	if (!s.isEmpty() )

 	{

 		QString part;

 		QString typ;

 		QString num;

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

 		typ=part.left (2);

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

 		if (typ=="mc" && num.toInt()>=0 && num.toInt() <mapCenters.count() )

 			return mapCenters.at(num.toInt() );

 	}		

 	for (int i=0; i<mapCenters.count(); i++)

 	{

 		lmo=mapCenters.at(i)->findObjBySelect(s);

 		if (lmo) return lmo;

 	}	

 	return NULL;

 }

 LinkableMapObj* VymModel::findID (const QString &s)

 {

 	LinkableMapObj *lmo;

 	for (int i=0; i<mapCenters.count(); i++)

 	{

 		lmo=mapCenters.at(i)->findID (s);

 		if (lmo) return lmo;

 	}	

 	return NULL;

 }

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

 // Interface 

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

 void VymModel::setVersion (const QString &s)

 {

 	version=s;

 }

 void VymModel::setAuthor (const QString &s)

 {

 	saveState (

 		QString ("setMapAuthor (\"%1\")").arg(author),

 		QString ("setMapAuthor (\"%1\")").arg(s),

 		QString ("Set author of map to \"%1\"").arg(s)

 	);

 	author=s;

 }

 QString VymModel::getAuthor()

 {

 	return author;

 }

 void VymModel::setComment (const QString &s)

 {

 	saveState (

 		QString ("setMapComment (\"%1\")").arg(comment),

 		QString ("setMapComment (\"%1\")").arg(s),

 		QString ("Set comment of map")

 	);

 	comment=s;

 }

 QString VymModel::getComment ()

 {

 	return comment;

 }

 QString VymModel::getDate ()

 {

 	return QDate::currentDate().toString ("yyyy-MM-dd");

 }

 int VymModel::branchCount()	// FIXME-2 Optimize this: use internal counter instead of going through whole map each time...

 {

 	int c=0;

 	BranchItem *cur=NULL;

 	BranchItem *prev=NULL;

 	int d;

 	next(cur,prev,d);

 	while (cur) 

 	{

 		c++;

 		next(cur,prev,d);

 	}

 	return c;

 }

 void VymModel::setHeading(const QString &s)

 {

 	BranchObj *sel=getSelectedBranch();

 	if (sel)

 	{

 		saveState(

 			sel,

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

 			sel,

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

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

 		sel->setHeading(s );

 		/* FIXME-3 testing only

 		*/

 		TreeItem *ti=getSelectedItem();

 		if (ti)

 		{

 			ti->setHeading (s);

 			//FIXME-3 VM ix is wrong ModelIndex below, ix2 is (hopefully) correct:

 			//QModelIndex ix=index( ti->row(), ti->column(), index (0,0,QModelIndex()) );

 			//FIXME-3 VM testing only cout <<"VM::setHeading  s="<<s.toStdString()<<"  ti="<<ti<<"  r,c=("<<ti->row()<<","<<ti->column()<<")"<<endl;

 			QModelIndex ix2=index (ti);

 			emit (dataChanged ( ix2,ix2));

 		}

 		else

 		{

 			cout << "Warning: VM::setHeading ti==NULL\n";

 		}

 		//cout <<"                (r,c)=("<<ix2.row()<<","<<ix2.column()<<")"<<endl;

 		reposition();

 		selection.update();

 		ensureSelectionVisible();

 	}

 }

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

 {

 	int d=0;

 	QTextDocument::FindFlags flags=0;

 	if (cs) flags=QTextDocument::FindCaseSensitively;

 	if (!findCurrent) 

 	{	// Nothing found or new find process

 		if (EOFind)

 			// nothing found, start again

 			EOFind=false;

 		findCurrent=NULL;	

 		findPrevious=NULL;	

 		next (findCurrent,findPrevious,d);

 	}	

 	bool searching=true;

 	bool foundNote=false;

 	while (searching && !EOFind)

 	{

 		if (findCurrent)

 		{

 			// Searching in Note

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

 			{

 				select (findCurrent);

 				/*

 				if (getSelectedBranch()!=itFind) 

 				{

 					select(itFind);

 					ensureSelectionVisible();

 				}

 				*/

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

 				{

 					searching=false;

 					foundNote=true;

 				}	

 			}

 			// Searching in Heading

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

 			{

 				select(findCurrent);

 				searching=false;

 			}

 		}	

 		if (!foundNote)

 		{

 			if (!next(findCurrent,findPrevious,d) )

 				EOFind=true;

 		}

 	//cout <<"still searching...  "<<qPrintable( itFind->getHeading())<<endl;

 	}	

 	if (!searching)

 		return getSelectedBranch();

 	else

 		return NULL;

 }

 void VymModel::findReset()

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

 	findCurrent=NULL;

 	findPrevious=NULL;

 	EOFind=false;

 }

 void VymModel::setScene (QGraphicsScene *s)

 {

 	mapScene=s;	// FIXME-2 VM should not be necessary anymore, move all occurences to MapEditor

     //init();	// Here we have a mapScene set, 

 			// which is (still) needed to create MapCenters

 }

 void VymModel::setURL(const QString &url)

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		QString oldurl=bo->getURL();

 		bo->setURL (url);

 		saveState (

 			bo,

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

 			bo,

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

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

 		);

 		updateActions();

 		reposition();

 		selection.update();

 		ensureSelectionVisible();

 	}

 }	

 QString VymModel::getURL()

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 		return bo->getURL();

 	else

 		return "";

 }

 QStringList VymModel::getURLs()	// FIXME-1	first, next moved to vymmodel

 {

 	return QStringList();

 	/*

 	QStringList urls;

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{		

 		bo=bo->first();	

 		while (bo) 

 		{

 			if (!bo->getURL().isEmpty()) urls.append( bo->getURL());

 			bo=bo->next();

 		}	

 	}	

 	return urls;

 	*/

 }

 void VymModel::linkFloatImageTo(const QString &dstString)	

 {

 	FloatImageObj *fio=selection.getFloatImage();

 	if (fio)

 	{

 		BranchObj *dst=(BranchObj*)findObjBySelect(dstString);

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

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

 		{			

 			LinkableMapObj *dstPar=dst->getParObj();

 			QString parString=getSelectString(dstPar);

 			QString fioPreSelectString=getSelectString(fio);

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

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

 			selection.unselect();

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

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

 			fio->setRelPos();

 			fio->reposition();

 			selection.select(fio);

 			saveState(

 				getSelectString(fio),

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

 				fioPreSelectString, 

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

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

 		}

 	}

 }

 void VymModel::setFrameType(const FrameObj::FrameType &t)

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		QString s=bo->getFrameTypeName();

 		bo->setFrameType (t);

 		saveState (bo, QString("setFrameType (\"%1\")").arg(s),

 			bo, QString ("setFrameType (\"%1\")").arg(bo->getFrameTypeName()),QString ("set type of frame to %1").arg(s));

 		reposition();

 		bo->updateLink();

 	}

 }

 void VymModel::setFrameType(const QString &s)	

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		saveState (bo, QString("setFrameType (\"%1\")").arg(bo->getFrameTypeName()),

 			bo, QString ("setFrameType (\"%1\")").arg(s),QString ("set type of frame to %1").arg(s));

 		bo->setFrameType (s);

 		reposition();

 		bo->updateLink();

 	}

 }

 void VymModel::setFramePenColor(const QColor &c)	

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		saveState (bo, QString("setFramePenColor (\"%1\")").arg(bo->getFramePenColor().name() ),

 			bo, QString ("setFramePenColor (\"%1\")").arg(c.name() ),QString ("set pen color of frame to %1").arg(c.name() ));

 		bo->setFramePenColor (c);

 	}	

 }

 void VymModel::setFrameBrushColor(const QColor &c)	

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		saveState (bo, QString("setFrameBrushColor (\"%1\")").arg(bo->getFrameBrushColor().name() ),

 			bo, QString ("setFrameBrushColor (\"%1\")").arg(c.name() ),QString ("set brush color of frame to %1").arg(c.name() ));

 		bo->setFrameBrushColor (c);

 	}	

 }

 void VymModel::setFramePadding (const int &i)

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		saveState (bo, QString("setFramePadding (\"%1\")").arg(bo->getFramePadding() ),

 			bo, QString ("setFramePadding (\"%1\")").arg(i),QString ("set brush color of frame to %1").arg(i));

 		bo->setFramePadding (i);

 		reposition();

 		bo->updateLink();

 	}	

 }

 void VymModel::setFrameBorderWidth(const int &i)

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		saveState (bo, QString("setFrameBorderWidth (\"%1\")").arg(bo->getFrameBorderWidth() ),

 			bo, QString ("setFrameBorderWidth (\"%1\")").arg(i),QString ("set border width of frame to %1").arg(i));

 		bo->setFrameBorderWidth (i);

 		reposition();

 		bo->updateLink();

 	}	

 }

 void VymModel::setIncludeImagesVer(bool b)	

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		QString u= b ? "false" : "true";

 		QString r=!b ? "false" : "true";

 		saveState(

 			bo,

 			QString("setIncludeImagesVertically (%1)").arg(u),

 			bo, 

 			QString("setIncludeImagesVertically (%1)").arg(r),

 			QString("Include images vertically in %1").arg(getObjectName(bo))

 		);	

 		bo->setIncludeImagesVer(b);

 		reposition();

 	}	

 }

 void VymModel::setIncludeImagesHor(bool b)	

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		QString u= b ? "false" : "true";

 		QString r=!b ? "false" : "true";

 		saveState(

 			bo,

 			QString("setIncludeImagesHorizontally (%1)").arg(u),

 			bo, 

 			QString("setIncludeImagesHorizontally (%1)").arg(r),

 			QString("Include images horizontally in %1").arg(getObjectName(bo))

 		);	

 		bo->setIncludeImagesHor(b);

 		reposition();

 	}	

 }

 void VymModel::setHideLinkUnselected (bool b)

 {

 	LinkableMapObj *sel=getSelectedLMO();

 	if (sel &&

 		(selectionType() == TreeItem::Branch || 

 		selectionType() == TreeItem::MapCenter  ||

 		selectionType() == TreeItem::Image ))

 	{

 		QString u= b ? "false" : "true";

 		QString r=!b ? "false" : "true";

 		saveState(

 			sel,

 			QString("setHideLinkUnselected (%1)").arg(u),

 			sel, 

 			QString("setHideLinkUnselected (%1)").arg(r),

 			QString("Hide link of %1 if unselected").arg(getObjectName(sel))

 		);	

 		sel->setHideLinkUnselected(b);

 	}

 }

 void VymModel::setHideExport(bool b)

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		bo->setHideInExport (b);

 		QString u= b ? "false" : "true";

 		QString r=!b ? "false" : "true";

 		saveState(

 			bo,

 			QString ("setHideExport (%1)").arg(u),

 			bo,

 			QString ("setHideExport (%1)").arg(r),

 			QString ("Set HideExport flag of %1 to %2").arg(getObjectName(bo)).arg (r)

 		);	

 		updateActions();

 		reposition();

 		selection.update();

 		// FIXME-3 VM needed? scene()->update();

 	}

 }

 void VymModel::toggleHideExport()

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 		setHideExport ( !bo->hideInExport() );

 }

 void VymModel::copy()

 {

 	LinkableMapObj *sel=getSelectedLMO();

 	if (sel &&

 		(selectionType() == TreeItem::Branch || 

 		selectionType() == TreeItem::MapCenter  ||

 		selectionType() == TreeItem::Image ))

 	{

 		if (redosAvail == 0)

 		{

 			// Copy to history

 			QString s=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 VymModel::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 VymModel::paste()		

 {   

 	BranchObj *sel=getSelectedBranch();

 	if (sel)

 	{

 		saveStateChangingPart(

 			sel,

 			sel,

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

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

 		);

 		pasteNoSave(0);

 		reposition();

 	}

 }

 void VymModel::cut()

 {

 	LinkableMapObj *sel=getSelectedLMO();

 	if ( sel && (selectionType() == TreeItem::Branch ||

 		selectionType()==TreeItem::MapCenter ||

 		selectionType()==TreeItem::Image))

 	{

 	/* No savestate! savestate is called in cutNoSave

 		saveStateChangingPart(

 			sel->getParObj(),

 			sel,

 			"cut ()",

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

 		);

 	*/	

 		copy();

 		deleteSelection();

 		reposition();

 	}

 }

 void VymModel::moveBranchUp()

 {

 	BranchObj* bo=getSelectedBranch();

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

 		reposition();

 		//FIXME-3 VM needed? scene()->update();

 		selection.update();

 		ensureSelectionVisible();

 	}

 }

 void VymModel::moveBranchDown()

 {

 	BranchObj* bo=getSelectedBranch();

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

 		reposition();

 		//FIXME-3 VM needed? scene()->update();

 		selection.update();

 		ensureSelectionVisible();

 	}	

 }

 void VymModel::sortChildren()	// FIXME-1 not implemented yet

 {

 /*

 	BranchObj* bo=getSelectedBranch();

 	if (bo)

 	{

 		if(treeItem->branchCount()>1)

 		{

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

 			bo->sortChildren();

 			reposition();

 			ensureSelectionVisible();

 		}

 	}

 */

 }

 void VymModel::createMapCenter()

 {

 	MapCenterObj *mco=addMapCenter (QPointF (0,0) );

 	select (mco);

 }

 BranchItem* VymModel::createBranch()	// FIXME-2 switcht addNewBrancInt to BranchItem...

 {

 	BranchObj* bo=addNewBranchInt (-2);

 	return (BranchItem*)bo->getTreeItem();

 }

 TreeItem* VymModel::createImage()

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		FloatImageObj *newfio=bo->addFloatImage(); // FIXME-1 VM Old model, merge with below

 		// Create TreeItem

 		QList<QVariant> cData;

 		cData << "VM:createImage" << "undef"<<"undef";

 		TreeItem *parti=bo->getTreeItem();

 		TreeItem *ti=new TreeItem (cData,parti);

 		ti->setLMO (newfio);

 		ti->setType (TreeItem::Image);

 		parti->appendChild (ti);

 		if (newfio)

 		{

 			newfio->setTreeItem (ti);

 			select (newfio); // FIXME-2 VM really needed here?

 			return ti;

 		}

 	}

 	return NULL;

 }

 MapCenterObj* VymModel::addMapCenter ()

 {

 	MapCenterObj *mco=addMapCenter (contextPos);

 	//FIXME-3 selection.select (mco);

 	updateActions();

 	ensureSelectionVisible();

 	saveState (

 		mco,

 		"delete()",

 		NULL,

 		QString ("addMapCenter (%1,%2)").arg (contextPos.x()).arg(contextPos.y()),

 		QString ("Adding MapCenter to (%1,%2)").arg (contextPos.x()).arg(contextPos.y())

 	);	

 	return mco;	

 }

 MapCenterObj* VymModel::addMapCenter(QPointF absPos)

 {

 	// Create TreeItem

 	QModelIndex parix=index(rootItem);

 	int n=rootItem->branchCount();

 	emit (layoutAboutToBeChanged() );

 	beginInsertRows (parix,n,n+1);

 	QList<QVariant> cData;

 	cData << "VM:addMapCenter" << "undef"<<"undef";

 	MapCenterItem *ti=new MapCenterItem (cData,rootItem);

 	cout << "VM::addMapCenter  ti="<<ti<<endl;

 	ti->setType (TreeItem::MapCenter);

 	rootItem->appendChild (ti);

 	endInsertRows();

 	emit (newChildObject (parix));

 	emit (layoutChanged() );

 	// Create MapObj

 	MapCenterObj *mapCenter = new MapCenterObj(mapScene,this);

 	mapCenter->setMapEditor(mapEditor);		//FIXME-3 VM needed to get defLinkStyle, mapLinkColorHint ... for later added objects

 	mapCenter->setTreeItem (ti);	// TreeItem needs to exist before setVisibility

 	ti->setLMO (mapCenter);

 	mapCenter->move (absPos);

     mapCenter->setVisibility (true);

 	mapCenter->setHeading (QApplication::translate("Heading of mapcenter in new map", "New map"));

 	mapCenters.append(mapCenter);

 	// Testing

 /*

 	qWarning ("MW::insertRow a");

     if (!insertRow(0, parix))

 	{

 		std::cout << "  war nix...\n";

 	}	

 	qWarning ("MW::insertRow b");

 */

 	return mapCenter;

 }

 MapCenterObj* VymModel::removeMapCenter(MapCenterObj* mco)

 {

 	int i=mapCenters.indexOf (mco);

 	if (i>=0)

 	{

 		mapCenters.removeAt (i);

 		delete (mco);

 		if (i>0) return mapCenters.at(i-1);	// Return previous MCO

 	}

 	return NULL;

 }

 MapCenterObj* VymModel::getLastMapCenter()

 {

 	if (mapCenters.size()>0)

 		return mapCenters.last();

 	else

 		return NULL;

 }

 BranchObj* VymModel::addNewBranchInt(int num)

 {

 	// Depending on pos:

 	// -3		insert in children of parent  above selection 

 	// -2		add branch to selection 

 	// -1		insert in children of parent below selection 

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

 	BranchObj *newbo=NULL;

 	BranchObj *bo=getSelectedBranch();

 	BranchItem *bi=getSelectedBranchItem();

 	if (bo)

 	{

 		if (num==-2)

 		{

 			// Create TreeItem

 			QList<QVariant> cData;

 			cData << "new" << "undef"<<"undef";

 			BranchItem *parbi=bi;

 			QModelIndex parix=index(parbi);

 			int n=parbi->branchCount();

 			emit (layoutAboutToBeChanged() );

 			beginInsertRows (parix,n,n+1);

 			bi=new BranchItem (cData,parbi);

 			bi->setType (TreeItem::Branch);

 			parbi->appendChild (bi);

 			endInsertRows ();

 			emit (newChildObject (parix));

 			emit (layoutChanged() );

 			// save scroll state. If scrolled, automatically select

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

 			newbo=bo->addBranch();

 			if (newbo)

 			{

 				bi->setLMO (newbo);

 				newbo->setTreeItem (bi);

 				select (newbo); // FIXME-2 VM really needed here?

 			}

 		}else if (num==-1)

 		{

 			num=bi->num()+1;

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

 			if (bo) newbo=bo->insertBranch(num);	//FIXME-1 VM still missing 

 		}else if (num==-3)

 		{

 			num=bi->num();

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

 			if (bo) newbo=bo->insertBranch(num);	//FIXME-1 VM still missing

 		}

 	}	

 	return newbo;

 }	

 BranchObj* VymModel::addNewBranch(int pos)

 {

 	// Different meaning than num in addNewBranchInt!

 	// -1	add above

 	//  0	add as child

 	// +1	add below

 	BranchObj *bo = getSelectedBranch();

 	BranchObj *newbo=NULL;

 	if (bo)

 	{

 		// FIXME-2 VM  do we still need this in model? setCursor (Qt::ArrowCursor);

 		newbo=addNewBranchInt (pos-2);

 		if (newbo)

 		{

 			saveState(

 				newbo,		

 				"delete ()",

 				bo,

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

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

 			reposition();

 			// selection.update(); FIXME-3

 			latestSelectionString=getSelectString(newbo);

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

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

 			// TODO: Get rid of this positioning workaround

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

 			sendData ("selectLatestAdded ()");

 			sendData (QString("move %1").arg(ps));

 			sendSelection();

 		}

 	}	

 	return newbo;

 }

 BranchObj* VymModel::addNewBranchBefore()

 {

 	BranchObj *newbo=NULL;

 	BranchObj *bo = getSelectedBranch();

 	if (bo && selectionType()==TreeItem::Branch)

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

 	{

 		QPointF p=bo->getRelPos();

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

 		// add below selection

 		newbo=parbo->insertBranch(bo->getTreeItem()->num()+1);		//FIXME-1 VM still missing

 		if (newbo)

 		{

 			newbo->move2RelPos (p);

 			// Move selection to new branch

 			bo->linkTo (newbo,-1);

 			saveState (newbo, "deleteKeepChildren ()", newbo, "addBranchBefore ()", 

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

 			reposition();

 			// selection.update(); FIXME-3 

 		}

 	}	

 	latestSelectionString=selection.getSelectString();

 	return newbo;

 }

 void VymModel::deleteSelection()

 {

 	BranchObj *bo = getSelectedBranch();	// FIXME-2 VM should not be necessary

 	if (!bo) return;

 	QModelIndex ix=getSelectedIndex();

 	if (!ix.isValid() ) return;

 	QModelIndex parentIndex=parent(ix);

 /*

 	if (!parentIndex.isValid()) 

 	{

 	cout << "VM::delete no valid parent ix\n";

 	return;

 	}

 */	

 	TreeItem *ti=bo->getTreeItem();

 	if (selectionType()==TreeItem::MapCenter)	

 	{

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

 		//selection.unselect();

 		/* FIXME-1 VM Note:  does saveStateRemovingPart work for MCO? (No parent!)

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

 		*/	

 		emit (layoutAboutToBeChanged() );

 		parentIndex=parent(index(ti));

 		cout << "VM::delete  ti="<<ti<<"  row="<<ix.row()<<"  parIndex.valid="<<parentIndex.isValid()<<endl;

 		int n=ix.row();

 		beginRemoveRows (parentIndex,n,n);

 		removeRows (n,1,parentIndex);

 		bo=removeMapCenter ((MapCenterObj*)bo);

 		endRemoveRows();

 		if (bo) 

 		{

 			select (bo);

 			ensureSelectionVisible();

 			ensureSelectionVisible();

 			reposition();

 		}	

 		emit (layoutChanged() );

 	}

 	if (selectionType()==TreeItem::Branch)

 	{

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

 		unselect();

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

 		emit (layoutAboutToBeChanged() );

 		cout << "VM::delete  ti="<<ti<<"  row="<<ix.row()<<endl;

 		parentIndex=parent(index(ti));

 		int n=ix.row();

 		beginRemoveRows (parentIndex,n,n);

 		removeRows (n,1,parentIndex);

 		endRemoveRows();

 		par->removeBranch(bo);	// remove from BranchObj lists...

 		select (par);

 		ensureSelectionVisible();

 		reposition();

 		emit (layoutChanged() );

 		return;

 	}

 	//FloatImageObj *fio=selection.getFloatImage(); 	//FIXME-1 VM still missing

 /*

 	if (fio)

 	{

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

 		saveStateChangingPart(

 			par, 

 			fio,

 			"delete ()",

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

 		);

 		unselect();

 		par->removeFloatImage(fio);

 		select (par);

 		reposition();

 		ensureSelectionVisible();

 		return;

 	}

 	*/

 }

 void VymModel::deleteKeepChildren()		//FIXME-1 VM still missing

 {

 	BranchObj *bo=getSelectedBranch();

 	BranchObj *par;

 	if (bo)

 	{

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

 		// Don't use this on mapcenter

 		if (!par) return;

 		// Check if we have childs at all to keep

 		if (bo->getTreeItem()->branchCount()==0) 

 		{

 			deleteSelection();

 			return;

 		}

 		QPointF p=bo->getRelPos();

 		saveStateChangingPart(

 			bo->getParObj(),

 			bo,

 			"deleteKeepChildren ()",

 			QString("Remove %1 and keep its children").arg(getObjectName(bo))

 		);

 		QString sel=getSelectString(bo);

 		unselect();

 		par->removeBranchHere(bo);

 		reposition();

 		select (sel);

 		getSelectedBranch()->move2RelPos (p);

 		reposition();

 	}	

 }

 void VymModel::deleteChildren()		//FIXME-1 VM still missing

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{		

 		saveStateChangingPart(

 			bo, 

 			bo,

 			"deleteChildren ()",

 			QString( "Remove children of branch %1").arg(getObjectName(bo))

 		);

 		bo->removeChildren();

 		reposition();

 	}	

 }

 bool VymModel::scrollBranch(BranchItem *bi)

 {

 	if (bi)	

 	{

 		if (bi->isScrolled()) return false;

 		if (bi->branchCount()==0) return false;

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

 		QString u,r;

 		r="scroll";

 		u="unscroll";

 		/* FIXME-1 no savestate yet

 		saveState(

 			bo,

 			QString ("%1 ()").arg(u),

 			bo,

 			QString ("%1 ()").arg(r),

 			QString ("%1 %2").arg(r).arg(getObjectName(bo))

 		);

 		*/

 		bi->toggleScroll();

 		//selection.update();

 		// FIXME-3 VM needed? scene()->update();

 		return true;

 	}	

 	return false;

 }

 bool VymModel::unscrollBranch(BranchItem *bi)

 {

 	if (bi)

 	{

 		if (bi->isScrolled()) return false;

 		if (bi->branchCount()==0) return false;

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

 		QString u,r;

 		u="scroll";

 		r="unscroll";

 		/* FIXME-1 no savestate yet

 		saveState(

 			bo,

 			QString ("%1 ()").arg(u),

 			bo,

 			QString ("%1 ()").arg(r),

 			QString ("%1 %2").arg(r).arg(getObjectName(bo))

 		);

 		*/

 		bi->toggleScroll();

 		// selection.update();

 		// FIXME-3 VM needed? scene()->update();

 		return true;

 	}	

 	return false;

 }

 void VymModel::toggleScroll()

 {

 	BranchItem *bi=(BranchItem*)getSelectedBranchItem();

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

 	{

 		if (bi->isScrolled())

 			unscrollBranch (bi);

 		else

 			scrollBranch (bi);

 	}

 }

 void VymModel::unscrollChildren() 	// FIXME-1	first, next moved to vymmodel

 {

 /*

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		bo->first();

 		while (bo) 

 		{

 			if (bo->isScrolled()) unscrollBranch (bo);

 			bo=bo->next();

 		}

 	}	

 */	

 }

 void VymModel::addFloatImage (const QPixmap &img) 

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

   {

 	FloatImageObj *fio=bo->addFloatImage();

     fio->load(img);

     fio->setOriginalFilename("No original filename (image added by dropevent)");	

 	QString s=getSelectString(bo);

 	saveState (PartOfMap, s, "nop ()", s, "copy ()","Copy dropped image to clipboard",fio  );

 	saveState (fio,"delete ()", bo,QString("paste(%1)").arg(curStep),"Pasting dropped image");

     reposition();

     // FIXME-3 VM needed? scene()->update();

   }

 }

 void VymModel::colorBranch (QColor c)

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		saveState(

 			bo, 

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

 			bo,

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

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

 		);	

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

 	}

 }

 void VymModel::colorSubtree (QColor c)

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo) 

 	{

 		saveStateChangingPart(

 			bo, 

 			bo,

 			QString ("colorSubtree (\"%1\")").arg(c.name()),

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

 		);	

 		bo->setColorSubtree (c); // color links, color children

 	}

 }

 QColor VymModel::getCurrentHeadingColor()

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo) return bo->getColor(); 

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

 	return Qt::black;

 }

 void VymModel::editURL()

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{		

 		bool ok;

 		QString text = QInputDialog::getText(

 				"VYM", tr("Enter URL:"), QLineEdit::Normal,

 				bo->getURL(), &ok, NULL);

 		if ( ok) 

 			// user entered something and pressed OK

 			setURL(text);

 	}

 }

 void VymModel::editLocalURL()

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{		

 		QStringList filters;

 		filters <<"All files (*)";

 		filters << tr("Text","Filedialog") + " (*.txt)";

 		filters << tr("Spreadsheet","Filedialog") + " (*.odp,*.sxc)";

 		filters << tr("Textdocument","Filedialog") +" (*.odw,*.sxw)";

 		filters << tr("Images","Filedialog") + " (*.png *.bmp *.xbm *.jpg *.png *.xpm *.gif *.pnm)";

 		QFileDialog *fd=new QFileDialog( NULL,vymName+" - " +tr("Set URL to a local file"));

 		fd->setFilters (filters);

 		fd->setCaption(vymName+" - " +tr("Set URL to a local file"));

 		fd->setDirectory (lastFileDir);

 		if (! bo->getVymLink().isEmpty() )

 			fd->selectFile( bo->getURL() );

 		fd->show();

 		if ( fd->exec() == QDialog::Accepted )

 		{

 			lastFileDir=QDir (fd->directory().path());

 			setURL (fd->selectedFile() );

 		}

 	}

 }

 void VymModel::editHeading2URL()

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 		setURL (bo->getHeading());

 }	

 void VymModel::editBugzilla2URL()

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{		

 		QString url= "https://bugzilla.novell.com/show_bug.cgi?id="+bo->getHeading();

 		setURL (url);

 	}

 }	

 void VymModel::editFATE2URL()

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{		

 		QString url= "http://keeper.suse.de:8080/webfate/match/id?value=ID"+bo->getHeading();

 		saveState(

 			bo,

 			"setURL (\""+bo->getURL()+"\")",

 			bo,

 			"setURL (\""+url+"\")",

 			QString("Use heading of %1 as link to FATE").arg(getObjectName(bo))

 		);	

 		bo->setURL (url);

 		updateActions();

 	}

 }	

 void VymModel::editVymLink()

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{		

 		QStringList filters;

 		filters <<"VYM map (*.vym)";

 		QFileDialog *fd=new QFileDialog( NULL,vymName+" - " +tr("Link to another map"));

 		fd->setFilters (filters);

 		fd->setCaption(vymName+" - " +tr("Link to another map"));

 		fd->setDirectory (lastFileDir);

 		if (! bo->getVymLink().isEmpty() )

 			fd->selectFile( bo->getVymLink() );

 		fd->show();

 		QString fn;

 		if ( fd->exec() == QDialog::Accepted )

 		{

 			lastFileDir=QDir (fd->directory().path());

 			saveState(

 				bo,

 				"setVymLink (\""+bo->getVymLink()+"\")",

 				bo,

 				"setVymLink (\""+fd->selectedFile()+"\")",

 				QString("Set vymlink of %1 to %2").arg(getObjectName(bo)).arg(fd->selectedFile())

 			);	

 			setVymLink (fd->selectedFile() );	// FIXME-2 ok?

 		}

 	}

 }

 void VymModel::setVymLink (const QString &s)

 {

 	// Internal function, no saveState needed

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{

 		bo->setVymLink(s);

 		reposition();

 		updateActions();

 		selection.update();

 		ensureSelectionVisible();

 	}

 }

 void VymModel::deleteVymLink()

 {

 	BranchObj *bo=getSelectedBranch();

 	if (bo)

 	{		

 		saveState(

 			bo,

 			"setVymLink (\""+bo->getVymLink()+"\")",

 			bo,