#include "mapeditor.h"

#include <qstatusbar.h>

#include <qmessagebox.h>

#include <qapplication.h>

#include <qpainter.h>

#include <qpopupmenu.h>

#include <qprinter.h>

#include <qpaintdevicemetrics.h>

#include <qfile.h>

#include <qfiledialog.h>

#include <qdir.h>

#include <qcolor.h>

#include <qcolordialog.h>

#include <qbitmap.h>

#include <qprocess.h>

#include <qinputdialog.h>

#include <qdragobject.h>

#include <qurloperator.h>

#include <qnetworkprotocol.h>

#include <qregexp.h>

#include <iostream>

#include <cstdlib>

#include <typeinfo>

#include "version.h"

#include "api.h"

#include "xml.h"

#include "texteditor.h"

#include "linkablemapobj.h"

#include "exports.h"

#include "misc.h"

#include "mainwindow.h"

#include "extrainfodialog.h"

#include "editxlinkdialog.h"

#include "settings.h"

#include "icons/flag-note.xpm"

#include "icons/flag-url.xpm"

#include "icons/flag-vymlink.xpm"	

#include "icons/flag-scrolled-right.xpm"

#include "icons/flag-tmpUnscrolled-right.xpm"

#include "icons/flag-questionmark.xpm"

#include "icons/flag-exclamationmark.xpm"

#include "icons/flag-hook-green.xpm"

#include "icons/flag-cross-red.xpm"

#include "icons/flag-stopsign.xpm"

#include "icons/flag-smiley-good.xpm"

#include "icons/flag-smiley-sad.xpm"

#include "icons/flag-clock.xpm"

#include "icons/flag-lamp.xpm"

#include "icons/flag-arrow-up.xpm"

#include "icons/flag-arrow-down.xpm"

#include "icons/flag-thumb-up.xpm"

#include "icons/flag-thumb-down.xpm"

#include "icons/flag-heart.xpm"

#include "icons/flag-flash.xpm"

#include "icons/flag-lifebelt.xpm"

extern TextEditor *textEditor;

extern int statusbarTime;

extern Main *mainWindow;

extern QString tmpVymDir;

extern FlagRowObj *systemFlagsDefault;

extern FlagRowObj *standardFlagsDefault;

extern MapEditor *clipboardME;

extern QPtrList <QAction> actionListBranches;

extern QAction *actionFileSave;

extern QAction *actionEditUndo;

extern QAction *actionEditCopy;

extern QAction *actionEditCut;

extern QAction *actionEditPaste;

extern QAction *actionEditMoveUp;

extern QAction *actionEditMoveDown;

extern QAction *actionEditToggleScroll;

extern QAction *actionEditOpenURL;

extern QAction *actionEditURL;

extern QAction *actionEditHeading2URL;

extern QAction *actionEditBugzilla2URL;

extern QAction *actionEditOpenVymLink;

extern QAction *actionEditVymLink;

extern QAction *actionEditDeleteVymLink;

extern QAction *actionEditHeading;

extern QAction *actionEditDelete;

extern QAction *actionEditAddBranch;

extern QAction *actionEditAddBranchAbove;

extern QAction *actionEditAddBranchBelow;

extern QAction *actionEditRemoveBranchHere;

extern QAction *actionEditRemoveChilds;

extern QAction *actionEditImportAdd;

extern QAction *actionEditImportReplace;

extern QAction *actionEditSaveBranch;

extern QAction *actionEditSelectFirst;

extern QAction *actionEditSelectLast;

extern QAction *actionEditLoadImage;

extern QAction *actionEditToggleFloatExport;

extern QAction* actionFormatPickColor;

extern QAction* actionFormatColorBranch;

extern QAction* actionFormatColorSubtree;

extern QAction *actionFormatLinkColorHint;

extern QAction *actionFormatBackColor;

extern QAction *actionFormatLinkColor;

extern QActionGroup* actionGroupModModes;

extern QAction* actionModModeColor;

extern QAction* actionModModeLink;

extern QAction* actionModModeCopy;

extern QActionGroup *actionGroupFormatFrameTypes;

extern QAction *actionFormatFrameNone;

extern QAction *actionFormatFrameRectangle;

extern QActionGroup *actionGroupFormatLinkStyles;

extern QAction *actionFormatHideLinkUnselected;

extern QAction *actionFormatLinkStyleLine;

extern QAction *actionFormatLinkStyleParabel;

extern QAction *actionFormatLinkStylePolyLine;

extern QAction *actionFormatLinkStylePolyParabel;

extern QAction *actionViewToggleNoteEditor;

extern QAction *actionSettingsAutoedit;

extern QAction *actionSettingsAutoselectHeading;

extern QAction *actionSettingsAutoselectText;

extern QAction *actionSettingsPasteNewHeading;

extern QAction *actionSettingsUseFlagGroups;

extern QPopupMenu *branchContextMenu;

extern QPopupMenu *branchLinksContextMenu;

extern QPopupMenu *branchLinksContextMenuDup;

extern QPopupMenu *floatimageContextMenu;

extern QPopupMenu *saveImageFormatMenu;

extern QPopupMenu *exportImageFormatMenu;

extern QPopupMenu *canvasContextMenu;

extern Settings settings;

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

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

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

MapEditor::MapEditor(

	QWidget* parent, bool interactive, const char* name, WFlags f) :

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

{

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

	mapNum++;

    viewport()->setAcceptDrops(true);

    mapCanvas = new QCanvas(1000,800);

	mapCanvas->setAdvancePeriod(30);

    setCanvas (mapCanvas);

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

	setVScrollBarMode ( QScrollView::AlwaysOn );

	setHScrollBarMode ( QScrollView::AlwaysOn );

	// Now create the _global_ system flags _once_:

	// (Later all OrnamentedObj copy from this 

	// and set their own canvas)

	if (!systemFlagsDefault)

	{

		systemFlagsDefault = new FlagRowObj (mapCanvas);

		systemFlagsDefault->setVisibility (false);

		systemFlagsDefault->setName ("systemFlagsDef");

		FlagObj *fo = new FlagObj (mapCanvas);

		fo->load(QPixmap(flag_note_xpm));

		fo->setName("note");

		fo->setToolTip(tr("Note","Systemflag"));

		systemFlagsDefault->addFlag (fo);	// makes deep copy

		fo->load(QPixmap(flag_url_xpm));

		fo->setName("url");

		fo->setToolTip(tr("WWW Document (external)","Systemflag"));

		systemFlagsDefault->addFlag (fo);

		fo->load(QPixmap(flag_vymlink_xpm));

		fo->setName("vymLink");

		fo->setToolTip(tr("Link to another vym map","Systemflag"));

		systemFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_scrolled_right_xpm));

		fo->setName("scrolledright");

		fo->setToolTip(tr("subtree is scrolled","Systemflag"));

		systemFlagsDefault->addFlag (fo);

		fo->load(QPixmap(flag_tmpUnscrolled_right_xpm));

		fo->setName("tmpUnscrolledright");

		fo->setToolTip(tr("subtree is temporary scrolled","Systemflag"));

		systemFlagsDefault->addFlag (fo);

		delete (fo);

	}

	if (!standardFlagsDefault)

	{

		standardFlagsDefault = new FlagRowObj (mapCanvas);

		standardFlagsDefault->setVisibility (false);

		standardFlagsDefault->setName ("standardFlagsDef");

		FlagObj *fo = new FlagObj (mapCanvas);

		fo->load(QPixmap(flag_exclamationmark_xpm));

		fo->setName ("exclamationmark");

		fo->setGroup("standard-mark");

		fo->setToolTip(tr("Take care!","Standardflag"));

		standardFlagsDefault->addFlag (fo);	// makes deep copy

		fo->load(QPixmap(flag_questionmark_xpm));

		fo->setName("questionmark");

		fo->setGroup("standard-mark");

		fo->setToolTip(tr("Really?","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_hook_green_xpm));

		fo->setName("hook-green");

		fo->setGroup("standard-hook");

		fo->setToolTip(tr("ok!","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_cross_red_xpm));

		fo->setName("cross-red");

		fo->setGroup("standard-hook");

		fo->setToolTip(tr("Not ok!","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_stopsign_xpm));

		fo->setName("stopsign");

		fo->setToolTip(tr("This won't work!","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_smiley_good_xpm));

		fo->setName("smiley-good");

		fo->setGroup("standard-smiley");

		fo->setToolTip(tr("Good","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_smiley_sad_xpm));

		fo->setName("smiley-sad");

		fo->setGroup("standard-smiley");

		fo->setToolTip(tr("Bad","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_clock_xpm));

		fo->setName("clock");

		fo->setToolTip(tr("Time critical","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_lamp_xpm));

		fo->setName("lamp");

		fo->setToolTip(tr("Idea!","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_arrow_up_xpm));

		fo->setName("arrow-up");

		fo->setGroup("standard-arrow");

		fo->setToolTip(tr("Important","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_arrow_down_xpm));

		fo->setName("arrow-down");

		fo->setGroup("standard-arrow");

		fo->setToolTip(tr("Unimportant","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_thumb_up_xpm));

		fo->setName("thumb-up");

		fo->setGroup("standard-thumb");

		fo->setToolTip(tr("I like this","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_thumb_down_xpm));

		fo->setName("thumb-down");

		fo->setGroup("standard-thumb");

		fo->setToolTip(tr("I like this","Standardflag"));

		fo->setToolTip(tr("I do not like this","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_heart_xpm));

		fo->setName("heart");

		fo->setToolTip(tr("I just love... ","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_flash_xpm));

		fo->setName("flash");

		fo->setToolTip(tr("Dangerous","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		fo->load(QPixmap(flag_lifebelt_xpm));

		fo->setName("lifebelt");

		fo->setToolTip(tr("This will help","Standardflag"));

		standardFlagsDefault->addFlag (fo);	

		delete (fo);

	}

    mapCenter = new MapCenterObj(mapCanvas);

    mapCenter->setVisibility (true);

	mapCenter->setMapEditor (this);

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

    printer=NULL;

    lineedit = new QLineEdit(this, "lineedit"  );

    connect( lineedit, SIGNAL( returnPressed() ), SLOT( finishedLineEditNoSave() ) );

    lineedit->hide();

    actColor=black; setColor (actColor);

	defLinkColor=QColor (0,0,255);

	defXLinkColor=QColor (180,180,180);

	linkcolorhint=DefaultColor;

	linkstyle=StylePolyParabel;

	mapCanvas->setBackgroundColor (white);

	// Create bitmap cursors, patform dependant

	#if defined(Q_OS_MACX)

		#include "icons/cursorhandopen16.xpm"

		#include "icons/cursorcolorpicker16.xpm"

		QBitmap cb( 16, 16, chandopen, TRUE );

		QBitmap cm( 16, 16, chandopenmask, TRUE );

		handOpenCursor=QCursor ( cb, cm );		

		// set hot spot to tip of picker			

		pickColorCursor=QCursor ( cursorcolorpicker_xpm, 1,15 ); 

	#else

		#include "icons/cursorhandopen.xpm"

		#include "icons/cursorcolorpicker.xpm"

		QBitmap cb( 32, 32, chandopen, TRUE );

		QBitmap cm( 32, 32, chandopenmask, TRUE );

		handOpenCursor=QCursor ( cb, cm );		

		// set hot spot to tip of picker			

		pickColorCursor=QCursor ( cursorcolorpicker_xpm, 5,27 ); 

	#endif

	pickingColor=false;

	drawingLink=false;

	copyingObj=false;

    editingBO=NULL;

    selection=NULL;

    selectionLast=NULL;

    movingObj=NULL;

	defXLinkWidth=1;

	defXLinkColor=QColor (230,230,230);

    mapChanged=false;

	mapDefault=true;

	mapUnsaved=false;

	zipped=true;

	filePath="";

	fileName="unnamed";

	mapName="";

	undosTotal=settings.readNumEntry("/vym/mapeditor/undoLevels",50);

	undosAvail=0;	

	undoNum=0;

	// Initialize find routine

	itFind=NULL;				

	EOFind=false;

	printFrame=true;

	printFooter=true;

	blockReposition=false;

	blockSaveState=false;

	isInteractive=interactive;

	if (isInteractive)

		// Create temporary files

		makeTmpDirs();

	// Initially set movingCentre

	updateViewCenter();

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

}

MapEditor::~MapEditor()

{

  if (imageBuffer) delete imageBuffer;

  if (urlOperator) {

    urlOperator->stop();

    delete urlOperator;

  }

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

	// Save Settings

	//settings.writeEntry( "/vym/mapeditor/editmode/autoselect",  );

}

QColor MapEditor::color()

{

    return actColor;

}

QColor MapEditor::backgroundColor()

{

    return mapCanvas->backgroundColor();

}

MapCenterObj* MapEditor::getMapCenter()

{

    return mapCenter;

}

QCanvas* MapEditor::getCanvas()

{

    return mapCanvas;

}

void MapEditor::adjustCanvasSize()

{

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

	// do some coordinate magic...

	//

	// Get rectangle of (scroll-)view. 

	// We want to be in canvas coords, so

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

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

												visibleWidth(), visibleHeight()) );	

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

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

	// to avoid jumping aroung...

	QRect map=mapCenter->getTotalBBox();

	// right edge - left edge

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

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

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

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

	)	

	{	

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

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

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

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

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

		int dx=0;

		int dy=0;

		if (cw > mapCanvas->width() )

		{

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

		}

		if (cw <  mapCanvas->width() )

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

		if (ch > mapCanvas->height() )

		{

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

		}

		if (ch <  mapCanvas->height() )

		{

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

		}

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

		mapCanvas->resize (cw,ch);

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

		{

			mapCenter->moveAllBy(dx,dy);

			mapCenter->reposition();

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

			scrollBy (dx,dy);

		}	

	}

}

bool MapEditor::isRepositionBlocked()

{

	return blockReposition;

}

void MapEditor::makeTmpDirs()

{

	// Create unique temporary directories

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

	QDir d;

	d.mkdir (tmpMapDir,true);

}

void MapEditor::delTmpDirs()

{

	removeDir (QDir(tmpMapDir));

}

void MapEditor::makeSubDirs(const QString &s)

{

	QDir d(s);

	d.mkdir(s);

	d.mkdir ("images");	

	d.mkdir ("flags");	

}

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

{

	// tmpdir		temporary directory to which data will be written

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

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

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

	//				Needed for XML export

	// completeMap	if false, only vympart will be written, without

	//				mapcenter

	// Save Header

	QString ls;

	switch (linkstyle)

	{

		case StyleLine: 

			ls="StyleLine";

			break;

		case StyleParabel:

			ls="StyleParabel";

			break;

		case StylePolyLine:	

			ls="StylePolyLine";

			break;

		default:

			ls="StylePolyParabel";

			break;

	}	

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

	QString colhint="";

	if (linkcolorhint==HeadingColor) 

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

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

	if (!saveSelection)

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

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

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

		          attribut("backgroundColor", mapCanvas->backgroundColor().name() ) +

		          attribut("linkStyle", ls ) +

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

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

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

		          colhint; 

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

	incIndent();

	// Find the used flags while traversing the tree

	standardFlagsDefault->resetUsedCounter();

	// Build xml recursivly

	if (!saveSelection)

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

	else

	{

		if ( typeid(*saveSelection) == typeid(BranchObj) )

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

		else	

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

				// This is used if selected branch is saved from mainwindow

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

	}

	// Save local settings

	s+=settings.getXMLData (destPath);

	// Save selection

	if (selection && !saveSelection ) 

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

	decIndent();

	s+=endElement("vymmap");

	if (writeflags)

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

	return s;

}

void MapEditor::saveState()

{

	// Save complete map

	saveState (CompleteMap,"",NULL,"",NULL);

}

void MapEditor::saveState(LinkableMapObj *undoSel)

{

	// save the given part of the map 

	saveState (PartOfMap,"",undoSel,"",NULL);

}

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

{

	// selection does not change during action,

	// so just save commands for undo and redo

	LinkableMapObj *unsel;

	if (selection)

		unsel=selection;

	else

		unsel=NULL;

	saveState (UndoCommand,uc,unsel,rc,unsel);

}

void MapEditor::saveState(const QString & uncom, LinkableMapObj *unsel) 

{

	saveState (UndoCommand,uncom,unsel,"FIXME-redoCom",NULL);

}

void MapEditor::saveState(const SaveMode &savemode, const QString &undoCom, LinkableMapObj *undoSel, const QString &redoCom, LinkableMapObj *redoSel)

{

	// Main saveState

	if (blockSaveState) return;

	/* TODO remove after testing

	cout << "ME::saveState()  begin\n"<<endl;

	cout << "    undosTotal="<<undosTotal<<endl;

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

	cout << "       undoNum="<<undoNum<<endl;

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

	*/

	setChanged();

	// Find out current undo directory

	if (undosAvail<undosTotal) undosAvail++;

	undoNum++;

	if (undoNum>undosTotal) undoNum=1;

	QString backupXML;

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

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

	// Create bakMapDir if not available

	QDir d(bakMapDir);

	if (!d.exists()) 

		makeSubDirs (bakMapDir);

	// Save current selection 

	QString redoSelection="";

	if (redoSel)

		redoSelection=redoSel->getSelectString();

	// Save the object, which should be undone

	QString undoSelection="";

	if (undoSel)

		undoSelection=undoSel->getSelectString();

	// Save depending on how much needs to be saved	

	QString undoCommand="";

	if (savemode==UndoCommand)

	{

		undoCommand=undoCom;

		backupXML="";

	}	

	else if (savemode==PartOfMap && undoSel)

	{

		undoCommand="undoPart (\""+ undoSelection+"\",\""+bakMapPath+"\")";

		backupXML=saveToDir (bakMapDir,mapName+"-",false, QPoint (),undoSel);

	} else

	{

		undoCommand="undoMap (\""+bakMapPath+"\")";

		backupXML=saveToDir (bakMapDir,mapName+"-",false, QPoint (),NULL);

		undoSelection="";

	}

	if (!backupXML.isEmpty())

		// Write XML Data to disk

		saveStringToDisk (QString(bakMapPath),backupXML);

	SimpleSettings set;

	set.setEntry (QString("undoCommand"),undoCommand);

	set.setEntry (QString("undoSelection"),undoSelection);

	set.setEntry (QString("redoCommand"),redoCom);

	set.setEntry (QString("redoSelection"),redoSelection);

	set.writeSettings(QString(bakMapDir+"/commands"));

	/* TODO remove after testing

	cout << "          into="<< bakMapDir<<endl;

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

	cout << "       undoNum="<<undoNum<<endl;

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

	cout << "    undoCom="<<undoCommand<<endl;

	cout << "    undoSel="<<undoSelection<<endl;

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

	cout << "    redoCom="<<redoCom<<endl;

	cout << "    redoSel="<<redoSelection<<endl;

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

	*/

}

void MapEditor::parseAtom(const QString &atom)

{

	API api;

	QString s,t;

	int x,y;

	bool ok;

	// Split string s into command and parameters

	api.parseCommand (atom);

	QString com=api.command();

	// External commands

	if (com=="moveBranchUp")

		moveBranchUp();

	else if (com=="moveBranchDown")

		moveBranchDown();

	else if (com=="move")

	{

		if (api.checkParamCount(2) && selection )

		{	

			x=api.parInt (ok,0);

			if (ok)

			{

				y=api.parInt (ok,1);

				if (ok) move (x,y);

			}

		}	

	}

	else if (com=="linkBranchToPos")

	{

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

		{

			if (api.checkParamCount(4))

			{

				s=api.parString(ok,0);

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

				if (dst)

				{	

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

					{

						// Get number in parent

						x=api.parInt (ok,1);

						if (ok)

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

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

					{

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

						// Get coordinates of mainbranch

						x=api.parInt (ok,2);

						if (ok)

						{

							y=api.parInt (ok,3);

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

						}

					}	

				}	

			}

		}

	} else if (com=="setHeading")

	{

		if (api.checkParamCount(1))

		{

			s=api.parString (ok,0);

			if (ok) setHeading (s);

		}	

	} else if (com=="setURL")

	{

		if (api.checkParamCount(1))

		{

			s=api.parString (ok,0);

			if (ok) setURL(s);

		}	

	} else if (com=="setVymLink")

	{

		if (api.checkParamCount(1))

		{

			s=api.parString (ok,0);

			if (ok) setVymLink(s);

		}	

	}

	// Internal commands, used for undo etc.	

	else if (com==QString("undoMap"))

	{

		if (api.checkParamCount(1))

			undoXML("",api.parString (ok,0));

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

	{

		if (api.checkParamCount(2))

		{

			s=api.parString (ok,0);

			t=api.parString (ok,1);

			undoXML(s,t);	

		}

	} else if (com=="select")

		if (api.checkParamCount(1))

		{

			s=api.parString(ok,0);

			if (ok) select (s);

		}	

	else

	{

		api.setError ("Unknown command in: "+atom);

		cout << "ME::parse   api should have error now...\n";

	}

	// Any errors?

	if (api.error())

	{

		cout << "MapEditor::parseAtom: Error!\n";

		cout << "  "<<api.errorDesc()<<endl;

	}	

}

void MapEditor::finishedLineEditNoSave()

{

	// This is called by finishedLineEdit or any MapEditor method,

	// which wants to assure, that lineedits finish, before e.g. a branch is 

	// deleted

	// After calling LineEdit and using the clipboard, the 

    // focus is not any longer on the main widget, we

    // have to restore it using parentWidget()->setFocus()

    if (editingBO!=NULL) 

	{

		editingBO->setHeading(lineedit->text() );

		editingBO=NULL;

		lineedit->releaseKeyboard();

		lineedit->hide();

		parentWidget()->setFocus();

		mapCenter->reposition();

		adjustCanvasSize();

		ensureSelectionVisible();

    }		

}

bool MapEditor::isDefault()

{

    return mapDefault;

}

bool MapEditor::isUnsaved()

{

    return mapUnsaved;

}

bool MapEditor::hasChanged()

{

    return mapChanged;

}

void MapEditor::setChanged()

{

	mapChanged=true;

	mapDefault=false;

	mapUnsaved=true;

	actionEditUndo->setEnabled (true);

	actionFileSave->setEnabled (true);

	findReset();

}

void MapEditor::closeMap()

{

	// Finish open lineEdits

	if (lineedit) finishedLineEditNoSave();

	// Unselect before disabling the toolbar actions

	if (selection) selection->unselect();

	selection=NULL;

	updateActions();

    clear();

	close();

}

void MapEditor::setFilePath(QString fname)

{

	setFilePath (fname,fname);

}

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

{

	if (fname.isEmpty())

	{

		filePath="";

		fileName="";

		destPath="";

	} else

	{

		filePath=fname;		// becomes absolute path

		fileName=fname;		// gets stripped of path

		destPath=destname;	// needed for vymlinks

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

		filePath=QDir(fname).absPath();

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

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

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

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

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

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

	}

}

QString MapEditor::getFilePath()

{

	return filePath;

}

QString MapEditor::getFileName()

{

	return fileName;

}

QString MapEditor::getMapName()

{

	return mapName;

}

QString MapEditor::getDestPath()

{

	return destPath;

}

int MapEditor::load (QString &fname, const LoadMode &lmode)

{

	// Finish open lineEdits

	if (lineedit) finishedLineEditNoSave();

	int returnCode=0;

	if (lmode==NewMap)

	{

		if (selection) selection->unselect();

		selection=NULL;

		mapCenter->clear();

		mapCenter->setMapEditor(this);

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

	} else

	{

		saveState(selection);

	}	

    mapBuilderHandler handler;

	QFile file( fname );

	// I am paranoid: file should exist anyway

	// according to check in mainwindow.

	if (!file.exists() )

	{

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

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

		returnCode=1;	

	} else

	{

		blockReposition=true;

		QXmlInputSource source( file);

		QXmlSimpleReader reader;

		reader.setContentHandler( &handler );

		reader.setErrorHandler( &handler );

		handler.setMapEditor( this );

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

		handler.setLoadMode (lmode);

		blockSaveState=true;

		bool ok = reader.parse( source );

		blockReposition=false;

		blockSaveState=false;

		file.close();

		if ( ok ) 

		{

			mapCenter->reposition();

			adjustCanvasSize();

			if (lmode==NewMap)

			{

				mapDefault=false;

				mapChanged=false;

				mapUnsaved=false;

			}

		} else 

		{

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

					   tr( handler.errorProtocol() ) );

			// returnCode=1;	

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

			// partially read by the parser

		}	

	}	

	updateActions();

	return returnCode;

}

int MapEditor::save (const SaveMode &savemode)

{

	// Finish open lineEdits