#include <QApplication>

 #include <typeinfo>

 #include "vymmodel.h"

 #include "attributeitem.h"

 #include "treeitem.h"

 #include "branchitem.h"

 #include "editxlinkdialog.h"

 #include "exports.h"

 #include "exportxhtmldialog.h"

 #include "file.h"

 #include "geometry.h"		// for addBBox

 #include "mainwindow.h"

 #include "misc.h"

 #include "parser.h"

 #include "process.h"

 #include "warningdialog.h"

 #include "xlinkitem.h"

 #include "xml-freemind.h"

 #include "xmlobj.h"

 #include "xml-vym.h"

 extern bool debug;

 extern Main *mainWindow;

 extern QDBusConnection dbusConnection;

 extern Settings settings;

 extern QString tmpVymDir;

 extern TextEditor *textEditor;

 extern FlagRow *standardFlagsMaster;

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

 {

 	while (rootItem->childCount() >0)

 		deleteItem (rootItem->getChildNum(0) );

 }

 void VymModel::init () 

 {

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

 	selectionBlocked=false;

 	// find routine

 	findReset();

 	// animations	// FIXME-3 switch to new animation system 

 	animationUse=settings.readBoolEntry("/animation/use",false);	// FIXME-3 add options to control _what_ is animated

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

 	// Network

 	netstate=Offline;

 	//Initialize DBUS object

 	adaptorModel=new AdaptorModel(this);	// Created and not deleted as documented in Qt

     if (!dbusConnection.registerObject (QString("/vymmodel_%1").arg(mapNum),this))

 		qWarning ("VymModel: Couldn't register DBUS object!");

 }

 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-3 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 << "VM::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, TreeItem *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-3 this can be done local to vymmodel maybe...

 	standardFlagsMaster->resetUsedCounter();

 	// Build xml recursivly

 	if (!saveSel)

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

 		s+=saveTreeToDir(tmpdir,prefix,offset);

 	else

 	{

 		switch (saveSel->getType())

 		{

 			case TreeItem::Branch:

 				// Save Subtree

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

 				break;

 			case TreeItem::MapCenter:

 				// Save Subtree

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

 				break;

 			case TreeItem::Image:

 				// Save Image

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

 				break;

 			default: 

 				// other types shouldn't be safed directly...

 				break;

 		}

 	}

 	// Save local settings

 	s+=settings.getDataXML (destPath);

 	// Save selection

 	if (getSelectedItem() && !saveSel ) 

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

 	xml.decIndent();

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

 	//cout << s.toStdString() << endl;

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

 	return s;

 }

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

 {

     QString s;

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

 		s+=rootItem->getBranchNum(i)->saveToDir (tmpdir,prefix,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

 	{

 		BranchItem *bi=getSelectedBranch();

 		if (!bi) return aborted;

 		if (lmode==ImportAdd)

 			saveStateChangingPart(

 				bi,

 				bi,

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

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

 		else	

 			saveStateChangingPart(

 				bi,

 				bi,

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

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

 	}	

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

 		mapEditor->setViewportUpdateMode (QGraphicsView::NoViewportUpdate);

 		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;

 		mapEditor->setViewportUpdateMode (QGraphicsView::MinimalViewportUpdate);

 		file.close();

 		if ( ok ) 

 		{

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

 			emitSelectionChanged();

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

 }

 bool VymModel::addMapInsertInt (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

 		handler.setLoadMode (ImportAdd);

 		blockReposition=true;

 		bool ok = reader.parse( source );

 		blockReposition=false;

 		if ( ok ) return true;

 		{	

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

 	return false;

 }

 bool VymModel::addMapInsertInt (const QString &path, int pos)

 {

 	BranchItem *selbi=getSelectedBranch();

 	if (selbi)

 	{

 		if (addMapInsertInt (path))

 		{

 			if (selbi->depth()>0)

 				relinkBranch (selbi->getLastBranch(), selbi,pos);

 			return true;	

 		} else

 		{

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

 			return false;

 		}	

 	}		

 	qWarning ("ME::addMapInsertInt nothing selected");

 	return false;

 }

 ImageItem* VymModel::loadFloatImageInt (BranchItem *dst,QString fn)

 {

 	ImageItem *ii=createImage(dst);

 	if (ii)

 	{

 		ii->load (fn);

 		reposition();

 		return ii;

 	}

 	return NULL;

 }	

 void VymModel::loadFloatImage ()

 {

 	BranchItem *selbi=getSelectedBranch();

 	if (selbi)

 	{

 		Q3FileDialog *fd=new Q3FileDialog( NULL);	// FIXME-4 get rid of Q3FileDialog

 		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;

 			ImageItem *ii;

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

 			{

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

 				ii=loadFloatImageInt (selbi,s);

 				//FIXME-3 check savestate for loadImage 

 				if (ii)

 					saveState(

 						(TreeItem*)ii,

 						"delete ()",

 						selbi, 

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

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

 					);

 				else

 					// TODO loadFIO error handling

 					qWarning ("Failed to load "+s);

 			}

 		}

 		delete (p);

 		delete (fd);

 	}

 }

 void VymModel::saveFloatImageInt  (ImageItem *ii, const QString &type, const QString &fn)

 {

 	ii->save (fn,type);

 }

 void VymModel::saveFloatImage ()

 {

 	ImageItem *ii=getSelectedImage();

 	if (ii)

 	{

 		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 (ii,fd->selectedFilter(),fn );

 		}

 		delete (fd);

 	}

 }

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

 {

 	BranchItem *selbi=getSelectedBranch();

 	BranchItem *bi;

 	if (selbi)

 	{

 		// 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() != ".." )

 			{

 				bi=addNewBranchInt(dst,-2);

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

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

 			bi=addNewBranchInt (dst,-2);

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

 			bi->setHeadingColor (QColor("black"));

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

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

 		}	

 	}		

 }

 void VymModel::importDirInt (const QString &s)	

 {

 	BranchItem *selbi=getSelectedBranch();

 	if (selbi)

 	{

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

 		QDir d(s);

 		importDirInt (selbi,d);

 	}

 }	

 void VymModel::importDir()	//FIXME-3 check me... (not tested yet)

 {

 	BranchItem *selbi=getSelectedBranch();

 	if (selbi)

 	{

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

 {

 	if (!mapChanged)

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

 	mapChanged=true;

 	mapDefault=false;

 	mapUnsaved=true;

 	latestAddedItem=NULL;

 	findReset();

 }

 QString VymModel::getObjectName (LinkableMapObj *lmo)	// FIXME-3 should be obsolete

 {

 	if (!lmo || !lmo->getTreeItem() ) return QString();

 	return getObjectName (lmo->getTreeItem() );

 }

 QString VymModel::getObjectName (TreeItem *ti)

 {

 	QString s;

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

 	s=ti->getHeading();

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

 	return QString ("%1 (%2)").arg(ti->getTypeName()).arg(s);

 }

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

 	bool noErr;

 	QString errMsg;

 	parseAtom (redoCommand,noErr,errMsg);

 	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 (!select (undoSelection))

 	{

 		qWarning ("VymModel::undo()  Could not select object for undo");

 		return;

 	}

 	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;

 	}	

 	bool noErr;

 	QString errMsg;

 	parseAtom (undoCommand,noErr,errMsg);

 	undosAvail--;

 	curStep--; 

 	if (curStep<1) curStep=stepsTotal;

 	redosAvail++;

 	blockSaveState=blockSaveStateOrg;

 /* testing only

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

 	//emitSelectionChanged();

 }

 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, TreeItem *saveSel)

 {

 	sendData(redoCom);	//FIXME-3 testing

 	// Main saveState

 	if (blockSaveState) return;

 	if (debug) cout << "VM::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(TreeItem *undoSel, TreeItem* 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(TreeItem* redoSel, const QString &comment)

 {

 	if (!redoSel)

 	{

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

 		return;

 	}

 	QString undoSelection;

 	QString redoSelection=getSelectString(redoSel);

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

 	{

 		undoSelection=getSelectString (redoSel->parent());

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

 		saveState (PartOfMap,

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

 			redoSelection, "delete ()", 

 			comment, 

 			redoSel);

 	}

 	if (redoSel->getType()==TreeItem::MapCenter) 

 	{

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

 		saveState (PartOfMap,

 			undoSelection, QString("addMapInsert (\"PATH\")"),

 			redoSelection, "delete ()", 

 			comment, 

 			redoSel);

 	}

 }

 void VymModel::saveState(TreeItem *undoSel, const QString &uc, TreeItem *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;

 }

 TreeItem* VymModel::findBySelectString(QString s)

 {

 	if (s.isEmpty() ) return NULL;

 	// Old maps don't have multiple mapcenters and don't save full path

 	if (s.left(2) !="mc")

 		s="mc:0,"+s;

 	QStringList parts=s.split (",");

 	QString typ;

 	int n;

 	TreeItem *ti=rootItem;

 	while (!parts.isEmpty() )

 	{

 		typ=parts.first().left(2);

 		n=parts.first().right(parts.first().length() - 3).toInt();

 		parts.removeFirst();

 		if (typ=="mc" || typ=="bo")

 			ti=ti->getBranchNum (n);

 		else if (typ=="fi")

 			ti=ti->getImageNum (n);

 		else if (typ=="ai")

 			ti=ti->getAttributeNum (n);

 		else if (typ=="xl")

 			ti=ti->getXLinkNum (n);

 		if(!ti) return NULL;		

 	}

 	return  ti;

 }

 TreeItem* VymModel::findID (const uint &i)	//FIXME-3 Search also other types...

 {

 	BranchItem *cur=NULL;

 	BranchItem *prev=NULL;

 	nextBranch(cur,prev);

 	while (cur) 

 	{

 		if (i==cur->getID() ) return cur;

 		nextBranch(cur,prev);

 	}

 	return NULL;

 }

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

 // Interface 

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

 void VymModel::setVersion (const QString &s)

 {

 	version=s;

 }

 QString VymModel::getVersion()

 {

 	return version;

 }

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

 {

 	int c=0;

 	BranchItem *cur=NULL;

 	BranchItem *prev=NULL;

 	nextBranch(cur,prev);

 	while (cur) 

 	{

 		c++;

 		nextBranch(cur,prev);

 	}

 	return c;

 }

 void VymModel::setSortFilter (const QString &s)

 {

 	sortFilter=s;

 	emit (sortFilterChanged (sortFilter));

 }

 QString VymModel::getSortFilter ()

 {

 	return sortFilter;

 }

 void VymModel::setHeading(const QString &s)

 {

 	BranchItem *selbi=getSelectedBranch();

 	if (selbi)

 	{

 		saveState(

 			selbi,

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

 			selbi,

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

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

 		selbi->setHeading(s );

 		emitDataHasChanged ( selbi);	//FIXME-3 maybe emit signal from TreeItem? 

 		reposition();

 		emitSelectionChanged();

 	}

 }

 QString VymModel::getHeading()

 {

 	TreeItem *selti=getSelectedItem();

 	if (selti)

 		return selti->getHeading();

 	else	

 		return QString();

 }

 void VymModel::setNote(const QString &s)

 {

 	TreeItem *selti=getSelectedItem();

 	if (selti) 

 	{

 		emitNoteHasChanged(selti);

 		saveState(

 			selti,

 			"setNote (\""+selti->getNote()+"\")", 

 			selti,

 			"setNote (\""+s+"\")", 

 			QString("Set note of %1 ").arg(getObjectName(selti)) );

 	}

 		selti->setNote(s);

 }

 QString VymModel::getNote()

 {

 	TreeItem *selti=getSelectedItem();

 	if (selti)

 		return selti->getNote();

 	else	

 		return QString();

 }

 void VymModel::findDuplicateURLs()	// FIXME-3 needs GUI

 {

 	// Generate map containing _all_ URLs and branches

 	QString u;

 	QMap <QString,BranchItem*> map;

 	BranchItem *cur=NULL;

 	BranchItem *prev=NULL;

 	nextBranch(cur,prev);

 	while (cur) 

 	{

 		u=cur->getURL();

 		if (!u.isEmpty() )

 			map.insertMulti (u,cur);

 		nextBranch(cur,prev);

 	}

 	// Extract duplicate URLs

 	QMap <QString, BranchItem*>::const_iterator i=map.constBegin();

 	QMap <QString, BranchItem*>::const_iterator firstdup=map.constEnd();	//invalid

 	while (i != map.constEnd())

 	{

 		if (i!=map.constBegin() && i.key()==firstdup.key())

 		{

 			if (  i-1==firstdup )

 			{

 				cout << firstdup.key().toStdString() << endl;

 				cout << " - "<< firstdup.value() <<" - "<<firstdup.value()->getHeadingStd()<<endl;

 			}	

 			cout << " - "<< i.value() <<" - "<<i.value()->getHeadingStd()<<endl;

 		} else

 			firstdup=i;

 		++i;

 	}

 }

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

 {

 	if (!s.isEmpty() && s!=findString)

 	{

 		findReset();

 		findString=s;

 	}

 	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;	

 		nextBranch (findCurrent,findPrevious);

 	}	

 	bool searching=true;

 	bool foundNote=false;

 	while (searching && !EOFind)

 	{

 		if (findCurrent)

 		{

 			// Searching in Note

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

 			{

 				select (findCurrent);

 				/*

 				if (getSelectedBranch()!=itFind) 

 				{

 					select(itFind);

 					emitShowSelection();

 				}

 				*/

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

 				{

 					searching=false;

 					foundNote=true;

 				}	

 			}

 			// Searching in Heading

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

 			{

 				select(findCurrent);

 				searching=false;

 			}

 		}	

 		if (!foundNote)

 		{

 			if (!nextBranch(findCurrent,findPrevious) )

 				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

 	findString.clear();

 	findCurrent=NULL;

 	findPrevious=NULL;

 	EOFind=false;

 }

 void VymModel::emitShowFindWidget()

 {

 	emit (showFindWidget());

 }

 void VymModel::setScene (QGraphicsScene *s)

 {

 	mapScene=s;	

 }

 void VymModel::setURL(const QString &url) 

 {

 	TreeItem *selti=getSelectedItem();

 	if (selti)

 	{

 		QString oldurl=selti->getURL();

 		selti->setURL (url);

 		saveState (

 			selti,

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

 			selti,

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

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

 		);

 		reposition();

 		emitDataHasChanged (selti);

 		emitShowSelection();

 	}

 }	

 QString VymModel::getURL()	

 {

 	TreeItem *selti=getSelectedItem();

 	if (selti)

 		return selti->getURL();

 	else	

 		return QString();

 }

 QStringList VymModel::getURLs(bool ignoreScrolled)	

 {

 	QStringList urls;

 	BranchItem *selbi=getSelectedBranch();

 	BranchItem *cur=selbi;

 	BranchItem *prev=NULL;

 	while (cur) 

 	{

 		if (!cur->getURL().isEmpty()  && !(ignoreScrolled && cur->hasScrolledParent(cur) )) 

 			urls.append( cur->getURL());

 		cur=nextBranch (cur,prev,true,selbi);

 	}	

 	return urls;

 }

 void VymModel::setFrameType(const FrameObj::FrameType &t)	//FIXME-4 not saved if there is no LMO

 {

 	BranchItem *bi=getSelectedBranch();

 	if (bi)

 	{

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

 		if (bo)

 		{

 			QString s=bo->getFrameTypeName();

 			bo->setFrameType (t);

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

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

 			reposition();

 			bo->updateLinkGeometry();

 		}

 	}

 }

 void VymModel::setFrameType(const QString &s)	//FIXME-4 not saved if there is no LMO

 {

 	BranchItem *bi=getSelectedBranch();

 	if (bi)

 	{

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

 		if (bo)

 		{

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

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

 			bo->setFrameType (s);

 			reposition();

 			bo->updateLinkGeometry();

 		}

 	}

 }

 void VymModel::setFramePenColor(const QColor &c)	//FIXME-4 not saved if there is no LMO

 {

 	BranchItem *bi=getSelectedBranch();

 	if (bi)

 	{

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

 		if (bo)

 		{

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

 				bi, 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)	//FIXME-4 not saved if there is no LMO

 {

 	BranchItem *bi=getSelectedBranch();

 	if (bi)

 	{

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

 		if (bo)

 		{

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

 				bi, 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) //FIXME-4 not saved if there is no LMO

 {

 	BranchItem *bi=getSelectedBranch();

 	if (bi)

 	{

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

 		if (bo)

 		{

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

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

 			bo->setFramePadding (i);

 			reposition();

 			bo->updateLinkGeometry();

 		}	

 	}	

 }

 void VymModel::setFrameBorderWidth(const int &i) //FIXME-4 not saved if there is no LMO

 {

 	BranchItem *bi=getSelectedBranch();

 	if (bi)

 	{

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

 		if (bo)

 		{

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

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

 			bo->setFrameBorderWidth (i);

 			reposition();

 			bo->updateLinkGeometry();

 		}	

 	}	

 }

 void VymModel::setIncludeImagesVer(bool b)

 {

 	BranchItem *bi=getSelectedBranch();

 	if (bi)

 	{

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

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

 		saveState(

 			bi,

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

 			bi, 

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

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

 		);	

 		bi->setIncludeImagesVer(b);

 		emitDataHasChanged ( bi);	

 		reposition();

 	}	

 }

 void VymModel::setIncludeImagesHor(bool b)	

 {

 	BranchItem *bi=getSelectedBranch();

 	if (bi)

 	{

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

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

 		saveState(

 			bi,

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

 			bi, 

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

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

 		);	

 		bi->setIncludeImagesHor(b);

 		emitDataHasChanged ( bi);

 		reposition();

 	}	

 }

 void VymModel::setHideLinkUnselected (bool b) // FIXME-2 Images still have visible link after load

 {

 	TreeItem *ti=getSelectedItem();

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

 	{

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

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

 		saveState(

 			ti,

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

 			ti, 

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

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

 		);	

 		((MapItem*)ti)->setHideLinkUnselected(b);

 	}

 }

 void VymModel::setHideExport(bool b)

 {

 	TreeItem *ti=getSelectedItem();

 	if (ti && 

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

 	{

 		ti->setHideInExport (b);

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

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

 		saveState(

 			ti,

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

 			ti,

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

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

 		);	

 			emitDataHasChanged(ti);

 			emitSelectionChanged();

 		updateActions();

 		reposition();

 		// emitSelectionChanged();

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

 	}

 }

 void VymModel::toggleHideExport()

 {

 	TreeItem *selti=getSelectedItem();

 	if (selti)

 		setHideExport ( !selti->hideInExport() );

 }

 void VymModel::addTimestamp()	//FIXME-3 new function, localize

 {

 	BranchItem *selbi=addNewBranch();

 	if (selbi)

 	{

 		QDate today=QDate::currentDate();

 		QChar c='0';

 		selbi->setHeading (QString ("%1-%2-%3")

 			.arg(today.year(),4,10,c)

 			.arg(today.month(),2,10,c)

 			.arg(today.day(),2,10,c));

 		emitDataHasChanged ( selbi);	//FIXME-3 maybe emit signal from TreeItem? 

 		reposition();

 		select (selbi);

 	}

 }

 void VymModel::copy()	

 {

 	TreeItem *selti=getSelectedItem();

 	if (selti &&

 		(selti->getType() == TreeItem::Branch || 

 		selti->getType() == TreeItem::MapCenter  ||

 		selti->getType() == TreeItem::Image ))

 	{

 		if (redosAvail == 0)

 		{

 			// Copy to history

 			QString s=getSelectString(selti);

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

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

 {   

 	BranchItem *selbi=getSelectedBranch();

 	if (selbi)

 	{

 		saveStateChangingPart(

 			selbi,

 			selbi,

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

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

 		);

 		pasteNoSave(0);

 		reposition();

 	}

 }

 void VymModel::cut()	

 {

 	TreeItem *selti=getSelectedItem();

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

 	{

 		copy();

 		deleteSelection();

 		reposition();

 	}

 }

 bool VymModel::moveUp(BranchItem *bi)	

 {

 	if (bi && bi->canMoveUp()) 

 		return relinkBranch (bi,(BranchItem*)bi->parent(),bi->num()-1);

 	else	

 		return false;

 }

 void VymModel::moveUp()	

 {

 	BranchItem *selbi=getSelectedBranch();

 	if (selbi)

 	{

 		QString oldsel=getSelectString();

 		if (moveUp (selbi))

 			saveState (

 				getSelectString(),"moveDown ()",

 				oldsel,"moveUp ()",

 				QString("Move up %1").arg(getObjectName(selbi)));

 	}

 }

 bool VymModel::moveDown(BranchItem *bi)	

 {

 	if (bi && bi->canMoveDown())

 		return relinkBranch (bi,(BranchItem*)bi->parent(),bi->num()+1);

 	else

 		return false;

 }

 void VymModel::moveDown()	

 {

 	BranchItem *selbi=getSelectedBranch();

 	if (selbi)

 	{

 		QString oldsel=getSelectString();

 		if ( moveDown(selbi))

 			saveState (

 				getSelectString(),"moveUp ()",

 				oldsel,"moveDown ()",

 				QString("Move down %1").arg(getObjectName(selbi)));

 	}

 }

 void VymModel::detach()	

 {

 	BranchItem *selbi=getSelectedBranch();

 	if (selbi && selbi->depth()>0)

 	{

 		// if no relPos have been set before, try to use current rel positions   

 		if (selbi->getLMO())

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

 				selbi->getBranchNum(i)->getBranchObj()->setRelPos();

 		QString oldsel=getSelectString();

 		int n=selbi->num();

 		QPointF p;

 		BranchObj *bo=selbi->getBranchObj();

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

 		QString parsel=getSelectString(selbi->parent());

 		if ( relinkBranch (selbi,rootItem,-1) )

 			saveState (

 				getSelectString (selbi),

 				QString("relinkTo (\"%1\",%2,%3,%4)").arg(parsel).arg(n).arg(p.x()).arg(p.y()),

 				oldsel,

 				"detach ()",

 				QString("Detach %1").arg(getObjectName(selbi))

 			);

 	}

 }

 void VymModel::sortChildren(bool inverse)

 {

 	BranchItem* selbi=getSelectedBranch();

 	if (selbi)

 	{

 		if(selbi->branchCount()>1)

 		{

 			if (!inverse)

 			{

 			saveStateChangingPart(

 				selbi,selbi, "sortChildren ()",

 				QString("Sort children of %1").arg(getObjectName(selbi)));

 			}

 			selbi->sortChildren(inverse);

 			reposition();

 			emitShowSelection();

 		}

 	}

 }

 BranchItem* VymModel::createMapCenter()

 {

 	BranchItem *newbi=addMapCenter (QPointF (0,0) );

 	return newbi;

 }

 BranchItem* VymModel::createBranch(BranchItem *dst)	

 {

 	if (dst)

 		return addNewBranchInt (dst,-2);

 	else

 		return NULL;

 }

 ImageItem* VymModel::createImage(BranchItem *dst)

 {

 	if (dst)

 	{

 		QModelIndex parix;

 		int n;

 		QList<QVariant> cData;

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

 		ImageItem *newii=new ImageItem(cData) ;	

 		//newii->setHeading (QApplication::translate("Heading of new image in map", "new image"));

 		emit (layoutAboutToBeChanged() );

 			parix=index(dst);

 			if (!parix.isValid()) cout << "VM::createII invalid index\n";

 			n=dst->getRowNumAppend(newii);

 			beginInsertRows (parix,n,n);

 			dst->appendChild (newii);	

 			endInsertRows ();

 		emit (layoutChanged() );

 		// save scroll state. If scrolled, automatically select

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

 		newii->createMapObj(mapScene);

 		reposition();

 		return newii;

 	} 

 	return NULL;

 }

 XLinkItem* VymModel::createXLink(BranchItem *bi,bool createMO)

 {

 	if (bi)

 	{

 		QModelIndex parix;

 		int n;

 		QList<QVariant> cData;

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

 		XLinkItem *newxli=new XLinkItem(cData) ;	

 		newxli->setBegin (bi);

 		emit (layoutAboutToBeChanged() );

 			parix=index(bi);

 			n=bi->getRowNumAppend(newxli);

 			beginInsertRows (parix,n,n);

 			bi->appendChild (newxli);	

 			endInsertRows ();

 		emit (layoutChanged() );

 		// save scroll state. If scrolled, automatically select

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

 		if (createMO) 

 		{

 			newxli->createMapObj(mapScene);

 			reposition();

 		}

 		return newxli;

 	} 

 	return NULL;

 }

 AttributeItem* VymModel::addAttribute()	

 {

 	BranchItem *selbi=getSelectedBranch();

 	if (selbi)

 	{

 		QList<QVariant> cData;

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

 		AttributeItem *a=new AttributeItem (cData);

 		if (addAttribute (a)) return a;

 	}

 	return NULL;

 }

 AttributeItem* VymModel::addAttribute(AttributeItem *ai)	// FIXME-2 savestate missing

 {

 	BranchItem *selbi=getSelectedBranch();

 	if (selbi)

 	{

 		emit (layoutAboutToBeChanged() );

 		QModelIndex parix=index(selbi);

 		int n=selbi->getRowNumAppend (ai);

 		beginInsertRows (parix,n,n);	

 		selbi->appendChild (ai);	

 		endInsertRows ();

 		emit (layoutChanged() );

 		ai->createMapObj(mapScene);		//FIXME-2 check that...

 		reposition();

 		return ai;

 	}

 	return NULL;

 }

 BranchItem* VymModel::addMapCenter ()

 {

 	BranchItem *bi=addMapCenter (contextPos);

 	updateActions();

 	emitShowSelection();

 	saveState (

 		bi,

 		"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 bi;	

 }

 BranchItem* VymModel::addMapCenter(QPointF absPos)	

 // createMapCenter could then probably be merged with createBranch

 {

 	// Create TreeItem

 	QModelIndex parix=index(rootItem);

 	QList<QVariant> cData;

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

 	BranchItem *newbi=new BranchItem (cData,rootItem);

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

 	int n=rootItem->getRowNumAppend (newbi);

 	emit (layoutAboutToBeChanged() );

 	beginInsertRows (parix,n,n);

 	rootItem->appendChild (newbi);

 	endInsertRows();

 	emit (layoutChanged() );

 	// Create MapObj

 	newbi->setPositionMode (MapItem::Absolute);

 	BranchObj *bo=newbi->createMapObj(mapScene);

 	if (bo) bo->move (absPos);

 	return newbi;

 }

 BranchItem* VymModel::addNewBranchInt(BranchItem *dst,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

 	// Create TreeItem

 	QList<QVariant> cData;

 	cData << "" << "undef";

 	BranchItem *parbi;

 	QModelIndex parix;

 	int n;

 	BranchItem *newbi=new BranchItem (cData);	

 	//newbi->setHeading (QApplication::translate("Heading of new branch in map", "new"));

 	emit (layoutAboutToBeChanged() );

 	if (num==-2)

 	{

 		parbi=dst;

 		parix=index(parbi);

 		n=parbi->getRowNumAppend (newbi);

 		beginInsertRows (parix,n,n);	

 		parbi->appendChild (newbi);	

 		endInsertRows ();

 	}else if (num==-1 || num==-3)

 	{

 		// insert below selection

 		parbi=(BranchItem*)dst->parent();

 		parix=index(parbi);  

 		n=dst->childNumber() + (3+num)/2;	//-1 |-> 1;-3 |-> 0

 		beginInsertRows (parix,n,n);	

 		parbi->insertBranch(n,newbi);	

 		endInsertRows ();

 	}

 	emit (layoutChanged() );

 	// Set color of heading to that of parent

 	newbi->setHeadingColor (parbi->getHeadingColor());

 	// save scroll state. If scrolled, automatically select

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

 	newbi->createMapObj(mapScene);

 	reposition();

 	return newbi;

 }	

 BranchItem* VymModel::addNewBranch(int pos)

 {

 	// Different meaning than num in addNewBranchInt!

 	// -1	add above

 	//  0	add as child

 	// +1	add below

 	BranchItem *newbi=NULL;

 	BranchItem *selbi=getSelectedBranch();

 	if (selbi)

 	{

 		// FIXME-3 setCursor (Qt::ArrowCursor);  //Still needed?

 		newbi=addNewBranchInt (selbi,pos-2);

 		if (newbi)

 		{

 			saveState(

 				newbi,		

 				"delete ()",

 				selbi,

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

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

 			reposition();

 			// emitSelectionChanged(); FIXME-3

 			latestAddedItem=newbi;

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

 			/* FIXME-4  network problem:  QString ps=qpointfToString (newbo->getAbsPos());

 			sendData ("selectLatestAdded ()");

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

 			sendSelection();

 			*/

 		}

 	}	

 	return newbi;

 }

 BranchItem* VymModel::addNewBranchBefore()	

 {

 	BranchItem *newbi=NULL;

 	BranchItem *selbi=getSelectedBranch();

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

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

 	{

 		//QPointF p=bo->getRelPos();

 		// add below selection

 		newbi=addNewBranchInt (selbi,-1);

 		if (newbi)

 		{

 			//newbi->move2RelPos (p);

 			// Move selection to new branch

 			relinkBranch (selbi,newbi,0);

 			saveState (newbi, "deleteKeepChildren ()", newbi, "addBranchBefore ()", 

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

 			// FIXME-3 needed? reposition();

 			// emitSelectionChanged(); FIXME-3 

 		}

 	}	

 	return newbi;

 }

 bool VymModel::relinkBranch (BranchItem *branch, BranchItem *dst, int pos)

 {

 	if (branch && dst)

 	{

 		unselect();

 		// Do we need to update frame type?

 		bool keepFrame=false;

 		emit (layoutAboutToBeChanged() );

 		BranchItem *branchpi=(BranchItem*)branch->parent();

 		// Remove at current position

 		int n=branch->childNum();

 /* FIXME-4 seg since 20091207, if ModelTest active. strange.

 		// error occured if relinking branch to empty mainbranch

 		cout<<"VM::relinkBranch:\n";

 		cout<<"    b="<<branch->getHeadingStd()<<endl;

 		cout<<"  dst="<<dst->getHeadingStd()<<endl;

 		cout<<"  pos="<<pos<<endl;

 		cout<<"   n1="<<n<<endl;

 */		

 		beginRemoveRows (index(branchpi),n,n);

 		branchpi->removeChild (n);

 		endRemoveRows();

 		if (pos<0 ||pos>dst->branchCount() ) pos=dst->branchCount();

 		// Append as last branch to dst

 		if (dst->branchCount()==0)

 			n=0;

 		else	

 			n=dst->getFirstBranch()->childNumber(); 

 		beginInsertRows (index(dst),n+pos,n+pos);

 		dst->insertBranch (pos,branch);

 		endInsertRows();

 		// Correct type if necessesary

 		if (branch->getType()==TreeItem::MapCenter) 

 			branch->setType(TreeItem::Branch);

 		// reset parObj, fonts, frame, etc in related LMO or other view-objects

 		branch->updateStyles(keepFrame);

 		emit (layoutChanged() );

 		reposition();	// both for moveUp/Down and relinking

 		if (dst->isScrolled() )

 		{

 			select (dst);	

 			branch->updateVisibility();

 		}

 		else	

 			select (branch);

 		return true;

 	}

 	return false;

 }

 bool VymModel::relinkImage (ImageItem *image, BranchItem *dst)

 {

 	if (image && dst)

 	{

 		emit (layoutAboutToBeChanged() );

 		BranchItem *pi=(BranchItem*)(image->parent());

 		QString oldParString=getSelectString (pi);

 		// Remove at current position

 		int n=image->childNum();

 		beginRemoveRows (index(pi),n,n);

 		pi->removeChild (n);

 		endRemoveRows();

 		// Add at dst

 		QModelIndex dstix=index(dst);

 		n=dst->getRowNumAppend (image);

 		beginInsertRows (dstix,n,n+1);	

 		dst->appendChild (image);	

 		endInsertRows ();

 		// Set new parent also for lmo

 		if (image->getLMO() && dst->getLMO() )

 			image->getLMO()->setParObj (dst->getLMO() );

 		emit (layoutChanged() );

 		saveState(

 			image,

 			QString("relinkTo (\"%1\")").arg(oldParString), 

 			image,

 			QString ("relinkTo (\"%1\")").arg(getSelectString (dst)),

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

 		return true;	

 	}

 	return false;

 }

 void VymModel::deleteSelection()	

 {

 	BranchItem *selbi=getSelectedBranch();

 	if (selbi)

 	{	// Delete branch

 		unselect();

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

 		BranchItem *pi=(BranchItem*)(deleteItem (selbi));

 		if (pi)

 		{

 			if (pi->isScrolled() && pi->branchCount()==0)

 			{

 				pi->unScroll();

 				emitDataHasChanged(pi);

 			}	

 			select (pi);

 			emitShowSelection();

 		}

 		return;

 	}

 	TreeItem *ti=getSelectedItem();

 	if (ti)

 	{	// Delete other item

 		TreeItem *pi=ti->parent();

 		if (!pi) return;

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

 		{

 			saveStateChangingPart(

 				pi, 

 				ti,

 				"delete ()",

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

 			);

 			unselect();

 			deleteItem (ti);

 			emitDataHasChanged (pi);

 			select (pi);

 			reposition();

 			emitShowSelection();

 		} else if (ti->getType()==TreeItem::XLink)

 		{

 			//FIXME-2 savestate missing

 			deleteItem (ti);

 		} else

 			qWarning ("VymmModel::deleteSelection()  unknown type?!");

 	}

 }

 void VymModel::deleteKeepChildren()	//FIXME-3 does not work yet for mapcenters

 {

 	BranchItem *selbi=getSelectedBranch();

 	BranchItem *pi;

 	if (selbi)

 	{

 		// Don't use this on mapcenter

 		if (selbi->depth()<2) return;

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

 		// Check if we have childs at all to keep

 		if (selbi->branchCount()==0) 

 		{

 			deleteSelection();

 			return;

 		}

 		QPointF p;

 		if (selbi->getLMO()) p=selbi->getLMO()->getRelPos();

 		saveStateChangingPart(

 			pi,

 			selbi,

 			"deleteKeepChildren ()",

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

 		);

 		QString sel=getSelectString(selbi);

 		unselect();

 		int pos=selbi->num();

 		BranchItem *bi=selbi->getFirstBranch();

 		while (bi)

 		{

 			relinkBranch (bi,pi,pos);

 			bi=selbi->getFirstBranch();

 			pos++;

 		}

 		deleteItem (selbi);

 		reposition();

 		select (sel);

 		BranchObj *bo=getSelectedBranchObj();

 		if (bo) 

 		{

 			bo->move2RelPos (p);

 			reposition();

 		}

 	}	

 }

 void VymModel::deleteChildren()		

 {

 	BranchItem *selbi=getSelectedBranch();

 	if (selbi)

 	{		

 		saveStateChangingPart(

 			selbi, 

 			selbi,

 			"deleteChildren ()",

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

 		);

 		emit (layoutAboutToBeChanged() );

 		QModelIndex ix=index (selbi);

 		int n=selbi->branchCount()-1;

 		beginRemoveRows (ix,0,n);

 		removeRows (0,n+1,ix);

 		endRemoveRows();

 		if (selbi->isScrolled()) selbi->unScroll();

 		emit (layoutChanged() );

 		reposition();

 	}	

 }

 TreeItem* VymModel::deleteItem (TreeItem *ti)

 {

 	if (ti)

 	{

 		TreeItem *pi=ti->parent();

 		QModelIndex parentIndex=index(pi);

 		emit (layoutAboutToBeChanged() );

 		int n=ti->childNum();

 		beginRemoveRows (parentIndex,n,n);

 		removeRows (n,1,parentIndex);

 		endRemoveRows();

 		reposition();

 		emit (layoutChanged() );

 		if (pi->depth()>=0) return pi;

 	}	

 	return NULL;

 }

 void VymModel::clearItem (TreeItem *ti)

 {

 	if (ti)

 	{

 		QModelIndex parentIndex=index(ti);

 		if (!parentIndex.isValid()) return;

 		int n=ti->childCount();

 		if (n==0) return;

 		emit (layoutAboutToBeChanged() );

 		beginRemoveRows (parentIndex,0,n-1);

 		removeRows (0,n,parentIndex);

 		endRemoveRows();