#include "mapeditor.h"

#include <q3dragobject.h>

#include <q3urloperator.h>

#include <q3networkprotocol.h>

#include <q3paintdevicemetrics.h>

#include <q3filedialog.h>

#include <iostream>

#include <cstdlib>

#include <typeinfo>

#include "version.h"

#include "api.h"

#include "editxlinkdialog.h"

#include "exports.h"

#include "extrainfodialog.h"

#include "file.h"

#include "linkablemapobj.h"

#include "mainwindow.h"

#include "misc.h"

#include "texteditor.h"

#include "warningdialog.h"

#include "xml.h"

extern TextEditor *textEditor;

extern int statusbarTime;

extern Main *mainWindow;

extern QString tmpVymDir;

extern QString clipboardDir;

extern bool clipboardEmpty;

extern FlagRowObj *standardFlagsDefault;

extern QMenu* branchContextMenu;

extern QMenu* branchAddContextMenu;

extern QMenu* branchRemoveContextMenu;

extern QMenu* branchLinksContextMenu;

extern QMenu* branchXLinksContextMenuEdit;

extern QMenu* branchXLinksContextMenuFollow;

extern QMenu* floatimageContextMenu;

extern QMenu* saveImageFormatMenu;

extern QMenu* canvasContextMenu;

extern QMenu* lastMapsMenu;

extern QMenu* importMenu;

extern QMenu* exportMenu;

extern Settings settings;

extern ImageIO imageIO;

extern QString iconPath;

extern QDir vymBaseDir;

extern QDir lastImageDir;

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

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

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

MapEditor::MapEditor(

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

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

{

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

	mapNum++;

    viewport()->setAcceptDrops(true);

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

	mapCanvas->setAdvancePeriod(30);

	mapCanvas->setBackgroundColor (Qt::white);

    setCanvas (mapCanvas);

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

	setVScrollBarMode ( Q3ScrollView::AlwaysOn );

	setHScrollBarMode ( Q3ScrollView::AlwaysOn );

    mapCenter = new MapCenterObj(mapCanvas);

    mapCenter->setVisibility (true);

	mapCenter->setMapEditor (this);

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

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

    printer=NULL;

    actColor=Qt::black; setColor (actColor);

	defLinkColor=QColor (0,0,255);

	defXLinkColor=QColor (180,180,180);

	linkcolorhint=DefaultColor;

	linkstyle=StylePolyParabel;

	// Create bitmap cursors, platform dependant

	#if defined(Q_OS_MACX)

		handOpenCursor=QCursor ( QPixmap(iconPath+"cursorhandopen16.png"),1,1 );		

		pickColorCursor=QCursor ( QPixmap (iconPath+"cursorcolorpicker16.png"), 1,15 ); 

	#else

		handOpenCursor=QCursor (QPixmap(iconPath+"cursorhandopen.png"),1,1);		

		pickColorCursor=QCursor ( QPixmap(iconPath+"cursorcolorpicker.png"), 5,27 ); 

	#endif

	pickingColor=false;

	drawingLink=false;

	copyingObj=false;

    editingBO=NULL;

    selection=NULL;

    selectionLast=NULL;

    movingObj=NULL;

	xelection.setMapCenter (mapCenter);

	defXLinkWidth=1;

	defXLinkColor=QColor (230,230,230);

    mapChanged=false;

	mapDefault=true;

	mapUnsaved=false;

	zipped=true;

	filePath="";

	fileName=tr("unnamed");

	mapName="";

	stepsTotal=settings.readNumEntry("/mapeditor/stepsTotal",50);

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

	// Initialize find routine

	itFind=NULL;				

	EOFind=false;

	printFrame=true;

	printFooter=true;

	blockReposition=false;

	blockSaveState=false;

	hidemode=HideNone;

	// Create temporary files

	makeTmpDirs();

	// Initially set movingCentre

	updateViewCenter();

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

	// Initialize history window;

	historyWindow.setME(this);

	historyWindow.setStepsTotal(stepsTotal);

	historyWindow.update (undoSet);

}

MapEditor::~MapEditor()

{

  if (imageBuffer) delete imageBuffer;

  if (urlOperator) {

    urlOperator->stop();

    delete urlOperator;

  }

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

}

QColor MapEditor::getColor()

{

    return actColor;

}

QColor MapEditor::getBackgroundColor()

{

    return mapCanvas->backgroundColor();

}

MapCenterObj* MapEditor::getMapCenter()

{

    return mapCenter;

}

Q3Canvas* MapEditor::getCanvas()

{

    return mapCanvas;

}

void MapEditor::adjustCanvasSize()

{

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

	// do some coordinate magic...

	//

	// Get rectangle of (scroll-)view. 

	// We want to be in canvas coords, so

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

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

												visibleWidth(), visibleHeight()) );	

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

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

	// to avoid jumping aroung...

	QRect map=mapCenter->getTotalBBox();

	// right edge - left edge

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

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

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

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

	)	

	{	

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

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

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

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

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

		int dx=0;

		int dy=0;

		if (cw > mapCanvas->width() )

		{

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

		}

		if (cw <  mapCanvas->width() )

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

		if (ch > mapCanvas->height() )

		{

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

		}

		if (ch <  mapCanvas->height() )

		{

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

		}

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

		mapCanvas->resize (cw,ch);

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

		{

			mapCenter->moveAllBy(dx,dy);

			mapCenter->reposition();

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

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

			scrollBy (dx,dy);

		}	

	}

}

bool MapEditor::isRepositionBlocked()

{

	return blockReposition;

}

QString MapEditor::getName (LinkableMapObj *lmo)

{

	QString s;

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

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

				      typeid(*lmo) == typeid(MapCenterObj))) 

	{

		s=(((BranchObj*)lmo)->getHeading());

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

		return QString("branch (%1)").arg(s);

		//return QString("branch (<font color=\"#0000ff\">%1</font>)").arg(s);

	}	

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

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

		//return QString ("floatimage [<font color=\"#0000ff\">%1</font>]").arg(((FloatImageObj*)lmo)->getOriginalFilename());

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

}

void MapEditor::makeTmpDirs()

{

	// Create unique temporary directories

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

	histPath=QDir::convertSeparators (tmpMapDir+"/history");

	QDir d;

	d.mkdir (tmpMapDir);

}

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

{

	// tmpdir		temporary directory to which data will be written

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

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

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

	//				Needed for XML export

	// Save Header

	QString ls;

	switch (linkstyle)

	{

		case StyleLine: 

			ls="StyleLine";

			break;

		case StyleParabel:

			ls="StyleParabel";

			break;

		case StylePolyLine:	

			ls="StylePolyLine";

			break;

		default:

			ls="StylePolyParabel";

			break;

	}	

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

	QString colhint="";

	if (linkcolorhint==HeadingColor) 

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

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

	if (!saveSel)

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

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

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

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

		          attribut("linkStyle", ls ) +

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

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

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

		          colhint; 

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

	incIndent();

	// Find the used flags while traversing the tree

	standardFlagsDefault->resetUsedCounter();

	// Reset the counters before saving

	FloatImageObj (mapCanvas).resetSaveCounter();

	// Build xml recursivly

	if (!saveSel)

		// Save complete map, if saveSel not set

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

	else

	{

		if ( typeid(*saveSel) == typeid(BranchObj) )

			// Save Subtree

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

		else if ( typeid(*saveSel) == typeid(FloatImageObj) )

			// Save image

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

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

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

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

	}

	// Save local settings

	s+=settings.getXMLData (destPath);

	// Save selection

	if (selection && !saveSel ) 

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

	decIndent();

	s+=endElement("vymmap");

	if (writeflags)

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

	return s;

}

void MapEditor::saveStateComplete(const QString &comment)

{

	// Save complete map, Undo will replace whole map

	saveState (CompleteMap,

		"", "",

		"", "", 

		comment, 

		mapCenter);

}

void MapEditor::saveStateChangingPart(LinkableMapObj *undoSel, const QString &comment)

{

	// save the selected part of the map, Undo will replace part of map 

	QString undoSelection="";

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

	saveState (PartOfMap,

		undoSelection, "",

		"", "", 

		comment, 

		undoSel);

}

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

{

	if (!redoSel  ||typeid(*redoSel) != typeid(BranchObj) ) 

	{

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

		return;

	}

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

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

	QString redoSelection=redoSel->getSelectString();

	saveState (PartOfMap,

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

		redoSelection, "delete ()", 

		comment, 

		redoSel);

}

void MapEditor::saveStateConstSelection(const QString &uc, const QString &rc, const QString &comment)

{

	// selection does not change during action,

	// so just save commands for undo and redo

	// and use current selection

	QString sel;

	if (selection) sel=selection->getSelectString();

	saveState (UndoCommand,

		sel, uc,

		sel, rc, 

		comment, 

		NULL);

}

void MapEditor::saveState(LinkableMapObj *undoSel, const QString &uc, LinkableMapObj *redoSel, const QString &rc, const QString &comment) 

{

	// "Normal" savestate: save commands, selections and comment

	// so just save commands for undo and redo

	// and use current selection

	QString redoSelection="";

	if (redoSel) redoSelection=redoSel->getSelectString();

	QString undoSelection="";

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

	saveState (UndoCommand,

		undoSelection, uc,

		redoSelection, rc, 

		comment, 

		NULL);

}

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

{

	// "Normal" savestate: save commands, selections and comment

	// so just save commands for undo and redo

	// and use current selection

	saveState (UndoCommand,

		undoSel, uc,

		redoSel, rc, 

		comment, 

		NULL);

}

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

{

	// Main saveState

	if (blockSaveState) return;

	/* TODO remove after testing

	*/

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

	setChanged();

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

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

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

	// Find out current undo directory

	if (undosAvail<stepsTotal) undosAvail++;

	curStep++;

	if (curStep>stepsTotal) curStep=1;

	QString backupXML;

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

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

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

	// Create bakMapDir if not available

	QDir d(bakMapDir);

	if (!d.exists()) 

		makeSubDirs (bakMapDir);

	// Save depending on how much needs to be saved	

	if (!saveSel)

		backupXML="";

	else 

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

	QString undoCommand="";

	if (savemode==UndoCommand)

	{

		undoCommand=undoCom;

	}	

	else if (savemode==PartOfMap )

	{

		undoCommand=undoCom;

		undoCommand.replace ("PATH",bakMapPath);

	} else

	{

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

	}

	if (!backupXML.isEmpty())

		// Write XML Data to disk

		saveStringToDisk (QString(bakMapPath),backupXML);

	// We would have to save all actions in a tree, to keep track of 

	// possible redos after a action. Possible, but we are too lazy: forget about redos.

	redosAvail=0;

	// Write the current state to disk

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

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

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

	undoSet.setEntry (QString("/history/step-%1/undoCommand").arg(curStep),undoCommand);

	undoSet.setEntry (QString("/history/step-%1/undoSelection").arg(curStep),undoSelection);

	undoSet.setEntry (QString("/history/step-%1/redoCommand").arg(curStep),redoCom);

	undoSet.setEntry (QString("/history/step-%1/redoSelection").arg(curStep),redoSelection);

	undoSet.setEntry (QString("/history/step-%1/comment").arg(curStep),comment);

	undoSet.writeSettings(histPath);

	/* TODO remove after testing

	*/

	//cout << "          into="<< histPath.toStdString()<<endl;

	cout << "    stepsTotal="<<stepsTotal<<

	", undosAvail="<<undosAvail<<

	", redosAvail="<<redosAvail<<

	", curStep="<<curStep<<endl;

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

	cout << "    comment="<<comment.toStdString()<<endl;

	cout << "    undoCom="<<undoCommand.toStdString()<<endl;

	cout << "    undoSel="<<undoSelection.toStdString()<<endl;

	cout << "    redoCom="<<redoCom.toStdString()<<endl;

	cout << "    redoSel="<<redoSelection.toStdString()<<endl;

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

	historyWindow.update (undoSet);

}

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=="addBranch")

	{

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

		{	

			y=api.parInt (ok,0);

			if (ok ) addNewBranchInt (y);

		}	

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

	{

		if (api.checkParamCount(2))

		{

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

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

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

			addMapReplace(s,t);	

		}

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

	{

		if (api.checkParamCount(2))

		{

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

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

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

			addMapInsert(t,y);	

		}

	} else if (com=="delete")

	{

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

		{	

			deleteSelection();

		}	

	} else if (com=="linkBranchToPos")

	{

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

		{

			if (api.checkParamCount(4))

			{

				// 0	selectstring of parent

				// 1	num in parent (for branches)

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

				s=api.parString(ok,0);

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

				if (dst)

				{	

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

					{

						// Get number in parent

						x=api.parInt (ok,1);

						if (ok)

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

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

					{

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

						// Get coordinates of mainbranch

						x=api.parInt (ok,2);

						if (ok)

						{

							y=api.parInt (ok,3);

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

						}

					}	

				}	

			}

		}

	} else if (com=="moveBranchUp")

		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=="moveRel")

	{

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

		{	

			x=api.parInt (ok,0);

			if (ok)

			{

				y=api.parInt (ok,1);

				if (ok) moveRel (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) setURLInt(s);

		}	

	} else if (com=="setVymLink")

	{

		if (api.checkParamCount(1))

		{

			s=api.parString (ok,0);

			if (ok) setVymLinkInt(s);

		}	

	}

	else if (com=="setFlag")

	{

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

		{

			if (api.checkParamCount(1) )

			{	

				s=api.parString(ok,0);

				if (ok) 

				{

					BranchObj* bo=(BranchObj*)selection;

					bo->activateStandardFlag(s);

					bo->updateFlagsToolbar();

				}	

			}	

		}

	}	

	else if (com=="unsetFlag")

	{

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

		{

			if (api.checkParamCount(1) )

			{	

				s=api.parString(ok,0);

				if (ok) 

				{

					BranchObj* bo=(BranchObj*)selection;

					bo->deactivateStandardFlag(s);

					bo->updateFlagsToolbar();

				}	

			}	

		}

	// Internal commands

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

	{

		if (api.checkParamCount(1))

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

	} else if (com=="select")

	{

		if (api.checkParamCount(1))

		{

			s=api.parString(ok,0);

			if (ok) select (s);

		}	

	}	

	else

	{

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

	}

	// Any errors?

	if (api.error())

	{

		// TODO Error handling

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

		qWarning(api.errorDesc());

	}	

}

void MapEditor::toggleHistoryWindow()

{

	if (historyWindow.isVisible())

		historyWindow.hide();

	else	

		historyWindow.show();

}

bool MapEditor::isDefault()

{

    return mapDefault;

}

bool MapEditor::isUnsaved()

{

    return mapUnsaved;

}

bool MapEditor::hasChanged()

{

    return mapChanged;

}

void MapEditor::setChanged()

{

	mapChanged=true;

	mapDefault=false;

	mapUnsaved=true;

	findReset();

}

void MapEditor::closeMap()

{

	// Unselect before disabling the toolbar actions

	if (selection) selection->unselect();

	selection=NULL;

	updateActions();

    clear();

	close();

}

void MapEditor::setFilePath(QString fname)

{

	setFilePath (fname,fname);

}

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

{

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

	{

		filePath="";

		fileName="";

		destPath="";

	} else

	{

		filePath=fname;		// becomes absolute path

		fileName=fname;		// gets stripped of path

		destPath=destname;	// needed for vymlinks

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

		filePath=QDir(fname).absPath();

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

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

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

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

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

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

		// Adjust history window

		historyWindow.setCaption (__VYM " - " +tr("History for ")+fileName);

	}

}

QString MapEditor::getFilePath()

{

	return filePath;

}

QString MapEditor::getFileName()

{

	return fileName;

}

QString MapEditor::getMapName()

{

	return mapName;

}

QString MapEditor::getDestPath()

{

	return destPath;

}

ErrorCode MapEditor::load (QString fname, LoadMode lmode)

{

	ErrorCode err=success;

	if (lmode==NewMap)

	{

		if (selection) selection->unselect();

		selection=NULL;

		mapCenter->clear();

		mapCenter->setMapEditor(this);

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

	} else

	{

		saveStateChangingPart(selection,"Load map");

	}	

    mapBuilderHandler handler;

	QFile file( fname );

	// I am paranoid: file should exist anyway

	// according to check in mainwindow.

	if (!file.exists() )

	{

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

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

		err=aborted;	

	} else

	{

		blockReposition=true;

		QXmlInputSource source( file);

		QXmlSimpleReader reader;

		reader.setContentHandler( &handler );

		reader.setErrorHandler( &handler );

		handler.setMapEditor( this );

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

		handler.setInputFile (file.name());

		handler.setLoadMode (lmode);

		blockSaveState=true;

		bool ok = reader.parse( source );

		blockReposition=false;

		blockSaveState=false;

		file.close();

		if ( ok ) 

		{

			mapCenter->reposition();

			adjustCanvasSize();

			if (lmode==NewMap)

			{

				mapDefault=false;

				mapChanged=false;

				mapUnsaved=false;

			}

		} else 

		{

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

					   tr( handler.errorProtocol() ) );

			// returnCode=1;	

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

			// partially read by the parser

		}	

	}	

	updateActions();

	return err;

}

int MapEditor::save (const SaveMode &savemode)

{

	int returnCode=0;

	// The SaveMode UndoCommand is not supported here

	if (savemode==UndoCommand) return 1;

	// Create mapName and fileDir

	makeSubDirs (fileDir);

	QString fname;

	if (saveZipped())

		// save as .xml

		fname=mapName+".xml";

	else

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

		fname=fileName;

	QString saveFile;

	if (savemode==CompleteMap || selection==NULL)

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

	else	

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

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

		return 1;

	if (returnCode==0)

	{

		mapChanged=false;

		mapUnsaved=false;

		updateActions();

	}

	return returnCode;

}

void MapEditor::setZipped (bool z)

{

	zipped=z;

}

bool MapEditor::saveZipped ()

{

	return zipped;

}

void MapEditor::print()

{

	if ( !printer ) 

	{

		printer = new QPrinter;

		printer->setColorMode (QPrinter::Color);

		printer->setPrinterName (settings.value("/mainwindow/printerName",printer->printerName()).toString());

	}

	QRect totalBBox=mapCenter->getTotalBBox();

	// Try to set orientation automagically

	// Note: Interpretation of generated postscript is amibiguous, if 

	// there are problems with landscape mode, see

	// http://sdb.suse.de/de/sdb/html/jsmeix_print-cups-landscape-81.html

	if (totalBBox.width()>totalBBox.height())

		// recommend landscape

		printer->setOrientation (QPrinter::Landscape);

	else	

		// recommend portrait

		printer->setOrientation (QPrinter::Portrait);

	if ( printer->setup(this) ) 

	// returns false, if printing is canceled

	{

		QPainter pp(printer);

		// Don't print the visualisation of selection

		LinkableMapObj *oldselection=NULL;

		if (selection) 

		{

			oldselection=selection;

			selection->unselect();

		}

		// Handle sizes of map and paper:

		//

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

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

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

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

		Q3PaintDeviceMetrics metrics (printer);

		double paperAspect = (double)metrics.width()   / (double)metrics.height();

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

		QRect mapRect=totalBBox;

		Q3CanvasRectangle *frame=NULL;

		Q3CanvasText *footerFN=NULL;

		Q3CanvasText *footerDate=NULL;

		if (printFrame || printFooter)

		{

			if (printFrame) 

			{

				// Print frame around map

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

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