source: trunk/gli/src/org/greenstone/gatherer/cdm/PlugInManager.java@ 5926

/**
 *#########################################################################
 *
 * A component of the Gatherer application, part of the Greenstone digital
 * library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */
package org.greenstone.gatherer.cdm;

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.plaf.basic.*;
import org.apache.xerces.parsers.*;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.cdm.Argument;
import org.greenstone.gatherer.cdm.ArgumentConfiguration;
import org.greenstone.gatherer.cdm.CollectionDesignManager;
import org.greenstone.gatherer.cdm.CommandTokenizer;
import org.greenstone.gatherer.cdm.Control;
import org.greenstone.gatherer.cdm.PlugIn;
import org.greenstone.gatherer.gui.DoubleImageButton;
import org.greenstone.gatherer.gui.GComboBox;
import org.greenstone.gatherer.msm.MSMUtils;
import org.greenstone.gatherer.util.StaticStrings;
import org.greenstone.gatherer.util.Utility;
import org.w3c.dom.*;
import org.xml.sax.*;
/** This class is for maintaining a list of known plug-ins, and importing new plugins using the parser. */
public class PlugInManager
    extends DOMProxyListModel {
    /** The library 'reserve' of base plugins. */
    private ArrayList library = null;
    /** The controls for editing the contents of this manager. */
    private Control controls = null;
    private DOMProxyListModel model;
    private JPanel separator;
    private PlugIn separator_plugin;
    /** The default size for a label. */
    static final private Dimension LABEL_SIZE = new Dimension(125, 25);
    /** Constructor.
     */
    public PlugInManager() {
    super(CollectionDesignManager.collect_config.getDocumentElement(), CollectionConfiguration.PLUGIN_ELEMENT, new PlugIn());
    Gatherer.println("PlugInManager: " + getSize() + " plugins parsed.");
    model = this;
    // Reload/Create the library
    loadPlugIns();
    savePlugIns();
    // Create the separator, cause we can reuse it.
    separator = getSeparator();
    }

    /** Method to add a new plugin to the library
     * @param plugin the new base PlugIn
     */
    public void addPlugIn(PlugIn plugin) {
    if(!library.contains(plugin)) {
        library.add(plugin);
    }
    }

    /** Method to assign a plugin
     * @param plugin the PlugIn to assign
     */
    public void assignPlugIn(PlugIn plugin) {
    if(plugin.getName().equals(StaticStrings.RECPLUG_STR) || plugin.getName().equals(StaticStrings.ARCPLUG_STR)) {
        addAfter(plugin, separator_plugin); // Adds after separator
    }
    else {
        addBefore(plugin, separator_plugin);
    }
    Gatherer.c_man.configurationChanged();
    }

    /** Destructor. */
    public void destroy() {
    if(controls != null) {
        controls.destroy();
        controls = null;
    }
    library.clear();
    library = null;
    }

    /** Method to retrieve the control for this manager.
     * @return the Control
     */
    public Control getControls() {
    if(controls == null) {
        // Build controls
        controls = new PlugInControl();
    }
    return controls;
    }

    /** Retrieve the base pluging of the given name, or null if no such plugin.
     * @param name the name of the base plugin to retrieve as a String
     * @return the PlugIn requested or null if no such plugin
     */
    public PlugIn getBasePlugIn(String name) {
    int library_size = library.size();
    for(int i = 0; i < library_size; i++) {
        PlugIn plugin = (PlugIn) library.get(i);
        if(plugin.getName().equals(name)) {
        return plugin;
        }
    }
    // No success.
    return null;
    }

    /** Method to move a plugin in the list order.
     * @param plugin the PlugIn you want to move.
     * @param direction true to move the plugin up, false to move it down.
     * @param all true to move to move all the way, false for a single step.
     */
    public void movePlugIn(PlugIn plugin, boolean direction, boolean all) {
    // Can't ever move RecPlug or ArcPlug.
    if(getSize() < 3) {
        //Gatherer.println("Not enough plugins to allow moving.");
        return;
    }
    if(plugin.getName().equals(StaticStrings.ARCPLUG_STR) || plugin.getName().equals(StaticStrings.RECPLUG_STR)) {
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.Move.Fixed"), Dictionary.get("CDM.Move.Title"), JOptionPane.ERROR_MESSAGE);
        return;
    }
    if(all) {
        // Move to top
        if(direction) {
        // Remove the moving plugin
        remove(plugin);
        // Retrieve the first plugin
        PlugIn first_plugin = (PlugIn) getElementAt(0);
        // Add the moving plugin before the first plugin
        addBefore(plugin, first_plugin);
        first_plugin = null;
        Gatherer.c_man.configurationChanged();
        }
        else {
        // Remove the moving plugin
        remove(plugin);
        // Locate the plugin immediately before the separator. We have to ensure the separator index is up to date, given we've just removed a plugin.
        int separator_index = -1;
        if((separator_index = findSeparatorIndex()) != -1) {
            PlugIn separator_plugin = (PlugIn) getElementAt(separator_index);
            // Add the moving plugin before the separator
            addBefore(plugin, separator_plugin);
            Gatherer.c_man.configurationChanged();
        }
        // Otherwise we aren't moving anywhere!
        }
    }
    else {
        // Try to move the plugin one step in the desired direction.
        int index = indexOf(plugin);
        ///ystem.err.println("Index of " + plugin + " = " + index);
        if(direction) {
        index--;
        if(index < 0) {
            String args[] = new String[2];
            args[0] = Dictionary.get("CDM.PlugInManager.PlugIn_Str");
            args[1] = plugin.getName();
            JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.Move.At_Top", args), Dictionary.get("CDM.Move.Title"), JOptionPane.ERROR_MESSAGE);
            return;
        }
        remove(plugin);
        add(index, plugin);
        Gatherer.c_man.configurationChanged();
        }
        else {
        index++;
        PlugIn next_plugin = (PlugIn) getElementAt(index);
        if(next_plugin.isSeparator()) {
            String args[] = new String[1];
            args[0] = plugin.getName();
            JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.Move.Cannot", args), Dictionary.get("CDM.Move.Title"), JOptionPane.ERROR_MESSAGE);
            // Still not going to move RecPlug or ArcPlug.
            return;
        }
        remove(plugin);
        add(index, plugin);
        Gatherer.c_man.configurationChanged();
        }
    }
    }

    /** We attempt to place the separator between the unfixed and the fixed plugins. Since we only know of two fixed plugins, we search for either of them, and place the separator before them.
     */
    public void placeSeparator() {
    ///ystem.err.println("Placing separator.");
    int separator_index = getSize();
    if(separator_index > 0) {
        boolean found_fixed = false;
        int index = separator_index - 1;
        while(index > 0) {
        PlugIn plugin = (PlugIn) getElementAt(index);
        String name = plugin.getName();
        if(name.equals(StaticStrings.RECPLUG_STR) || name.equals(StaticStrings.ARCPLUG_STR)) {
            found_fixed = true;
            index--;
        }
        else {
            if(found_fixed) {
            separator_index = index + 1;
            index = -1;
            }
            else {
            index--;
            }
        }
        name = null;
        plugin = null;
        }
    }
    Element element = CollectionDesignManager.collect_config.document.createElement(CollectionConfiguration.PLUGIN_ELEMENT);
    element.setAttribute(CollectionConfiguration.TYPE_ATTRIBUTE, CollectionConfiguration.SEPARATOR_ATTRIBUTE);
    element.setAttribute(CollectionConfiguration.SEPARATOR_ATTRIBUTE, CollectionConfiguration.TRUE_STR);
    separator_plugin = new PlugIn(element, null);
    ///atherer.println("Adding plugin separator at: " + separator_index);
    add(separator_index, separator_plugin);
    }

    /** This method removes an assigned plugin. I was tempted to call it unassign, but remove is more consistant. Note that there is no way to remove a plugin from the library.
     * @param plugin The <strong>PlugIn</strong> to remove.
     */
    public void removePlugIn(PlugIn plugin) {
    remove(plugin);
    Gatherer.c_man.configurationChanged();
    }

    /** Method to cache the current contents of library (known plugins) to file.
     */
    public void savePlugIns() {
    try {
        FileOutputStream file = new FileOutputStream(Utility.BASE_DIR + "plugins.dat");
        ObjectOutputStream out = new ObjectOutputStream(file);
        out.writeObject(library);
        out.close();
    }
    catch (Exception error) {
        Gatherer.printStackTrace(error);
    }
    }

    /** Determine the current separator index. */
    private int findSeparatorIndex() {
    int separator_index = getSize() - 1;
    while(separator_index >= 0) {
        PlugIn search = (PlugIn) getElementAt(separator_index);
        if(search.isSeparator()) {
        return separator_index;
        }
        separator_index--;
    }
    return separator_index;
    }


    /** Retrieve a list of those plugins that are in library but not in the assigned plugins. */
    private Object[] getAvailable() {
    ArrayList available = new ArrayList();
    int library_size = library.size();
    for(int i = 0; i < library_size; i++) {
        PlugIn plugin = (PlugIn) library.get(i);
        if(!plugin.isAbstract()) {
        available.add(plugin);
        }
        plugin = null;
    }
    // Now go through the assigned plugins, and remove any that match.
    available.removeAll(children());
    //Gatherer.println("There are a total of " + library.size() + " plugins in the library.");
    //Gatherer.println("However " + children().size() + " are in use,");
    //Gatherer.println("So only " + available.size() + " remain.");
    Collections.sort(available);
    return available.toArray();
    }

    /** Method to extract just the plugins name from a file object.
     * @param plugin The <strong>File</strong> which references a certain plugin.
     * @return A <strong>String</strong> containing just the plugins name, without extension.
     */
    private String getPlugInName(File plugin) {
    String name = plugin.getName();
    if(name.indexOf(".") != -1) {
        name = name.substring(0, name.indexOf("."));
    }
    return name;
    }

    /** Method to load the details of a single plug-in.
     * @param plugin The plugin <strong>File</strong> you wish to load.
     */
    private void loadPlugIn(File plugin) {
    Document document = null;
    // Run pluginfo on this plugin, and then send the results for parsing.
    try {
        String args[] = null;
        if(Utility.isWindows()) {
        args = new String[4];
        if(Gatherer.config.perl_path != null) {
            args[0] = Gatherer.config.perl_path;
        }
        else {
            args[0] = "Perl.exe";
        }
        args[1] = Gatherer.config.gsdl_path + "bin" + File.separator + "script" + File.separator + "pluginfo.pl";
        args[2] = "-xml";
        args[3] = getPlugInName(plugin);
        }
        else {
        args = new String[3];
        args[0] = "pluginfo.pl";
        args[1] = "-xml";
        args[2] = getPlugInName(plugin);
        }
        // Create the process.
        Runtime runtime = Runtime.getRuntime();
        Process process = runtime.exec(args);
        //InputStream input_stream = process.getErrorStream();
        BufferedReader error_in = new BufferedReader(new InputStreamReader(process.getErrorStream()));
        String line = "";
        StringBuffer xml = new StringBuffer("");
        boolean xml_content = false;
        while((line = error_in.readLine()) != null) {
        if(xml_content) {
            xml.append(line);
            xml.append("\n");
        }
        else if(line.trim().startsWith("<?xml")) {
            xml_content = true;
            xml.append(line);
            xml.append("\n");
        }
        }
        error_in = null;
        process = null;
        runtime = null;
        args = null;
        // If something has gone horribly wrong then xml will be empty.
        if(xml.length() != 0) {
        // Then read the xml from the piped input stream.
        InputSource source = new InputSource(new StringReader(xml.toString()));
        DOMParser parser = new DOMParser();
        parser.parse(source);
        document = parser.getDocument();
        parser = null;
        source = null;
        }
        else {
        String plugin_name = getPlugInName(plugin);
        //Gatherer.println("Zero length argument xml detected for: " + plugin_name);
        String[] margs = new String[1];
        margs[0] = plugin_name;
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.PlugInManager.PlugIn_XML_Parse_Failed", margs), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
        }
    }
    catch (Exception error) {
        System.err.println("Failed when trying to parse: " + plugin.getName());
        error.printStackTrace();
    }
    if(document != null) {
        parseXML(document.getDocumentElement());
    }
    }

    /** Method to initially load information from the standard plug-ins within the gsdl Perl library.
     */
    private void loadPlugIns() {
    // Attempt to restore the cached file.
    try {
        FileInputStream file = new FileInputStream(Utility.BASE_DIR + "plugins.dat");
        ObjectInputStream input = new ObjectInputStream(file);
        library = (ArrayList) input.readObject();
    }
    catch (Exception error) {
    }
    if(library == null) {
        library = new ArrayList();
        // Retrieve the gsdl home directory...
        String directory = Gatherer.config.gsdl_path;
        directory = directory + "perllib" + File.separator + "plugins" + File.separator;
        loadPlugIns(new File(directory));
    }
    }
    /** Method to load plug-in information from a specified directory. Of course no plug-ins may be found at this location.
     * @param directory A <strong>File</strong> indicating the directory to be scanned for plug-ins.
     */
    private void loadPlugIns(File directory) {
    File files[] = directory.listFiles();
    if(files != null) {
        // Create a progress indicator.
        ParsingProgress progress = new ParsingProgress(Dictionary.get("CDM.PlugInManager.Parsing.Title"), Dictionary.get("CDM.PlugInManager.Parsing.Message"), files.length);
        for(int i = 0; i < files.length; i++) {
        // We only want to check Perl Modules.
        if(files[i].getName().endsWith(".pm")) {
            loadPlugIn(files[i]);
        }
        progress.inc();
        }
        progress.dispose();
    }
    }

    private PlugIn parseXML(Node root) {
    PlugIn plugin = new PlugIn();
    String node_name = null;
    for(Node node = root.getFirstChild(); node != null;
        node = node.getNextSibling()) {
        node_name = node.getNodeName();
        if(node_name.equalsIgnoreCase("Name")) {
        String name = MSMUtils.getValue(node);
        // We can save ourselves some processing time if a plugin with this name already exists in our manager. If so retrieve it and return it.
        PlugIn existing = getBasePlugIn(name);
        if(existing != null) {
            return existing;
        }
        plugin.setName(name);
        }
        else if(node_name.equalsIgnoreCase("Desc")) {
        plugin.setDescription(MSMUtils.getValue(node));
        }
        else if(node_name.equalsIgnoreCase(CollectionConfiguration.ABSTRACT_ELEMENT)) {
            System.err.println("Is " + plugin.getName() + " abstract? " + MSMUtils.getValue(node).equalsIgnoreCase(CollectionConfiguration.YES_STR));
        plugin.setIsAbstract(MSMUtils.getValue(node).equalsIgnoreCase(CollectionConfiguration.YES_STR));
        }
        // Parse the multitude of arguments.
        else if(node_name.equalsIgnoreCase("Arguments")) {
        for(Node arg = node.getFirstChild(); arg != null; arg = arg.getNextSibling()) {
            node_name = arg.getNodeName();
            // An option.
            if(node_name.equalsIgnoreCase("Option")) {
            Argument argument = new Argument();
            // If its an option we parse the multitude of details an options might have.
            for(Node det = arg.getFirstChild(); det != null; det = det.getNextSibling()) {
                node_name = det.getNodeName();
                if(node_name.equalsIgnoreCase("Name")) {
                argument.setName(MSMUtils.getValue(det));
                }
                else if(node_name.equalsIgnoreCase("Desc")) {
                argument.setDescription(MSMUtils.getValue(det));
                }
                else if(node_name.equalsIgnoreCase("Type")) {
                argument.setType(MSMUtils.getValue(det));
                }
                else if(node_name.equalsIgnoreCase("Default")) {
                argument.setDefaultValue(MSMUtils.getValue(det));
                }
                else if(node_name.equalsIgnoreCase("List")) {
                // Two final loops are required to parse lists.
                for(Node value = det.getFirstChild(); value != null; value = value.getNextSibling()) {
                    if(value.getNodeName().equalsIgnoreCase("Value")) {
                    String key = null;
                    String desc = "";
                    for(Node subvalue = value.getFirstChild(); subvalue != null; subvalue = subvalue.getNextSibling()) {
                        node_name = subvalue.getNodeName();
                        if(node_name.equalsIgnoreCase("Name")) {
                        key = MSMUtils.getValue(subvalue);
                        }
                        else if(node_name.equalsIgnoreCase("Desc")) {
                        desc = MSMUtils.getValue(subvalue);
                        }
                    }
                    if(key != null) {
                        argument.addOption(key, desc);
                    }
                    }
                }
                }
                else if(node_name.equalsIgnoreCase("Required")) {
                String v = MSMUtils.getValue(det);
                if(v != null && v.equalsIgnoreCase("yes")) {
                    argument.setRequired(true);
                }
                }
            }
            plugin.addArgument(argument);
            }
            // A super plugin class.
            else if(node_name.equalsIgnoreCase("PlugInfo")) {
            PlugIn super_plugin = parseXML(arg);
            plugin.setSuper(super_plugin);
            }
        }
        }
    }
    if(plugin.getName() != null) {
        addPlugIn(plugin);
        return plugin;
    }
    return null;
    }

    /** A class which provodes controls for assigned and editing plugins. */
    private class PlugInControl
    extends JPanel
    implements Control {
    /** Button for adding plugins. */
    private JButton add = null;
    /** Button for configuring the selected plugin. */
    private JButton configure = null;
    /** Buttom to move an assinged plugin as low in the order as possible. */
    private JButton move_bottom_button = null;
    /** Button to move an assigned plugin one position lower in the order. */
    private JButton move_down_button = null;
    /** Button to move an assigned plugin as high in the order as possible. */
    private JButton move_top_button = null;
    /** Button to move an assigned plugin one position higher in the order. */
    private JButton move_up_button = null;
    /** Button to remove the selected plugin. */
    private JButton remove = null;
    /** A combobox containing all of the known plugins, including those that may have already been assigned. */
    private GComboBox plugin = null;
    /** The label next to the plugin combobox. */
    private JLabel plugin_label = null;
    /** The label above the assigned plugin list. */
    private JLabel plugin_list_label = null;
    /** The title of this view. */
    private JLabel title = null;
    /** A list of assigned plugins. */
    private JList plugin_list = null;
    /** The area where the add, configure and remove buttons are placed. */
    private JPanel button_pane = null;
    /** The region which divides the central portion of the view into list and controls */
    private JPanel central_pane = null;
    /** The area where title label and instructions sit. */
    private JPanel header_pane = null;
    /** The area where movement buttons are placed. */
    private JPanel movement_pane = null;
    /** The small region containing the plugin combobox and its label. */
    private JPanel plugin_pane = null;
    /** The pane containing the assigned plugin list and its label. */
    private JPanel plugin_list_pane = null;
    /** The text area containing instructions on the use of this control. */
    private JTextArea instructions = null;

    /** Constructor.
     */
    public PlugInControl() {
        // Create
        add = new JButton();
        add.setMnemonic(KeyEvent.VK_A);
        Dictionary.registerBoth(add, "CDM.PlugInManager.Add", "CDM.PlugInManager.Add_Tooltip");

        button_pane = new JPanel();
        central_pane = new JPanel();

        configure = new JButton();
        configure.setEnabled(false);
        configure.setMnemonic(KeyEvent.VK_C);
        Dictionary.registerBoth(configure, "CDM.PlugInManager.Configure", "CDM.PlugInManager.Configure_Tooltip");

        header_pane = new JPanel();

        instructions = new JTextArea();
        instructions.setBackground(Gatherer.config.getColor("coloring.collection_tree_background", false));
        instructions.setEditable(false);
        instructions.setLineWrap(true);
        instructions.setRows(6);
        instructions.setWrapStyleWord(true);
        Dictionary.registerText(instructions, "CDM.PlugInManager.Instructions");

        move_top_button = new DoubleImageButton("", Utility.getImage("arrow-top.gif"), Utility.getImage("arrow-top-disabled.gif"));
        move_top_button.setEnabled(false);
        move_top_button.setMnemonic(KeyEvent.VK_T);
        // move_top_button.setDisplayedMnemonicIndex(8);  // !! English-centric hack
        move_top_button.setPreferredSize(Utility.DOUBLE_IMAGE_BUTTON_SIZE);
        Dictionary.registerBoth(move_top_button, "CDM.Move.Move_Top", "CDM.Move.Move_Top_Tooltip");

        move_up_button = new DoubleImageButton("", Utility.getImage("arrow-up.gif"), Utility.getImage("arrow-up-disabled.gif"));
        move_up_button.setEnabled(false);
        move_up_button.setMnemonic(KeyEvent.VK_U);
        move_up_button.setPreferredSize(Utility.DOUBLE_IMAGE_BUTTON_SIZE);
        Dictionary.registerBoth(move_up_button, "CDM.Move.Move_Up", "CDM.Move.Move_Up_Tooltip");

        move_down_button = new DoubleImageButton("", Utility.getImage("arrow-down.gif"), Utility.getImage("arrow-down-disabled.gif"));
        move_down_button.setEnabled(false);
        move_down_button.setMnemonic(KeyEvent.VK_D);
        move_down_button.setPreferredSize(Utility.DOUBLE_IMAGE_BUTTON_SIZE);
        Dictionary.registerBoth(move_down_button, "CDM.Move.Move_Down", "CDM.Move.Move_Down_Tooltip");

        move_bottom_button = new DoubleImageButton("", Utility.getImage("arrow-bottom.gif"), Utility.getImage("arrow-bottom-disabled.gif"));
        move_bottom_button.setEnabled(false);
        move_bottom_button.setMnemonic(KeyEvent.VK_B);
        move_bottom_button.setPreferredSize(Utility.DOUBLE_IMAGE_BUTTON_SIZE);
        Dictionary.registerBoth(move_bottom_button, "CDM.Move.Move_Bottom", "CDM.Move.Move_Bottom_Tooltip");

        movement_pane = new JPanel();

        PlugInComboboxListener picl = new PlugInComboboxListener();
        plugin = new GComboBox(getAvailable());
        plugin.setBackgroundNonSelectionColor(Gatherer.config.getColor("coloring.editable_background", false));
        plugin.setBackgroundSelectionColor(Gatherer.config.getColor("coloring.collection_selection_background", false));
        plugin.setEditable(true);
        plugin.setTextNonSelectionColor(Gatherer.config.getColor("coloring.workspace_tree_foreground", false));
        plugin.setTextSelectionColor(Gatherer.config.getColor("coloring.collection_selection_foreground", false));
        picl.itemStateChanged(new ItemEvent(plugin, 0, null, ItemEvent.SELECTED));

        plugin_label = new JLabel();
        Dictionary.registerText(plugin_label, "CDM.PlugInManager.PlugIn");

        plugin_list = new JList(model);
        plugin_list.setCellRenderer(new ListRenderer());
        plugin_list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        plugin_list_label = new JLabel();
        plugin_list_label.setHorizontalAlignment(JLabel.CENTER);
        plugin_list_label.setOpaque(true);
        Dictionary.registerText(plugin_list_label, "CDM.PlugInManager.Assigned");

        plugin_list_pane = new JPanel();
        plugin_pane = new JPanel();

        remove = new JButton();
        remove.setEnabled(false);
        remove.setMnemonic(KeyEvent.VK_R);
        Dictionary.registerBoth(remove, "CDM.PlugInManager.Remove", "CDM.PlugInManager.Remove_Tooltip");

        title = new JLabel();
        title.setHorizontalAlignment(JLabel.CENTER);
        title.setOpaque(true);
        Dictionary.registerText(title, "CDM.PlugInManager.Title");

        // Listeners
        add.addActionListener(new AddListener());
        configure.addActionListener(new ConfigureListener());
        MoveListener ml = new MoveListener();
        move_bottom_button.addActionListener(ml);
        move_down_button.addActionListener(ml);
        move_top_button.addActionListener(ml);
        move_up_button.addActionListener(ml);
        plugin.addItemListener(picl);
        remove.addActionListener(new RemoveListener());
        plugin_list.addMouseListener(new ClickListener());
        plugin_list.addListSelectionListener(new ListListener());
        picl = null;

        // Layout
        title.setBorder(BorderFactory.createEmptyBorder(0,0,2,0));

        instructions.setBorder(BorderFactory.createEmptyBorder(2,5,2,5));

        header_pane.setLayout(new BorderLayout());
        header_pane.add(title, BorderLayout.NORTH);
        header_pane.add(new JScrollPane(instructions), BorderLayout.CENTER);

        plugin_list_label.setBorder(BorderFactory.createEmptyBorder(0,2,0,2));

        movement_pane.setBorder(BorderFactory.createEmptyBorder(0,2,0,0));
        movement_pane.setLayout(new GridLayout(4,1));
        movement_pane.add(move_top_button);
        movement_pane.add(move_up_button);
        movement_pane.add(move_down_button);
        movement_pane.add(move_bottom_button);

        plugin_list_pane.setLayout(new BorderLayout());
        plugin_list_pane.add(plugin_list_label, BorderLayout.NORTH);
        plugin_list_pane.add(new JScrollPane(plugin_list), BorderLayout.CENTER);
        plugin_list_pane.add(movement_pane, BorderLayout.EAST);

        plugin_label.setBorder(BorderFactory.createEmptyBorder(0,0,5,0));

        plugin_pane.setBorder(BorderFactory.createEmptyBorder(5,0,5,0));
        plugin_pane.setLayout(new GridLayout(1,2));
        plugin_pane.add(plugin_label);
        plugin_pane.add(plugin);

        button_pane.setLayout(new GridLayout(1,3));
        button_pane.add(add);
        button_pane.add(configure);
        button_pane.add(remove);

        // Scope these mad bordering skillz.
        // !! TO DO: Dictionary registration !!
        JPanel temp = new JPanel(new BorderLayout());
        temp.setBorder
        (BorderFactory.createCompoundBorder
         (BorderFactory.createEmptyBorder(5,0,5,0),
          BorderFactory.createCompoundBorder
          (BorderFactory.createTitledBorder(Dictionary.get("CDM.PlugInManager.Controls")),
           BorderFactory.createEmptyBorder(2,2,2,2))));

        temp.add(plugin_pane, BorderLayout.NORTH);
        temp.add(button_pane, BorderLayout.SOUTH);

        central_pane.setLayout(new BorderLayout());
        central_pane.add(plugin_list_pane, BorderLayout.CENTER);
        central_pane.add(temp, BorderLayout.SOUTH);

        setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
        setLayout(new BorderLayout());
        add(header_pane, BorderLayout.NORTH);
        add(central_pane, BorderLayout.CENTER);
    }

    /** Method which acts like a destructor, tidying up references to persistant objects.
     */
    public void destroy() {
    }

    /** This method is overridden to ensure the instructions are scrolled to top, before the super classes updateUI() is called.
     */
    public void gainFocus() {
        if(instructions != null) {
        instructions.setCaretPosition(0);
        }
        super.updateUI();
    }

    public void loseFocus() {
    }

    /** This class listens for actions upon the add button in the controls, and if detected calls the <i>assignPlugIn()</i> method. */
    private class AddListener
        implements ActionListener {
        /** Any implementation of <i>ActionListener</i> must include this method so that we can be informed when an action has occured on one of our target controls.
         * @param event An <strong>ActionEvent</strong> containing information garnered from the control action.
         */
        public void actionPerformed(ActionEvent event) {
        Object selected_object = plugin.getSelectedItem();
        if(selected_object != null) {
            // Retrieve the base plugin if any
            PlugIn base_plugin = getBasePlugIn(selected_object.toString());

            // Create a new element in the DOM
            Element element = CollectionDesignManager.collect_config.document.createElement(CollectionConfiguration.PLUGIN_ELEMENT);
            // Remember that the plugin supplied might be a custom string rather than a base plugin
            PlugIn new_plugin = null;
            if(base_plugin != null) {
            //Gatherer.println("New PlugIn based on existing PlugIn");
            element.setAttribute(CollectionConfiguration.TYPE_ATTRIBUTE, base_plugin.getName());
            new_plugin = new PlugIn(element, base_plugin);
            }
            else {
            //Gatherer.println("New Custom PlugIn");
            element.setAttribute(CollectionConfiguration.TYPE_ATTRIBUTE, selected_object.toString());
            new_plugin = new PlugIn(element, null);
            }
            if(!model.contains(new_plugin) || new_plugin.getName().equals(StaticStrings.UNKNOWNPLUG_STR)) {
            // Automatically chain to configuration. This ensures required arguments are filled out.
            ArgumentConfiguration ac = new ArgumentConfiguration(new_plugin);
            if(ac.display()) {
                assignPlugIn(new_plugin);
                plugin_list.setSelectedValue(new_plugin, true);
                // Since we weren't cancelled, and if there was a base plugin, ensure it no longer is shown as available, unless it is the UnknownPlugIn which can be added several times
                if(base_plugin != null && !base_plugin.getName().equals(StaticStrings.UNKNOWNPLUG_STR)) {
                plugin.removeItem(base_plugin);
                }
            }
            ac = null;
            new_plugin = null;
            plugin.setSelectedIndex(0);
            }
            else {
            JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.PlugInManager.PlugIn_Exists"), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
            }
            base_plugin = null;
        }
        }
    }

    /** Listens for double clicks apon the list and react as if the configure button was pushed. */
    private class ClickListener
        extends MouseAdapter {
        /** Called whenever the mouse is clicked over a registered component, we use this to chain through to the configure prompt.
         * @param event A <strong>MouseEvent</strong> containing information about the mouse click.
        */
        public void mouseClicked(MouseEvent event) {
        if(event.getClickCount() == 2 ) {
            if(!plugin_list.isSelectionEmpty()) {
            PlugIn plugin = (PlugIn) plugin_list.getSelectedValue();
            if(!plugin.isSeparator()) {
                ArgumentConfiguration ac = new ArgumentConfiguration(plugin);
                if(ac.display()) {
                refresh(plugin);
                }
                ac.destroy();
                ac = null;
            }
            }
        }
        }
    }

    /** This class listens for actions upon the configure button in the controls, and if detected creates a new <strong>ArgumentConfiguration</strong> dialog box to allow for configuration.
     * @see org.greenstone.gatherer.cdm.ArgumentConfiguration
     */
    private class ConfigureListener
        implements ActionListener {
        /** Any implementation of <i>ActionListener</i> must include this method so that we can be informed when an action has occured on one of our target controls.
         * @param event An <strong>ActionEvent</strong> containing information garnered from the control action.
         */
        public void actionPerformed(ActionEvent event) {
        if(!plugin_list.isSelectionEmpty()) {
            PlugIn plugin = (PlugIn) plugin_list.getSelectedValue();
            if(!plugin.isSeparator()) {
            ArgumentConfiguration ac = new ArgumentConfiguration(plugin);
            if(ac.display()) {
                refresh(plugin);
            }
            ac.destroy();
            ac = null;
            }
        }
        }
    }

    /** listens for changes in the list selection and enables the configure and remove buttons if there is a selection, disables them if there is no selection */
    private class ListListener
        implements ListSelectionListener {

        public void valueChanged(ListSelectionEvent e) {
        if (!e.getValueIsAdjusting()) { // we get two events for one change in list selection - use the false one (the second one)
            if (plugin_list.isSelectionEmpty()) {
            move_top_button.setEnabled(false);
            move_up_button.setEnabled(false);
            move_down_button.setEnabled(false);
            move_bottom_button.setEnabled(false);
            configure.setEnabled(false);
            remove.setEnabled(false);
            }
            else {
               configure.setEnabled(true);
               // Some buttons are only available for plugins other than ArcPlug and RecPlug
               PlugIn selected_plugin = (PlugIn) plugin_list.getSelectedValue();
               String plugin_name = selected_plugin.getName();
               if(plugin_name.equals(StaticStrings.ARCPLUG_STR) || plugin_name.equals(StaticStrings.RECPLUG_STR)) {
               move_top_button.setEnabled(false);
               move_up_button.setEnabled(false);
               move_down_button.setEnabled(false);
               move_bottom_button.setEnabled(false);
               remove.setEnabled(false);
               }
               else {
              // Move ups are only enabled if the selected plugin isn't already at the top
              PlugIn first_plugin = (PlugIn) getElementAt(0);
              if(!first_plugin.equals(selected_plugin)) {
                 move_top_button.setEnabled(true);
                 move_up_button.setEnabled(true);
              }
              else {
                 move_top_button.setEnabled(false);
                 move_up_button.setEnabled(false);
              }
              // And move downs are only allowed when the selected plugin isn't at an index one less than the separator line.
              int separator_index = findSeparatorIndex();
              int selected_index = plugin_list.getSelectedIndex();
              if(selected_index != separator_index - 1) {
                 move_down_button.setEnabled(true);
                 move_bottom_button.setEnabled(true);
              }
              else {
                 move_down_button.setEnabled(false);
                 move_bottom_button.setEnabled(false);
              }
              remove.setEnabled(true);
               }
               selected_plugin = null;
               plugin_name = null;
            }
        }
        }
    }

    /** A special list renderer which is able to render separating lines as well. */
    private class ListRenderer
        extends DefaultListCellRenderer {
        /** Return a component that has been configured to display the specified value. That component's paint method is then called to "render" the cell. If it is necessary to compute the dimensions of a list because the list cells do not have a fixed size, this method is called to generate a component on which getPreferredSize  can be invoked.
         * @param list - The <strong>JList</strong> we're painting.
         * @param value - The value returned by list.getModel().getElementAt(index) as an <strong>Object</strong>.
         * @param index - The cells index as an <i>int</i>.
         * @param isSelected - <i>true</i> if the specified cell was selected.
         * @param cellHasFocus - <i>true</i> if the specified cell has the focus.
         * @return A <strong>Component</strong> whose paint() method will render the specified value.
         * @see javax.swing.JList
         * @see javax.swing.JSeparator
         * @see javax.swing.ListModel
         * @see javax.swing.ListSelectionModel
         */
        public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
        PlugIn plugin = (PlugIn) value;
        if(plugin.isSeparator()) {
            return separator;
        }
        else {
            return super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
        }
        }
    }


    /** Listens for actions apon the move buttons in the manager controls, and if detected calls the <i>movePlugIn()</i> method of the manager with the appropriate details. */
    private class MoveListener
        implements ActionListener {
        /** Any implementation of <i>ActionListener</i> must include this method so that we can be informed when an action has occured on one of our target controls.
         * @param event An <strong>ActionEvent</strong> containing information garnered from the control action.
         */
        public void actionPerformed(ActionEvent event) {
        if (!plugin_list.isSelectionEmpty()) {
            Object object = plugin_list.getSelectedValue();
            if (object instanceof PlugIn) {
            PlugIn plugin = (PlugIn) object;
            if (event.getSource() == move_top_button) {
                movePlugIn(plugin, true, true);
            }
            else if (event.getSource() == move_up_button) {
                movePlugIn(plugin, true, false);
            }
            else if (event.getSource() == move_down_button) {
                movePlugIn(plugin, false, false);
            }
            else if (event.getSource() == move_bottom_button) {
                movePlugIn(plugin, false, true);
            }
            plugin_list.setSelectedValue(plugin, true);
            }
        }
        }
    }

    /** This listener reacts to changes in the current selection of the plugin combobox. */
    private class PlugInComboboxListener
        implements ItemListener {
        /** When a user selects a certain plugin, update the tooltip to show the plugin description. */
        public void itemStateChanged(ItemEvent event) {
            if(event.getStateChange() == ItemEvent.SELECTED) {
                // Retrieve the selected plugin
                Object current_selection = plugin.getSelectedItem();
                // And reset the tooltip. If the plugin is null or is a string, then go back to the default message
                if(current_selection == null || current_selection instanceof String) {
                    Dictionary.registerTooltip(plugin, "CDM.PlugInManager.PlugIn_Tooltip");
                }
                else {
                    PlugIn current_plugin = (PlugIn) current_selection;
                    Dictionary.registerTooltip(plugin, Utility.formatHTMLWidth(current_plugin.getDescription(), 40), false);
                    current_plugin = null;
                }
                current_selection = null;
            }
        }
    }

    /** This class listens for actions upon the remove button in the controls, and if detected calls the <i>removePlugIn()</i> method.
     */
    private class RemoveListener
        implements ActionListener {
        /** Any implementation of <i>ActionListener</i> must include this method so that we can be informed when an action has occured on one of our target controls.
         * @param event An <strong>ActionEvent</strong> containing information garnered from the control action.
         */
        public void actionPerformed(ActionEvent event) {
        if(!plugin_list.isSelectionEmpty()) {
            Object [] objects = plugin_list.getSelectedValues();
            for(int i = 0; i < objects.length; i++) {
            if(objects[i] instanceof PlugIn) {
                removePlugIn((PlugIn)objects[i]);
            }
            }
            // Refresh the available plugins
            plugin.setModel(new DefaultComboBoxModel(getAvailable()));
        }
        remove.setEnabled(false);
        }
    }
    }
    /** Creates a list separator.
     * Code courtesy of Farwell, Paul. Contact <a href="mailto:[email protected]">[email protected]</a>
     */
    static private JPanel getSeparator() {
    // We put the separator inside a panel to control its appearance
    JPanel _sepPanel = new JPanel();
    _sepPanel.setOpaque(false);
    _sepPanel.setBorder(BorderFactory.createEmptyBorder(1, 3, 1, 3));
    _sepPanel.setLayout(new BoxLayout(_sepPanel, BoxLayout.Y_AXIS));
    _sepPanel.add(Box.createRigidArea(new Dimension(0, 4)));
    _sepPanel.add(new JPopupMenu.Separator());
    _sepPanel.add(Box.createRigidArea(new Dimension(0, 4)));
    return _sepPanel;
    }
}