/* ActionBar Modifier v05, by Rainer M. Engel, 2012 (engel[..]endime.de)
 * 
 * ActionBar is a plugin created by Jerome Mutterer working in ImageJ/FIJI 
 * http://imagejdocu.tudor.lu/doku.php?id=plugin:utilities:action_bar:start
 * 
 * optional things, which might come.. (wishes can be mailed, who knows..)
 * - update operation (like ActionBar_Updater Macro)
 * - delete/blank button
 * - create button (wizard)
 */

print("\\Clear");

print("starting ActionBar Modifier v05..");
print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");

ijDir	= getDirectory("imagej");
ActBar	= ijDir+"plugins"+File.separator+"ActionBar"+File.separator; 

listBars= getFileList(ActBar);

print("-> starting to print found ActionBars...");
print("///////////////////////////////////////////////////////////");

n = 0; 
fABars	= newArray();	//Array to store found ActionBars
for (i=0; i<listBars.length; i++) {
	showProgress(i, listBars.length);
	if (matches(listBars[i], ".*.txt")) {
		n++;
		print(n+" | "+listBars[i]);
		fABars = Array.concat(fABars,listBars[i]);
	}
}
print("///////////////////////////////////////////////////////////");


// User Interface MAIN ------------------------------------------------------------
// --------------------------------------------------------------------------------
	Dialog.create("Choose an ActionBar to work with..");
	Dialog.addMessage("refer to log-window to get\nthe correct number");
	Dialog.addSlider("ActionBar:", 1, n, 1);
	Dialog.addMessage("choose an option to perform on this bar");
	Dialog.addChoice("Operation:", newArray("run", "open for edit", "backup (create)", "backup (restore)", "add row (after)", "add column (after)", "add column (before)", "switch button positions", "trim rows", "delete row", "delete column", "delete bar/content"), "run");
	Dialog.addCheckbox("create 'empty.png'", false);
	Dialog.addCheckbox("verbose", false);
	Dialog.show();
	CNumber	= Dialog.getNumber();
	mOption	= Dialog.getChoice();
	emptyPNG= Dialog.getCheckbox();
	verbose = Dialog.getCheckbox();

// --------------------------------------------------------------------------------
// --------------------------------------------------------------------------------

//Result
CBar = "plugins/ActionBar/"+fABars[CNumber-1];


// RUN ActionBar ##################################################################
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (mOption == "run") {
	run("Action Bar","/"+CBar);
	
	print("-> ActionBar operation completed, have a nice day :)");
	print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ################################################################################



// Open for EDIT ##################################################################
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (mOption == "open for edit") {
	openBar	= ActBar+fABars[CNumber-1];	
	open(openBar);	

	print("-> ActionBar operation completed, have a nice day :)");
	print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ################################################################################



// DELETE BAR/CONTENT #############################################################
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (mOption == "delete bar/content") {
	yes = getBoolean("Do you really want to delete the ActionBar "+fABars[CNumber-1]+"\nand its icon subfolder?");

	if (yes) {
		//delete ActionBar......................
		openBar	= ActBar+fABars[CNumber-1];
		//print(openBar);
		delBar	= File.delete(openBar);
		print("-> deletion of Bar: "+delBar+" file deleted");

		//scan icon folder and delete all icons
		shortN	= replace(fABars[CNumber-1], ".[a-zA-Z0-9]*$", "");
		folderB	= ActBar+"icons"+File.separator+shortN+File.separator;
		//print(folderB);
		listB	= getFileList(folderB);

		//print("Files found: "+listB.length);
		
		delC	= 0;
		for (i=0; i<listB.length; i++) { 
			showProgress(i, listB.length);
			//print(ActBar+listB[i]);
			delIco	= File.delete(folderB+listB[i]);		
			if (delIco){
				delC++;
			}			
		}
		print("-> icons deleted: "+delC);
				
		delFol	= File.delete(folderB);		
		print("-> deletion of Fld: "+delFol+" folder deleted");
	}
	print("-> ActionBar operation completed, have a nice day :)");
	print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ################################################################################



// ################################################################################
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ################################################################################
// READ selected ActionBar

if (mOption != "run" && mOption != "open for edit" && mOption != "delete bar/content") {
	
ActScr	= File.openAsString(ActBar+fABars[CNumber-1]);

SRClines= split(ActScr,"\n");
print("-> found "+lengthOf(SRClines)+" lines in ActionBar-Script");

rowsA	= newArray();	//Array to store startPoints of found rows
rowsO	= newArray();	//Array to store endPoints of found rows
buttonA	= newArray();	//Array to store startPoints of found buttons
for (i=0; i<SRClines.length; i++){
	 if (matches(SRClines[i], "<line>.*")){
	 	rowsA = Array.concat(rowsA,i);
	 } else if (matches(SRClines[i], "</line>.*")) {	
	 	rowsO = Array.concat(rowsO,i);
	 } else if (matches(SRClines[i], "^<button>.*")){
	 	buttonA = Array.concat(buttonA,SRClines[i]);	
	 }
}
bPerLine = (buttonA.length/rowsA.length);
print("-> found "+rowsA.length+" rows");
print("-> found "+bPerLine+" buttons per row");

if (verbose) {
	for (i=0; i<rowsA.length; i++){
		print("row "+(i+1)+" is from line "+(rowsA[i])+1+" to "+(rowsO[i])+1);
	}
}

// Create some global variables..
ActBarI	= ActBar;						//the path to all ActionBars
ActBar	= ActBar+fABars[CNumber-1];				//a version for below operations (complete)
closeBar= replace(fABars[CNumber-1], "_", " ");			
closeBar= replace(closeBar, ".[a-zA-Z0-9]*$", ""); 		//for close&open (refresh)
backBar	= replace(fABars[CNumber-1], ".[a-zA-Z0-9]*$", ""); 	//name without extention 

// Default values to fill rows/columns
label	= "label=#";
icon	= "icon="+backBar+File.separator+"empty.png";
macro1	= "arg=<macro>";
macro2	= "showMessage(\"You pressed a button\")";
macro3	= "</macro>";

// Create "empty.png" in needed size..... 
existCheck = File.exists(ActBarI+"icons"+File.separator+backBar+File.separator+"empty.png");
//print("existCheck: "+existCheck);
//print("emptyPNG: "+emptyPNG);
if (existCheck == 0 && emptyPNG == true) {
	pngFld	= ActBarI+"icons"+File.separator+backBar+File.separator;
	pngList	= getFileList(pngFld);
	setBatchMode(true);
	open(pngFld+pngList[0]);
	//Set grey BG
	setForegroundColor(238,238,238);
	run("Select All");
	run("Fill", "slice");
	run("Select None");
	//Set black font
	setForegroundColor(0, 0, 0);
	saveAs("PNG", pngFld+"empty.png");
	close();	
	setBatchMode(false);
}

} //End 

// ################################################################################
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ################################################################################



// BACKUP (CREATE) ################################################################
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (mOption == "backup (create)") {

	yes = getBoolean("Do you really want to create a backup?\nThis overwrites any existing ones for this bar.");
	if (yes) {
		nada	= File.delete(ActBarI+backBar+".backup");
		outLog 	= File.open(ActBarI+backBar+".backup");
		for (i=0; i<SRClines.length; i++){
			print(outLog, SRClines[i]);			
		}
		File.close(outLog);
		print("-> ActionBar operation completed, what happens next :)");
	}
	if (yes == false) {
	print("-> ActionBar operation skipped, what happens next :/");
	}
	print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ################################################################################



// BACKUP (RESTORE) ###############################################################
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (mOption == "backup (restore)") {
	existCheck = File.exists(ActBarI+backBar+".backup");
	//print("existCheck: "+existCheck);
	if (existCheck == 0) {
		exit("There was no appropriate backup found!\nExiting here..");
	}
	
	yes = getBoolean("Do you really want to restore a backup?\nThis overwrites "+fABars[CNumber-1]+" ..");
	if (yes) {
		nada	= File.delete(ActBar);
		if (nada == false) {
			exit("ActionBar can not be deleted/overwritten!\nExiting here..");
		}
		outLog	= File.open(ActBar);

		BackupScr= File.openAsString(ActBarI+backBar+".backup");
		BACKlines= split(BackupScr,"\n");
		
		for (i=0; i<BACKlines.length; i++){
			print(outLog, BACKlines[i]);	
		}
		File.close(outLog);
		print("-> ActionBar operation completed, what happens next :)");
	}
	if (yes == false) {
	print("-> ActionBar operation skipped, what happens next :/");
	}
	print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ################################################################################



// ADD ROW (AFTER) ################################################################
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (mOption == "add row (after)") {

	//DIALOG
	Dialog.create("ActionBar Modifier | add row (after)..");
	Dialog.addMessage("Define the row after which to add a new one."); 
	Dialog.addSlider("add after row", 1, rowsA.length, 1);
	Dialog.addCheckbox("refresh Bar after completion", true);
	Dialog.show();
	addL 	= Dialog.getNumber();
	runAfter = Dialog.getCheckbox();
	print("-> add row after row: "+addL);
	//print(toL);

	nada 	= File.delete(ActBar);
	outLog	= File.open(ActBar);
		
	for (i=0; i<rowsA[0]; i++){ //this prints the header lines
		print(outLog, SRClines[i]);
	}

	bCount 	= 1;
	rCount	= 1;

	
	fromL1 	= 1;
	toL1 	= addL;
	fromL2 	= addL+1;
	toL2 	= rowsA.length;
	
	for (i=rowsA[fromL1-1]; i<(rowsO[toL1-1])+1; i++){ //this prints the body (lines)
	 	if (matches(SRClines[i], "<button>.*")) { //make new button numbering
	 		print(outLog, "<button> "+bCount+" line "+rCount);
	 		bCount++;
	 		if (bCount > bPerLine) {
	 			bCount = 1;
	 			rCount++;
	 		}
	 	} else {
	 		print(outLog, SRClines[i]);
	 	}
	}
	
	//------------------------------------------------------- new row start
	print(outLog, "<line>");
	for (i=0; i<bPerLine; i++){
		print(outLog, "<button> "+bCount+" line "+rCount);
		print(outLog, label);
	 	print(outLog, icon);
	 	print(outLog, macro1);		 	
	 	print(outLog, "showMessage(\"You pressed button "+bCount+" line "+rCount+"\")");		 	
	 	print(outLog, macro3);
	 	
	 	bCount++;
	 	if (bCount > bPerLine) {
	 		bCount = 1;
	 		rCount++;
	 	}
	}
	print(outLog, "</line>");
	//------------------------------------------------------- new row end
	
	if (addL != rowsA.length) {
		for (i=rowsA[fromL2-1]; i<(rowsO[toL2-1])+1; i++){ //this prints the body (lines)
	 		if (matches(SRClines[i], "<button>.*")) { //make new button numbering
	 			print(outLog, "<button> "+bCount+" line "+rCount);
	 			bCount++;
	 			if (bCount > bPerLine) {
	 				bCount = 1;
	 				rCount++;
	 			}
	 		} else {
	 			print(outLog, SRClines[i]);
		 	}
		}
	}
	

	//this prints the footer lines
	print(outLog, "");
	print(outLog, "// end of file");
	File.close(outLog);

	if (runAfter) {
		run ("Close AB", closeBar);
		run("Action Bar","/"+CBar);
	}
	print("-> ActionBar operation completed, have a nice day :)");
	print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ################################################################################



// ADD COLUMN (AFTER) #############################################################
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (mOption == "add column (after)") {

	//DIALOG
	Dialog.create("ActionBar Modifier | add column (after)..");
	Dialog.addMessage("Define the column after which to add a new one."); 
	Dialog.addSlider("add after column", 1, bPerLine, 1);
	Dialog.addCheckbox("refresh Bar after completion", true);
	Dialog.show();
	addC 	= Dialog.getNumber();
	runAfter = Dialog.getCheckbox();
	print("-> add column after column: "+addC);


	nada 	= File.delete(ActBar);
	outLog	= File.open(ActBar);
		
	for (i=0; i<rowsA[0]; i++){ //this prints the header lines
		print(outLog, SRClines[i]);
	}
	
	bCount 	= 1;
	rCount	= 1;

	for (i=0; i<(rowsA.length); i++){
	//for (i=0; i<1; i++){
		//print("true");
		//print(rowsA[i]);
		//print(rowsO[i]);
		sliceAIn	= rowsA[i];
		sliceAOut	= (addC)*6+rowsA[i]+1;
		sliceBIn	= (addC)*6+rowsA[i]+1;
		sliceBOut	= rowsO[i]+1;
/*
		print(sliceAIn);
		print(sliceAOut);
		print(sliceBIn);
		print(sliceBOut);
*/
		//Modify Array, cut column AWAY ;-)
		SliceA 	= Array.slice(SRClines, sliceAIn, sliceAOut);

		//Add this lines for new button.........................
		SliceAdd= newArray("<button> I am new here",label,icon,macro1,macro2,macro3);
		SliceA	= Array.concat(SliceA,SliceAdd);
		// .....................................................
		
		SliceB 	= Array.slice(SRClines, sliceBIn, sliceBOut);
		rowSlice= Array.concat(SliceA,SliceB);
		
		for (j=0; j<(rowSlice.length); j++){

	 		if (matches(rowSlice[j], "<button>.*")) { //make new button numbering
	 			print(outLog, "<button> "+bCount+" line "+rCount);
	 			bCount++;
	 			if (bCount > (bPerLine+1)) {
	 				bCount = 1;
	 				rCount++;
	 			}
	 		} else {
	 			print(outLog, rowSlice[j]);
		 	}
		}
	}
	
	
/*
	for (i=rowsA[0]; i<(rowsO[(rowsA.length)-1]); i++){
		print(SRClines[i]);
	}
*/

	//this prints the footer lines
	print(outLog, "");
	print(outLog, "// end of file");
	File.close(outLog);
	
	if (runAfter) {
		run ("Close AB", closeBar);
		run("Action Bar","/"+CBar);
	}
	print("-> ActionBar operation completed, have a nice day :)");
	print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ################################################################################



// ADD COLUMN (BEFORE) #############################################################
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (mOption == "add column (before)") {

	//DIALOG
	Dialog.create("ActionBar Modifier | add column (before)..");
	Dialog.addMessage("Define the column before which to add a new one."); 
	Dialog.addSlider("add after column", 1, bPerLine, 1);
	Dialog.addCheckbox("refresh Bar after completion", true);
	Dialog.show();
	addC 	= Dialog.getNumber();
	runAfter = Dialog.getCheckbox();
	print("-> add column before column: "+addC);


	nada 	= File.delete(ActBar);
	outLog	= File.open(ActBar);

		
	for (i=0; i<rowsA[0]; i++){ //this prints the header lines
		print(outLog, SRClines[i]);
	}
	
	bCount 	= 1;
	rCount	= 1;

	for (i=0; i<(rowsA.length); i++){
	//for (i=0; i<1; i++){
		//print("true");
		//print(rowsA[i]);
		//print(rowsO[i]);
		sliceAIn	= rowsA[i];
		sliceAOut	= (addC-1)*6+rowsA[i]+1;
		sliceBIn	= (addC-1)*6+rowsA[i]+1;
		sliceBOut	= rowsO[i]+1;
/*
		print(sliceAIn);
		print(sliceAOut);
		print(sliceBIn);
		print(sliceBOut);
*/
		//Modify Array, cut column AWAY ;-)
		SliceA 	= Array.slice(SRClines, sliceAIn, sliceAOut);

		//Add this lines for new button.........................
		SliceAdd= newArray("<button> I am new here",label,icon,macro1,macro2,macro3);
		SliceA	= Array.concat(SliceA,SliceAdd);
		// .....................................................
		
		SliceB 	= Array.slice(SRClines, sliceBIn, sliceBOut);
		rowSlice= Array.concat(SliceA,SliceB);
		
		for (j=0; j<(rowSlice.length); j++){

	 		if (matches(rowSlice[j], "<button>.*")) { //make new button numbering
	 			print(outLog, "<button> "+bCount+" line "+rCount);
	 			bCount++;
	 			if (bCount > (bPerLine+1)) {
	 				bCount = 1;
	 				rCount++;
	 			}
	 		} else {
	 			print(outLog, rowSlice[j]);
		 	}
		}
	}
	
	
/*
	for (i=rowsA[0]; i<(rowsO[(rowsA.length)-1]); i++){
		print(SRClines[i]);
	}
*/

	//this prints the footer lines
	print(outLog, "");
	print(outLog, "// end of file");
	File.close(outLog);

	if (runAfter) {
		run ("Close AB", closeBar);
		run("Action Bar","/"+CBar);
	}
	print("-> ActionBar operation completed, have a nice day :)");
	print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");	
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ################################################################################



// SWITCH BUTTON POSITION #########################################################
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (mOption == "switch button positions") {

	//DIALOG
	Dialog.create("ActionBar Modifier | switch button positions..");
	Dialog.addMessage("Define the position of buttons between to switch."); 
	Dialog.addSlider("from x-position", 1, bPerLine, 1);
	Dialog.addSlider("from row", 1, rowsA.length, 1);
	Dialog.addMessage(""); 
	Dialog.addSlider("to x-position", 1, bPerLine, bPerLine);
	Dialog.addSlider("to row", 1, rowsA.length, rowsA.length);
	Dialog.addCheckbox("refresh Bar after completion", true);
	Dialog.show();
	fromX 	= Dialog.getNumber();
	fromR	= Dialog.getNumber();
	toX	= Dialog.getNumber();
	toR	= Dialog.getNumber();
	runAfter = Dialog.getCheckbox();

	if (fromX == toX && fromR == toR) {
		exit("Won't make sense! Have you ever tried, lifting yourself up?");
	}

	
	print("-> switch button from: X "+fromX+", line "+fromR+" | to X "+toX+", line "+toR);


	slice1AIn	= 0;	//rowsA[fromR-1];
	slice1AOut	= (fromX-1)*6+rowsA[fromR-1]+1;
	slice1BIn	= (fromX)*6+rowsA[fromR-1]+1;
	slice1BOut	= rowsO[rowsO.length-1]+1;

	sourceGrep	= Array.slice(SRClines, slice1AOut, slice1BIn);
	
	slice2AIn	= 0;	//rowsA[toR-1];
	slice2AOut	= (toX-1)*6+rowsA[toR-1]+1;
	slice2BIn	= (toX)*6+rowsA[toR-1]+1;
	slice2BOut	= rowsO[rowsO.length-1]+1;

	targetGrep	= Array.slice(SRClines, slice2AOut, slice2BIn);

	if (verbose) {
		print("source button ...........................");
		for (i=0; i<sourceGrep.length; i++){ // source grep content
			print(sourceGrep[i]);
		}
		print("...................................................");
		print("target button ...........................");
		for (i=0; i<targetGrep.length; i++){ // target grep content
			print(targetGrep[i]);
		}
		print("...................................................");
	
	}
/*
	print(slice1AIn);
	print(slice1AOut);
	print(slice1BIn);
	print(slice1BOut);
	print(slice2AIn);
	print(slice2AOut);
	print(slice2BIn);
	print(slice2BOut);
*/

	//Modify Array, cut to source button (Source Patch)
	SliceA 	= Array.slice(SRClines, slice1AIn, slice1AOut);
	//Add target butten here
	SliceA	= Array.concat(SliceA,targetGrep);
	//Add content after source button		
	SliceB 	= Array.slice(SRClines, slice1BIn, slice1BOut);
	SliceB	= Array.concat(SliceA,SliceB);
		
	//Modify Array, cut to target button (Target Patch)
	SliceC	= Array.slice(SliceB, slice2AIn, slice2AOut);
	//Add target butten here
	SliceC	= Array.concat(SliceC,sourceGrep);
	//Add content after source button		
	SliceD 	= Array.slice(SliceB, slice2BIn, slice2BOut);
	outLines= Array.concat(SliceC,SliceD);	

		
	nada 	= File.delete(ActBar);
	outLog	= File.open(ActBar);
	
	bCount 	= 1;
	rCount	= 1;
				
	for (j=0; j<(outLines.length); j++){

	 	if (matches(outLines[j], "<button>.*")) { //make new button numbering
 			print(outLog, "<button> "+bCount+" line "+rCount);
 			//print(outLog, outLines[j]);
 			bCount++;
 			if (bCount > (bPerLine)) {
 				bCount = 1;
 				rCount++;
 			}
 		} else {
 			print(outLog, outLines[j]);
	 	}
	}

	//this prints the footer lines
	print(outLog, "");
	print(outLog, "// end of file");
	File.close(outLog);

	if (runAfter) {
		run ("Close AB", closeBar);
		run("Action Bar","/"+CBar);
	}
	print("-> ActionBar operation completed, have a nice day :)");
	print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ################################################################################



// TRIM ROWS ######################################################################
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (mOption == "trim rows") {

	//DIALOG
	Dialog.create("ActionBar Modifier | trim rows..");
	Dialog.addMessage("Define the rows to keep (from - to)."); 
	Dialog.addSlider("first row", 1, rowsA.length, 1);
	Dialog.addSlider("last row", 1, rowsA.length, rowsA.length);
	Dialog.addCheckbox("refresh Bar after completion", true);
	Dialog.show();
	fromL 	= Dialog.getNumber();
	toL 	= Dialog.getNumber();
	runAfter = Dialog.getCheckbox();
	print("-> trimming from row "+fromL+" to "+toL);
	//print(toL);

	nada 	= File.delete(ActBar);
	outLog	= File.open(ActBar);
			
	for (i=0; i<rowsA[0]; i++){ //this prints the header lines
		print(outLog, SRClines[i]);
	}

	bCount 	= 1;
	rCount	= 1;
	
	for (i=rowsA[fromL-1]; i<(rowsO[toL-1])+1; i++){ //this prints the body (lines)
	 	if (matches(SRClines[i], "<button>.*")) { //make new button numbering
	 		print(outLog, "<button> "+bCount+" line "+rCount);
	 		bCount++;
	 		if (bCount > bPerLine) {
	 			bCount = 1;
	 			rCount++;
	 		}
	 	} else {
	 		print(outLog, SRClines[i]);
	 	}
	}

	//this prints the footer lines
	print(outLog, "");
	print(outLog, "// end of file");
	File.close(outLog);

	if (runAfter) {
		run ("Close AB", closeBar);
		run("Action Bar","/"+CBar);
	}
	print("-> ActionBar operation completed, have a nice day :)");
	print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ################################################################################



// DELETE ROW #####################################################################
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (mOption == "delete row") {

	//DIALOG
	Dialog.create("ActionBar Modifier | delete row..");
	Dialog.addMessage("Define the row to remove from ActionBar."); 
	Dialog.addSlider("delete row", 1, rowsA.length, 1);
	Dialog.addCheckbox("refresh Bar after completion", true);
	Dialog.show();
	delL 	= Dialog.getNumber();
	runAfter = Dialog.getCheckbox();
	print("-> delete row: "+delL);
	//print("Line to delete: "+delL);

	nada 	= File.delete(ActBar);
	outLog	= File.open(ActBar);
		
	for (i=0; i<rowsA[0]; i++){ //this prints the header lines
		print(outLog, SRClines[i]);
	}

	bCount 	= 1;
	rCount	= 1;

	
	if (delL == 1) {			// the first Line will be removed
		fromL1 	= delL+1;
		toL1 	= rowsA.length;
			for (i=rowsA[fromL1-1]; i<(rowsO[toL1-1])+1; i++){ //this prints the body (lines)
			 	if (matches(SRClines[i], "<button>.*")) { //make new button numbering
			 		print(outLog, "<button> "+bCount+" line "+rCount);
	 				bCount++;
			 		if (bCount > bPerLine) {
			 			bCount = 1;
			 			rCount++;
			 		}
			 	} else {
			 		print(outLog, SRClines[i]);
			 	}
			}
			
	} else if (delL == rowsA.length) {	// the last Line will be removed
		fromL1 	= 1;
		toL1 	= (rowsA.length)-1;
			for (i=rowsA[fromL1-1]; i<(rowsO[toL1-1])+1; i++){ //this prints the body (lines)
			 	if (matches(SRClines[i], "<button>.*")) { //make new button numbering
			 		print(outLog, "<button> "+bCount+" line "+rCount);
	 				bCount++;
			 		if (bCount > bPerLine) {
			 			bCount = 1;
			 			rCount++;
			 		}
			 	} else {
			 		print(outLog, SRClines[i]);
			 	}
			}
	} else {				// a line in the middle will be removed
		fromL1 	= 1;
		toL1 	= delL-1;
		fromL2 	= delL+1;
		toL2 	= rowsA.length;
			for (i=rowsA[fromL1-1]; i<(rowsO[toL1-1])+1; i++){ //this prints the body (lines)
			 	if (matches(SRClines[i], "<button>.*")) { //make new button numbering
			 		print(outLog, "<button> "+bCount+" line "+rCount);
	 				bCount++;
			 		if (bCount > bPerLine) {
			 			bCount = 1;
			 			rCount++;
			 		}
			 	} else {
			 		print(outLog, SRClines[i]);
			 	}
			}
			for (i=rowsA[fromL2-1]; i<(rowsO[toL2-1])+1; i++){ //this prints the body (lines)
			 	if (matches(SRClines[i], "<button>.*")) { //make new button numbering
			 		print(outLog, "<button> "+bCount+" line "+rCount);
	 				bCount++;
			 		if (bCount > bPerLine) {
			 			bCount = 1;
			 			rCount++;
			 		}
			 	} else {
			 		print(outLog, SRClines[i]);
			 	}
			}
	} 

	//this prints the footer lines
	print(outLog, "");
	print(outLog, "// end of file");
	File.close(outLog);

	if (runAfter) {
		run ("Close AB", closeBar);
		run("Action Bar","/"+CBar);
	}
	print("-> ActionBar operation completed, have a nice day :)");
	print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ################################################################################



// DELETE COLUMN ##################################################################
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (mOption == "delete column") {

	//DIALOG
	Dialog.create("ActionBar Modifier | delete column..");
	Dialog.addMessage("Define the column to delete."); 
	Dialog.addSlider("add after column", 1, bPerLine, 1);
	Dialog.addCheckbox("refresh Bar after completion", true);
	Dialog.show();
	delC 	= Dialog.getNumber();
	runAfter = Dialog.getCheckbox();
	print("-> delete column: "+delC);


	nada 	= File.delete(ActBar);
	outLog	= File.open(ActBar);
			
	for (i=0; i<rowsA[0]; i++){ //this prints the header lines
		print(outLog, SRClines[i]);
	}
	
	bCount 	= 1;
	rCount	= 1;

	for (i=0; i<(rowsA.length); i++){
	//for (i=0; i<1; i++){
		//print("true");
		//print(rowsA[i]);
		//print(rowsO[i]);
		sliceAIn	= rowsA[i];
		sliceAOut	= (delC-1)*6+rowsA[i]+1;
		sliceBIn	= delC*6+rowsA[i]+1;
		sliceBOut	= rowsO[i]+1;
	
/*		print(sliceAIn);
		print(sliceAOut);
		print(sliceBIn);
		print(sliceBOut);
*/
		//Modify Array, cut column AWAY ;-)
		SliceA 	= Array.slice(SRClines, sliceAIn, sliceAOut);
		SliceB 	= Array.slice(SRClines, sliceBIn, sliceBOut);
		rowSlice= Array.concat(SliceA,SliceB);
		
		for (j=0; j<(rowSlice.length); j++){

	 		if (matches(rowSlice[j], "<button>.*")) { //make new button numbering
	 			print(outLog, "<button> "+bCount+" line "+rCount);
	 			bCount++;
	 			if (bCount > (bPerLine-1)) {
	 				bCount = 1;
	 				rCount++;
	 			}
	 		} else {
	 			print(outLog, rowSlice[j]);
		 	}
		}
	}
	
	
/*
	for (i=rowsA[0]; i<(rowsO[(rowsA.length)-1]); i++){
		print(SRClines[i]);
	}
*/

	//this prints the footer lines
	print(outLog, "");
	print(outLog, "// end of file");
	File.close(outLog);

	if (runAfter) {
		run ("Close AB", closeBar);
		run("Action Bar","/"+CBar);
	}
	print("-> ActionBar operation completed, have a nice day :)");
	print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ################################################################################