This class installs and updates ImageJ's menus. Note that menu labels,

even in submenus, must be unique. This is because ImageJ uses a single

hash table for all menu labels. If you look closely, you will see that

File->Import->Text Image... and File->Save As->Text Image... do not use

the same label. One of the labels has an extra space.

*/

  public static final char PLUGINS_MENU = 'p';

  public static final char IMPORT_MENU = 'i';

  public static final char SAVE_AS_MENU = 's';

  public static final char SHORTCUTS_MENU = 'h'; // 'h'=hotkey

  public static final char ABOUT_MENU = 'a';

  public static final char FILTERS_MENU = 'f';

  public static final char TOOLS_MENU = 't';

  public static final char UTILITIES_MENU = 'u';

   

  public static final int WINDOW_MENU_ITEMS = 5; // fixed items at top of Window menu

 

  public static final int NORMAL_RETURN = 0;

  public static final int COMMAND_IN_USE = -1;

  public static final int INVALID_SHORTCUT = -2;

  public static final int SHORTCUT_IN_USE = -3;

  public static final int NOT_INSTALLED = -4;

  public static final int COMMAND_NOT_FOUND = -5;

 

  public static final int MAX_OPEN_RECENT_ITEMS = 15;

  private static Menus instance;

  private static MenuBar mbar;

  private static CheckboxMenuItem gray8Item,gray16Item,gray32Item,

      color256Item,colorRGBItem,RGBStackItem,HSBStackItem;

  private static PopupMenu popup;

  private static ImageJ ij;

  private static Applet applet;

  private Hashtable demoImagesTable = new Hashtable();

  private static String pluginsPath, macrosPath;

  private static Properties menus;

  private static Properties menuSeparators;

  private static Menu pluginsMenu, saveAsMenu, shortcutsMenu, utilitiesMenu, macrosMenu;

  static Menu window, openRecentMenu;

  private static Hashtable pluginsTable;

 

  private static int nPlugins, nMacros;

  private static Hashtable shortcuts;

  private static Hashtable macroShortcuts;

  private static Vector pluginsPrefs; // commands saved in IJ_Prefs

  static int windowMenuItems2; // non-image windows listed in Window menu + separator

  private String error;

  private String jarError;

  private String pluginError;

    private boolean isJarErrorHeading;

  private static boolean installingJars, duplicateCommand;

  private static Vector jarFiles;  // JAR files in plugins folder with "_" in their name

  private Map menuEntry2jarFile = new HashMap();

  private static Vector macroFiles;  // Macro files in plugins folder with "_" in their name

  private static int userPluginsIndex; // First user plugin or submenu in Plugins menu

  private static boolean addSorted;

  private static int defaultFontSize = IJ.isWindows()?14:0;

  private static int fontSize = Prefs.getInt(Prefs.MENU_SIZE, defaultFontSize);

  private static Font menuFont;

  static boolean jnlp; // true when using Java WebStart

   

  Menus(ImageJ ijInstance, Applet appletInstance) {

    ij = ijInstance;

    applet = appletInstance;

    instance = this;

  }

  String addMenuBar() {

    nPlugins = nMacros = userPluginsIndex = 0;

    addSorted = installingJars = duplicateCommand = false;

    error = null;

    mbar = null;

    menus = new Properties();

    pluginsTable = new Hashtable();

    shortcuts = new Hashtable();

    pluginsPrefs = new Vector();

    macroShortcuts = null;

    setupPluginsAndMacrosPaths();

    Menu file = getMenu("File");

    Menu newMenu = getMenu("File>New", true);

    addPlugInItem(file, "Open...", "ij.plugin.Commands(\"open\")", KeyEvent.VK_O, false);

    addPlugInItem(file, "Open Next", "ij.plugin.NextImageOpener", KeyEvent.VK_O, true);

    getMenu("File>Open Samples", true);

    addOpenRecentSubMenu(file);

    Menu importMenu = getMenu("File>Import", true);

    file.addSeparator();

    addPlugInItem(file, "Close", "ij.plugin.Commands(\"close\")", KeyEvent.VK_W, false);

    addPlugInItem(file, "Close All", "ij.plugin.Commands(\"close-all\")", 0, false);

    addPlugInItem(file, "Save", "ij.plugin.Commands(\"save\")", KeyEvent.VK_S, false);

    saveAsMenu = getMenu("File>Save As", true);

    addPlugInItem(file, "Revert", "ij.plugin.Commands(\"revert\")", KeyEvent.VK_R,  false);

    file.addSeparator();

    addPlugInItem(file, "Page Setup...", "ij.plugin.filter.Printer(\"setup\")", 0, false);

    addPlugInItem(file, "Print...", "ij.plugin.filter.Printer(\"print\")", KeyEvent.VK_P, false);

   

    Menu edit = getMenu("Edit");

    addPlugInItem(edit, "Undo", "ij.plugin.Commands(\"undo\")", KeyEvent.VK_Z, false);

    edit.addSeparator();

    addPlugInItem(edit, "Cut", "ij.plugin.Clipboard(\"cut\")", KeyEvent.VK_X, false);

    addPlugInItem(edit, "Copy", "ij.plugin.Clipboard(\"copy\")", KeyEvent.VK_C, false);

    addPlugInItem(edit, "Copy to System", "ij.plugin.Clipboard(\"scopy\")", 0, false);

    addPlugInItem(edit, "Paste", "ij.plugin.Clipboard(\"paste\")", KeyEvent.VK_V, false);

    addPlugInItem(edit, "Paste Control...", "ij.plugin.frame.PasteController", 0, false);

    edit.addSeparator();

    addPlugInItem(edit, "Clear", "ij.plugin.filter.Filler(\"clear\")", 0, false);

    addPlugInItem(edit, "Clear Outside", "ij.plugin.filter.Filler(\"outside\")", 0, false);

    addPlugInItem(edit, "Fill", "ij.plugin.filter.Filler(\"fill\")", KeyEvent.VK_F, false);

    addPlugInItem(edit, "Draw", "ij.plugin.filter.Filler(\"draw\")", KeyEvent.VK_D, false);

    addPlugInItem(edit, "Invert", "ij.plugin.filter.Filters(\"invert\")", KeyEvent.VK_I, true);

    edit.addSeparator();

    getMenu("Edit>Selection", true);

    Menu optionsMenu = getMenu("Edit>Options", true);

   

    Menu image = getMenu("Image");

    Menu imageType = getMenu("Image>Type");

      gray8Item = addCheckboxItem(imageType, "8-bit", "ij.plugin.Converter(\"8-bit\")");

      gray16Item = addCheckboxItem(imageType, "16-bit", "ij.plugin.Converter(\"16-bit\")");

      gray32Item = addCheckboxItem(imageType, "32-bit", "ij.plugin.Converter(\"32-bit\")");

      color256Item = addCheckboxItem(imageType, "8-bit Color", "ij.plugin.Converter(\"8-bit Color\")");

      colorRGBItem = addCheckboxItem(imageType, "RGB Color", "ij.plugin.Converter(\"RGB Color\")");

      imageType.add(new MenuItem("-"));

      RGBStackItem = addCheckboxItem(imageType, "RGB Stack", "ij.plugin.Converter(\"RGB Stack\")");

      HSBStackItem = addCheckboxItem(imageType, "HSB Stack", "ij.plugin.Converter(\"HSB Stack\")");

      image.add(imageType);

     

    image.addSeparator();

    getMenu("Image>Adjust", true);

    addPlugInItem(image, "Show Info...", "ij.plugin.filter.Info", KeyEvent.VK_I, false);

    addPlugInItem(image, "Properties...", "ij.plugin.filter.ImageProperties", KeyEvent.VK_P, true);

    getMenu("Image>Color", true);

    getMenu("Image>Stacks", true);

    getMenu("Image>Stacks>Tools_", true);

    Menu hyperstacksMenu = getMenu("Image>Hyperstacks", true);

    image.addSeparator();

    addPlugInItem(image, "Crop", "ij.plugin.Resizer(\"crop\")", KeyEvent.VK_X, true);

    addPlugInItem(image, "Duplicate...", "ij.plugin.Duplicator", KeyEvent.VK_D, true);

    addPlugInItem(image, "Rename...", "ij.plugin.SimpleCommands(\"rename\")", 0, false);

    addPlugInItem(image, "Scale...", "ij.plugin.Scaler", KeyEvent.VK_E, false);

    getMenu("Image>Transform", true);

    getMenu("Image>Zoom", true);

    getMenu("Image>Overlay", true);

    image.addSeparator();

    getMenu("Image>Lookup Tables", true);

   

    Menu process = getMenu("Process");

    addPlugInItem(process, "Smooth", "ij.plugin.filter.Filters(\"smooth\")", KeyEvent.VK_S, true);

    addPlugInItem(process, "Sharpen", "ij.plugin.filter.Filters(\"sharpen\")", 0, false);

    addPlugInItem(process, "Find Edges", "ij.plugin.filter.Filters(\"edge\")", 0, false);

    addPlugInItem(process, "Find Maxima...", "ij.plugin.filter.MaximumFinder", 0, false);

    addPlugInItem(process, "Enhance Contrast", "ij.plugin.ContrastEnhancer", 0, false);

    getMenu("Process>Noise", true);

    getMenu("Process>Shadows", true);

    getMenu("Process>Binary", true);

    getMenu("Process>Math", true);

    getMenu("Process>FFT", true);

    Menu filtersMenu = getMenu("Process>Filters", true);

    process.addSeparator();

    getMenu("Process>Batch", true);

    addPlugInItem(process, "Image Calculator...", "ij.plugin.ImageCalculator", 0, false);

    addPlugInItem(process, "Subtract Background...", "ij.plugin.filter.BackgroundSubtracter", 0, false);

    addItem(process, "Repeat Command", KeyEvent.VK_R, true);

   

    Menu analyzeMenu = getMenu("Analyze");

    addPlugInItem(analyzeMenu, "Measure", "ij.plugin.filter.Analyzer", KeyEvent.VK_M, false);

    addPlugInItem(analyzeMenu, "Analyze Particles...", "ij.plugin.filter.ParticleAnalyzer", 0, false);

    addPlugInItem(analyzeMenu, "Summarize", "ij.plugin.filter.Analyzer(\"sum\")", 0, false);

    addPlugInItem(analyzeMenu, "Distribution...", "ij.plugin.Distribution", 0, false);

    addPlugInItem(analyzeMenu, "Label", "ij.plugin.filter.Filler(\"label\")", 0, false);

    addPlugInItem(analyzeMenu, "Clear Results", "ij.plugin.filter.Analyzer(\"clear\")", 0, false);

    addPlugInItem(analyzeMenu, "Set Measurements...", "ij.plugin.filter.Analyzer(\"set\")", 0, false);

    analyzeMenu.addSeparator();

    addPlugInItem(analyzeMenu, "Set Scale...", "ij.plugin.filter.ScaleDialog", 0, false);

    addPlugInItem(analyzeMenu, "Calibrate...", "ij.plugin.filter.Calibrator", 0, false);

    addPlugInItem(analyzeMenu, "Histogram", "ij.plugin.Histogram", KeyEvent.VK_H, false);

    addPlugInItem(analyzeMenu, "Plot Profile", "ij.plugin.filter.Profiler(\"plot\")", KeyEvent.VK_K, false);

    addPlugInItem(analyzeMenu, "Surface Plot...", "ij.plugin.SurfacePlotter", 0, false);

    getMenu("Analyze>Gels", true);

    Menu toolsMenu = getMenu("Analyze>Tools", true);

    // the plugins will be added later, with a separator

    addPluginsMenu();

    Menu window = getMenu("Window");

    addPlugInItem(window, "Show All", "ij.plugin.WindowOrganizer(\"show\")", KeyEvent.VK_CLOSE_BRACKET, false);

    addPlugInItem(window, "Put Behind [tab]", "ij.plugin.Commands(\"tab\")", 0, false);

    addPlugInItem(window, "Cascade", "ij.plugin.WindowOrganizer(\"cascade\")", 0, false);

    addPlugInItem(window, "Tile", "ij.plugin.WindowOrganizer(\"tile\")", 0, false);

    window.addSeparator();

    Menu help = getMenu("Help");

    addPlugInItem(help, "ImageJ Website...", "ij.plugin.BrowserLauncher", 0, false);

    addPlugInItem(help, "ImageJ News...", "ij.plugin.BrowserLauncher(\""+IJ.URL+"/notes.html\")", 0, false);

    addPlugInItem(help, "Documentation...", "ij.plugin.BrowserLauncher(\""+IJ.URL+"/docs\")", 0, false);

    addPlugInItem(help, "Installation...", "ij.plugin.SimpleCommands(\"install\")", 0, false);

    addPlugInItem(help, "Mailing List...", "ij.plugin.BrowserLauncher(\"https://list.nih.gov/archives/imagej.html\")", 0, false);

    help.addSeparator();

    addPlugInItem(help, "Dev. Resources...", "ij.plugin.BrowserLauncher(\""+IJ.URL+"/developer/index.html\")", 0, false);

    addPlugInItem(help, "Plugins...", "ij.plugin.BrowserLauncher(\""+IJ.URL+"/plugins\")", 0, false);

    addPlugInItem(help, "Macros...", "ij.plugin.BrowserLauncher(\""+IJ.URL+"/macros/\")", 0, false);

    addPlugInItem(help, "Macro Functions...", "ij.plugin.BrowserLauncher(\""+IJ.URL+"/developer/macro/functions.html\")", 0, false);

    help.addSeparator();

    addPlugInItem(help, "Update ImageJ...", "ij.plugin.ImageJ_Updater", 0, false);

    addPlugInItem(help, "Refresh Menus", "ij.plugin.ImageJ_Updater(\"menus\")", 0, false);

    help.addSeparator();

    Menu aboutMenu = getMenu("Help>About Plugins", true);

    addPlugInItem(help, "About ImageJ...", "ij.plugin.AboutBox", 0, false);

       

    if (applet==null) {

      menuSeparators = new Properties();

      installPlugins();

    }

    // make  sure "Quit" is the last item in the File menu

    file.addSeparator();

    addPlugInItem(file, "Quit", "ij.plugin.Commands(\"quit\")", 0, false);

    if (fontSize!=0)

      mbar.setFont(getFont());

    if (ij!=null)

      ij.setMenuBar(mbar);

   

    if (pluginError!=null)

      error = error!=null?error+="\n"+pluginError:pluginError;

    if (jarError!=null)

      error = error!=null?error+="\n"+jarError:jarError;

    return error;

  }

 

  void addOpenRecentSubMenu(Menu menu) {

    openRecentMenu = getMenu("File>Open Recent");

     for (int i=0; i<MAX_OPEN_RECENT_ITEMS; i++) {

      String path = Prefs.getString("recent" + (i/10)%10 + i%10);

      if (path==null) break;

      MenuItem item = new MenuItem(path);

      openRecentMenu.add(item);

      item.addActionListener(ij);

    }

    menu.add(openRecentMenu);

  }

  static void addItem(Menu menu, String label, int shortcut, boolean shift) {

    if (menu==null)

      return;

    MenuItem item;

    if (shortcut==0)

      item = new MenuItem(label);

    else {

      if (shift) {

        item = new MenuItem(label, new MenuShortcut(shortcut, true));

        shortcuts.put(new Integer(shortcut+200),label);

      } else {

        item = new MenuItem(label, new MenuShortcut(shortcut));

        shortcuts.put(new Integer(shortcut),label);

      }

    }

    if (addSorted) {

      if (menu==pluginsMenu)

        addItemSorted(menu, item, userPluginsIndex);

      else

        addOrdered(menu, item);

    } else

      menu.add(item);

    item.addActionListener(ij);

  }

 

  void addPlugInItem(Menu menu, String label, String className, int shortcut, boolean shift) {

    pluginsTable.put(label, className);

    nPlugins++;

    addItem(menu, label, shortcut, shift);

  }

  CheckboxMenuItem addCheckboxItem(Menu menu, String label, String className) {

    pluginsTable.put(label, className);

    nPlugins++;

    CheckboxMenuItem item = new CheckboxMenuItem(label);

    menu.add(item);

    item.addItemListener(ij);

    item.setState(false);

    return item;

  }

  static Menu addSubMenu(Menu menu, String name) {

    String value;

    String key = name.toLowerCase(Locale.US);

    int index;

     Menu submenu=new Menu(name.replace('_', ' '));

    index = key.indexOf(' ');

    if (index>0)

      key = key.substring(0, index);

     for (int count=1; count<100; count++) {

      value = Prefs.getString(key + (count/10)%10 + count%10);

      if (value==null)

        break;

      if (count==1)

        menu.add(submenu);

      if (value.equals("-"))

        submenu.addSeparator();

      else

        addPluginItem(submenu, value);

    }

    if (name.equals("Lookup Tables") && applet==null)

      addLuts(submenu);

    return submenu;

  }

 

  static void addLuts(Menu submenu) {

    String path = IJ.getDirectory("luts");

    if (path==null) return;

    File f = new File(path);

    String[] list = null;

    if (applet==null && f.exists() && f.isDirectory())

      list = f.list();

    if (list==null) return;

    if (IJ.isLinux()) StringSorter.sort(list);

    submenu.addSeparator();

     for (int i=0; i<list.length; i++) {

       String name = list[i];

       if (name.endsWith(".lut")) {

         name = name.substring(0,name.length()-4);

         MenuItem item = new MenuItem(name);

        submenu.add(item);

        item.addActionListener(ij);

        nPlugins++;

      }

    }

  }

  static void addPluginItem(Menu submenu, String s) {

    if (s.startsWith("\"-\"")) {

      // add menu separator if command="-"

      addSeparator(submenu);

      return;

    }

    int lastComma = s.lastIndexOf(',');

    if (lastComma<=0)

      return;

    String command = s.substring(1,lastComma-1);

    int keyCode = 0;

    boolean shift = false;

    if (command.endsWith("]")) {

      int openBracket = command.lastIndexOf('[');

      if (openBracket>0) {

        String shortcut = command.substring(openBracket+1,command.length()-1);

        keyCode = convertShortcutToCode(shortcut);

        boolean functionKey = keyCode>=KeyEvent.VK_F1 && keyCode<=KeyEvent.VK_F12;

        if (keyCode>0 && !functionKey)

          command = command.substring(0,openBracket);

        //IJ.write(command+": "+shortcut);

      }

    }

    if (keyCode>=KeyEvent.VK_F1 && keyCode<=KeyEvent.VK_F12) {

      shortcuts.put(new Integer(keyCode),command);

      keyCode = 0;

    } else if (keyCode>=265 && keyCode<=290) {

      keyCode -= 200;

      shift = true;

    }

    addItem(submenu,command,keyCode,shift);

    while(s.charAt(lastComma+1)==' ' && lastComma+2<s.length())

      lastComma++; // remove leading spaces

    String className = s.substring(lastComma+1,s.length());

    //IJ.log(command+"  "+className);

    if (installingJars)

      duplicateCommand = pluginsTable.get(command)!=null;

    pluginsTable.put(command, className);

    nPlugins++;

  }

  void checkForDuplicate(String command) {

    if (pluginsTable.get(command)!=null) {

    }

  }

 

  void addPluginsMenu() {

    String value,label,className;

    int index;

    //pluginsMenu = new Menu("Plugins");

    pluginsMenu = getMenu("Plugins");

    for (int count=1; count<100; count++) {

      value = Prefs.getString("plug-in" + (count/10)%10 + count%10);

      if (value==null)

        break;

      char firstChar = value.charAt(0);

      if (firstChar=='-')

        pluginsMenu.addSeparator();

      else if (firstChar=='>') {

        String submenu = value.substring(2,value.length()-1);

        //Menu menu = getMenu("Plugins>" + submenu, true);

        Menu menu = addSubMenu(pluginsMenu, submenu);

        if (submenu.equals("Shortcuts"))

          shortcutsMenu = menu;

        else if (submenu.equals("Utilities"))

          utilitiesMenu = menu;

        else if (submenu.equals("Macros"))

          macrosMenu = menu;

      } else

        addPluginItem(pluginsMenu, value);

    }

    userPluginsIndex = pluginsMenu.getItemCount();

    if (userPluginsIndex<0) userPluginsIndex = 0;

  }

  /** Install plugins using "pluginxx=" keys in IJ_Prefs.txt.

    Plugins not listed in IJ_Prefs are added to the end

    of the Plugins menu. */

  void installPlugins() {

    String value, className;

    char menuCode;

    Menu menu;

    String[] pluginList = getPlugins();

    String[] pluginsList2 = null;

    Hashtable skipList = new Hashtable();

     for (int index=0; index<100; index++) {

      value = Prefs.getString("plugin" + (index/10)%10 + index%10);

      if (value==null)

        break;

      menuCode = value.charAt(0);

      switch (menuCode) {

        case PLUGINS_MENU: default: menu = pluginsMenu; break;

        case IMPORT_MENU: menu = getMenu("File>Import"); break;

        case SAVE_AS_MENU: menu = getMenu("File>Save As"); break;

        case SHORTCUTS_MENU: menu = shortcutsMenu; break;

        case ABOUT_MENU: menu = getMenu("Help>About Plugins"); break;

        case FILTERS_MENU: menu = getMenu("Process>Filters"); break;

        case TOOLS_MENU: menu = getMenu("Analyze>Tools"); break;

        case UTILITIES_MENU: menu = utilitiesMenu; break;

      }

      String prefsValue = value;

      value = value.substring(2,value.length()); //remove menu code and coma

      className = value.substring(value.lastIndexOf(',')+1,value.length());

      boolean found = className.startsWith("ij.");

      if (!found && pluginList!=null) { // does this plugin exist?

        if (pluginsList2==null)

          pluginsList2 = getStrippedPlugins(pluginList);

        for (int i=0; i<pluginsList2.length; i++) {

          if (className.startsWith(pluginsList2[i])) {

            found = true;

            break;

          }

        }

      }

      if (found && menu!=pluginsMenu) {

        addPluginItem(menu, value);

        pluginsPrefs.addElement(prefsValue);

        if (className.endsWith("\")")) { // remove any argument

          int argStart = className.lastIndexOf("(\"");

          if (argStart>0)

            className = className.substring(0, argStart);

        }

        skipList.put(className, "");

      }

    }

    if (pluginList!=null) {

      for (int i=0; i<pluginList.length; i++) {

        if (!skipList.containsKey(pluginList[i]))

          installUserPlugin(pluginList[i]);

      }

    }

    installJarPlugins();

    installMacros();

  }

 

  /** Installs macro files that are located in the plugins folder and have a "_" in their name. */

  void installMacros() {

    if (macroFiles==null)

      return;

    for (int i=0; i<macroFiles.size(); i++) {

      String name = (String)macroFiles.elementAt(i);

      installMacro(name);

    }   

  }

  /** Installs a macro in the Plugins menu, or submenu, with

    with underscores in the file name replaced by spaces. */

  void installMacro(String name) {

    Menu menu = pluginsMenu;

    String dir = null;

    int slashIndex = name.indexOf('/');

    if (slashIndex>0) {

      dir = name.substring(0, slashIndex);

      name = name.substring(slashIndex+1, name.length());

      menu = getPluginsSubmenu(dir);

      slashIndex = name.indexOf('/');

      if (slashIndex>0) {

        String dir2 = name.substring(0, slashIndex);

        name = name.substring(slashIndex+1, name.length());

        String menuName = "Plugins>"+dir+">"+dir2;

        menu = getMenu(menuName);

        dir += File.separator+dir2;

      }

    }

    String command = name.replace('_',' ');

    if (command.endsWith(".js"))

      command = command.substring(0, command.length()-3); //remove ".js"

    else

      command = command.substring(0, command.length()-4); //remove ".txt" or ".ijm"

    command.trim();

    if (pluginsTable.get(command)!=null) // duplicate command?

      command = command + " Macro";

    MenuItem item = new MenuItem(command);

    addOrdered(menu, item);

    item.addActionListener(ij);

    String path = (dir!=null?dir+File.separator:"") + name;

    pluginsTable.put(command, "ij.plugin.Macro_Runner(\""+path+"\")");

    nMacros++;

  }

  static int addPluginSeparatorIfNeeded(Menu menu) {

    if (menuSeparators == null)

      return 0;

    Integer i = (Integer)menuSeparators.get(menu);

    if (i == null) {

      if (menu.getItemCount() > 0)

        addSeparator(menu);

      i = new Integer(menu.getItemCount());

      menuSeparators.put(menu, i);

    }

    return i.intValue();

  }

  /** Inserts 'item' into 'menu' in alphanumeric order. */

  static void addOrdered(Menu menu, MenuItem item) {

    String label = item.getLabel();

    int start = addPluginSeparatorIfNeeded(menu);

    for (int i=start; i<menu.getItemCount(); i++) {

      if (label.compareTo(menu.getItem(i).getLabel())<0) {

        menu.insert(item, i);

        return;

      }

    }

    menu.add(item);

  }

 

  public static String getJarFileForMenuEntry(String menuEntry) {

    if (instance == null)

      return null;

    return (String)instance.menuEntry2jarFile.get(menuEntry);

  }

  /** Install plugins located in JAR files. */

  void installJarPlugins() {

    if (jarFiles==null)

      return;

    installingJars = true;

    for (int i=0; i<jarFiles.size(); i++) {

            isJarErrorHeading = false;

      String jar = (String)jarFiles.elementAt(i);

      InputStream is = getConfigurationFile(jar);

            if (is==null) continue;

            int maxEntries = 100;

            String[] entries = new String[maxEntries];

            int nEntries=0;

            LineNumberReader lnr = new LineNumberReader(new InputStreamReader(is));

            try {

                while(true) {

                    String s = lnr.readLine();

                    if (s==null || nEntries==maxEntries-1) break;

          if (s.length()>=3 && !s.startsWith("#"))

            entries[nEntries++] = s;

              }

            }

            catch (IOException e) {}

      finally {

        try {if (lnr!=null) lnr.close();}

        catch (IOException e) {}

      }

      for (int j=0; j<nEntries; j++)

        installJarPlugin(jar, entries[j]);

    }   

  }

   

    /** Install a plugin located in a JAR file. */

    void installJarPlugin(String jar, String s) {

    addSorted = false;

    Menu menu;

        if (s.startsWith("Plugins>")) {

      int firstComma = s.indexOf(',');

      if (firstComma==-1 || firstComma<=8)

        menu = null;

      else {

            String name = s.substring(8, firstComma);

        menu = getPluginsSubmenu(name);

      }

        } else if (s.startsWith("\"") || s.startsWith("Plugins")) {

          String name = getSubmenuName(jar);

          if (name!=null)

            menu = getPluginsSubmenu(name);

          else

        menu = pluginsMenu;

      addSorted = true;

    } else {

      int firstQuote = s.indexOf('"');

      String name = firstQuote < 0 ? s

        : s.substring(0, firstQuote).trim();

      int comma = name.indexOf(',');

      if (comma >= 0)

        name = name.substring(0, comma);

      if (name.startsWith("Help>About")) // for backward compatibility

        name = "Help>About Plugins";

      menu = getMenu(name);

    }

    int firstQuote = s.indexOf('"');

    if (firstQuote==-1)

      return;

    s = s.substring(firstQuote, s.length()); // remove menu

    if (menu!=null) {

      addPluginSeparatorIfNeeded(menu);

            addPluginItem(menu, s);

            addSorted = false;

        }

    String menuEntry = s;

    if (s.startsWith("\"")) {

      int quote = s.indexOf('"', 1);

      menuEntry = quote<0?s.substring(1):s.substring(1, quote);

    } else {

      int comma = s.indexOf(',');

      if (comma > 0)

        menuEntry = s.substring(0, comma);

    }

    if (duplicateCommand) {

      if (jarError==null) jarError = "";

            addJarErrorHeading(jar);

      String jar2 = (String)menuEntry2jarFile.get(menuEntry);

      if (jar2 != null && jar2.startsWith(pluginsPath))

        jar2 = jar2.substring(pluginsPath.length());

      jarError += "    Duplicate command: " + s

        + (jar2 != null ? " (already in " + jar2 + ")"

           : "") + "\n";

    } else

      menuEntry2jarFile.put(menuEntry, jar);

    duplicateCommand = false;

    }

   

    void addJarErrorHeading(String jar) {

        if (!isJarErrorHeading) {

                if (!jarError.equals(""))

                    jarError += " \n";

                jarError += "Plugin configuration error: " + jar + "\n";

                isJarErrorHeading = true;

            }

    }

  private static Menu getMenu(String menuName) {

    return getMenu(menuName, false);

  }

  private static Menu getMenu(String menuName, boolean readFromProps) {

    if (menuName.endsWith(">"))

      menuName = menuName.substring(0, menuName.length() - 1);

    Menu result = (Menu)menus.get(menuName);

    if (result == null) {

      int offset = menuName.lastIndexOf('>');

      if (offset < 0) {

        result = new Menu(menuName);

        if (mbar == null)

          mbar = new MenuBar();

        if (menuName.equals("Help"))

          mbar.setHelpMenu(result);

        else

          mbar.add(result);

        if (menuName.equals("Window"))

          window = result;

        else if (menuName.equals("Plugins"))

          pluginsMenu = result;

      } else {

        String parentName = menuName.substring(0, offset);

        String menuItemName = menuName.substring(offset + 1);

        Menu parentMenu = getMenu(parentName);

        result = new Menu(menuItemName);

        addPluginSeparatorIfNeeded(parentMenu);

        if (readFromProps)

          result = addSubMenu(parentMenu, menuItemName);

        else if (parentName.startsWith("Plugins") && menuSeparators != null)

          addItemSorted(parentMenu, result, parentName.equals("Plugins")?userPluginsIndex:0);

        else

          parentMenu.add(result);

        if (menuName.equals("File>Open Recent"))

          openRecentMenu = result;

      }

      menus.put(menuName, result);

    }

    return result;

  }

  Menu getPluginsSubmenu(String submenuName) {

    return getMenu("Plugins>" + submenuName);

    }

   

  String getSubmenuName(String jarPath) {

    //IJ.log("getSubmenuName: \n"+jarPath+"\n"+pluginsPath);

    if(pluginsPath == null)

      return null;

    if (jarPath.startsWith(pluginsPath))

      jarPath = jarPath.substring(pluginsPath.length() - 1);

    int index = jarPath.lastIndexOf(File.separatorChar);

    if (index<0) return null;

    String name = jarPath.substring(0, index);

    index = name.lastIndexOf(File.separatorChar);

    if (index<0) return null;

    name = name.substring(index+1);

    if (name.equals("plugins")) return null;

    return name;

    }

  static void addItemSorted(Menu menu, MenuItem item, int startingIndex) {

    String itemLabel = item.getLabel();

    int count = menu.getItemCount();

    boolean inserted = false;

    for (int i=startingIndex; i<count; i++) {

      MenuItem mi = menu.getItem(i);

      String label = mi.getLabel();

      //IJ.log(i+ "  "+itemLabel+"  "+label + "  "+(itemLabel.compareTo(label)));

      if (itemLabel.compareTo(label)<0) {

        menu.insert(item, i);

        inserted = true;

        break;

      }

    }

    if (!inserted) menu.add(item);

  }

    static void addSeparator(Menu menu) {

      menu.addSeparator();

    }

    /** Opens the configuration file ("plugins.config") from a JAR file and returns it as an InputStream. */

  InputStream getConfigurationFile(String jar) {

    try {

      ZipFile jarFile = new ZipFile(jar);

      Enumeration entries = jarFile.entries();

      while (entries.hasMoreElements()) {

        ZipEntry entry = (ZipEntry) entries.nextElement();

            if (entry.getName().endsWith("plugins.config"))

          return jarFile.getInputStream(entry);

      }

    }

      catch (Throwable e) {

        IJ.log(jar+": "+e);

      }

    return autoGenerateConfigFile(jar);

  }

 

    /** Creates a configuration file for JAR/ZIP files that do not have one. */

  InputStream autoGenerateConfigFile(String jar) {

    StringBuffer sb = null;

    try {

      ZipFile jarFile = new ZipFile(jar);

      Enumeration entries = jarFile.entries();

      while (entries.hasMoreElements()) {

        ZipEntry entry = (ZipEntry) entries.nextElement();

        String name = entry.getName();

        if (name.endsWith(".class") && name.indexOf("_")>0 && name.indexOf("$")==-1

        && name.indexOf("/_")==-1 && !name.startsWith("_")) {

          if (Character.isLowerCase(name.charAt(0))&&name.indexOf("/")!=-1)

            continue;

          if (sb==null) sb = new StringBuffer();

          String className = name.substring(0, name.length()-6);

          int slashIndex = className.lastIndexOf('/');

          String plugins = "Plugins";

          if (slashIndex >= 0) {

            plugins += ">" + className.substring(0, slashIndex).replace('/', '>').replace('_', ' ');

            name = className.substring(slashIndex + 1);

          } else

            name = className;

          name = name.replace('_', ' ');

          className = className.replace('/', '.');

          //if (className.indexOf(".")==-1 || Character.isUpperCase(className.charAt(0)))

          sb.append(plugins + ", \""+name+"\", "+className+"\n");

        }

      }

    }

      catch (Throwable e) {

        IJ.log(jar+": "+e);

      }

    //IJ.log(""+(sb!=null?sb.toString():"null"));

    if (sb==null)

      return null;

    else

        return new ByteArrayInputStream(sb.toString().getBytes());

  }

 

  /** Returns a list of the plugins with directory names removed. */

  String[] getStrippedPlugins(String[] plugins) {

    String[] plugins2 = new String[plugins.length];

    int slashPos;

    for (int i=0; i<plugins2.length; i++) {

      plugins2[i] = plugins[i];

      slashPos = plugins2[i].lastIndexOf('/');

      if (slashPos>=0)

        plugins2[i] = plugins[i].substring(slashPos+1,plugins2[i].length());

    }

    return plugins2;

  }

 

  void setupPluginsAndMacrosPaths() {

    pluginsPath = macrosPath = null;

    String homeDir = Prefs.getHomeDir();

    if (homeDir==null) return;

    if (homeDir.endsWith("plugins"))

      pluginsPath = homeDir+Prefs.separator;

    else {

      String property = System.getProperty("plugins.dir");

      if (property!=null && (property.endsWith("/")||property.endsWith("\\")))

        property = property.substring(0, property.length()-1);

      String pluginsDir = property;

      if (pluginsDir==null)

        pluginsDir = homeDir;

      else if (pluginsDir.equals("user.home")) {

        pluginsDir = System.getProperty("user.home");

        if (!(new File(pluginsDir+Prefs.separator+"plugins")).isDirectory())

          pluginsDir = pluginsDir + Prefs.separator + "ImageJ";

        property = null;

        // needed to run plugins when ImageJ launched using Java WebStart

        if (applet==null) System.setSecurityManager(null);

        jnlp = true;

      }

      pluginsPath = pluginsDir+Prefs.separator+"plugins"+Prefs.separator;

      if (property!=null&&!(new File(pluginsPath)).isDirectory())

        pluginsPath = pluginsDir + Prefs.separator;

      macrosPath = pluginsDir+Prefs.separator+"macros"+Prefs.separator;

    }

    File f = macrosPath!=null?new File(macrosPath):null;

    if (f!=null && !f.isDirectory())

      macrosPath = null;

    f = pluginsPath!=null?new File(pluginsPath):null;

    if (f==null || (f!=null && !f.isDirectory())) {

      pluginsPath = null;

      return;

    }

  }

   

  /** Returns a list of the plugins in the plugins menu. */

  public static synchronized String[] getPlugins() {

    File f = pluginsPath!=null?new File(pluginsPath):null;

    if (f==null || (f!=null && !f.isDirectory()))

      return null;

    String[] list = f.list();

    if (list==null)

      return null;

    Vector v = new Vector();

    jarFiles = null;

    macroFiles = null;

    for (int i=0; i<list.length; i++) {

      String name = list[i];

      boolean isClassFile = name.endsWith(".class");

      boolean hasUnderscore = name.indexOf('_')>=0;

      if (hasUnderscore && isClassFile && name.indexOf('$')<0 ) {

        name = name.substring(0, name.length()-6); // remove ".class"

        v.addElement(name);

      } else if (hasUnderscore && (name.endsWith(".jar") || name.endsWith(".zip"))) {

        if (jarFiles==null) jarFiles = new Vector();

        jarFiles.addElement(pluginsPath + name);

      } else if ((hasUnderscore&&name.endsWith(".txt")) || name.endsWith(".ijm") || name.endsWith(".js")) {

        if (macroFiles==null) macroFiles = new Vector();

        macroFiles.addElement(name);

      } else {

        if (!isClassFile)

          checkSubdirectory(pluginsPath, name, v);

      }

    }

    list = new String[v.size()];

    v.copyInto((String[])list);

    StringSorter.sort(list);

    return list;

  }

 

  /** Looks for plugins and jar files in a subdirectory of the plugins directory. */

  private static void checkSubdirectory(String path, String dir, Vector v) {

    if (dir.endsWith(".java"))

      return;

    File f = new File(path, dir);

    if (!f.isDirectory())

      return;

    String[] list = f.list();

    if (list==null)

      return;

    dir += "/";

    int classCount=0, otherCount=0;

    String className = null;

    for (int i=0; i<list.length; i++) {

      String name = list[i];

      boolean hasUnderscore = name.indexOf('_')>=0;

      if (hasUnderscore && name.endsWith(".class") && name.indexOf('$')<0) {

        name = name.substring(0, name.length()-6); // remove ".class"

        v.addElement(dir+name);

        classCount++;

        className = name;

        //IJ.write("File: "+f+"/"+name);