source: trunk/gli/src/org/greenstone/gatherer/cdm/ClassifierManager.java@ 12072

/**
 *#########################################################################
 *
 * 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.net.*;
import java.util.*;
import java.util.jar.*;
import javax.swing.*;
import javax.swing.event.*;
import org.apache.xerces.parsers.*;
import org.greenstone.gatherer.Configuration;
import org.greenstone.gatherer.DebugStream;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.LocalGreenstone;
import org.greenstone.gatherer.gui.DesignPaneHeader;
import org.greenstone.gatherer.gui.GComboBox;
import org.greenstone.gatherer.gui.GLIButton;
import org.greenstone.gatherer.remote.RemoteGreenstoneServer;
import org.greenstone.gatherer.util.JarTools;
import org.greenstone.gatherer.util.StaticStrings;
import org.greenstone.gatherer.util.Utility;
import org.greenstone.gatherer.util.XMLTools;
import org.w3c.dom.*;
import org.xml.sax.*;

/** This class is responsible for keeping track of all the classifiers assigned to this collection, and providing methods for adding and removing them.
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 2.3
 */
public class ClassifierManager
    extends DOMProxyListModel {

    /** A list of known, but currently unassigned, classifiers. */
    private ArrayList library = null;
    /** The controls for editing the contents of this manager. */
    private Control controls = null;

    private DOMProxyListModel model;

    /** Constructor.
     * @see org.greenstone.gatherer.cdm.DynamicListModel
     * @see org.greenstone.gatherer.collection.CollectionManager
     */
    public ClassifierManager() {
    super(CollectionDesignManager.collect_config.getDocumentElement(), CollectionConfiguration.CLASSIFY_ELEMENT, new Classifier());
    this.model = this;
    DebugStream.println("ClassifierManager: " + getSize() + " classifiers parsed.");
    // Reload/Create the library
    loadClassifiers();
    saveClassifiers();
    }

    /** Method to add a new classifier to library.
     * @param classifier The new <strong>Classifier</strong>.
     * @see org.greenstone.gatherer.cdm.DynamicListModel
     */
    private void addClassifier(Classifier classifier) {
    if(!library.contains(classifier)) {
        library.add(classifier);
    }
    }

    /** Method to assign a classifier.
     * @param classifier The base <strong>Classifier</strong> to assign.
     * @see org.greenstone.gatherer.cdm.DynamicListModel
     */
    private void assignClassifier(Classifier classifier) {
    if(!contains(classifier)) {
        Element element = classifier.getElement();
        // Locate where we should insert this new classifier.
        Node target_node = CollectionConfiguration.findInsertionPoint(element);
        add(root, classifier, target_node);
        Gatherer.c_man.configurationChanged();
    }
    }

    public static boolean clearClassifierCache() {

    DebugStream.println("deleting classifiers.dat");
    File class_file = new File(Gatherer.getGLIUserDirectoryPath() + "classifiers.dat");
    if (class_file.exists()) {
        return Utility.delete(class_file);
    }
    return true;
    }
    /** Destructor.
     * @see org.greenstone.gatherer.Gatherer
     * @see org.greenstone.gatherer.cdm.CollectionDesignManager
     * @see org.greenstone.gatherer.cdm.DynamicListModel
     */
    public void destroy() {
    if(controls != null) {
        controls.destroy();
        controls = null;
    }
    library.clear();
    library = null;
    }

    public Classifier getBaseClassifier(String name) {
    int library_size = library.size();
    for(int i = 0; i < library_size; i++) {
        Classifier classifier = (Classifier) library.get(i);
        if(classifier.getName().equals(name)) {
        return classifier;
        }
    }
    // No success.
    return null;
    }

    /** Method to retrieve the classifier with the given index.
     * @param index The index of the desired classifier as an <i>int</i>.
     * @return The requested Classifier or <i>null</i> if no such classifier exists.
     */
    public Classifier getClassifier(int index) {
    if(0 <= index && index < getSize()) {
        return (Classifier) getElementAt(index);
    }
    return null;
    }

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

    /** Called when the detail mode has changed which in turn may cause several design elements to be available/hidden
     * @param mode the new mode as an int
     */
    public void modeChanged(int mode) {

    }



    /** Determine if the Phind classifier has been assigned.
     * @return true if it has, false otherwise
     */
    public boolean isPhindClassifierAssigned() {
    for(int i = 0; i < getSize(); i++) {
        Classifier classifier = (Classifier) getElementAt(i);
        if(classifier.getName().equalsIgnoreCase(StaticStrings.PHIND_CLASSIFIER)) {
        return true;
        }
        classifier = null;
    }
    return false;
    }

    /** Method to move a classifier in the list order.
     * @param classifier the Classifier you want to move.
     * @param direction true to move the classifier up, false to move it down.
     * @param all true to move to move all the way, false for a single step.
     */
    private void moveClassifier(Classifier classifier, boolean direction, boolean all) {
    if(getSize() < 2) {
        DebugStream.println("Not enough classifiers to allow moving.");
        return;
    }
    if(all) {
        // Move to top
        if(direction) {
        // Remove the moving classifier
        remove(classifier);
        // Retrieve the first classifier
        Classifier first_classifier = (Classifier) getElementAt(0);
        // Add the moving classifier before the first classifier
        addBefore(classifier, first_classifier);
        first_classifier = null;
        }
        else {
        // Remove the moving classifier
        remove(classifier);
        // And add after last classifier
        add(getSize(), classifier);
        }
    }
    else {
        // Try to move the classifier one step in the desired direction.
        int index = indexOf(classifier);
        ///ystem.err.println("Index of " + classifier + " = " + index);
        if(direction) {
        index--;
        if(index < 0) {
            String args[] = new String[2];
            args[0] = Dictionary.get("CDM.ClassifierManager.Classifier");
            args[1] = classifier.getName();
            JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.Move.At_Top", args), Dictionary.get("CDM.Move.Title"), JOptionPane.ERROR_MESSAGE);
            return;
        }
        remove(classifier);
        add(index, classifier);
        }
        else {
        index++;
        if(index >= getSize()) {
            String args[] = new String[2];
            args[0] = Dictionary.get("CDM.ClassifierManager.Classifier_Str");
            args[1] = classifier.getName();
            JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.Move.At_Bottom", args), Dictionary.get("CDM.Move.Title"), JOptionPane.ERROR_MESSAGE);
            return;
        }
        remove(classifier);
        add(index, classifier);
        }
    }
    
    Gatherer.c_man.configurationChanged();
    // tell the format manager to update the names of its format statements
    Gatherer.c_man.getCollection().cdm.format_manager.refresh();
    }
    
    /** This method removes an assigned classifier. I was tempted to call it unassign, but remove is more consistant. Note that there is no way to remove a classifier from the library.
     * @param classifier The Classifier to remove
     * @see org.greenstone.gatherer.cdm.DynamicListModel
     */
    private void removeClassifier(Classifier classifier) {
    remove(classifier);
    Gatherer.c_man.configurationChanged();
    }

    /** Method to cache the current contents of library (known classifiers) to file.
     * @see org.greenstone.gatherer.util.Utility
     */
    private void saveClassifiers() {
    try {
        File classifiers_dat_file = new File(Gatherer.getGLIUserDirectoryPath() + "classifiers.dat");
        FileOutputStream file = new FileOutputStream(classifiers_dat_file);
        ObjectOutputStream out = new ObjectOutputStream(file);
        out.writeObject(library);
        out.close();
    }
    catch (Exception error) {
    }
    }

    private Object[] getAvailable() {
    ArrayList available = new ArrayList();
    int library_size = library.size();
    for(int i = 0; i < library_size; i++) {
        Classifier classifier = (Classifier) library.get(i);
        if(!classifier.isAbstract()) {
        available.add(classifier);
        }
        classifier = null;
    }
    return available.toArray();
    }

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

    /** Method to load the details of a single plug-in.
     * @param classifier The classifier <strong>File</strong> you wish to load.
     */
    private void loadClassifier(String classifier, String lang) {
    ///ystem.err.println("Attempting to parse " + classifier);
    Document document = null;
    InputStream input_stream = null;

    long start;
    long end;
    // Run classinfo on this classifier, and then send the results for parsing.
    try {
        StringBuffer xml = null;
        if (Gatherer.isGsdlRemote) {
        String classinfo_output = RemoteGreenstoneServer.getScriptOptions("classinfo.pl", "&classifier=" + classifier);
        xml = new StringBuffer(classinfo_output);
        }
        else {
        String args[] = null;
        if(Utility.isWindows()) {
            args = new String[6];
            if(Configuration.perl_path != null) {
            args[0] = Configuration.perl_path;
            }
            else {
            args[0] = "Perl.exe";
            }
            args[1] = LocalGreenstone.getBinScriptDirectoryPath() + "classinfo.pl";
            args[2] = "-xml";
            args[3] = "-language";
            args[4] = lang;
            args[5] = getClassifierName(classifier);
        }
        else {
            args = new String[5];
            args[0] = "classinfo.pl";
            args[1] = "-xml";
            args[2] = "-language";
            args[3] = lang;
            args[4] = getClassifierName(classifier);
        }

        // Create the process.
        Runtime runtime = Runtime.getRuntime();
        Process process = runtime.exec(args);

        input_stream = process.getErrorStream();
        xml = XMLTools.readXMLStream(input_stream);
        }

        if (xml.length() > 0) {
        document = CollectionDesignManager.XMLStringToDOM(xml, classifier);
        }
        else {
        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.ClassifierManager.Classifier_XML_Parse_Failed", classifier), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
        }
    }
    catch (Exception exception) {
        DebugStream.println("Failed when trying to parse: " + classifier);
        DebugStream.printStackTrace(exception);
    }

    if (document != null) {
        parseXML(document.getDocumentElement());
    }
    }

    /** Method to initially load information from the standard classifiers within the gsdl Perl library.
     * @see org.greenstone.gatherer.util.Utility
     */
    private void loadClassifiers() {
    // Attempt to restore the cached file.
    File classifiers_dat_file = new File(Gatherer.getGLIUserDirectoryPath() + "classifiers.dat");
    try {
        FileInputStream file = new FileInputStream(classifiers_dat_file);
        ObjectInputStream input = new ObjectInputStream(file);
        library = (ArrayList) input.readObject();
    }
    catch (Exception error) {
        DebugStream.println("Unable to open " + classifiers_dat_file);
    }

    if(library == null) {
        library = new ArrayList();

        if (Gatherer.isGsdlRemote) {
        String classinfo_output = RemoteGreenstoneServer.getScriptOptions("classinfo.pl", "&listall=");
        loadClassifiers(new StringBuffer(classinfo_output));
        }

        else {
        // Retrieve the gsdl home directory...
        String directory = LocalGreenstone.getDirectoryPath();
        directory = directory + "perllib" + File.separator + "classify" + File.separator;

        String current_lang = Configuration.getLanguage();
        File files[] = (new File(directory)).listFiles();
        if(files != null) {
            // Create a progress indicator.
            ParsingProgress progress = new ParsingProgress(Dictionary.get("CDM.ClassifierManager.Parsing.Title"), Dictionary.get("CDM.ClassifierManager.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")) {
                loadClassifier(files[i].getName(), current_lang);
            }
            progress.inc();
            }
            progress.dispose();
            progress.destroy();
            progress = null;
        }
        }
    }
    }



    /** Method to load classifier information from a specified input stream (could be local or through URL). Of course no classifiers may be found at this location.
     * @param input_stream An <strong>InputStream</strong> indicating the where list of classifiers -- encoded in XML -- can be read from
     */
    private void loadClassifiers(StringBuffer xml)
    {
    Document document = CollectionDesignManager.XMLStringToDOM(xml, "-listall");

    // Parse XML to build up list of classifier names
    Node root = document.getDocumentElement();

    NamedNodeMap attributes = root.getAttributes();
    Node length_node = attributes.getNamedItem("length");
    String num_classifiers_str = length_node.getNodeValue();
    int num_classifiers = Integer.parseInt(num_classifiers_str);
    String class_list[] = new String[num_classifiers];

    Node node = root.getFirstChild();
    int i = 0;
    while (node != null) {
        String node_name = node.getNodeName();
        if (node_name.equalsIgnoreCase("ClassifyName")) {
        String name = XMLTools.getValue(node);
        class_list[i] = name;
        i++;        
        }

        node = node.getNextSibling();
    }

    String current_lang = Configuration.getLanguage();
    if (num_classifiers>0) {
        // Create a progress indicator.
        ParsingProgress progress = new ParsingProgress(Dictionary.get("CDM.ClassifierManager.Parsing.Title"), Dictionary.get("CDM.ClassifierManager.Parsing.Message"), num_classifiers);

        for (i=0; i<num_classifiers; i++) {
        String classifier = class_list[i];
        loadClassifier(classifier, current_lang);
        progress.inc();
        }
        progress.dispose();
        progress.destroy();
        progress = null;
    }
    }


    /** Parses a DOM tree model turning it into a Classifier and its associated arguments.
     * @param root The <strong>Node</strong> at the root of the DOM model.
     * @return A newly created <strong>Classifier</strong> based on the information parsed from the DOM model.
     * @see org.greenstone.gatherer.cdm.Argument
     */
    private Classifier parseXML(Node root) {
    Classifier classifier = new Classifier();
    String node_name = null;
    for(Node node = root.getFirstChild(); node != null;
        node = node.getNextSibling()) {
        node_name = node.getNodeName();
        if(node_name.equals("Name")) {
        String name = XMLTools.getValue(node);
        // We can save ourselves some processing time if a classifier with this name already exists in our manager. If so retrieve it and return it.
        Classifier existing = getBaseClassifier(name);
        if(existing != null) {
            return existing;
        }
        classifier.setName(name);
        }
        else if(node_name.equals("Desc")) {
        classifier.setDescription(XMLTools.getValue(node));
        }
        else if(node_name.equals("Abstract")) {
        classifier.setIsAbstract(XMLTools.getValue(node).equalsIgnoreCase(CollectionConfiguration.YES_STR));
        }
        // Parse the multitude of arguments.
        else if(node_name.equals("Arguments")) {
        for(Node arg = node.getFirstChild(); arg != null; arg = arg.getNextSibling()) {
            node_name = arg.getNodeName();
            // An option.
            if(node_name.equals("Option")) {
            Argument argument = new Argument();
            argument.parseXML((Element)arg);
            classifier.addArgument(argument);
            }
        }
        }
        // A super classifier class.
        else if(node_name.equals("ClassInfo")) {
        Classifier super_classifier = parseXML(node);
        classifier.setSuper(super_classifier);
        }
        
    }
    if(classifier.getName() != null) {
        addClassifier(classifier);
        return classifier;
    }
    return null;
    }

    /** A class which provides controls for assigned and editing classifiers. */
    private class ClassifierControl
    extends JPanel
    implements Control {
    /** A combobox containing all of the known classifiers, including those that may have already been assigned. */
    private GComboBox classifier = null;
    /** Button for adding classifiers. */
    private JButton add = null;
    /** Button for configuring the selected classifier. */
    private JButton configure = null;
    private JButton move_down_button;
    private JButton move_up_button;

    /** Button to remove the selected classifier. */
    private JButton remove = null;

    /** A list of assigned classifiers. */
    private JList classifier_list = null;

    /** Constructor.
     * @see org.greenstone.gatherer.cdm.ClassifierManager.ClassifierControl.AddListener
     * @see org.greenstone.gatherer.cdm.ClassifierManager.ClassifierControl.ConfigureListener
     * @see org.greenstone.gatherer.cdm.ClassifierManager.ClassifierControl.RemoveListener
     */
    public ClassifierControl() {
        Collections.sort(library);
        // Create
        add = new GLIButton();
        add.setMnemonic(KeyEvent.VK_A);
        Dictionary.registerBoth(add, "CDM.ClassifierManager.Add", "CDM.ClassifierManager.Add_Tooltip");
        JPanel button_pane = new JPanel();
        JPanel central_pane = new JPanel();
        configure = new GLIButton();
        configure.setEnabled(false);
        configure.setMnemonic(KeyEvent.VK_C);
        Dictionary.registerBoth(configure, "CDM.ClassifierManager.Configure", "CDM.ClassifierManager.Configure_Tooltip");
        JPanel header_pane = new DesignPaneHeader("CDM.GUI.Classifiers", "classifiers");

        ClassifierComboboxListener ccl = new ClassifierComboboxListener();
        classifier = new GComboBox(getAvailable());
        classifier.setBackgroundNonSelectionColor(Configuration.getColor("coloring.editable_background", false));
        classifier.setBackgroundSelectionColor(Configuration.getColor("coloring.collection_selection_background", false));
        classifier.setEditable(true);
        classifier.setTextNonSelectionColor(Configuration.getColor("coloring.workspace_tree_foreground", false));
        classifier.setTextSelectionColor(Configuration.getColor("coloring.collection_selection_foreground", false));
        if(classifier.getItemCount() > 0) {
        classifier.setSelectedIndex(0);
        ccl.itemStateChanged(new ItemEvent(classifier, 0, null, ItemEvent.SELECTED));
        }

        JLabel classifier_label = new JLabel();
        Dictionary.registerText(classifier_label, "CDM.ClassifierManager.Classifier");
        classifier_list = new JList(model);
        classifier_list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        JLabel classifier_list_label = new JLabel();
        //      classifier_list_label.setHorizontalAlignment(JLabel.CENTER);
        classifier_list_label.setOpaque(true);
        Dictionary.registerText(classifier_list_label, "CDM.ClassifierManager.Assigned");
        JPanel classifier_list_pane = new JPanel();
        JPanel classifier_pane = new JPanel();
        remove = new GLIButton();
        remove.setEnabled(false);
        remove.setMnemonic(KeyEvent.VK_R);
        Dictionary.registerBoth(remove, "CDM.ClassifierManager.Remove", "CDM.ClassifierManager.Remove_Tooltip");

        JPanel temp = new JPanel(new BorderLayout());

        JPanel move_button_pane = new JPanel();

        move_up_button = new GLIButton("", JarTools.getImage("arrow-up.gif"));
        move_up_button.setEnabled(false);
        move_up_button.setMnemonic(KeyEvent.VK_U);
        Dictionary.registerBoth(move_up_button, "CDM.Move.Move_Up", "CDM.Move.Move_Up_Tooltip");

        move_down_button = new GLIButton("", JarTools.getImage("arrow-down.gif"));
        move_down_button.setEnabled(false);
        move_down_button.setMnemonic(KeyEvent.VK_D);
        Dictionary.registerBoth(move_down_button, "CDM.Move.Move_Down", "CDM.Move.Move_Down_Tooltip");

        // Listeners
        add.addActionListener(new AddListener());
        add.addActionListener(CollectionDesignManager.buildcol_change_listener);
        classifier.addItemListener(ccl);
        configure.addActionListener(new ConfigureListener());
        configure.addActionListener(CollectionDesignManager.buildcol_change_listener);
        remove.addActionListener(new RemoveListener());
        remove.addActionListener(CollectionDesignManager.buildcol_change_listener);
        classifier_list.addMouseListener(new ClickListener());
        classifier_list.addListSelectionListener(new ListListener());
        ccl = null;

        MoveListener ml = new MoveListener();
        move_down_button.addActionListener(ml);
        move_down_button.addActionListener(CollectionDesignManager.buildcol_change_listener);
        move_up_button.addActionListener(ml);
        move_up_button.addActionListener(CollectionDesignManager.buildcol_change_listener);

        // Layout
        move_button_pane.setLayout(new GridLayout(4,1));
        move_button_pane.add(move_up_button);
        move_button_pane.add(new JPanel());
        move_button_pane.add(new JPanel());
        move_button_pane.add(move_down_button);

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

        classifier_list_pane.setLayout(new BorderLayout());
        classifier_list_pane.add(classifier_list_label, BorderLayout.NORTH);
        classifier_list_pane.add(new JScrollPane(classifier_list), BorderLayout.CENTER);
        classifier_list_pane.add(move_button_pane, BorderLayout.EAST);

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

        classifier_pane.setBorder(BorderFactory.createEmptyBorder(5,0,5,0));
        classifier_pane.setLayout(new BorderLayout(5,0));
        classifier_pane.add(classifier_label, BorderLayout.WEST);
        classifier_pane.add(classifier, BorderLayout.CENTER);

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

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

        central_pane.setBorder(BorderFactory.createEmptyBorder(5,0,0,0));
        central_pane.setLayout(new BorderLayout());
        central_pane.add(classifier_list_pane, BorderLayout.CENTER);
        central_pane.add(temp, BorderLayout.SOUTH);

        setBorder(BorderFactory.createEmptyBorder(0,5,0,0));
        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() {
        add = null;
        classifier = null;
        classifier_list = null;
        configure = null;
        //instructions = null;
        remove = null;
    }

    public void gainFocus() {
    }

    public void loseFocus() {
    }

    /** This class listens for actions upon the add button in the controls, and if detected calls the assignClassifier() method.
     */
    private class AddListener
        implements ActionListener {
        /** Any implementation of ActionListener must include this method so that we can be informed when an action has occured on one of our target controls, so that we can add the selected Classifier.
         * @param event An <strong>ActionEvent</strong> containing information garnered from the control action.
         * @see org.greenstone.gatherer.Gatherer
         * @see org.greenstone.gatherer.cdm.ArgumentConfiguration
         * @see org.greenstone.gatherer.cdm.Classifier
         */
        public void actionPerformed(ActionEvent event) {
        Object selected_object = classifier.getSelectedItem();
        // If there is something in the combobox, but we haven't registered a selection, then add the object and select it!
        if(selected_object != null) {
            // Retrieve the base classifier
            Classifier base_classifier = getBaseClassifier(selected_object.toString());

            // Create a new element in the DOM
            Element element = CollectionDesignManager.collect_config.document.createElement(CollectionConfiguration.CLASSIFY_ELEMENT);
            Classifier new_classifier = null;
            if(base_classifier != null) {
            DebugStream.println("Creating Classifier based on existing Classifer.");
            element.setAttribute(CollectionConfiguration.TYPE_ATTRIBUTE, base_classifier.getName());
            new_classifier = new Classifier(element, base_classifier);
            }
            else {
            DebugStream.println("Creating new custom Classifier.");
            element.setAttribute(CollectionConfiguration.TYPE_ATTRIBUTE, selected_object.toString());
            new_classifier = new Classifier(element, null);
            // Also we add the custom classifier name to the combobox for convienence.
            classifier.addItem(selected_object);
            }
            element = null;
            // Automatically chain to configuration. This ensures required arguments are filled out.
            ArgumentConfiguration ac = new ArgumentConfiguration(new_classifier);
            if(ac.display()) {
            if(!model.contains(new_classifier)) {
                assignClassifier(new_classifier);
                classifier_list.setSelectedValue(new_classifier, true);
            }
            else {
                JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.ClassifierManager.Classifier_Exists"), Dictionary.get("General.Error"), JOptionPane.ERROR_MESSAGE);
            }
            }
            ac = null;
            new_classifier = null;
        }
        }
    }

    /** This listener reacts to changes in the current selection of the classifier combobox. */
    private class ClassifierComboboxListener
        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 = classifier.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(classifier, "CDM.ClassifierManager.Classifier_Tooltip");
                }
                else {
                    Classifier current_classifier = (Classifier) current_selection;
                    Dictionary.registerTooltipText(classifier, Utility.formatHTMLWidth(current_classifier.getDescription(), 40));
                    current_classifier = null;
                }
                current_selection = 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(!classifier_list.isSelectionEmpty()) {
            Classifier classifier = (Classifier) classifier_list.getSelectedValue();
            ArgumentConfiguration ac = new ArgumentConfiguration(classifier);
            if(ac.display()) {
                refresh(classifier);
            }
            ac.destroy();
            ac = null;
            // cos I can't be bothered checking every argument to see if it has changed or not, we'll asasume that the configuration has changed if someone has clicked configure
            Gatherer.c_man.configurationChanged();
            }
        }
        }
    }

    /** This class listens for actions upon the configure button in the controls, and if detected creates a new ArgumentConfiguration dialog box to allow for configuration.
     */
    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.
         * @see org.greenstone.gatherer.cdm.ArgumentConfiguration
         * @see org.greenstone.gatherer.cdm.Classifier
         */
        public void actionPerformed(ActionEvent event) {
        if(!classifier_list.isSelectionEmpty()) {
           Classifier classifier = (Classifier) classifier_list.getSelectedValue();
           ArgumentConfiguration ac = new ArgumentConfiguration(classifier);
           if(ac.display()) {
               refresh(classifier);
           }
           ac.destroy();
           ac = null;
           // cos I can't be bothered checking every argument to see if it has changed or not, we'll asasume that the configuration has changed if someone has clicked configure
           Gatherer.c_man.configurationChanged();
        }
        }
    }

    /** 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 (classifier_list.isSelectionEmpty()) {
            move_up_button.setEnabled(false);
            move_down_button.setEnabled(false);
            configure.setEnabled(false);
            remove.setEnabled(false);
            }
            else {
            configure.setEnabled(true);
            remove.setEnabled(true);
            int selected_index = classifier_list.getSelectedIndex();
            move_up_button.setEnabled(selected_index !=0);
            move_down_button.setEnabled(selected_index != model.getSize()-1);
            }
        }
        }
    }

    /** Listens for actions apon the move buttons in the manager controls, and if detected calls the <i>moveClassifier()</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(!classifier_list.isSelectionEmpty()) {
            Object object = classifier_list.getSelectedValue();
            if(object instanceof Classifier) {
            Classifier classifier = (Classifier) object;
            if(event.getSource() == move_up_button) {
                moveClassifier(classifier, true, false);
            }
            else if(event.getSource() == move_down_button) {
                moveClassifier(classifier, false, false);
            }
            classifier_list.setSelectedValue(classifier, true);
            }
        }
        }
    }

    /** This class listens for actions upon the remove button in the controls, and if detected calls the <i>removeClassifier()</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(classifier_list.isSelectionEmpty()) {
            remove.setEnabled(false);
            return;
        }
        int selected_index = classifier_list.getSelectedIndex();
        Object selected_classifier = classifier_list.getSelectedValue();
        if (!(selected_classifier instanceof Classifier)) {
            return; // what else could we have here???
        }
        removeClassifier((Classifier)selected_classifier);

        if (selected_index >= classifier_list.getModel().getSize()) {
            selected_index--;
        }
        if (selected_index >=0) {
            classifier_list.setSelectedIndex(selected_index);
        } else {
            // no more classifiers in the list
            remove.setEnabled(false);
        }
        }
    }
    }
}