/* Mesquite source code.  Copyright 1997-2004 W. Maddison and D. Maddison. 
Version 1.01, January 2004.
Disclaimer:  The Mesquite source code is lengthy and we are few.  There are no doubt inefficiencies and goofs in this code. 
The commenting leaves much to be desired. Please approach this source code with the spirit of helping out.
Perhaps with your help we can be more than a few, and make Mesquite better.

Mesquite is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY.
Mesquite's web site is http://mesquiteproject.org

This source code and its compiled class files are free and modifiable under the terms of 
GNU Lesser General Public License.  (http://www.gnu.org/copyleft/lesser.html)
*/

package mesquite.lib;

import java.awt.*;
import java.net.*;
import java.util.*;
import java.io.*;
import java.awt.image.*;
import mesquite.lib.duties.*;
import edu.stanford.ejalbert.*;  //for Browserlauncher



/* ============================Class MesquiteModule============================================ */
/** The Mesquite system operates around a tree of modules (subclasses of MesquiteModule), with the class containing the "main" method being
the <strong>trunk</strong> module, and the other modules like branches that are attached to the trunk.<p>

When Mesquite starts up, the trunk starts up and surveys the mesquite folder to acquire information about all of the available modules
(i.e., all of the available subclasses of MesquiteModule). To be found, a module must be in a folder (directory) of the same name as itself; that is,
a module whose class file is "MyModule.class" must be in a directory named "MyModule".  Mesquite remembers the modules in a vector of MesquiteModuleInfo objects.  
Later, when modules need to be "hired" to perform certain tasks, this vector of information can be used to help choose which module to hire.  To be hired, a module is instantiated
and linked to its employer module.  Thus, a new branch sprouts in the Mesquite bureacratic hierarchy. 
<p>

Modules are chosen for hire by other modules according to their talents.  What talents a module has is implicit in its superclass.  For instance, a module
that subclasses the NumberForTree class (itself a subclass of MesquiteModule) calculates a number for a tree.  Any module that
wants numbers calculated for trees can therefore hire a module that is an instance of the NumberForTree class. 
The basic talent-defining classes are part of the Mesquite Class LIbrary, in the subpackage duties.  There is in addition a system to determine whether a
module is compatible with a particular condition (e.g. operating on continuous-valued data.)<p>

The only types of module that the trunk knows of directly are the FileCoordinator and FileInterpreter classes.  Each instance
of the File Coordinator is associated with one file, and it is responsible for using employee modules to
read and write the file, and to hire tree windows and data windows.  The trunk is a specific subclass of MesquiteModule,
a MesquiteTrunk<p>  

Because menus are composed hierarchically along the employee tree,  menu composition is most easily done where there is easy access to
employee-employer relations.  For this reason, it is most convenient to have the menu composition embedded within the module code.  In order not to
burden the MesquiteModule class with numerous methods to handle employee-employer relations, the MesquiteModule class was split into three: its superclass,
EmployeeEmployer (which handles employee-employer relations), MenuOwner (which handles all menu issues) and MesquiteModule itself, which handles its basic functions.
EmployeeEmployer and MenuOwner are intended to be used ONLY as superclasses to MesquiteModule<p>

The MesquiteModule class is more or less equivalent to the MacClade proto4 ModuleRecord, while its instantiated objects
are more or less equivalent to the MacClade proto4 Tasks.  Hence, "task" is sometimes used in names for
MesquiteModule objects.<p>
*/


public abstract class MesquiteModule extends EmployerEmployee implements Commandable, Showable, Logger, Explainable, Identifiable, FileDirtier, MesquiteListener {
	LeakFinder leakFinder = MesquiteTrunk.leakFinderObject;
	/** Static storage so that everyone can find the trunk MesquiteModule object*/
	public static MesquiteTrunk mesquiteTrunk; 
	/** The root of the mesquite classpath.*/
	public static File mesquiteDirectory=null;  
	/** The root of the mesquite classpath.*/
	public static String mesquiteDirectoryPath=null;  
	/** The directory that includes all the preference files.*/
	public static File prefsDirectory=null;  
	/** The user's directory.*/
	public static File userDirectory=null;  
	/** The window, created by mesquiteTrunk, that displays the log.*/
	public static LogWindow logWindow;
	/** true if name of MesquiteModule is to be shown in alerts*/
	private static final boolean showModuleInAlert = true;
	/** true if name of MesquiteModule is to be shown in log entries*/
	private static final boolean showModuleInLog = false;
	/** true if alerts should show a dialog, or merely write to log.*/
	private static final boolean alertUseDialog = true;
	/** the file path to the web browser for showing web pages*/
	protected static String browserString = null;	
	/** true if does extra check for module compatibility at startup.*/
	public static boolean checkMethodsAtStartup = false;
	
	/** This module was hired as a default choice in scripting*/
	public boolean hiredAsDefaultInScripting = false;
	//
	/** Has module requested enabling of macro auto-save?*/
	private boolean autoSaveMacros = false;

	private boolean lastEmployee = false;
	public static int totalFinalized = 0;
	/** the MesquiteModuleInfo that refers to the module*/
	protected MesquiteModuleInfo moduleInfo = null;
	/** The project that the module was hired under.  Almost all modules are descendant from a file coordinating module that belongs to
	a specific project*/
	protected MesquiteProject proj=null;  
	/** for the paging system (may be defunct)*/
	Vector pagingsEphemeral = new Vector();
	/** for the paging system (may be defunct)*/
	Vector pagingsPersistent = new Vector();
	
	public static int textEdgeCompensationHeight = 0;
	public static int textEdgeCompensationWidth = 10;
	private static int instantiations = 0;
	private int idNumber;
	private String permanentIDString = null;
	private String assignedIDString = null;
	private static Random randomNumberGenerator;
	static {
		randomNumberGenerator = new Random(System.currentTimeMillis());
	}
	
	/** The constructor in general is to be avoided, because modules are instantiated momentarily on startup to gather
	information.  The usual functions of a constructor are performed by startJob*/
	public MesquiteModule () {
		super();
		setModule(this);
		instantiations++;
		idNumber = instantiations;
		permanentIDString = Integer.toString(idNumber) + "." + System.currentTimeMillis() + "." + Math.abs(randomNumberGenerator.nextLong());
		assignedIDString = null;//new String(permanentIDString);
	}
	/*.................................................................................................................*/
	/** instantiations of modules are numbered sequentially so they can be referred to by number*/
	public long getID(){
		return idNumber;
	}
	/*.................................................................................................................*/
	/** A string that uniquely refers to this module (unique even across runs of Mesquite)*/
	public String getPermanentIDString(){
		if (assignedIDString == null)
			return permanentIDString;
		else
			return assignedIDString;
	}
	/*.................................................................................................................*/
	/** A string that should uniquely refer to this module during this run time
	public String getAssignedIDString(){
		return assignedIDString;
	}
	/*.................................................................................................................*/
	/** Broadcasts that an id has been assigned to a module.  This is used for scripting, in which a module assigns itself
	an id string in a snapshot (e.g., a TreeContext) that an interested module can clue in to (e.g., TreeOfContext).  This
	allows the interested module to hook up to the assigning module even if the former was script-created before the latter
	(see interaction between BasicTreeWindow and TreeOfContext)*/
	public void broadCastAssignedID(MesquiteModule module, String assignedID, CommandRecord commandRec){
		if (assignedID == null)
			return;
		if (employees ==null)
			return;
		Enumeration enum=employees.elements();
		while (enum.hasMoreElements()){
			MesquiteModule mb = (MesquiteModule)enum.nextElement();
			mb.broadCastAssignedID(module, assignedID, commandRec);
		}
	}
		
	/*.................................................................................................................*/
	/** superStartJob is called automatically when an employee is hired.  This is intended for use by superclasses of modules that need
	their own constructor-like call, without relying on the subclass to be polite enough to call super.startJob().*/
	public boolean superStartJob(String arguments, Object condition, CommandRecord commandRec, boolean hiredByName){
		return true;
	}
	/*.................................................................................................................*/
	/** startJob is called automatically when an employee is hired.  The parameter scripting indicates if the hiring occurs in the context
	of automated scripting (e.g., on reading a Mesquite block of a NEXUS file).  The module can limit user interface calls (e.g. dialog boxes)
	when scripting occurs.<p>
	The MesquiteModule should override this method, to add code to 
	initialize things it needs, and to hire relevant necessary employees.  startJob must return
	true if the module was successfully started; false otherwise.  Thus, if the module needs a data matrix
	but the file has none, it returns false and the hiring process is undone.<p>
	Most modules will ignore the arguments and condition.*/
	public abstract boolean startJob(String arguments, Object condition, CommandRecord commandRec, boolean hiredByName);
	/*.................................................................................................................*/
	/** endJob is called as a module is quitting; modules should put their clean up code here.*/
 	public void endJob() {
 	}
	/*.................................................................................................................*/
	public void finalize() throws Throwable {
		totalFinalized++;
		super.finalize();
	}
	/*.................................................................................................................*/
	/** dispose is called automatically when an employee is fired. It fires all employees and their subemployees etc.  
	The MesquiteModule should call endJob to 
	finalize things it needs..  NOTE: if a module wants to quit on its own accord, it should call "iQuit" so that
	the replacement hiring system can take effect.*/
 	protected void dispose() {
 		if (assignedMenuSpec !=null)
 			assignedMenuSpec.removeGuestModule(this);
 		if (moduleMenuSpec !=null)
 			moduleMenuSpec.removeGuestModule(this);
 		doomed = true;
	   	MesquiteWindow w = getModuleWindow();
 		if (w !=null) {
 			w.hide();
 		}
		boolean employerDoomed =  (employer!=null && employer.doomed);
		
 		if (!employerDoomed)
			incrementMenuResetSuppression();
		storePreferences();
		if (pagingsEphemeral!=null)
			pagingsEphemeral.removeAllElements();
		if (pagingsPersistent!=null)
			pagingsPersistent.removeAllElements();
		disposeMenuSpecifications();
 		if (w !=null) {
	   		if (!w.disposed()) {
		   		w.dispose();
	   		}
			resetAllMenuBars();
   		}

 	//	if (employer!=null && quit) //TODO: only call this if the employer quit on its own
	//		employer.employeeQuit(this);
 		if (MesquiteTrunk.trackActivity) MesquiteMessage.notifyProgrammer ("MesquiteModule " + getName() + "  closing down ");
		closeDownAllEmployees (this);
		if (employer!=null && !employer.doomed && employer.employees!=null) {
			employer.employees.removeElement(this, false);
		}
 		if (!employerDoomed)
 			resetContainingMenuBar();
		employer = null; //MEMORY: cut this out to promote memory leaks (tying modules together WHILE debugging NEW aug 99
		if (employees!=null)
			employees.dispose();
		employees = null;
 		if (!employerDoomed)
			decrementMenuResetSuppression();
		proj = null;
		totalDisposed++;
   	 }
	/*.................................................................................................................*/
	/** To be called by a module to close down on its own (as opposed to being fired).  This might happen, for
	example, if conditions change so that the module can no longer function (e.g. all stored matrices are deleted 
	from a file, and so StoredMatrices can no longer supply matrices). A module could
	also call its own endJob() method, but iQuit is to be preferred because it evokes the automatic replacement
	hiring system if available.  (See setHiringCommand of EmployerEmployee) */
	public final void iQuit(){
		incrementMenuResetSuppression();
  		doomAll();
		MesquiteModule employerMod = employer;
		MesquiteModule localRefEmployer = employer;
		boolean employerDoomed =  (employer==null || employer.doomed || employerMod.quittingConditions());
		if (!employerDoomed) {
			localRefEmployer.incrementEmployeeBrowserRefreshSuppression(MesquiteModule.class);
			localRefEmployer.refreshBrowser(MesquiteModule.class);
  		}
		endJob();
		dispose();
		MesquiteCommand command = getHiringCommand();
		resetAllWindowsMenus();
		/* if hiringCommand isn't null, then look among the module info's for possible replacements
		and use the hiringCommand to attempt to hire them.
		In looking for possible replacements:
			-- use the hiringCondition to find compatible modules
			-- don't choose again the current module
		With each candidate replacement, call the command's doIt method, passing the name of 
		the candidate as an argument.  If the Object returned by doIt is non-null and is an instance of the
		candidate module, then it is assume the replacement was successful and the search for replacements is ended.
		(It may make sense to notify the user of the replacement.)
		*/
		if (employerDoomed || employerMod.quittingConditions()) {
		}
		else if (command!=null){
			resetContainingMenuBar();
			alert("Module \"" + getName() + "\" has quit; a replacement module will be sought."); //TODO: ask user

			MesquiteModuleInfo c=null;
			boolean found = false;
			if (getHiringCondition()==null){
				String name =ListDialog.queryList(module.containerOfModule(), "Select replacement", "Select module to replace " + getName(), MesquiteString.helpString, getHiredAs(), null, employerMod);
				if (StringUtil.blank(name)) {

					hiredAs = null;
					hiringCondition = null;
					employerMod.employeeQuit(this);
					decrementMenuResetSuppression();
					if (!employerDoomed) localRefEmployer.decrementEmployeeBrowserRefreshSuppression(MesquiteModule.class);
					return;
				}
				CommandRecord cr = new CommandRecord(false);
				cr.setEmergencyRehire(true);
				Object mb = command.doIt(StringUtil.tokenize(name), cr);
				if (mb!=null && mb instanceof MesquiteModule && ((MesquiteModule)mb).getModuleInfo()!= getModuleInfo() && getHiredAs()!=null && getHiredAs().isAssignableFrom(mb.getClass())) {
					alert("Module \"" + ((Listable)mb).getName() + "\" hired to replace \"" + getName() + "\", which has quit");
					decrementMenuResetSuppression();
					if (!employerDoomed) localRefEmployer.decrementEmployeeBrowserRefreshSuppression(MesquiteModule.class);
					return;
				}
				
				
				MesquiteModuleInfo prevC = null;
				while ((c = MesquiteTrunk.mesquiteModulesInfoVector.findNextModule(getHiredAs(), c)) != null) {  // if wasn't successful, find first that works.
					if (c!=prevC){
						cr = new CommandRecord(false);
						cr.setEmergencyRehire(true);
						mb = command.doIt(StringUtil.tokenize(c.getName()), cr);
						if (mb!=null && mb instanceof MesquiteModule && ((MesquiteModule)mb).getModuleInfo()!= getModuleInfo() && getHiredAs()!=null && getHiredAs().isAssignableFrom(mb.getClass())) {
							alert("Module \"" + ((Listable)mb).getName() + "\" hired to replace \"" + getName() + "\", which has quit");
							decrementMenuResetSuppression();
							if (!employerDoomed) localRefEmployer.decrementEmployeeBrowserRefreshSuppression(MesquiteModule.class);
							return;
						}
						prevC = c;
					}
				}
			}
			else {
				String name =ListDialog.queryList(module.containerOfModule(), "Select replacement", "Select module to replace " + getName(), MesquiteString.helpString, getHiredAs(), getHiringCondition(), employerMod);
				if (StringUtil.blank(name)) {
					hiredAs = null;
					hiringCondition = null;
					employerMod.employeeQuit(this);
					decrementMenuResetSuppression();
					if (!employerDoomed) localRefEmployer.decrementEmployeeBrowserRefreshSuppression(MesquiteModule.class);
					return;
				}
				Object mb = command.doIt(StringUtil.tokenize(name));
				if (mb!=null && mb instanceof MesquiteModule && ((MesquiteModule)mb).getModuleInfo()!= getModuleInfo() && getHiredAs()!=null && getHiredAs().isAssignableFrom(mb.getClass())) {
					alert("Module \"" + ((Listable)mb).getName() + "\" hired to replace \"" + getName() + "\", which has quit");
					decrementMenuResetSuppression();
					if (!employerDoomed) localRefEmployer.decrementEmployeeBrowserRefreshSuppression(MesquiteModule.class);
					return;
				}

				MesquiteModuleInfo prevC = null;
				while ((c = MesquiteTrunk.mesquiteModulesInfoVector.findNextModule(getHiredAs(), c, getHiringCondition(), getProject(), employerMod)) != null) {  // if wasn't successful, find first that works.
					if (c!=prevC){
						mb = command.doIt(StringUtil.tokenize(c.getName()));
						if (mb!=null && mb instanceof MesquiteModule && ((MesquiteModule)mb).getModuleInfo()!= getModuleInfo() && getHiredAs()!=null && getHiredAs().isAssignableFrom(mb.getClass())) {
							alert("Module \"" + ((Listable)mb).getName() + "\" hired to replace \"" + getName() + "\", which has quit");
							decrementMenuResetSuppression();
							if (!employerDoomed) localRefEmployer.decrementEmployeeBrowserRefreshSuppression(MesquiteModule.class);
							return;
						}
					}
					prevC = c;
				}
			}
			alert("Employee quit but no replacement hire was found");
			employerMod.employeeQuit(this);
			
		}
		else {
			//alert("Module \"" + getName() + "\" has quit."); 
			employerMod.employeeQuit(this);
		}
		
		decrementMenuResetSuppression();
		if (!employerDoomed) localRefEmployer.decrementEmployeeBrowserRefreshSuppression(MesquiteModule.class);
		
	}
	/*.................................................................................................................*/
	/** Query module as to whether conditions are such that it will have to quit soon -- e.g. if its taxa block has been doomed.  The tree window, data window, 
	etc. override this to return true if their object is doomed. This is useful in case MesquiteListener disposing method is not called for an employer before one of its
	employees discovers that it needs to quit.  If the employer is going to quit anyway,there is no use to use auto rehire for the quit employee.*/
	public boolean quittingConditions(){
		if (employer!=null) {
			return employer.quittingConditions();
		}
		return false;
	}
	
	/*.................................................................................................................*/
 	/** A method called immediately after the file has been established but not yet read in.*/
 	public void projectEstablished() {
 	}
	/*.................................................................................................................*/
 	/** A method called immediately after the file has been read in or completely set up (if a new file).*/
 	public void fileReadIn(MesquiteFile f) {
 	}
	/*.................................................................................................................*/
 	/** A method called immediately before a file is to be saved.*/
 	public void fileAboutToBeWritten(MesquiteFile f) {
 	}
	/*.................................................................................................................*/
 	/** A method called when a FileElement added to the project; module can respond as needed (e.g., 
 	InitializeParsimony can add default model set to a CharacterData.  (currently only called for Taxa and CharacterData additions).*/
 	public void fileElementAdded(FileElement element) {
 	}
	/*.................................................................................................................*/
	/** Returns duty Class the module belongs to; should be defined not by module itself but by abstract class representing duty */
   	 public abstract Class getDutyClass();
	/*.................................................................................................................*/
	/** Returns module info for module*/
   	 public MesquiteModuleInfo getModuleInfo(){
   	 	return moduleInfo;
   	 }
 	/** Notifies all employees that a class field has changed.*/
	public void classFieldChanged (Class c, String fieldName, CommandRecord commandRec) {
 		if (employees==null || doomed)
 			return;
 		Enumeration e = employees.elements();
 		while (e.hasMoreElements()) {
			Object obj = e.nextElement();
			MesquiteModule mbe = (MesquiteModule)obj;
	 		if (mbe!=null) {
	 			mbe.classFieldChanged(c, fieldName, commandRec);
	 		}
		}
	}
	/*.................................................................................................................*/
	/** A generic call to tell employer that the module's parameters have changed
	sufficiently that its basic calculations are no longer valid, and a recalculation should
	be requested.  The employer receives the message as a call to its employeeParametersChanged.
	(Typically, this might follow an outputInvalid call, which */
 	public final void parametersChanged(Notification notification, CommandRecord commandRec) {
		if (commandRec !=null) commandRec.tick("Parameters of module changed");
 		if (employer!=null && !doomed) {
 			if (!hasOldStyleEPC(employer))
 				employer.employeeParametersChanged(this, this, notification, commandRec);
 		}
	}
 	public final void parametersChanged(CommandRecord commandRec) {
		parametersChanged(null, commandRec);
	}
	private boolean hasOldStyleEPC(MesquiteModule mb){
 			try {
 				mb.getClass().getMethod("employeeParametersChanged", new Class[] {MesquiteModule.class, MesquiteModule.class, CommandRecord.class});
 			}
 			catch(NoSuchMethodException e){
 				return false;
 			}
 			catch(SecurityException e){
 				return false; //hope for best
 			}
 			alert("The module " + employer.getName() +" appears to be old and incompatible with the current version of Mesquite.");
 			return true;
	}
	/*.................................................................................................................*/
	/** Generated by an employee calling its parametersChanged method.  The MesquiteModule should act accordingly, for instance, asking
	the employee to do a recalculation. */
 	public void employeeParametersChanged(MesquiteModule employee, MesquiteModule source, Notification notification, CommandRecord commandRec) {
		if (commandRec !=null) commandRec.tick("Parameters of employee module changed");
 		if (employer!=null && !doomed) {
 			if (!hasOldStyleEPC(employer))
 				employer.employeeParametersChanged(this, source, notification, commandRec);
 		}
	}
	/*.................................................................................................................*/
	/** This passes an employeeOutputInvalid call to the employer, and so on, until some employer overrides it to do something about it.  
	The purpose of this is not to call for recalculations, but primarily to allow the output to be turned blank while
	long recalculations are done. To force recalculation, parametersChanged should be called after outputInvalid is called*/
	public final void outputInvalid(CommandRecord commandRec) {
		if (employer!=null && !doomed)
			employer.employeeOutputInvalid(this, this, commandRec);
	}
	/*.................................................................................................................*/
	/** Generated by an employee calling its outputInvalide method.  The MesquiteModule should blank any output. */
	public void employeeOutputInvalid(MesquiteModule employee, MesquiteModule source, CommandRecord commandRec) {
		if (employer!=null && !doomed)
			employer.employeeOutputInvalid(this, source, commandRec);
	}
	/*.................................................................................................................*/
	/** Generated by an employee who quit.  The MesquiteModule should act accordingly. */
 	public void employeeQuit(MesquiteModule employee) {
	}
	/*.................................................................................................................*/
	/** Sets this module to remain one of the last employees of its employers. */
	public void setToLastEmployee(boolean last){
		lastEmployee = last;
	}
	/*.................................................................................................................*/
	/** Returns whether this module is to remain one of the last employees of its employers. */
	public boolean getIfLastEmployee(){
		return lastEmployee;
	}
	/*.................................................................................................................*/
	/** Sets whether module has requested to enable auto-save of macros. */
	public void setAutoSaveMacros(boolean aut){
		autoSaveMacros = aut;
	}
	/*.................................................................................................................*/
	/** Returns whether module has requested to enable auto-save of macros. */
	public boolean getAutoSaveMacros(){
		return autoSaveMacros;
	}
	/*.................................................................................................................*/
	/** Called typically by employer to indicate that will be called soon, therefore don't update graphics. */
 	public void onHold() {
	}
	/*.................................................................................................................*/
	/** Called typically by employer to turn off hold, therefore don't update graphics. */
 	public void offHold() {
	}
	/*.................................................................................................................*/
	private String prefsPath (){
		return prefsDirectory  + MesquiteFile.fileSeparator +  getShortClassName(this.getClass()) +".pref";
	}
	/*.................................................................................................................*/
	/** This causes the file "prefs" in the module's directory to be read, and the contents
	are then sent to "processPreferencesFromFile".*/
	public final void loadPreferences () {
		if (MesquiteFile.fileExists(prefsPath())){
			String[] prefsString = MesquiteFile.getFileContentsAsStrings(prefsPath());
			if (prefsString!=null)
				processPreferencesFromFile(prefsString);
		}
	}
	/*.................................................................................................................*/
	/** This is called following a "loadPreferences" call by a module.  A module can override it
	to process the preferences string*/
	public void processPreferencesFromFile (String[] prefs) {
	}
	/*.................................................................................................................*/
	/** This causes the file "prefs" in the module's directory to be written, using contents
	returned by the module via "preparePreferencesForFile"*/
	public final void storePreferences () {
		String[] prefsString = preparePreferencesForFile();
		if (prefsString!=null)
			 MesquiteFile.putFileContents(prefsPath(), prefsString, false);
	}
	/*.................................................................................................................*/
	/** This is called following a "storePreferences" call by a module. A module should override it
	to indicate the strings to save to its preferences file. */
	public String[] preparePreferencesForFile () {
		return null;
	}
	/*.................................................................................................................*/
	/** returns path to this module's directory*/
	public String getPath() {  
		if (this == MesquiteTrunk.mesquiteTrunk)
			return getRootPath() + "mesquite" + MesquiteFile.fileSeparator;
		return  moduleInfo.getDirectoryPath();
	}
	/*.................................................................................................................*/
	/** returns path to the root directory of Mesquite (i.e., above mesquite, images, etc.)*/
	public static String getRootPath() {
			String s= StringUtil.getAllButLastItem(mesquiteDirectoryPath, MesquiteFile.fileSeparator);
			if (s==null)
				return null;
			else
				return s + MesquiteFile.fileSeparator;
	}
	/*.................................................................................................................*/
	/** returns path to the root directory of Mesquite images*/
	public static String getRootImageDirectoryPath() {
		String s = getRootPath();
		if (s==null)
			return null;
		else
			return s + "images/";
	}
	/*.................................................................................................................*/
	public static String getSizedRootImageFilePath(int s, String imageFileName){
		return getRootImageDirectoryPath() + s + imageFileName;
	}
	/*.................................................................................................................*/
	/** returns path to the root directory of the documentation of Mesquite*/
	public static String getDocsPath() {
			String s= StringUtil.getAllButLastItem(mesquiteDirectoryPath, MesquiteFile.fileSeparator);
			if (s==null)
				return null;
			else
				return s + MesquiteFile.fileSeparator + "docs/mesquite/";
	}
	/*.................................................................................................................*/
 	/** returns a local file path expected by the module.  This allows the module to say "I am going to need this".  Mesquite
 	check on startup and issues warning if not found . */
 	public String  getExpectedPath(){ 
 		return null;
   	}
	/*.................................................................................................................*/
	/** Displays an alert in log; also in dialog if flag is set.*/
	public void alert(String s, String windowTitle, String logTitle) {
		if (startupBailOut)
			return;
		if (showModuleInAlert)
			logln(logTitle+": (" + getName() + "): " + s);
		else
			logln(logTitle+": " + s);
		
		if (alertUseDialog) {
			AlertDialog.notice(containerOfModule(),windowTitle, s);
		}
	}
	/*.................................................................................................................*/
	/** Displays an alert in log; also in dialog if flag is set.*/
	public void alert(String s) {
		alert(s,"Alert", "ALERT");
	}
	/*.................................................................................................................*/
	/** If scripting, puts alert in log; otherwise puts up alert dialog.*/
	public void discreetAlert(CommandRecord commandRec, String s) {
		discreetAlert(commandRec != null && commandRec.scripting(), s);
	}
	/*.................................................................................................................*/
	/** If scripting, puts alert in log; otherwise puts up alert dialog.*/
	public void discreetAlert(boolean beDiscreet, String s) {
		if (beDiscreet)
			logln("Note: " + s);
		else
			alert(s,"Note", "Note");
	}
	/*.................................................................................................................*/
	/** Displays a message and returns false.  For use when a method fails and is returning false to indicate this, and needs to present a notice to the user.
	(This method was made so as to change easily statements of "return false" so that they also gave a message, without having to split into two lines.) */
	public boolean sorry(CommandRecord commandRec, String s) {
		if (commandRec !=null) commandRec.tick("Sorry, module couldn't be started");
		if (!startupBailOut){
			if (!commandRec.scripting()) 
				alert(s);
			else
				logln("Message from " + getNameForMenuItem() + ": " + s);
		}
		return false;
	}
	/*.................................................................................................................*/
	/** Places string in log AND in System.out.println.*/
	public void log(String s) {
		logNoEcho(s);
		if (!MesquiteTrunk.isMacOS() || (MesquiteTrunk.isMacOSX() && MesquiteTrunk.getJavaVersionAsDouble()>1.39))
			System.out.print(s);
	}
	/*.................................................................................................................*/
	/** Places string and newline character in log AND in System.out.println.*/
	public void logln(String s) {
		loglnNoEcho(s);
		if (!MesquiteTrunk.isMacOS() || (MesquiteTrunk.isMacOSX() && MesquiteTrunk.getJavaVersionAsDouble()>1.39))
			System.out.println(s);
	}
	/*.................................................................................................................*/
	/** Places string in log.*/
	public void logNoEcho(String s) {
		if (logWindow!=null) {
			if (showModuleInLog)
				logWindow.append(getName() + "-- " + s);
			else
				logWindow.append(s);
		}
		MesquiteFile.writeToLog(s);  //TODO: have a flag that turns this on
		Object cOM = containerOfModule();
		if (cOM instanceof MesquiteWindow)
			((MesquiteWindow)cOM).log(s);
	}
	/*.................................................................................................................*/
	/** Places string and newline character in log.*/
	public void loglnNoEcho(String s) {
		if (logWindow!=null) {
			if (showModuleInLog)
				logWindow.append(getName() + "-- " + s + "\n");
			else
				logWindow.append(s + "\n");
		}
		MesquiteFile.writeToLog(s+ StringUtil.lineEnding());
		Object cOM = containerOfModule();
		if (cOM != null && cOM instanceof MesquiteWindow)
			((MesquiteWindow)cOM).logln(s);
	}
	/*.................................................................................................................*/
	/** Shows the log window.*/
	public static void showLogWindow() {
		showLogWindow(true);
	}
	/*.................................................................................................................*/
	/** Shows the log window.*/
	public static void showLogWindow(boolean bringToFront) {
		if (logWindow!=null) {
			if (bringToFront || !logWindow.isVisible())
				logWindow.setVisible(true);
		}
	}
	/*.................................................................................................................*/
	/** passes which object is being disposed (from MesquiteListener interface)*/
	public void disposing(Object obj){
	}
	/*.................................................................................................................*/
	/** passes which object is being disposed (from MesquiteListener interface)*/
	public boolean okToDispose(Object obj, int queryUser){
		return true;  //TODO: respond
	}
	/*.................................................................................................................*/
	/** passes which object changed, along with optional integer (e.g. for character) (from MesquiteListener interface)*/
	public void changed(Object caller, Object obj, Notification notification, CommandRecord commandRec){
	}
	/*.................................................................................................................*/
	/** Requests modules to start profiling.*/
 	public void startProfiling(){
 		Enumeration e = employees.elements();
 		while (e.hasMoreElements()) {
			Object obj = e.nextElement();
			MesquiteModule mbe = (MesquiteModule)obj;
	 		mbe.startProfiling();
		}
 	}
	/*.................................................................................................................*/
	/** Requests modules to report profiling.*/
 	public void reportProfiling(){
 		Enumeration e = employees.elements();
 		while (e.hasMoreElements()) {
			Object obj = e.nextElement();
			MesquiteModule mbe = (MesquiteModule)obj;
	 		mbe.reportProfiling();
		}
 	}
 	public boolean permanentIDExists(String id) {
		if (id == null || employees ==null)
			return false;
		if (id.equalsIgnoreCase(getPermanentIDString())) //had been getAssignedIDString
			return true;
		Enumeration enum=employees.elements();
		while (enum.hasMoreElements()){
			MesquiteModule mb = (MesquiteModule)enum.nextElement();
			if (mb.permanentIDExists(id))
				return true;
		}
		return false;
	}

	/*.................................................................................................................*/
	/** A request for the MesquiteModule to perform a command.  It is passed two strings, the name of the command and the arguments.
	This should be overridden by any module that wants to respond to a command.*/
 	public Object doCommand(String commandName, String arguments, CommandRecord commandRec, CommandChecker checker) { 
		if (checker.compare(MesquiteModule.class, null, null, commandName, "showEmployeeTree")) {
		     	EmployeeTree etM = (EmployeeTree)findImmediateEmployeeWithDuty(EmployeeTree.class);
		     	if (etM == null)
		     		etM = (EmployeeTree)hireEmployee(commandRec, EmployeeTree.class, null);
		     	if (etM!=null)
		     		etM.showEmployeeTreeWindow(this);
		     	return etM;
		}
		else if (checker.compare(MesquiteModule.class, "Show employers of this module", null, commandName, "employers")) {
			logln(getEmployerPath());
		}
		else  if (checker.compare(MesquiteModule.class, null, null, commandName, "dumpParameterTree")) {
	     		System.out.println("=============\nParameters of modules of window of " + getName() + "\n" + listEmployeeParameters("") + "\n=============");
	 	}
		else  if (checker.compare(MesquiteModule.class, "Shows manual in browser", null, commandName, "showManual")) {
	     		showManual();
	 	}
		else  if (checker.compare(MesquiteModule.class, null, null, commandName, "showCommandPage")) {
	     		showWebPage(getCommandPagePath(), true);
	 	}
		else  if (checker.compare(MesquiteModule.class, null, null, commandName, "showMiniInfoWindow")) {
	     		return new ModuleInfoWindow(module);
	 	}
		else  if (checker.compare(MesquiteModule.class, null, null, commandName, "setAssignedID")) {
	     		if (getFileCoordinator()!=null && getFileCoordinator().permanentIDExists(arguments))
	     			assignedIDString = getPermanentIDString(); // make new one if old exists
	     		else
	     			assignedIDString = arguments;
	     		if (getFileCoordinator()!=null)
	     			getFileCoordinator().broadCastAssignedID(this, arguments, commandRec);
	     		else
	     			mesquiteTrunk.broadCastAssignedID(this, arguments, commandRec);
	     		return assignedIDString;
	 	}
		else  if (checker.compare(MesquiteModule.class, null, null, commandName, "getWindow")) {
	     		return getModuleWindow();
	 	}
		else  if (checker.compare(MesquiteModule.class, null, null, commandName, "saveMacro")) {
			
			String recipe = Snapshot.getSnapshotCommands(this, null, "");
	    	 	MesquiteMacro.saveMacro(this, "Untitled Macro for " + getNameForMenuItem(), 0, recipe);

	 	}
		else  if (checker.compare(MesquiteModule.class, null, null, commandName, "applyMacro")) {
				MesquiteModuleInfo mmi = getModuleInfo();
				if (mmi==null)
					return null;
				Vector macros = mmi.getMacros();
				if (macros ==null || macros.size()<=0)
					return null;
				MesquiteInteger io = new MesquiteInteger(0);
	   			int macroNumber = MesquiteInteger.fromString(arguments, io); 
	   			if (macroNumber>=0 && macroNumber<macros.size()) {
	   				MesquiteMacro macro = (MesquiteMacro)macros.elementAt(macroNumber);
	    	 		if (macro!=null) {
						Puppeteer p = new Puppeteer(this);
						p.applyMacroFile(macro.getPath(), this, commandRec);
	    	 		}
    	 		}
				
	     		return null;
	 	}
		else  if (checker.compare(MesquiteModule.class, null, null, commandName, "showWindow")) {
	     		if (getModuleWindow()!=null) {
	     			getModuleWindow().setVisible(true);
	     			//getModuleWindow().repaint();
	     		}
	     		return getModuleWindow();
	 	}
		else  if (checker.compare(MesquiteModule.class, null, null, commandName, "repaintWindow")) {
	     		if (getModuleWindow()!=null) {
	     			getModuleWindow().repaintAll();
	     		}
	     		return null;
	 	}
    	 	else if (checker.compare(MesquiteModule.class, null, null, commandName, "showFile")) {
    	 		if (arguments==null)
    	 			return null;
    	 		FileCoordinator fc = getFileCoordinator();
    	 		if (fc!=null)
    	 			return fc.displayFile(MesquiteFile.composePath(getProject().getHomeDirectoryName(), parser.getFirstToken(arguments)), -1, commandRec);  //
    	 		
		}
		else  if (checker.compare(MesquiteModule.class, null, null, commandName, "getFileCoordinator")) {
	     		return getFileCoordinator();
	 	}
		else  if (checker.compare(MesquiteModule.class, null, null, commandName, "getProject")) {
	     		return getProject();
	 	}
    	 	else if (checker.compare(MesquiteModule.class, null, null, commandName, "getProjectID")) {
    	 		MesquiteProject proj = getProject();
    	 		if (proj!=null)
    	 			return new MesquiteInteger((int)proj.getID());
    	 	}
		else if  (checker.compare(MesquiteModule.class, null, null, commandName, "getEmployee")) {
 			MesquiteModule mb =  findEmployeeWithName(parser.getFirstToken(arguments));
 			return mb;
 			//TODO: add getEmployeeWithDuty and pass duty class name
		}
		else if  (checker.compare(MesquiteModule.class, null, null, commandName, "hireEmployee")) {
 			MesquiteModule mb = hireNamedEmployee(commandRec, MesquiteModule.class, arguments);
 			return mb;
		}
		else if  (checker.compare(MesquiteModule.class, null, null, commandName, "fireEmployee")) {
 			MesquiteModule mb = findEmployeeWithName(parser.getFirstToken(arguments));
 			if (mb!=null)
 				fireEmployee(mb);
		}
		else if (checker.getAccumulateMode()) {
			if (this instanceof CommandableOwner){
				Commandable[] commandables = ((CommandableOwner)this).getCommandablesForAccumulation();
				
				for (int i=0; commandables!=null && i<commandables.length; i++){
					checker.addString("<ul><li><strong>Commands for " + getShortClassName(commandables[i].getClass())+ "</strong>");
			 		checker.accumulateOnlyFrom(commandables[i].getClass());
			 		commandables[i].doCommand(null, null, CommandRecord.getRecNSIfNull(), checker);//Ã
					checker.addString("</ul>");
				}
			}
		}
		else {
			//AFTERDEMO:
    	 		if (commandName!=null && !checker.getAccumulateMode()) {
			 	MesquiteMessage.warnProgrammer("Module " + getName() + " did not respond to command " + commandName + " with arguments (" + arguments + ")");
				//MesquiteMessage.printStackTrace();
			}
		}
/* // the following should be place so that superclasses can respond to command, at least where latter is commandable
    	 	else 
    	 		return super.doCommand(commandName, arguments, commandRec, checker);
  */
 		return null;
 	}
	/*___________________________ Windows __________________________*/
	/*.................................................................................................................*/
	/** Returns the window of the MesquiteModule, or if none, the window of the nearest employer with a window.
	EMBEDDED VERSION  *
 	public Frame containerOfModule() {
		Object f = getParent ();
		while (! (f instanceof Frame) && !(f==null))
			f = ((Component) f).getParent ();
		return  (Frame) f;
   	 }
	/*.................................................................................................................*/
	/** Returns the window of the MesquiteModule, or if none, the window of the nearest employer with a window.
	NONEMBEDDED VERSION*/
 	public Frame containerOfModule() {
 		if (getModuleWindow()!=null) 
 			return getModuleWindow();
 		else if (employer!=null)
 			return employer.containerOfModule();
 		else
 			return null;
   	 }
	/*.................................................................................................................*/
	/** Returns the employer with a window*/
 	public MesquiteModule employerWithWindow() {
 		if (getModuleWindow()!=null) 
 			return this;
 		else if (employer!=null)
 			return employer.employerWithWindow();
 		else
 			return null;
   	 }
	/*.................................................................................................................*/
	/** Returns the project of the MesquiteModule*/
 	public MesquiteProject getProject() {
 		if (proj!=null) 
 			return proj;
 		else if (employer!=null)
 			return employer.getProject();
 		else {
 			//System.out.println("Error: request by \"" + getName() + "\" for current project, but project is null");
 			return null;
 		}
   	 }
	/*.................................................................................................................*/
	/** sets the file of the MesquiteModule*/
 	public void setProject(MesquiteProject proj) {
 		this.proj = proj;
   	 }
	/*.................................................................................................................*/
	/** Requests a window to close.  In the process, subclasses of MesquiteWindow might close down their owning MesquiteModules etc.*/
 	public void windowGoAway(MesquiteWindow whichWindow) {
			whichWindow.hide();
			//whichWindow.dispose();
	}
 	
	/*__________________________________________________________*/
	/*___________________________ Commands __________________________*/
	/*.................................................................................................................*/
	/**  Commands are created here.  This method is used in case Mesquite wants to catalogue available Commands
	(so far, this has not proved useful).  The commands used to be stored within a single static vector, but this caused many otherwise
	defunct objects (the Commandables that are the object of the commands) to be referenced and thus not GC'd.
	In the future, commands might be more sophisticated,
	and passed here will be not only the commandName, but also the parameter types expected and how they are to be called.
	See the sublibrary for more information about Commands. */
	public final static MesquiteCommand makeCommand(String commandName, Commandable ownerObject){
		MesquiteCommand c = new MesquiteCommand(commandName, ownerObject);
		return c;
	}
	/*__________________________________________________________*/


	
	/*__________________________________________________________*/
	/*___________________________ NEXUS file reading/writing __________________________*/
	/*.................................................................................................................*/
	/** Adds NEXUS block to the file. */
	public void addNEXUSBlock(NexusBlock nb){
		FileCoordinator fCoord = getFileCoordinator();
		NexusFileInterpreter fi = (NexusFileInterpreter)fCoord.findEmployeeWithDuty(NexusFileInterpreter.class);
		if (fi!=null) {
			fi.addBlock(nb);
		}
	}
	/*.................................................................................................................*/
	/** Remove NEXUS block from the file. */
	public void removeNEXUSBlock(NexusBlock nb){
		FileCoordinator fCoord = getFileCoordinator();
		NexusFileInterpreter fi = (NexusFileInterpreter)fCoord.findEmployeeWithDuty(NexusFileInterpreter.class);
		if (fi!=null) {
			fi.removeBlock(nb);
		}
	}
	/*.................................................................................................................*/
	/** Finds the NEXUS block containing the given FileElement. */
	public NexusBlock findNEXUSBlock(FileElement e){
		FileCoordinator fCoord = getFileCoordinator();
		NexusFileInterpreter fi = (NexusFileInterpreter)fCoord.findEmployeeWithDuty(NexusFileInterpreter.class);
		if (fi!=null)
			return fi.findBlock(e);
		else return null;
	}
	/*.................................................................................................................*/
	/** Read the nexus block passed (passed only to modules claiming they can read it). */
	public NexusBlock readNexusBlock(MesquiteFile file, String name, FileBlock block, StringBuffer blockComments, String fileReadingArguments, CommandRecord commandRec){return null;} 
	/** Read the nexus command in the given block (passed only to modules claiming they can read it).  Returns true if successful*/
	public boolean readNexusCommand(MesquiteFile file, String blockName, String command, MesquiteString comment){
		return false;
	}
	/*.................................................................................................................*/
	private boolean findReaderForCommand (MesquiteFile mf, String blockName, String commandName, String command, MesquiteString comment, MesquiteModule mb) {
		if (mb ==null)
			return false;
		Enumeration enum=mb.getEmployeeVector().elements(); 

		//look among employees for one that can read
		while (enum.hasMoreElements()){
			Object obj = enum.nextElement();
			MesquiteModule employeeModule = (MesquiteModule)obj;
			MesquiteModuleInfo mbi = employeeModule.getModuleInfo();
			if (mbi==null)
				System.out.println("no employees of ownerModule!!!");
			else if (mbi.nexusCommandTest!=null) {
				if (mbi.nexusCommandTest.readsWritesCommand(blockName, commandName, command)) {
					if (employeeModule.readNexusCommand(mf, blockName, command, comment))
						return true;
				}
			}
		}
		enum=mb.getEmployeeVector().elements(); // WHY ARE ONLY EMPLOYEES OF FILE COORDINATOR USED????
		//look among employees for one that can read
		while (enum.hasMoreElements()){
			Object obj = enum.nextElement();
			MesquiteModule employeeModule = (MesquiteModule)obj;
			if (findReaderForCommand(mf, blockName, commandName, command, comment, employeeModule)) {
				return true;
			}
		}
		
		return false;
	}
	/*.................................................................................................................*/
	/** Read the unrecognized command, first by looking for a module reading it, second by storing it as unrecognized within the nexus block. */
	public void readUnrecognizedCommand(MesquiteFile file, NexusBlock nBlock, String blockName, FileBlock block, String commandName, String command, StringBuffer blockComments, MesquiteString comment){
		if (!findReaderForCommand(file, blockName, commandName, command, comment, getFileCoordinator()))
			if (nBlock!=null)
				nBlock.storeUnrecognizedCommand(command);
	}
	/*.................................................................................................................*/
	/** Return any nexus commands belonging to block in file. */
	public String getNexusCommands(MesquiteFile file, String blockName){ return "";}
	

	/** Return Mesquite commands that will put the module (approximately) back into its current state. Used
	so that on file save, a Mesquite block can be saved that will return the user more or less to previous state. */
  	 public Snapshot getSnapshot(MesquiteFile file) {  //this allows employees to be dealt with
	   	 	Snapshot temp = new Snapshot();
	 	 	return temp;
  	 }
	
	/*__________________________________________________________*/
	/** for the paging system (may be defunct)*/
	public void pageModule(MesquiteModule fromModule, boolean persistent){
		if (!persistent)
			pagingsEphemeral.addElement(fromModule);
		else
			pagingsPersistent.addElement(fromModule);
	}
	/*.................................................................................................................*/
	/** for the paging system (may be defunct)*/
	public void removePaging(MesquiteModule fromModule){
		pagingsEphemeral.removeElement(fromModule);
		pagingsPersistent.removeElement(fromModule);
	}
	/*.................................................................................................................*/
	/** for the paging system (may be defunct)*/
	protected void returningPage(MesquiteModule pagedModule){
	}
	/*.................................................................................................................*/
	/** for the paging system (may be defunct)*/
	protected void respondToPaging(){
		Enumeration enum = pagingsEphemeral.elements();
		while (enum.hasMoreElements()){
			MesquiteModule fromModule = (MesquiteModule)enum.nextElement();
			fromModule.returningPage(this);
		}
		enum = pagingsPersistent.elements();
		while (enum.hasMoreElements()){
			MesquiteModule fromModule = (MesquiteModule)enum.nextElement();
			fromModule.returningPage(this);
		}
		pagingsEphemeral.removeAllElements();
	}
	/*___________________________ Utilities __________________________*/
	/*.................................................................................................................*/
	/*.................................................................................................................*/
 	private boolean parametersInPath(MesquiteModule module) {
 		if  (StringUtil.blank(module.getParameters())) {
	 		if (module.getEmployeeVector()==null)
	 			return false;
	 		int num = module.getEmployeeVector().size();
	 		for (int i=0; i<num; i++) {
				Object obj = module.getEmployeeVector().elementAt(i);
				MesquiteModule mb = (MesquiteModule)obj;
				if (parametersInPath(mb))
					return true;
	 		}
 		}
 		else
 			return true;
		return false;
   	 }
	/*.................................................................................................................*/
 	public String accumulateParameters(String spacer) {
 		if (parametersInPath(this)) {
	 		String thisBranch;
	 		if  (StringUtil.blank(getParameters()))
	 			thisBranch = spacer + getName()  + StringUtil.lineEnding();
	 		else
	 			thisBranch=spacer + getName() + ":  " + getParameters() + StringUtil.lineEnding();
	 		if (getEmployeeVector()!=null){
		 		int num = getEmployeeVector().size();
		 		spacer +="    ";
		 		for (int i=0; i<num; i++) {
					Object obj = getEmployeeVector().elementAt(i);
					MesquiteModule mb = (MesquiteModule)obj;
					thisBranch += mb.accumulateParameters(spacer);
		 		}
	 		}
			return thisBranch;
		}
		else
			return "";
   	 }
 	/** returns current parameters, for logging etc.. */
 	public String getParameters() {
 		return "";
   	 }
 	/** returns name plus current parameters, for logging etc.. */
 	public String getNameAndParameters() {
 		String p = getParameters();
 		if (StringUtil.blank(p))
 			return getName();
 		else
 			return getName() + " (" + p + ")";
   	 }
	/*.................................................................................................................*/
 	/** Lists  the parameters of  all employees of this MesquiteModule.*/
 	//TODO: use stringbuffer here (pass it)
 	public String listEmployeeParameters (String spacer) {
 		String thisBranch="";
 		
		thisBranch += spacer +getName() + ": " + getParameters() + StringUtil.lineEnding();
 		int num = employees.size();
 		spacer +="  ";
 		for (int i=0; i<num; i++) {
			Object obj = employees.elementAt(i);
			MesquiteModule mb = (MesquiteModule)obj;
			//thisBranch += spacer + mb.getName() + ": " + mb.getParameters() + StringUtil.lineEnding();
			thisBranch += mb.listEmployeeParameters(spacer);
 		}
 		return thisBranch;
   	 }
   	 
 	String listEmployees (String spacer, MesquiteInteger count) {
 		String thisBranch="";
 		
 		int num = employees.size();
 		spacer = "    " + spacer;
 		for (int i=0; i<num; i++) {
 			count.increment();
			Object obj = employees.elementAt(i);
			MesquiteModule mb = (MesquiteModule)obj;
			thisBranch += spacer + count.getValue() + "  -- " + mb.getName() + StringUtil.lineEnding();
			thisBranch += mb.listEmployees(spacer, count);
 		}
 		return thisBranch;
   	 }
 	MesquiteModule getDeepEmployee (int target, MesquiteInteger count) {
 		for (int i=0; i<employees.size(); i++) {
 			count.increment();
 			MesquiteModule mb = (MesquiteModule)employees.elementAt(i);
			if (count.getValue() == target)
				return mb;
			MesquiteModule found = mb.getDeepEmployee(target, count);
			if (found !=null)
				return found;
 		}
 		return null;
   	 }
	/*.................................................................................................................*/
 	/** returns short (not full package) name of class*/
 	public static String getShortClassName(Class classToShow) {
 		if (classToShow == null) {
 			return "";
 		}
 		else {
			 return StringUtil.getLastItem(classToShow.getName(), ".");
		}
 	}
	/*.................................................................................................................*/
 	/** returns short (not full package) name of class*/
 	public String getShortClassName() {
 		 return StringUtil.getLastItem(getClass().getName(), ".");
 	}
	/*.................................................................................................................*/
	/** returns whether name of Module matches passed String.  First checks to see if name matches directly (e.g., "Tree Window"); then checks to see if matches at whole package path
	(e.g. mesquite.minimal.BasicTreeWindowMaker.BasicTreeWindowMaker); then checks to see if matches at immediate classname (e.g., BasicTreeWindowMaker)*/
	public boolean nameMatches(String s) {
		if (s==null)
			return false;
		if (s.equalsIgnoreCase(getName()))
			return true;
		if (s.equals(getClass().getName()))
			return true;
		if (s.equals(getShortClassName()))
			return true;
		s = StringUtil.getLastItem(s, ".");
		if (s!=null && s.equals(getShortClassName()))
			return true;
		return false;
	}
	/*.................................................................................................................*/
	/** returns whether the passed class, or a superclass or interface of it, has the passed name*/
	public static boolean nameIsInstanceOf(String n, Class c){
		if (c==null || StringUtil.blank(n))
			return false;
		Class sup= c;
		while (sup!=null) {
			if (n.equalsIgnoreCase(getShortClassName(sup)))
				return true;
			if (n.equalsIgnoreCase(sup.getName()))
				return true;
			sup = sup.getSuperclass();
		}
		//also check using  Class[] getInterfaces() to see if the class has an interface of the given name
		Class[] interfaces = c.getInterfaces();
		for (int i=0; i<interfaces.length; i++) {
			if (interfaces[i].getName().equalsIgnoreCase(n))
				return true;
		}
		return false;
		
	}
	/*.................................................................................................................*/
 	/** returns path to manual.  Null if manual doesn't exist*/
 	public String getManualPath() {
 		if (MesquiteTrunk.isApplet()) 
 			return null;
 		String manualPath;
 		String manP;
 		if (this instanceof MesquiteTrunk)
 			manP= "docs" + MesquiteFile.fileSeparator + "mesquiteTrunk.html";
 		else
 			manP= "manual.html";
		manualPath = getPath() + manP; 
		File testing = new File(manualPath);
		if (testing.exists())
			return manualPath;
		else
			return null;
 	}
	/*.................................................................................................................*/
 	/** returns path to page showing the commands.  Null if page doesn't exist*/
 	public String getCommandPagePath() {
 		if (MesquiteTrunk.isApplet()) 
 			return null;
		if (!CommandChecker.documentationComposed) {
			CommandChecker checker = new CommandChecker();
			checker.composeDocumentation();
		}	
 		String manualPath;
		manualPath = MesquiteModule.prefsDirectory + MesquiteFile.fileSeparator + "commands" + MesquiteFile.fileSeparator  + MesquiteModule.getShortClassName(getClass()) + ".html"; 
		
		File testing = new File(manualPath);
		if (testing.exists()) {
			return manualPath;
		}
		else {
			return null;
		}
 	}
	/*.................................................................................................................*/
 	/** returns path to manual.  Null if manual doesn't exist*/
 	public String getBrowserManualPath() {
 		if (MesquiteTrunk.isApplet()) 
 			return null;
 		String manualPath;
 		//String manP;
 		if (this instanceof MesquiteTrunk)
 			manualPath= getDocsPath() + "mesquiteTrunk.html";
 		else
 			manualPath= getPath() + "manual.html";
		File testing = new File(manualPath);
		if (testing.exists()) {
			return manualPath;
		}
		else
			return null;
 	}
	/*.................................................................................................................*/
 	/** shows manual for module*/
 	public void showManual() {
	 	showWebPage(getBrowserManualPath(), true);
 	}
	/*.................................................................................................................*/
	//TODO: have showWebPage(MesquiteFile file, String path) and showWebPage(MesquiteProject project, String path) to say relative to what (otherwise relative to Mesquite home folder)
 	/** requests browser to show page.  boolean indicates whether the standard auto-generated documentation pages for all the modules should be composed if they haven't been. *
 	public static void TEMPshowWebPage(String path, boolean autoCompose) {
		if (path !=null) {
			if (MesquiteTrunk.isApplet()) {
	 			//TODO: FILL THIS IN
			}
			else {
				if (System.getProperty("os.name").startsWith("Mac OS X") && path.indexOf(":/")<0) {
					osXshowLocalWebPage(path, autoCompose);
					return;
				}
				if (path.indexOf(":/")<0) {//local file
					File testing = new File(path);
					if (!testing.exists()) {
						MesquiteTrunk.mesquiteTrunk.alert("The requested page could not be shown, because the file could not be found." );
						return;
					}
					path = MesquiteFile.massageFilePathToURL(path);
				}
				try {
					BrowserLauncher.openURL(path);
				}
				catch (IOException e) {
					browserString = null;
					MesquiteTrunk.mesquiteTrunk.alert("The requested page could not be shown, because the web browser could not be used properly.  There may be a problem with insufficient memory or the location of the web page or browser." );
				}
			}
		}
 	}	
	/*.................................................................................................................*/
 	public static void showWebPage(String path, boolean autoCompose) {
		if (path !=null) {
			if (MesquiteTrunk.isApplet()) {
	 			//TODO: FILL THIS IN
			}
			else {
				String pathToCheck = path;
				if (path.indexOf("#")>0)
					pathToCheck = StringUtil.getAllButLastItem(path, "#");
				path = pathToCheck;  //Todo: this is temporary, as the launching methods don't seem to handle within-page anchors
				String[] browserCommand = null;
					
				
				if (MesquiteTrunk.isMacOSX()){ //Mac OS X
					if (path.indexOf(":/")>=0) { //remote OSX file, use browser laucher
						try {
							BrowserLauncher.openURL(path);
						}
						catch (IOException e) {
							browserString = null;
							MesquiteTrunk.mesquiteTrunk.alert("The requested page could not be shown, because the web browser could not be used properly.  There may be a problem with insufficient memory or the location of the web page or browser." );
						}
						return;
					}
					else { 
						File testing = new File(pathToCheck);
						if (!testing.exists()) {
							MesquiteTrunk.mesquiteTrunk.alert("The requested page could not be shown, because the file could not be found." );
							return;
						}
						browserString = "open";
						String[] b = {browserString, "-a", "Internet Explorer.app", path};
						browserCommand = b;
					}
				}
				else {
					if (path.indexOf(":/")<0) {//local file
						File testing = new File(pathToCheck);
						if (!testing.exists()) {
							MesquiteTrunk.mesquiteTrunk.alert("The requested page could not be shown, because the file could not be found." );
							return;
						}
						path = MesquiteFile.massageFilePathToURL(path);
					}
					browserString = MesquiteFile.checkFilePath(browserString, "Please select a web browser.");
					if (StringUtil.blank(browserString)){
						browserString = MesquiteString.queryString(mesquiteTrunk.containerOfModule(), "Enter browser path", "If you wish, enter the path to the browser (E.g., /hard_disk/programs/myBrowser.exe)", "");
						if (StringUtil.blank(browserString))
							return;
					}
					String[] b = {browserString, path};
					browserCommand = b;
				}
				if (!CommandChecker.documentationComposed) {
					CommandChecker checker = new CommandChecker();
					checker.composeDocumentation();
				}	
				try {
					//String[] browserCommand = {browserString, arg1, arg2, arg3};

					Runtime.getRuntime().exec(browserCommand); 
				}
				catch (IOException e) {
					browserString = null;
					MesquiteTrunk.mesquiteTrunk.alert("The requested page could not be shown, because the web browser could not be used properly.  There may be a problem with insufficient memory or the location of the web page or browser." );
				}
			}
		}
 	}	
	/*.................................................................................................................*/
	/** Asks for hierarchy browser panel (File coordinator or trunk should override to return.*/
 	public HPanel getBrowserPanel(){
 		if (employer!=null)
 			return getEmployer().getBrowserPanel();
 		else
 			return null;
 	}
	/*.................................................................................................................*/
	/** In some way shows the module, either by showing its window or its place in hierarchy*/
 	public void showMe(){
 		if (getModuleWindow()!=null) {
 			getModuleWindow().setVisible(true);
 		}
 		else {
		     	HPanel hp;
		     	EmployeeTree etM = (EmployeeTree)findImmediateEmployeeWithDuty(EmployeeTree.class);
		     	if (etM == null)
		     		etM = (EmployeeTree)hireEmployee(new CommandRecord(false), EmployeeTree.class, null);
		     	if (etM!=null) {
		     		hp = etM.showEmployeeTreeWindow(MesquiteTrunk.mesquiteTrunk);
		     		if (hp !=null)
		     			hp.highlightNode(this);
		     	}
 		}
 	}
 	/*__________________________________________________________*/
	/*_____________________ NEEDED ON MESQUITE STARTUP____________________________*/
	/*.................................................................................................................*/
	/** Returns the name of the module in very short form.  For use for column headings and other constrained places.  Unless overridden returns getName()*/
 	public String getVeryShortName(){
 		return getName();
 	}
	/*.................................................................................................................*/
	/** Returns the name of the module for menu items.  Unless overridden returns getName()*/
 	public String getNameForMenuItem(){
 		return getName();
 	}
	/*.................................................................................................................*/
	/** Returns the name of the module*/
 	public abstract String getName();
	/*.................................................................................................................*/
 	/** Returns the authors of the module.  */
 	public String getAuthors()  {
		MesquiteModuleInfo mmi = getPackageIntroModule();
 		if (mmi!=null && mmi.getPackageAuthors()!=null)
 			return mmi.getPackageAuthors();
 		//if part of standard
 		if (inStandardPackages()) {
 			return MesquiteTrunk.mesquiteTrunk.getAuthors();
 		}
 		return null;
   	 }
	/*.................................................................................................................*/
 	/** returns the version number string of the module. */
 	public String  getVersion(){ 
		MesquiteModuleInfo mmi = getPackageIntroModule();
 		if (mmi!=null && mmi.getPackageVersion()!=null)
 			return mmi.getPackageVersion();
 		//if part of standard
 		if (inStandardPackages()) {
 			return MesquiteTrunk.mesquiteTrunk.getVersion();
 		}
 		return null;
   	}
	/*.................................................................................................................*/
 	/** returns the year released, as a string.  //TODO: SHOULD BE ABSTRACT TO FORCE INCLUSION*/
 	public String  getDateReleased(){ 
		MesquiteModuleInfo mmi = getPackageIntroModule();
 		if (mmi!=null && mmi.getPackageDateReleased()!=null)
 			return mmi.getPackageDateReleased();
 		//if part of standard
 		if (inStandardPackages()) {
 			return MesquiteTrunk.mesquiteTrunk.getDateReleased();
 		}
 		return null;
   	}
	/*.................................................................................................................*/
 	/** Returns whether or not the module does substantive calculations and thus should be cited.  If true, its citation will
 	appear in the citations panel of the windows */
 	public boolean showCitation()  {
 		return false;
   	 }
	/*.................................................................................................................*/
 	/** Returns the citation of the module. By default this returns the citation of the package in which the module resides, and returns if
 	only if "showCitation" returns true.  The method may be overridden for module-specific citations.*/
 	public String getCitation()  {
 		if (!showCitation())
 			return null;
		MesquiteModuleInfo mmi = getPackageIntroModule();
 		if (mmi!=null && mmi.getPackageCitation()!=null)
 			return mmi.getPackageCitation();
 		//if part of standard
 		if (inStandardPackages()) {
 			return MesquiteTrunk.mesquiteTrunk.getCitation();
 		}
 		return null;
   	 }
   	 private boolean inStandardPackages(){
 		//String packageName = StringUtil.getAllButLastItem(StringUtil.getAllButLastItem(getClass().getName(), "."), ".");  //getting package string
 		for (int i=0; i<MesquiteTrunk.standardPackages.length; i++)
 			if (getClass().getName().startsWith("mesquite." + MesquiteTrunk.standardPackages[i]))
 				return true;
 		return false;
 				
   	 }
	/*.................................................................................................................*/
	/** Returns the name of the module introducing package of modules (e.g., "#aParsimonyIntro")*/
 	public MesquiteModuleInfo getPackageIntroModule(){
 		String packageName = StringUtil.getAllButLastItem(StringUtil.getAllButLastItem(getClass().getName(), "."), ".");  //getting package string
 		return MesquiteTrunk.mesquiteModulesInfoVector.findModule(packageName, PackageIntroInterface.class);
 	}
	/*.................................................................................................................*/
	/** returns version of the Mesquite system */
	public final static String getMesquiteVersion() {
		return "1.01";
	}
	/*.................................................................................................................*/
	/** returns build number of the Mesquite system ("e58") */
	public final static String getBuildVersion() {
		//0.95.80    14 Mar 01 - first beta release 
		//0.96  2 April 01 beta  - second beta release
		//0.97 30 May 01 - not a release version
		//0.98  24 July 01 0.98
		//0.99   released 21 Aug 02   hits at posting: 12860 home page; 3251 download; 466 source
		//0.991 = d21   released 14 Sep 02    hits at posting: 13599 home page; 3460 download; 502 source
		//0.992 = d24   released 27 Sep 02    approximate hits at posting: 14171 home page; 3590 download; 525 source
		//0.993 = d42   released 10 Jan 03    approximate hits at posting: 16122 home page; 4458 download; 671 source
		//0.994 = d51   released 7 Feb 03    approximate hits at posting: 16790 home page; 4831 download; 720 source
		//0.995 = e23   released 21 May 03    approximate hits at posting: 19389 home page; 6088 download; 898 source
		//0.996 = e30   released 21 June 03    approximate hits at posting: 20028 home page; 6349 download; 958 source
		//1.0 = e58   released 22 September 03    approximate hits at posting: 21315 home page; 6880 download; 1087 source
		//1.01 = e80   released 14 January 04    approximate hits at posting: 25636 home page; 8753 download; 1359 source
		return " (build e81)";
	}
	/*.................................................................................................................*/
	/** returns whether this module is a prerelease version.  This returns "TRUE" here, forcing modules to override to claim they are not prerelease */
   	public boolean isPrerelease(){
   		return true;  
   	}
	/*.................................................................................................................*/
	/** returns whether this module is requesting to appear as a primary choice */
   	public boolean requestPrimaryChoice(){
   		return false;  
   	}
	/*.................................................................................................................*/
	/** returns whether this module does substantive calculations affecting analysis results, 
		or only a graphical/UI/input-output module */
   	public boolean isSubstantive(){
   		return true;
   	}
	/*.................................................................................................................*/
	/** returns whether this or employee modules are substantive and prerelease */
   	public boolean anySubstantivePrereleases(){
		if (isSubstantive() && isPrerelease())
			return true;
		if (employees ==null)
			return false;
		Enumeration enum=employees.elements();
		while (enum.hasMoreElements()){
			MesquiteModule mb = (MesquiteModule)enum.nextElement();
			if (mb.anySubstantivePrereleases())
				return true;
		}
		return false;
   	}
	/*.................................................................................................................*/
 	/** returns whether the module is compatible with the current OS, Mesquite system, Java VM, and so on.  If false then the module will not be loaded as a possibility at startup*/
 	public boolean  compatibleWithSystem(){ 
 		return true;
   	}
	/*.................................................................................................................*/
  	 public String getAppletInfo() {
		return getName() + ", version " + getVersion();
   	 }
   	 
	/*.................................................................................................................*/
  	 public String toString() {
		return getName() + " (id# " + getID() +")";
   	 }
	/*.................................................................................................................*/
 	/** returns an explanation of what the module does.  //TODO: SHOULD BE ABSTRACT TO FORCE INCLUSION*/
 	public  String getExplanation()  {
 		return "(no explanation supplied by module)";
   	 }
   	 
 	/*.................................................................................................................*/
	/** for FileDirtier interface */
	public void fileDirtiedByCommand(MesquiteCommand command){
			if (getProject()!=null && getProject().getHomeFile()!=null)
				getProject().getHomeFile().setDirtiedByCommand(true);
	}
	/*.................................................................................................................*/
 	/** Returns the name of the duty; set by the duty-defining library classes.*/
 	public String getDutyName() {
 		return "";
   	 }
	/*.................................................................................................................*/
 	/** Returns name of default module for superclass.*/
	public String[] getDefaultModule (){return null;}
	/*.................................................................................................................*/
	/** Returns CompatibilityTest so other modules know if this is compatible with some object. */
	public CompatibilityTest getCompatibilityTest(){return null;}
	/*.................................................................................................................*/
	/** Returns NexusBlockTest so interpreter knows if this module can interpret a block. */
	public  NexusBlockTest getNexusBlockTest(){return null;}
	/*.................................................................................................................*/
	/** Returns NexusCommandTest so interpreter knows if this module can interpret a command. */
	public  NexusCommandTest getNexusCommandTest(){return null;}
	/*.................................................................................................................*/
	/**Returns true if the module is to appear in menus and other places in which users can choose, and if can be selected in any way other than by direct request*/
	public boolean getUserChooseable(){
		return true;
	}
	/*.................................................................................................................*/
	/** Returns duty Class that module would like to hire immediately upon hiring. If a module wants to present a user with a choice of 
	employees to hire, it can request a submenu listing these possible employees.  However, if one of these employees would like to immediately
	(on startup) hire a user-specified subemployee (without having to go through a dialog box, etc.), this employee can indicate this by
	passing back through getHireSubchoice the duty class of the subemployee it would like to hire.  Mesquite then lists a subsubmenu
	indicating possible subemployees.  That way, the user not only chooses the employee, but specifies the subemployee.  When
	the employee is started via startJob, the tokenized string of the name of the
	module that the user requested as subemployee is passed as an argument.*/
	public  Class getHireSubchoice(){return null;}
	/*.................................................................................................................*/
	/** Called during Mesquite startup when the list of available modules is being constructed.*/
	public void mesquiteStartup(){
	}
}