/*
 * V1.0 Edited by Jing
 * 
 * - Fixed the installation of eclipse using different names [without spaces] 
 * Bug: Plugin will only work if Eclipse is installed in C:/eclipse/
 * Fix: run() modified so that the internal path is dynamic with respect to the 
 * root folder [folder in which eclipse is installed]  instead of being static to c:/eclipse/
 * Now: User can install eclipse into a folder named "blah" instead of "eclipse" and the plugin will still run correctly
 * 
 * - Fixed the bug for installation of eclipse into a folder with spaces
 * Bug: Build will not generate makefile, run make file or create the simu.exe or complete any build functions correctly
 * if there is a space in the path to eclipse.
 * Fix: All instances of "cmd" [dos/unix command] are fixed to a format that supports spaces
 * A new function is created called toUnixPath that will convert a path to unix [used by cygwin]
 * Quotes are added to path names so that it will support spaces in file names.
 * 
 */
 
package CDBuilder.buttons;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.MessageBox;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;
import org.eclipse.ui.PlatformUI;

import CDBuilder.CDBuilderPlugin;
import CDBuilder.console.ConsoleDocument;
import CDBuilder.console.StreamHandler;

/**
 * @author sddsim
 *
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */

public class RunMakeFileAction extends Action implements IWorkbenchWindowActionDelegate  {
	
		
	public class conWrite implements Runnable {
		String line;
		public conWrite(String line) {
			this.line = line;
		}
		public void run() {
			ConsoleDocument.getCDOS().set(line);
		}
	}


	class makefileTasks implements IRunnableWithProgress{
		boolean vMode;
		boolean simuexists = false;
		boolean makeexists = false;
		//main object files
		String[] mainOFiles = {"queue.o", "main.o", "generat.o","cpu.o","transduc.o","distri.o","com.o","linpack.o","debug.o", "trafico.o"};
		String originalMakefile;
		IContainer container; 
		IPath projectPath; 
		IPath internalPath;
		IWorkspaceRoot root;
	
		
		public makefileTasks(boolean vMode, IContainer container, IPath projectPath, IPath internalPath, IWorkspaceRoot root) {
			this.vMode = vMode;
			this.container = container;
			this.projectPath = projectPath;
			this.internalPath = internalPath;
			this.root = root;
		}

		public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException 
		{
			try {
				
				//Updates console
				Display.getDefault().syncExec(new conWrite("Starting Compilation of Project..." + "\n"));	
				Display.getDefault().syncExec(new conWrite("Searching for .cpp files..." + "\n"));
								
						
				monitor.setTaskName("Building Project");
				monitor.beginTask("Building Project", 9);
				monitor.subTask("Searching For CPP Files");				
				monitor.worked(1);
				
				if (monitor.isCanceled())
					throw new InterruptedException("User has cancelled the compilation");
				


				String[] cppFiles = null;
				cppFiles = findMembers(container,cppFiles);
				String[] oFiles = new String [cppFiles.length]; 
				for (int a = 0; a < oFiles.length-1; a++ ){ 
					if (cppFiles[a]!=null){
						//changing files.cpp to objectFiles.cpp
						oFiles[a] = new String(cppFiles[a].substring(0,cppFiles[a].length()-4)+".o");	
						for (int b = 0; b<mainOFiles.length; b++) {
							if (mainOFiles[b]!=null ){
								if (oFiles[a].indexOf(mainOFiles[b])!= -1 && oFiles[a].length() == mainOFiles[b].length()){
									mainOFiles[b] = null;
								}
							}
						}
					}
				}
				String parameters = new String(""); 
			
			     
				//old code commented out
				String projectPathForUnix = projectPath.toString().charAt(0) + projectPath.toString().substring(2);
				String internalPathForUnix = internalPath.toString().charAt(0) + internalPath.toString().substring(2);
				
				System.out.println("internalPathForUnix: " + internalPathForUnix);
				System.out.println("projectPathForUnix: " + projectPathForUnix);
				
				
				for (int i = 0; i<cppFiles.length; i++) {
					if (cppFiles[i]!=null) {
						int index = cppFiles[i].lastIndexOf("/");
						parameters += " /cygdrive/"+ toUnixPath(projectPath)+ cppFiles[i].substring(index+1, cppFiles[i].length());
						System.out.println(parameters);
					}
				}
				if (parameters.length()==0) {
					Display.getDefault().syncExec(new Runnable() {
					   public void run() {
						ConsoleDocument.getCDOS().set(".cpp files were not found in this project..." + "\n");
						ConsoleDocument.getCDOS().set("project compilation failed... \n");
						MessageBox PCGui = new MessageBox(new Shell(), SWT.ICON_ERROR | SWT.OK);
						PCGui.setMessage("There were no .cpp files found in your project, \n project compilation failed and will be canceled");
						PCGui.setText(".cpp files were not found");
						PCGui.open();	
					   }
					});
				 	System.out.println(".cpp files were not found in this project");
				} 
				else {
					monitor.worked(1);


					if (monitor.isCanceled())
						throw new InterruptedException("User has cancelled the compilation");
					monitor.subTask("checking for existing Simu.exe...");
					monitor.worked(1);
					Display.getDefault().syncExec(new conWrite("checking for existing Simu.exe..." + "\n"));
					
					if (simuexists) {
						System.out.println("It exist:   " + projectPathForUnix);
						monitor.subTask("backing up old Simu.exe...");
						Display.getDefault().syncExec(new conWrite("Removing Simu.exe..." + "\n"));
						Process backupSProc = Runtime.getRuntime().exec("cmd /c cp \"/cygdrive/"+projectPathForUnix +"simu.exe\""+ " \"/cygdrive/" + projectPathForUnix + "simuOriginal.exe\"");
						System.out.println(projectPathForUnix);
						StreamHandler BSPerrorHandler = new StreamHandler(backupSProc.getErrorStream(), "ERROR", vMode);            
						StreamHandler BSPoutputHandler = new StreamHandler(backupSProc.getInputStream(), "OUTPUT", vMode);
						BSPerrorHandler.start();
						BSPoutputHandler.start();
						backupSProc.waitFor();
						Process removeSimuProc = Runtime.getRuntime().exec("cmd /c rm \"/cygdrive/" + projectPathForUnix + "simu.exe\"");
						StreamHandler RSPerrorHandler = new StreamHandler(removeSimuProc.getErrorStream(), "ERROR", vMode);            
						StreamHandler RSPoutputHandler = new StreamHandler(removeSimuProc.getInputStream(), "OUTPUT", vMode);
						RSPerrorHandler.start();
						RSPoutputHandler.start();
						removeSimuProc.waitFor();
						simuexists = false;
					}
				
					if (monitor.isCanceled())
						throw new InterruptedException("User has cancelled the compilation");
					monitor.subTask("Generating project dependencies...");
					

				
					monitor.worked(1);
				
					
					Display.getDefault().syncExec(new conWrite("Generating project dependencies..." + "\n"));
					
					
		
					
					generateDependFiles(vMode, internalPathForUnix, parameters);
					
					monitor.worked(1);
					monitor.subTask("Generating the makefile...");

					if (monitor.isCanceled())
						throw new InterruptedException("User has cancelled the compilation");
				
					Display.getDefault().syncExec(new conWrite("Generating the makefile..." + "\n"));
					
					//  testing purposes
					//	Display.getDefault().syncExec(new conWrite (internalPath + "\n"));
					//	Display.getDefault().syncExec(new conWrite (projectPath + "\n"));
					
					char [] array = new char [1]; //make a new char array 
					array[0] = '^'; // put the ^ inside
					
					FileReader reader = new FileReader(""+internalPath+"makefile1"+""); //read in the template makefile
					FileWriter writer = new FileWriter(""+projectPath+"Makefile"+""); //creates the new specific makefile
					
					if (monitor.isCanceled())
						throw new InterruptedException("User has cancelled the compilation");
					//*** The Makefile Write Algorithm
					int j = 0;
					int i = 0; 
					int times = 0;
					while (i!=-1) {
						if (monitor.isCanceled())
							throw new InterruptedException("User has cancelled the compilation");
						i = reader.read();
						if (j == 1)	{
							array[0] = '|';
							if (i==array[0]){
								writer.write("|\n");
								i = '#';
								if (times == 0)	{
									writer.write("EXAMPLESOBJS= ");
									for (i = 0; i<oFiles.length;i++){
										if (oFiles[i]!=null) 
											writer.write(" "+oFiles[i]);
									}
									for (int k =0; k<mainOFiles.length; k++){
										if (mainOFiles[k]!=null)
											writer.write(" " +mainOFiles[k]);
										if (monitor.isCanceled())
											throw new InterruptedException("User has cancelled the compilation");
									}
									writer.write("\n#");
									times ++;
								} 
								else if (times == 1) {
									for (int k=0; k<cppFiles.length; k++){
										
										if (oFiles[k]!=null){
											
											int index =oFiles[k].lastIndexOf("/");
											writer.write(oFiles[k].substring(index+1, oFiles[k].length())+ ": /cygdrive/" + toUnixPath(projectPath)+ cppFiles[k]+"\n");
											writer.write("\t${CPP} -c ${LDFLAGS} ${INCLUDES_CPP} ${DEFINES_CPP} ${DEBUGFLAGS} ${CPPFLAGS} $< \n");
											if (monitor.isCanceled())
												throw new InterruptedException("User has cancelled the compilation");
										
										}
									}
									times=2;
								} 
								else if (times == 2) {
									for (int h = 0; h<oFiles.length; h++){
										if (monitor.isCanceled())
											throw new InterruptedException("User has cancelled the compilation");
										if (oFiles[h]!=null) {
											int fir= oFiles[h].lastIndexOf("/");
											int in = oFiles[h].lastIndexOf(".");
											
											FileReader read = new FileReader(""+internalPath + oFiles[h].substring(fir+1, in) +".d"+""); //read in the template makefile
											int g = 0;
											while ((g = read.read())!=-1)
												writer.write(g);
										}
									}
								}
							} 
						else 
							array[0]='^';
						}
						if (i==array[0]) j = 1;
						if (i==-1) break;
					writer.write(i);
					}	
					writer.close();
					reader.close();				
					//**** End Of Makefile write algorithm
				
				
				
					// Run The makefile
					monitor.worked(1);
					monitor.subTask("Running the makefile...");
					if (monitor.isCanceled())
						throw new InterruptedException("User has cancelled the compilation");
					Display.getDefault().syncExec(new conWrite("Running the makefile..." + "\n"));
				
					//the following format is required for running makefile in cmd
				  	//make -f "/cygdrive/C/eclipse test/runtime-workspace/atm/atm/Makefile" OBJS="/cygdrive/C/eclipse\ test/runtime-workspace/atm/atm/Balanceverifier.cpp /cygdrive/C/eclipse\ test/runtime-workspace/atm/atm/CardReader.cpp /cygdrive/C/eclipse\ test/runtime-workspace/atm/atm/UserInterface.cpp /cygdrive/C/eclipse\ test/runtime-workspace/atm/atm/cashdispenser.cpp /cygdrive/C/eclipse\ test/runtime-workspace/atm/atm/pinverifier.cpp /cygdrive/C/eclipse\ test/runtime-workspace/atm/atm/register.cpp" -C "/cygdrive/C/eclipse test/plugins/CD++Builder_1.1.0/internal/"

					System.out.println("makeProject: " + "cmd  /c make -f \"/cygdrive/"+projectPathForUnix+"Makefile\" OBJS=\""+parameters+"\" -C \"/cygdrive/"+internalPathForUnix+"\"");
					Process makeProjectProc = Runtime.getRuntime().exec("cmd  /c make -f \"/cygdrive/"+projectPathForUnix+"Makefile\" OBJS=\""+parameters+"\" -C \"/cygdrive/"+internalPathForUnix+"\"");	
					System.out.println("parameters: " + parameters);
					StreamHandler MPPerrorHandler = new StreamHandler(makeProjectProc.getErrorStream(), "ERROR",vMode,root,false);            
					StreamHandler MPPoutputHandler = new StreamHandler(makeProjectProc.getInputStream(), "OUTPUT", vMode,root,false);
					MPPerrorHandler.start();
					MPPoutputHandler.start();
					makeProjectProc.waitFor();
					if (monitor.isCanceled())
						throw new InterruptedException("User has cancelled the compilation");


					// Moves the necessary Object Files to the project
					monitor.worked(1);
					monitor.subTask("Transfering Object Files...");
					Display.getDefault().syncExec(new conWrite("Transfering newly created project files..." + "\n"));
							
					for (i = 0; i<oFiles.length;i++) {
						if (oFiles[i]!=null){//beg if
							if (monitor.isCanceled())
								throw new InterruptedException("User has cancelled the compilation");
							
//							//getting move to work:--- the following format works for moving files to other folders
						    //mv "/cygdrive/C/eclipse test/plugins/CD++Builder_1.1.0/internal/Balanceverifier.o" "/cygdrive/C/eclipse test/runtime-workspace/atm/atm/"
							System.out.println("movObjProc: " + "cmd /c mv \"/cygdrive/"+internalPathForUnix + oFiles[i]+"\" \"/cygdrive/"+projectPathForUnix+"\"");	
							Process moveObjProc =  Runtime.getRuntime().exec("cmd /c mv \"/cygdrive/"+internalPathForUnix + oFiles[i]+"\" \"/cygdrive/"+projectPathForUnix+"\"");
							StreamHandler moPerrorHandler = new StreamHandler(moveObjProc.getErrorStream(), "ERROR", vMode);            
							StreamHandler moPoutputHandler = new StreamHandler(moveObjProc.getInputStream(), "OUTPUT", vMode);
							moPerrorHandler.start();
							moPoutputHandler.start();
							moveObjProc.waitFor();
						}//end if
					}
				
					//Moves The Simu Executable
					monitor.worked(1);
					monitor.subTask("Finalizing Project...");
					if (monitor.isCanceled())
						throw new InterruptedException("User has cancelled the compilation");
					Display.getDefault().syncExec(new conWrite("Finalizing project..." + "\n"));
				
				    //removeDFiles
					Process removeDFilesProc = Runtime.getRuntime().exec("cmd /c rm -f \"/cygdrive/" + internalPathForUnix +"*.d\"");
					StreamHandler rmDerrorHandler = new StreamHandler(removeDFilesProc.getErrorStream(), "ERROR",vMode);            
					StreamHandler rmDoutputHandler = new StreamHandler(removeDFilesProc.getInputStream(), "OUTPUT", vMode);
					rmDerrorHandler.start();
					rmDoutputHandler.start();
					removeDFilesProc.waitFor();
				
					Process moveSimuProc = Runtime.getRuntime().exec("cmd /c mv \"/cygdrive/"+ internalPathForUnix + "simu.exe\" "+" \"/cygdrive/"+ projectPathForUnix+"\"");
					StreamHandler msPerrorHandler = new StreamHandler(moveSimuProc.getErrorStream(), "ERROR",vMode);            
					StreamHandler msPoutputHandler = new StreamHandler(moveSimuProc.getInputStream(), "OUTPUT", vMode);
					msPerrorHandler.start();
					msPoutputHandler.start();
					moveSimuProc.waitFor();
						
					
					
					// refreshes Project 
					container.refreshLocal(1, null);
					Display.getDefault().syncExec(new Runnable() {
						public void run() {
							container  = root.getContainerForLocation(projectPath);
						}
					});
					monitor.worked(1);
					findMembers(container, cppFiles);
			
					if (simuexists) 
						Display.getDefault().syncExec(new conWrite("Simu was created, ready to to start simulations..." + "\n"));
					else  
						Display.getDefault().syncExec(new conWrite("ERROR - Simu was not created, Simulation cannot commence" + "\n"));
							
					
					monitor.done();

				}  				
				
				
			}
			catch (NullPointerException np) {
				Display.getDefault().syncExec(new Runnable() {
					public void run() {
						MessageBox npGui = new MessageBox(new Shell(), SWT.ICON_ERROR | SWT.OK);
						npGui.setMessage("You must select a file or project folder to start compiling! ");
						npGui.setText("Project Not Selected");
						npGui.open();
						ConsoleDocument.getCDOS().set("Compiling is terminated, Please select a project or folder from the navigator.");
					}
				});
			}
			catch (FileNotFoundException FNF) {
				FNF.printStackTrace();
				Display.getDefault().syncExec(new Runnable() {
					public void run() {
						MessageBox FNFGui = new MessageBox(new Shell(), SWT.ICON_ERROR | SWT.OK);
						FNFGui.setMessage("A File in the internal directory of the plugin is corrupted. \n Please re-install CD++ Builder. ");
						FNFGui.setText("Internal File Corrupted");
						FNFGui.open();
						ConsoleDocument.getCDOS().set("Compiling is terminated, a File in the internal directory of the plugin is corrupted. Please re-install CD++ Builder.");
					}
				});
			}
			catch (InterruptedException IE) {
				throw IE;
			}
			catch (Exception e) {
				System.out.println("Within the Runnable: " + e);
			}
				
		}			

		private String [] findMembers(IContainer container, String[] cppFiles){
			try{
				int j = 0;
				IResource[] filesInProject = container.members(); 
				cppFiles = new String [filesInProject.length];
				for (int i =0; i<filesInProject.length; i++) { //gets all the .cpp files and put them inside member 
					if (filesInProject[i].getName().endsWith("cpp")) {
						cppFiles[j] =filesInProject[i].getName();
						j++;	
					}
					if (filesInProject[i].getName().equalsIgnoreCase("makefile")){
						makeexists = true;
						originalMakefile = filesInProject[i].getName();
					}
					
									
					if (filesInProject[i].getName().equalsIgnoreCase("simu.exe"))
						simuexists = true;
				}
			}catch (Exception e){
				System.out.println(e);
			}
			return cppFiles; //get the members (files/folders) of the container
		}
	
		private void generateDependFiles(
			boolean runVmode,
			String internalPathForUnix,
			String parameters)
			throws IOException, InterruptedException {//beg generateDependFiles
						
/*TESTING for multiple files --- To have multiple parameters [for OBJS] the parameters will need to be surrounded by " " 
make -f generalmakefile HEY="/cygdrive/C/eclipse\ test/plugins/CD++Builder_1.1.0/internal/" OBJS="/cygdrive/C/eclipse\ test/runtime-workspace/atm/atm/Balanceverifier.cpp /cygdrive/C/eclipse\ test/runtime-workspace/atm/atm/CardReader.cpp /cygdrive/C/eclipse\ test/runtime-workspace/atm/atm/UserInterface.cpp /cygdrive/C/eclipse\ test/runtime-workspace/atm/atm/cashdispenser.cpp /cygdrive/C/eclipse\ test/runtime-workspace/atm/atm/pinverifier.cpp /cygdrive/C/eclipse\ test/runtime-workspace/atm/atm/register.cpp" -C "/cygdrive/C/eclipse test/plugins/CD++Builder_1.1.0/internal/"
THE ABOVE formating is required to get eclipse working for "project dependencies" */
			
			String tempString =
				new String(
					"make -f generalmakefile "
						+ "HEY=\"/cygdrive/"
						+ toUnixPath(internalPath)
						+ "\" OBJS=\""
						+ parameters
						+ "\" -C \"/cygdrive/"
						+ internalPathForUnix
						+ "\"");
			
			System.out.println(tempString);
			
			Process genDepenProc = Runtime.getRuntime().exec("cmd /c \"" + tempString + "\"");

			StreamHandler GDPerrorHandler =
				new StreamHandler(
					genDepenProc.getErrorStream(),
					"ERROR",
					runVmode,
					root,
					true);
			StreamHandler GDPoutputHandler =
				new StreamHandler(
					genDepenProc.getInputStream(),
					"OUTPUT",
					runVmode,
					root,
					true);

			GDPerrorHandler.start();
			GDPoutputHandler.start();

			genDepenProc.waitFor();
			if (GDPerrorHandler.getErrors()) {

				throw new InterruptedException("Compilation Error");
			}
		}
	}

/**
 * This method will take a path [valid windows path stored in an IPath object] and convert it into a unix path.
 * Any spaces in the path name will be replaced by "/ "
 * Valid windows path must contain "*:/" where the "*:/" reprents the root directory [or drive] such as "C:/"
 * The function will return null if the the argument is null. 
 * Note: This method is made static so that other classes  can call it without repricating the code. 
 * @author Jing Cao
 * @param winPath - IPath obj represnting the path to a program/folder
 * @return a string representing the path in unix format
 * @version 1.1
 */
	public static String toUnixPath(IPath winPath)
	{//beg toUnixPath
		String unixPath;//this will store the unixPath
		
		//check for null argument 
		if (winPath == null) //This shouldn't happen and should be redundant, but just incase!
				throw new NullPointerException("ERROR: You're trying to convert a string that is NULL!");
		
		//got to here that means that the winPath contains a valid string!
		//so convert the path to unix format
		
		//change the path so that c: becomes c
		unixPath = winPath.toString().charAt(0) + winPath.toString().substring(2);
		unixPath = unixPath.replaceAll(" ", "\\\\ "); //find all spaces and replace with "\ "		
	    //NOTE the: four back slashes! This is done due to how the parser functions
	    //			It will only create one '\' for the string; even though it looks like it's going to create 2.
	    
	    //debugging code
		//System.out.println("unix path: " + unixPath);
		
		return unixPath;
		
	}//end toUnixPath

	public void dispose() {

		
	}


	public void init(IWorkbenchWindow window) {

		
	}


	public void run(IAction action) {
		try {
			PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().showView("ConsoleView");
		}
		catch (Exception e) {
			System.out.println("Your active page Console View didn't want to work :" + e);
		}
		ConsoleDocument.getCDOS().clear();
		PlatformUI.getWorkbench().saveAllEditors(true);
		Shell parent = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
		IPreferenceStore store = CDBuilderPlugin.getDefault().getPreferenceStore();
			
		boolean vMode;
		if(store.getInt("vModeChoice") == 3) {
			verboseGui vGui = new verboseGui(parent);
			vGui.create();
			vGui.open();
			if(!vGui.isPressed())
				return;
			vGui.close();
			vMode = vGui.runInVMode();
			if(vGui.noAskAgain()) {
				if(vMode)
					store.setValue("vModeChoice", 1);
				else
					store.setValue("vModeChoice", 2);
			}
			
		}
		else {
			if(store.getInt("vModeChoice") == 1)
				vMode = true;
			else
				vMode = false;
		}
		
		//Gets the root of the workbench
		IWorkspaceRoot root = (IWorkspaceRoot)PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getInput();
			
			

		// Finds the path for the internal folder
		// -------------------------------beg Jing's Edit--------------------------------
		// InternalPath is now made dynamic to the root location of the eclipse folder
		// instead of being static to c:/eclipse
		String tempString = root.getLocation().toString();
		tempString = tempString.substring(0,tempString.lastIndexOf("/")+1);	
		IPath internalPath = new Path(tempString.concat("/plugins/CD++Builder_1.1.0/internal/"));
		//---------------------------------end Jing's Edit-------------------------------

		
		// Finds the path for the current Project, in case the user selection was a folder
		// instead of a file, it will correct for that
		IPath projectPath;
		projectPath = root.getLocation();
		String selectPath = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getSelectionService().getSelection(IPageLayout.ID_RES_NAV).toString();
		selectPath = selectPath.substring(selectPath.indexOf("/")+1, selectPath.length()-1); //concatenate the string to get rid of []
		projectPath = projectPath.append(selectPath +"/");
		
		IContainer container = root.getContainerForLocation(projectPath);
		IFile files = root.getFileForLocation(projectPath);
		if (files != null) { 
			if (files.exists()){ 
				projectPath = projectPath.removeLastSegments(1); //get ride of the last segment of the path name (file name)
				projectPath = projectPath.append("/"); //add a / in the path
			}
			container  = root.getContainerForLocation(projectPath); 
		}
		
		ProgressMonitorDialog pmDialog = new ProgressMonitorDialog(parent);
		try {
			pmDialog.run(true, true, new makefileTasks(vMode,container, projectPath, internalPath, root));
		}
		

		catch (InterruptedException IE) {
			if (IE.getMessage().equals("Compilation Error")){
				try {
				//show task view for Eclipse 2.X	
				//	PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().showView("org.eclipse.ui.views.TaskList");
				
					//show problems view for Eclipse 3.0
					PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().showView("org.eclipse.ui.views.ProblemView");
				} catch (Exception e) {
					e.printStackTrace();
				}
			}		
			ConsoleDocument.getCDOS().set(IE.getMessage());
		}
		
		catch (Exception E) {
			System.out.println("Outside The Runnable: " +E);
		}

	}


	public void selectionChanged(IAction action, ISelection selection) {

		
	}

}