//========================================================
// This Tools imports mind maps into a doors structure
// or exports doors structure into a freemind mindmap (XML) form
//
//========================================================

/*

1.0		Jul 2008	GJS	first cut

*/
pragma runLim, 0
pragma stack, 60000

//========================================================
//constants

string SCRIPTVERSION = "MindMap Support v1.0"
bool DEBUG = false

Regexp mapHeader = regexp "<map.*>";
Regexp comment = regexp "<!--.*>";
Regexp openNode = regexp "<node.*>";
Regexp closedNode = regexp "<node.*/>";
Regexp endNode = regexp "</node>";
Regexp icon = regexp "<icon.*>";
Regexp hyperlink = regexp "LINK.*";
Regexp arrowlink = regexp "<arrowlink.*>";

//=============================================================
// var


Skip DOORStoMMid = createString
Skip MMidtoDOORS = createString
Object curObj = current
Module curMod = current
bool objectInsert = true;
bool unbiased = false;
bool nodeleft = false;
bool makeHeader = true;
string lastline = "start"
Buffer mindMap = create
Buffer output = create
Stream mmFile
Object homeObj
bool nodeOpenNoKidsYet = false
string tabs="", temp;
int insertionOffset,insertLevel


//===========================================================
//dialogue config

string dbtabs[]={"Import","Export"}

DB Init
DBE Ilabel = null

DB Select_File
DBE dbetab = null
DBE label2 = null			// object level question
DBE label1 = null			// tool info
DBE label3 = null			// header question
DBE location = null 		// File Selector
DBE insertionMode = null;		// module or object based start point
DBE exportMode = null;		// module or object based start point
DBE unbiasedMode = null;		// export map as biased or unbiased?
DBE headerMode = null;		// turn first level nodes to headers
DBE importBut = null;	// Button to start the import
DBE exportBut = null;	// Button to start the import
DBE helpBut = null;			// Button to load help
DBE closeBut = null;		// close gracefully


DB Dummy = centered "Dummy"

//##############################################################################
//## basic function to replace any occurence of char "toReplace" by string "replacement"
//##############################################################################
void replaceChar (string &str, char toReplace, string replacement){
 if ( ! null str ) {
    int i;
    Buffer b = create ();
    for (i = 0; i < length str; i++) {
      if (str[i] == toReplace) {
        b += replacement;
      } else {
        b += str[i];
      }
    }  
    str = stringOf (b);
    delete (b);
 }   
 return
}// end replaceChar

//==== cleanString() ========
//take in a string. Remove all forward slash, quotes, carriage returns, tabs and amphersands
//===========================
void cleanString(string &quotes){
  replaceChar (quotes, '/', "_");
  replaceChar (quotes, '"', "'");
  replaceChar (quotes, '\n', ",");
  replaceChar (quotes, '\t', "  ");
  replaceChar (quotes, '&', " and ");
}





//============================================================
// dumpSkips
//============================================================

void dumpSkips (){
	string dataStr
	string keyNo
	//save curMod
	
	for keyNo in DOORStoMMid do{
		if (null keyNo) continue
		print "DOORS to MM key :"keyNo" , data :"
		if (find (DOORStoMMid,keyNo,dataStr)){
			print dataStr"";
		} else {
			print " no Data ";
		}
		print "\n";
	}
	for keyNo in MMidtoDOORS do{
		if (null keyNo) continue
		print "MM to DOORS key :"keyNo" , data :"
		if (find (MMidtoDOORS,keyNo,dataStr)){
			print dataStr"";
		} else {
			print " no Data ";
		}
		print "\n";
	}	
}//================ end dumpskips ==========================

//=====================================================
// get destination
//======================================================
string getDestination (string lineData){
	Regexp destinationStart = regexp "DESTINATION=\".*\"";
	Regexp voidDestination = regexp "DESTINATION=\"_\"";
	int intStrt = 0;
	int intEnd = 0;
	string ret;
	if (voidDestination lineData){
		ret = "<No ID>";
	}else if (destinationStart lineData) {
		intStrt = start 0;
		intEnd = intStrt+35;
		ret = lineData[intStrt+27:intEnd];
	} else {
		ret = "<No ID>";
	}

	return ret
	
}//===========end get destination ============================

//=====================================================
// get ID no
//======================================================
string getIDNo (string lineData){
	Regexp IDStart = regexp "ID=\".*\"";
	Regexp voidID = regexp "ID=\"_\"";
	int intStrt = 0;
	int intEnd = 0;
	string ret;
	if (voidID lineData){
		ret = "<No ID>";
	}else if (IDStart lineData) {
		intStrt = start 0;
		intEnd = intStrt+27;
		intStrt = intStrt+18;
		ret = lineData[intStrt:intEnd];
	} else {
		ret = "<No ID>";
	}

	return ret
	
}//===========end getID ============================

//=====================================================
// get ID
//======================================================
string getID (string lineData){
	Regexp IDStart = regexp "ID=\".*\"";
	Regexp voidID = regexp "ID=\"_\"";
	int intStrt = 0;
	int intEnd = 0;
	string ret;
	if (voidID lineData){
		ret = "<No ID>";
	}else if (IDStart lineData) {
		intStrt = start 0;
		intEnd = intStrt+27;
		ret = lineData[intStrt+4:intEnd];
	} else {
		ret = "<No ID>";
	}

	return ret
	
}//===========end getID ============================

//=====================================================
// get text
//======================================================
string getText (string lineData, int adjust){
	Regexp textStart = regexp "text=";
	Regexp TEXTStart = regexp "TEXT=";
	int intStrt = 0;
	int intEnd = 0;
	string ret;
	if (textStart lineData) {
		intStrt = end 0;
		intEnd = length(lineData)-adjust;
		ret = lineData[intStrt+2:intEnd];
	} else if (TEXTStart lineData) {
		intStrt = end 0;
		intEnd = length(lineData)-adjust;
		ret = lineData[intStrt+2:intEnd];
	} else {
		ret = "<Blank Branch or non-supported data in Map>";
	}
	if ((null ret)or(ret=="")){
		ret = "<Blank Branch or non-supported data in Map>";
	}
	return ret
	
}//===========end getText ============================



//====================================================
//processline
//====================================================
Object processline (Object lastObj, string lineData) {
	Object newObj
	bool obCreate = false
	bool head=false;
	string firstLine=""
	string myID = getID(lineData)
	if (DEBUG) {
		if (closedNode lineData){
			print "===========================\n"tabs "processing line: "getText(lineData,4)"\n"tabs "nodeOpenNoKids:"nodeOpenNoKidsYet " insertlevel:"insertLevel "\n";
		}else {
			print "===========================\n"tabs "processing line: "getText(lineData,3)"\n"tabs "nodeOpenNoKids:"nodeOpenNoKidsYet " insertlevel:"insertLevel "\n";
		}
	}
	if (DEBUG) print ""tabs "mm line ID: "myID "\n";
	if (mapHeader lineData) {
		lastline="map head\n";
	} else if (comment lineData) {
		lastline="comment\n";
	} else if (closedNode lineData) {
		if ((lastline=="open\n")||(lastline=="map head\n")||(nodeOpenNoKidsYet)||(lastObj==homeObj)){
			newObj = create(below(lastObj));
			insertLevel++
			tabs = tabs"\t"
		} else {
			newObj = create(after(lastObj));
		}
		if (homeObj==parent(newObj)) head = true;
		if((head)&&(makeHeader)){
			newObj."Object Heading" = getText(lineData,4);
		}else{				
			newObj."Object Text" = getText(lineData,4);
		}
		nodeOpenNoKidsYet=false
		obCreate=true;
		lastline="closed\n";
	} else if (openNode lineData) {
		if ((lastline=="open\n")||(lastline=="map head\n")||(nodeOpenNoKidsYet)||(lastObj==homeObj)){
			newObj = create(below(lastObj));
			insertLevel++
			tabs = tabs"\t"
		} else {
			newObj = create(after(lastObj));
		}
		if ((homeObj==parent(newObj))||(homeObj==parent(parent(newObj)))) head = true;
		if((head)&&(makeHeader)){
			newObj."Object Heading" = getText(lineData,3);
		}else{	
			newObj."Object Text" = getText(lineData,3);
		}
		nodeOpenNoKidsYet=true
		obCreate=true;
		lastline="open\n";
	} else if (endNode lineData) {
		if (!nodeOpenNoKidsYet) {
			lastObj = parent(lastObj);
			tabs = tabs[0:(length(tabs)-2)]
			insertLevel--
			if (DEBUG) print tabs" bumped up\n"
		}else{
			nodeOpenNoKidsYet = false
		}
		lastline="end\n";					// ******************** gs note to self - need to count the number of ends out / level of next object!
	} else if (icon lineData) {
		lastline="icon\n";
	} else if (hyperlink lineData) {
		lastline="has link\n";
	} else if (arrowlink lineData) {
		string absNum = lastObj."Absolute Number""";
		string dest = getDestination(lineData)
		bool addedOb = put (DOORStoMMid,absNum"",dest"");
		if ((DEBUG)&&(addedOb)) print ""tabs"added object to DOORS to MMid: "absNum" , "dest" \n";
		lastline="arrowlink\n";
	} else {
		lastline="something else\n"
	}
	
	if (DEBUG) print ""tabs"this object was identified as:"lastline"\n"
	if (obCreate) {
		string mmIDInfo = getIDNo(lineData);
		string obID = identifier(newObj)
		if (DEBUG) print ""tabs" created new object\t"obID" - "mmIDInfo":\n";
		bool addedOb = put (MMidtoDOORS, mmIDInfo"", obID"" );
		if ((DEBUG)&&(addedOb)) print ""tabs"added object to MMid to DOORS\n";
	}else if (DEBUG) {
		print ""tabs"last\t"identifier lastObj" ""\n";
	}
	if (obCreate){
		return newObj;
	} else {
		return lastObj;
	}
}

//======================================
//processMap
//======================================
void processMap(){
	Regexp myLine = regexp ".*";
	int from=0
	int max=0
	Object lastObj
	if (!null curObj){
		homeObj =curObj
	}else{
		ack "no current object selected, forcing module level insertion of new objects";
		homeObj = create(curMod);
		curObj = homeObj
		homeObj."Object Heading"="Mindmap header";
	}
	lastObj = homeObj
	insertionOffset = level(lastObj)
	if (DEBUG) print"insertionOffset:"insertionOffset" headerObject:"identifier(lastObj)"\n"
	insertLevel=0
	while (search(myLine, mindMap, from)) { 
        // takes a line at
        // a time from source 
       int offset = end 0 ;
        // end of the match within source 
        string mymatch = mindMap[from:from+offset] ;
        from += offset + 2      ;
         // move 'from' over any newline 
        if (null mymatch)         // we are done
            break ;
        if (DEBUG) print "**************************\nIncoming Line: "mymatch"\nlastline:"lastline"\n";    
        lastObj = processline(lastObj,mymatch);
        max = max >? length mymatch ;
        //if (DEBUG) print mymatch"\n\n"
        // remember max line length
    } 
	return
}//end processMap

//==========================================
// processExport
//==========================================
void processExport(Object procOb, string tabstring){
	bool openNode = true;
	bool header = false;
	Object child
	if (null first(procOb)) {
		if (DEBUG) print identifier(procOb)" - no kids \n";
		openNode = false;
	} else {
		child = first(procOb)
		if (DEBUG) print "\tChecking first below procOb - "identifier(child)"\n"
		if ((table(child))||(row(child))||(cell(child))){
			if (DEBUG) print identifier(procOb)" - child is table \n";
			openNode = false;
		} else {
			if (DEBUG) print identifier(procOb)" - has ok kids \n";
		}
	}
	output += tabstring"<node"; //start the xml node
	if (tabstring=="\t"){ // see if first level node
		if (unbiased){
			if (nodeleft){
				nodeleft = false
				output += " POSITION=\"left\" ";
			}else{
				nodeleft = true
				output += " POSITION=\"right\" ";
			}
		}
	}
	output += " TEXT=\""
	if (!null(procOb."Object Heading")) {
		temp=procOb."Object Heading""";
		cleanString(temp);
		 output+=temp; // add heading to XML node
		 header = true
	 }
	 if (!null(procOb."Object Text")){
		 if (header) output+=" ";
		 temp=procOb."Object Text"
		 cleanString(temp)
		 output+=temp; // add text to xml node
	 }
	 if (openNode){
		 output+="\">\n"; //leave the xml node open
	 }else{
		 output+="\"/>\n"; // close the xml node
	 }
	 if (openNode){
		 string temptabstring = tabstring"\t"
		 for child in procOb do{
			  processExport(child,temptabstring);
		 }
		 output+=tabstring"</node>\n"; // close the open node
	 }
	 return
}


//======================================
//importFile
//======================================
void importFile(DB Select_File){
	string filespot = get(location);
	objectInsert = get(insertionMode);
	makeHeader = get(headerMode);
	if (!canOpenFile(filespot,false)){
		ack "cannot open file\n"filespot"";
	} else {
		hide Select_File;
		destroy Select_File;
		mindMap = readFile (filespot);
		processMap; 
	}
	if (DEBUG) print filespot"\n"objectInsert"\n\n";
	if (DEBUG) dumpSkips;
	delete DOORStoMMid
	delete MMidtoDOORS
	return
}
//============ end importFile =============

//======================================
//exportFile
//======================================

void exportFile(DB Select_File){
	string filespot = get(location);
	objectInsert = get(exportMode);
	unbiased = get(unbiasedMode);
	Object startobj;
	string tabstring="";
	output="<map>\n"
	if (objectInsert){
		startobj=current;
		if (null startobj){
			ack "no starting object selected when asking to export in object tree mode)";
			return
		}else{
			hide Select_File;
			destroy Select_File;
			processExport(startobj,tabstring);
		}
	}else{
		hide Select_File;
		destroy Select_File;
		output+="<node TEXT=\""name curMod"\">\n";
		tabstring="\t";
		for startobj in top curMod do {
			processExport(startobj,tabstring);
		}
		output+="</node>\n";
	}
	output+="</map>";
	mmFile = write filespot;
	mmFile << output
	close mmFile
	flush mmFile
	if (DEBUG) print output"";
	delete output;
	delete DOORStoMMid;
	delete MMidtoDOORS;
	ack "Done - file written to "filespot""
	return
}
//============ end exportFile =============

//======================================
//processDB
// grab the data from the DBE ready to act
//======================================
void processDB(DB Select_File){
	int tabsel = get(dbetab);
	if (tabsel==0){
		importFile(Select_File); //  import mm
	} else {
		exportFile(Select_File); // export mm
	}
	return
}
//============ end importFile =============

//=========================================
//tabswitch
// switch the dbe fields to support the switching of tabs 
//=========================================
void tabswitch (DBE dbetab){
	int tabsel = get(dbetab)
	if (tabsel==0){
		// set ui for import
		set(label1,"Specify Mindmap to load :");
		set(label2,"Insert mindmap as hierarchy under the current Object or at the module root");
		show(insertionMode);
		hide(exportMode);
		hide(unbiasedMode);
		show(label3);
		show(headerMode);
		active(importBut);
		inactive(exportBut);
	} else {
		// set ui for export
		set(label1,"Specify file to save to :");
		set(label2,"Create mindmap from hierarchy under the current Object or from the module root");
		hide(insertionMode);
		show(exportMode);
		show(unbiasedMode);
		hide(label3);
		hide(headerMode);
		active(exportBut);
		inactive(importBut);
	}
	return
}
//============ end tabswitch



//==== CreateSelectFile() =======
//==================================
void createSelectFile (){

	bool insertMode = true;
	bool headMode = true;
	if (null curObj) insertMode=false;

	Select_File = centered SCRIPTVERSION;
	dbetab = tab(Select_File,dbtabs,tabswitch)
	//separator Select_File;
	
	
	//=======  Import bits =========
	label1 = label(Select_File,"Specify Mindmap to load :")
	location = fileName(Select_File, "C:/Mindmap.mm","*.mm","Freemind Mindmap");
	separator Select_File;
	label2 = label(Select_File,"Insert mindmap as hierarchy under the current Object or at the module root");
	insertionMode = toggle (Select_File,"Insert at Object Level",insertMode);
	exportMode = toggle (Select_File,"Export tree using current object as central node",insertMode);
	unbiasedMode = toggle (Select_File,"Make nodes unbiased",insertMode);
	label3 = label(Select_File,"When populating objects insert text of first level map nodes as headers?");
	headerMode = toggle (Select_File,"Use first level nodes as headers",headMode);
	importBut = apply(Select_File,"Import", processDB);
	exportBut = apply(Select_File,"Export", processDB);

	//close(Select_File, true, closegracefully);
	
	// arrange in tab
	label1->"top"->"inside"->dbetab;
	label1->"left"->"inside"->dbetab;
	location->"top"->"spaced"->label1;
	location->"left"->"inside"->dbetab;
	label2->"top"->"spaced"->location;
	label2->"left"->"inside"->dbetab;
	insertionMode->"top"->"spaced"->label2;
	insertionMode->"left"->"inside"->dbetab;
	exportMode->"top"->"spaced"->label2;
	exportMode->"left"->"inside"->dbetab;
	unbiasedMode->"top"->"spaced"->exportMode;
	unbiasedMode->"left"->"inside"->dbetab;
	label3->"top"->"spaced"->insertionMode;
	label3->"left"->"inside"->dbetab;
	headerMode->"top"->"spaced"->label3;
	headerMode->"left"->"inside"->dbetab;

	
	//finetune the ui...
	inactive(exportBut);
	setFocus(location);
	hide(exportMode);
	hide(unbiasedMode);	
	
	
	realize Select_File
	setSize (Select_File,500,400)
	show Select_File
	return
}
//==== end of CreateSelectFile() ===


//=======================================================================
// main

if (null curMod){
	ack "you need to have a module open in exclusive to import a mindmap to";
} else if (isEdit curMod) {
	createSelectFile;
} else {
	ack "module needs to be in exclusive";
}
dule needs to be i