source: trunk/gli/src/org/greenstone/gatherer/cdm/custom/CustomAZList.java@ 4932

package org.greenstone.gatherer.cdm.custom;
/**
 *#########################################################################
 *
 * 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.
 *
 * <BR><BR>
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * <BR><BR>
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * <BR><BR>
 *
 * 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.
 *
 * <BR><BR>
 *
 * 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.
 *
 * <BR><BR>
 *
 * 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.
 *########################################################################
 */
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.tree.*;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.cdm.Classifier;
import org.greenstone.gatherer.cdm.ClassifierManager;
import org.greenstone.gatherer.cdm.CustomClassifier;
import org.greenstone.gatherer.file.FileNode;
import org.greenstone.gatherer.msm.ElementWrapper;
import org.greenstone.gatherer.msm.Metadata;
import org.greenstone.gatherer.msm.MetadataSet;
import org.greenstone.gatherer.msm.MetadataSetManager;
import org.greenstone.gatherer.msm.MSMUtils;
import org.greenstone.gatherer.util.ArrayTools;
import org.greenstone.gatherer.util.Utility;
import org.greenstone.gatherer.valuetree.GValueModel;
import org.greenstone.gatherer.valuetree.GValueNode;
import org.greenstone.gatherer.gui.SimpleMenuBar;
import org.greenstone.gatherer.gui.ModalDialog;
import org.w3c.dom.*;
/** Provides the functionality for a custom AZList, including a GUI for configuration of this classifier. 
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 2.3
 */
final public class CustomAZList
    implements CustomClassifier {
    /** When this the control dialog is disposed, should we go ahead a add this custom AZ list (by processing all file records and building a new hierarchy)? */
    private boolean process = false;
    /** are we currently processing?? */
    private boolean is_processing = false;
    /** A reference to the Gatherer for access to the Collection and MetadataSetManager. */
    private Gatherer gatherer = null;
    /** A mapping from a String pattern to a specific GValueNode within the hidden hierarchy. */
    private Hashtable mappings = null;
    /** The button used to cancel the dialog. */
    private JButton cancel = null;
    /** The button used to confirm and close the dialog. */
    private JButton ok = null;
    /** The dialog which contains the controls for configuring this custom classifier. */
    private JDialog controls = null;
    /** The checkbox used to indicate whether there is a name given for the classifier button (in the Greenstone collections menubar). */
    private JCheckBox buttonname_label = null;
    /** The checkbox used to indicate that the final classifier should be sorted in some way. */
    private JCheckBox sort_label = null;
    /** The control allowing you to choose the assigned metadata this classifier should be based on. */
    private JComboBox metadata = null;
    /** The metadata the final classifier should be sorted by. */
    private JComboBox sort = null;
    /** A field for entering the button name. */
    private JTextField buttonname = null;
    /** A field which provides a clear indication of the current ranges selected for your custom classifier. */
    private JTextField separators_preview = null;
    /** An array of togglebuttons showing what separations are available. */
    private JToggleButton separators[] = null;
    /** A reference to the progress dialog if it exists. */
    private ProgressDialog pd = null;
    /** A private dictionary for this custom classifier. */
    private ResourceBundle dictionary = null;
    /** The name of the hidden metadata. We at least luck out in that we don't need a live reference to the metadata, because the user can never change it (or if they do its their own stinking fault). */
    private String hidden_mde_name = null;
    /** The name of this pseudo-classifier. */
    final static public String NAME = "CustomAZList";
    /** The size of a label. */
    final static private Dimension LABEL_SIZE = new Dimension(200,25);
    /** The size of the controls for this pseudo-classifier. */
    final static private Dimension SIZE = new Dimension(550,425);
    /** An array of values for the separators. */
    final static private String VALUES[] = {"Numbers", "A", "B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
    /** The same array as above, except as integer values (note that "Numbers" becomes "#"). */
    static public int INT_VALUES[] = {'#','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
    /** A third array which is almost the same as the others (can anyone else say poor code reuse) but subsitutes "#" for "Numbers". */
    static public String STRING_VALUES[] = {"#","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
    /** Default Constructor. Needed to load this class dynamically. */
    public CustomAZList() {}
    /** Constructor.
     * @param gatherer A reference to the <strong>Gatherer</strong>.
     */
    public CustomAZList(Gatherer gatherer) {
    this.gatherer = gatherer;
    }
    /** Used to compare this classifier to another classifier for the purposes of ordering.
     * @param object The other classifier as an <strong>Object</strong>.
     * @see org.greenstone.gatherer.cdm.Classifier
     * @see org.greenstone.gatherer.cdm.CustomClassifier
     */
    public int compareTo(Object object) {
    if(object instanceof Classifier) {
        Classifier classifier = (Classifier) object;
        return NAME.compareTo(classifier.getName());
    }
    else if(object instanceof CustomClassifier) {
        CustomClassifier classifier = (CustomClassifier) object;
        return NAME.compareTo(classifier.getName());
    }               
    return NAME.compareTo(object.toString());   
    }
    /** Ensure that the dialog can be correctly garbage collected. */
    public void destroy() {
    controls = null;
    }
    public void hide() {
    controls.setVisible(false);
    }
    /** Produce a new copy of this custom classifier. Remember that what the classifier manager does is create instances of all possible classifiers, then as they are assigned creates and assigns copies of the original reserve. This way we only have to parse arguments once. 
     * @return A new <strong>CustomClassifier</strong> which is a copy of this one.
     * @see org.greenstone.gatherer.Gatherer
     */
    public CustomClassifier copy() {
    return new CustomAZList(gatherer);
    }
    /** Show the controls for configuring this pseudo-classifier. 
      * @param show <i>true</i> to actually display the configuration dialog on screen, <i>false</i> to do everything except show the control and process the data (useful for setting the control up and/or reloading custom classifiers from collect.cfg).
      * @see org.greenstone.gatherer.Configuration
      * @see org.greenstone.gatherer.Gatherer
      * @see org.greenstone.gatherer.cdm.custom.CustomAZList.ButtonNameListener
      * @see org.greenstone.gatherer.cdm.custom.CustomAZList.CancelListener
      * @see org.greenstone.gatherer.cdm.custom.CustomAZList.OKListener
      * @see org.greenstone.gatherer.cdm.custom.CustomAZList.SeparatorListener
      * @see org.greenstone.gatherer.cdm.custom.CustomAZList.SortListener
      * @see org.greenstone.gatherer.collection.CollectionManager
      * @see org.greenstone.gatherer.msm.ElementWrapper
      * @see org.greenstone.gatherer.msm.MetadataSetManager
      */
    public boolean display(boolean show) {
    if(controls == null) {
        
        Vector elements = gatherer.c_man.getCollection().msm.getAssignedElements();
        // Creation
        controls = new ModalDialog(gatherer.g_man);
        controls.setModal(true);
        controls.setSize(SIZE);
        controls.setTitle(get("Title_JDialog"));
        controls.setJMenuBar(new SimpleMenuBar("7.7")); 
        JPanel content_pane = (JPanel) controls.getContentPane();
        JPanel upper_pane = new JPanel();
        JPanel metadata_pane = new JPanel();
        JLabel metadata_label = new JLabel(get("Metadata_JLabel"));
        metadata_label.setPreferredSize(LABEL_SIZE);
        metadata = new JComboBox(elements);
        JPanel buttonname_pane = new JPanel();
        buttonname_label = new JCheckBox(get("Buttonname_JCheckBox"));
        buttonname_label.setPreferredSize(LABEL_SIZE);
        buttonname = new JTextField();
        buttonname.setBackground(Color.lightGray);
        buttonname.setEnabled(false);
        JPanel sort_pane = new JPanel();
        sort_label = new JCheckBox(get("Sort_JLabel"));
        sort = new JComboBox(elements);
        JPanel separations_pane = new JPanel();
        JLabel separations_label = new JLabel(get("Separations_JLabel"));
        separations_label.setPreferredSize(LABEL_SIZE);
        separators_preview = new JTextField();
        separators_preview.setBackground(Gatherer.config.getColor("coloring.collection_tree_background", false));
        separators_preview.setEnabled(false); // View only.
        separators_preview.setForeground(Color.black);
        JPanel lower_pane = new JPanel();
        JPanel button_pane = new JPanel();
        ok = new JButton(get("OK_JButton"));
        cancel = new JButton(get("Cancel_JButton"));
        // Connection
        buttonname_label.addActionListener(new ButtonNameListener());
        cancel.addActionListener(new CancelListener());
        ok.addActionListener(new OKListener());
        sort_label.addActionListener(new SortListener());
        // The Toggle Button block. Done all at once so we don't end up with three for loops.
        JPanel center_pane = new JPanel();
        center_pane.setLayout(new GridLayout(3, 9));
        separators = new JToggleButton[VALUES.length];
        SeparatorListener sl = new SeparatorListener();
        for(int i = 0; i < VALUES.length; i++) {
        separators[i] = new JToggleButton(get(VALUES[i]));
        separators[i].addActionListener(sl);
        if(i != 0) {
            center_pane.add(separators[i]);
        }
        else {
            JLabel temp = new JLabel(get(VALUES[0]));
            temp.setHorizontalAlignment(JLabel.CENTER);
            center_pane.add(temp);
        }
        }
        separators_preview.setText(getPreview(true));
        // Layout
        metadata_pane.setBorder(BorderFactory.createEmptyBorder(1,0,1,0));
        metadata_pane.setLayout(new BorderLayout());
        metadata_pane.add(metadata_label, BorderLayout.WEST);
        metadata_pane.add(metadata, BorderLayout.CENTER);
                
        buttonname_pane.setBorder(BorderFactory.createEmptyBorder(1,0,1,0));
        buttonname_pane.setLayout(new BorderLayout());
        buttonname_pane.add(buttonname_label, BorderLayout.WEST);
        buttonname_pane.add(buttonname, BorderLayout.CENTER);
                
        sort_pane.setBorder(BorderFactory.createEmptyBorder(1,0,1,0));
        sort_pane.setLayout(new BorderLayout());
        sort_pane.add(sort_label, BorderLayout.WEST);
        sort_pane.add(sort, BorderLayout.CENTER);

        upper_pane.setBorder(BorderFactory.createEmptyBorder(0,0,4,0));
        upper_pane.setLayout(new GridLayout(3, 1));
        upper_pane.add(metadata_pane);
        upper_pane.add(buttonname_pane);
        upper_pane.add(separations_label);
                
        separations_pane.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createEmptyBorder(5,0,5,0), BorderFactory.createRaisedBevelBorder()));
        separations_pane.setLayout(new BorderLayout());
        separations_pane.add(separators_preview, BorderLayout.CENTER);
                
        lower_pane.setLayout(new GridLayout(2,1));
        lower_pane.add(separations_pane);
        lower_pane.add(button_pane);
                
        button_pane.setLayout(new GridLayout(1,2));
        button_pane.add(ok);
        button_pane.add(cancel);
                
        content_pane.setBorder(BorderFactory.createEmptyBorder(4,5,5,5));
        content_pane.setLayout(new BorderLayout());
        content_pane.add(upper_pane, BorderLayout.NORTH);
        content_pane.add(center_pane, BorderLayout.CENTER);
        content_pane.add(lower_pane, BorderLayout.SOUTH);
        // Display
        Dimension screen_size = Gatherer.config.screen_size;
        controls.setLocation((screen_size.width - SIZE.width) / 2, (screen_size.height - SIZE.height) / 2);
        screen_size = null;
        if(show) {
        controls.setVisible(true);
        // Create the new metadata, hierarchy etc.
        if(process) {
            process((ElementWrapper)metadata.getSelectedItem(), getPreview(false));
            return true;
        }
        return false;
        }
        else {
        return true;
        }
        // We do everything -except- display the control.
    }
    else {
        // we already have the controls
        process = false;
        controls.setVisible(true);
        if(process) {
        process((ElementWrapper)metadata.getSelectedItem(), getPreview(false));
        return true;
        }
        return false;
    }
    }
    /** Determine if this classifier and another given classifier are equal.
      * @param object The classifier to check against for equality, as an <strong>Object</strong>.
      * @see org.greenstone.gatherer.cdm.CustomClassifier
      */
    public boolean equals(Object object) {
    if(object instanceof CustomClassifier) {
        CustomClassifier classifier = (CustomClassifier) object;
        if(getCommand().equalsIgnoreCase(classifier.getCommand())) {
        //if (toString().equalsIgnoreCase(classifier.toString())) {
        return true;
        }
        return false;
    }
    else {
        if(getCommand().equalsIgnoreCase(object.toString())) {
        return true;
        }
        return false;
    }
    }
    /** Method to return this pseudo-classifier represented as a String.
      * @return A <strong>String</strong>.
      */
    public String getCommand() {
    StringBuffer text = new StringBuffer("classify ");
    text.append("Hierarchy");
    text.append(" -metadata ");
    text.append(hidden_mde_name); // @TODO
    if(buttonname_label.isSelected()) {
        text.append(" -buttonname \"");
        text.append(buttonname.getText());
        text.append("\"");
    }
    text.append(" -hfile ");
    text.append(hidden_mde_name + ".txt");
    text.append(" -hlist_at_top");
    text.append("\n");
    return text.toString();
    }
    /** Retrieve the custom command, a command line that overrides and replaces some other 'actual' classifier.
     * @param index The number of the classifer this one is replacing.
     */
    public String getCustomCommand(int index) {
    StringBuffer text = new StringBuffer("customclassifier ");
    text.append(NAME);
    text.append(" -replaces CL");
    text.append(index);
    text.append(" -separations ");
    text.append(getPreview(false));
    return text.toString();
    }
    /** Get the name of this custom classifier.
      * @return The name as a <strong>String</strong>.
      */
    public String getName() {
    return NAME;
    }
    /** Process a record by adding hidden metadata as necessary.
      * @param record The <strong>FileNode</strong> to be edited.
      * @see org.greenstone.gatherer.msm.ElementWrapper
      */
    public void process(FileNode record) {
    is_processing = true;
    ElementWrapper element = (ElementWrapper) metadata.getSelectedItem();
    if(element != null) {
        addMetadata(0L, record, element);
    }
    is_processing = false;
    }
    /** Recreate a CustomAZList given several parameters including the real classifier created during custom design.
      * @param classifier The real <strong>Classifier</strong>.
      * @param separations A <strong>String</strong> representing the choosen separations.
      * @see org.greenstone.gatherer.Gatherer
      * @see org.greenstone.gatherer.cdm.Argument
      * @see org.greenstone.gatherer.collection.CollectionManager
      * @see org.greenstone.gatherer.msm.ElementWrapper
      * @see org.greenstone.gatherer.msm.MetadataSetManager
      * @see org.greenstone.gatherer.valuetree.GValueModel
      * @see org.greenstone.gatherer.valuetree.GValueNode
      */
    public void recreate(Classifier classifier, String separations) {
    // Rebuild controls
    display(false);
    // Calculate original element.
    hidden_mde_name = classifier.getArgument("metadata").getValue();
    ElementWrapper hidden_mde = gatherer.c_man.getCollection().msm.getElement(hidden_mde_name);
    String mde_name = (hidden_mde_name.substring(MetadataSetManager.HIDDEN.length() + 1)).replace('_','.');
    ElementWrapper mde = gatherer.c_man.getCollection().msm.getElement(mde_name);
    // Set metadata element combobox.
    metadata.setSelectedItem(mde);
    // Set button name.
    String bn = classifier.getArgument("buttonname").getValue();
    if(bn != null) {
        buttonname_label.setSelected(true);
        buttonname.setBackground(Color.white);
        buttonname.setEnabled(true);
        buttonname.setText(bn);
    }
    // Set sort element.
    String sort_mde_name = classifier.getArgument("sort").getValue();
    ElementWrapper sort_mde = gatherer.c_man.getCollection().msm.getElement(sort_mde_name);
    if(sort_mde != null) {
        sort_label.setSelected(true);
        sort.setBackground(Color.white);
        sort.setEnabled(true);
        sort.setSelectedItem(sort_mde);
    }
    // Recover value tree.
    GValueModel model = gatherer.c_man.getCollection().msm.getValueTree(hidden_mde);
    // For each token in the tokenizer, set toggle buttons and recover node.
    StringTokenizer tokenizer = new StringTokenizer(separations, ",");
    mappings = new Hashtable();
    while(tokenizer.hasMoreTokens()) {
        String key = tokenizer.nextToken();
        for(int j = 1; j < STRING_VALUES.length; j++) {
        if(key.startsWith(STRING_VALUES[0])) {
            j = STRING_VALUES.length;
        }
        else if(key.startsWith(STRING_VALUES[j])) {
            separators[j].setSelected(true);
            j = STRING_VALUES.length;
        }
        }
        // Rebuild mappings hashtable for this pattern. Add it if not present.
        GValueNode node = model.addValue(key);
        // If the key is simple, ie "C", then add the mapping "C"->node
        if(node == null) {
        // Do nothing.
        }
        else if(key.indexOf("-") == -1) {
        mappings.put(key, node);
        }
        // If the key is more complex, say "D-L", then we add mappings for all string values so "D"->node, "E"->node, ... "L"->node. This is miles eaiser to do here, than when you are trying to match a records metadata ie matchin "D-L" to "Igloos are cool". Note that it is guarantee that the keys are all of the same length, ie "A-L", "MA-ML", "MMA-STF", "STFA-ZZZZ".
        else {
        String start = key.substring(0, key.indexOf("-"));
        String end = key.substring(key.indexOf("-") + 1);
        for(key = start; key != null && key.compareTo(end) <= 0; key = increment(key)) {
            ///ystem.err.println("Adding " + key + " -> " + node);
            mappings.put(key, node);    
        }
        }
    }
    separators_preview.setText(getPreview(true));
    }
    /** Sets the value of Gatherer, for those classes loaded dynamically.
      * @param gatherer A reference to the <strong>Gatherer</strong>.
      */
    public void setGatherer(Gatherer gatherer) {
    this.gatherer = gatherer;
    }

    public void setManager(ClassifierManager manager) {
    }

    /** Translate this object into a string such as you would find in the collection configuration file.
      * @return A <strong>String</strong> representation.
      */
    public String toString() {
    StringBuffer text = new StringBuffer("classify ");
    text.append(NAME);
    text.append(" -metadata ");
    text.append(metadata.getSelectedItem().toString());
    if(buttonname_label.isSelected()) {
        text.append(" -buttonname \"");
        text.append(buttonname.getText());
        text.append("\"");
    }
    text.append(" -separations ");
    text.append(getPreview(false));
    return text.toString();
    }
    /** Add a pertinant piece of metadata to the given record. */
    private void addMetadata(long id, FileNode record, ElementWrapper element) {
    // Add custom metadata based on target metadata. No recursion.
    ArrayList temp_value = Gatherer.c_man.getCollection().gdm.getMetadata(record.getFile(), element);
    boolean found = false; // Only want to add the custom classifier metadata once.
    for(int i = 0; !found && i < temp_value.size(); i++) {
        String metadata_value = (String)temp_value.get(i);
        for(Enumeration keys = mappings.keys(); metadata_value != null && keys.hasMoreElements(); ) {
        String key = (String)keys.nextElement();
        // Try to match the value and the pattern. Remember to check for any case, ie key is '#' and metadata_value starts with anything other than a character.
        if(metadata_value.toUpperCase().startsWith(key) || (key.equals("#") && !Character.isLetter(metadata_value.charAt(0)))) {
            GValueNode node = (GValueNode) mappings.get(key);
            if(node != null) { // And it shouldn't.
            Metadata metadata = new Metadata(node);
            //record.addMetadata(id, metadata, MetaEditPromptBox.ACCUMULATE_ALL, false, 1);
            Gatherer.c_man.getCollection().msm.fireMetadataChanged(0, record, null, metadata);
            found = true;
            }
        }
        }
    }
    } 
    /** Create a separation preview String from the currently selected toggle buttons.
      * @param spaces <i>true</i> if the returned String should contain spaces for readability, <i>false</i> if we mean to process it and spaces would just make that more difficult.
      * @return A <strong>String</strong> representing the current separation state, such as "#, A-L, M-Z".
      */
    private String getPreview(boolean spaces) {
    String sep_sep = ",";
    if(spaces) {
        sep_sep = ", ";
    }
    StringBuffer preview = new StringBuffer(get(VALUES[0]));
    for(int i = 1; i < separators.length - 1; i++) {
        if(separators[i].isSelected()) {
        // Special case, where we specifically avoid #-#, A...
        if(i == 1) {
            preview.append(sep_sep);
            preview.append(get(VALUES[i]));
        }
        // Check previous value. We don't want ...A-L, M-M, N...
        else if(separators[i - 1].isSelected()) {
            preview.append(sep_sep);
            preview.append(get(VALUES[i]));
        }
        // Otherwise ..-VALUE[i-1], VALUE[i]...
        else {
            preview.append("-");
            preview.append(get(VALUES[i-1]));
            preview.append(sep_sep);
            preview.append(get(VALUES[i]));
        }
        }
    }
    // Special case of "...-Y,Z" 
    if(separators[separators.length - 1].isSelected()) {
        preview.append("-");
        preview.append(get(VALUES[VALUES.length - 2]));
        preview.append(sep_sep);
        preview.append(get(VALUES[VALUES.length - 1]));
    }
    // Otherwise "...-Z"
    else {
        preview.append("-");
        preview.append(get(VALUES[VALUES.length - 1]));
    }               
    return preview.toString();
    } 
    /** Load the custom argument dictionary if necessary, then retrieve the requested phrase.
      * @param key A key <strong>String</strong> which maps to the phrase to retrieve.
      * @return A phrase as a <strong>String</strong>.
      * @see org.greenstone.gatherer.Dictionary
      * @see org.greenstone.gatherer.Gatherer
      */
    private String get(String key) {
    if(dictionary == null) {
        dictionary = ResourceBundle.getBundle("org.greenstone.gatherer.cdm.custom." + NAME, Gatherer.config.getLocale("general.locale", false));
    }
    return dictionary.getString(key);
    }
    /** Listens to the buttonname checkbox, and enable buttonname appropriately when action detected. */
    private class ButtonNameListener
    implements ActionListener {
    /** When an action is performed on a registered control, this method is called which either enables or disables the buttonname field depending on the buttonname checkbox.
     * @param event An <strong>ActionEvent</strong> containing information about the action performed.
            */
    public void actionPerformed(ActionEvent event) {
        if(buttonname_label.isSelected()) {
        buttonname.setBackground(Color.white);
        buttonname.setEnabled(true);
        }
        else {
        buttonname.setBackground(Color.lightGray);
        buttonname.setEnabled(false);
        }                    
    }
    }
    /** Listens to the cancel button, and disposes appropriately when action detected. */
    private class CancelListener
    implements ActionListener {
    /** If the cancel button is pressed then we should dispose of the dialog without processing any records.
     * @param event An <strong>ActionEvent</strong> containing information about the action performed.
            */
    public void actionPerformed(ActionEvent event) {
        process = false;
        
        controls.setVisible(false);
    }
    }
    /** Listens to the ok button, and sets process to true then disposes appropriately when action detected. */
    private class OKListener
    implements ActionListener {
    /** If the ok button is pressed then we should dispose of the dialog after processing all records.
     * @param event An <strong>ActionEvent</strong> containing information about the action performed.
            */
    public void actionPerformed(ActionEvent event) {
        process = true;
        controls.setVisible(false);
    }
    }
    /** Listens for the toggling of a separator value, and updates the separator preview field. */
    private class SeparatorListener
    implements ActionListener {
    /** When one of the separator buttons is toggled we update the separator preview field.
     * @param event An <strong>ActionEvent</strong> containing information about the action performed.
            */
    public void actionPerformed(ActionEvent event) {
        separators_preview.setText(getPreview(true));
    }
    }
    /** Listens to the sort checkbox, and enables/disables sort appropriately when action detected. */
    private class SortListener
    implements ActionListener {
    /** If this checkbox is actioned, enabled or disable the sort control based on whether we are checked (selected) or not.
     * @param event An <strong>ActionEvent</strong> containing information about the action performed.
            */
    public void actionPerformed(ActionEvent event) {
        if(sort_label.isSelected()) {
        sort.setBackground(Color.white);
        sort.setEnabled(true);
        }
        else {
        sort.setBackground(Color.lightGray);
        sort.setEnabled(false);
        }                    
    }
    }
    /** Display a progress bar while creating the required hidden system hierarchy. 
     * @param element An <strong>ElementWrapper</strong> containing the metadata element we want to build a custom classifier on.
     * @param state A <strong>String</strong> representing the currently selected separators, of the form "#,A-L,MA-ML,MM-MZ,N-Z". 
     */
    private void process(ElementWrapper element, String state) {
    // Create a new progress bar dialog, using these divisions:
    // 33% - Creation and removal of old metadata tree.
    // 33% - Creation of new metadata tree, 33 / <number of separations>.
    // 33% - Allocation of metadata to records, 33 / <number of files>.
    // Hopefully the previous dialog should have already vanished (its dispose() caused by the process click).
    is_processing = true;
    pd = new ProgressDialog("Custom Classifier Creation", "Preparing for operation.");
    // Step 1: Create the new dummy element and add it if necessary.
    pd.setText("Creating dummy metadata element.");
    ///ystem.out.println("Creating dummy metadata element.");
    MetadataSet hidden_mds = gatherer.c_man.getCollection().msm.getSet(MetadataSetManager.HIDDEN);
    Element hidden_e = hidden_mds.getElement(element.toString().replace('.','_'));
    boolean found = true;
    ElementWrapper hidden_mde = null;
    if(hidden_mde != null) {
        hidden_mde = new ElementWrapper(hidden_e);
    }
    else {
        String language_code = Gatherer.config.interface_language;
        hidden_mde = hidden_mds.addElement(element.toString().replace('.','_'), language_code);
        found = false;
    }
    hidden_mde_name = hidden_mde.toString();
    pd.increase(1,2,20);
    // Step 2: Remove any existing value tree for this element. Wastefull I know but I don't want to lag for too long, and this is the quickest way.
    pd.setText("Removing any existing hierarchy.");
    ///ystem.out.println("Removing any existing hierarchy.");
    if(found) {
        hidden_mds.removeValueTree(hidden_mde);
    }
    pd.increase(1,2,20);
    // Step 3: Create a value tree for this element.
    pd.setText("Creating new hierary root.");
    ///ystem.out.println("Creating new hierary root.");
    GValueModel value_tree = gatherer.c_man.getCollection().msm.getValueTree(hidden_mde);
    pd.increase(5, 5, 5);
    // Step 4: Build the single level value hierarchy using state's value. Here a hashtable mapping string patterns to value nodes is built.
    pd.setText("Creating separations.");
    ///ystem.out.println("Creating separations.");
    StringTokenizer tokenizer = new StringTokenizer(state, ",");
    int separator_count = tokenizer.countTokens();
    mappings = new Hashtable();
    for(int i = 0; i < separator_count; i++) {
        String key = tokenizer.nextToken();
        GValueNode node = value_tree.addValue(key);
                // If the key is simple, ie "C", then add the mapping "C"->node
        if(key.indexOf("-") == -1) {
        mappings.put(key, node);
        }
                // If the key is more complex, say "D-L", then we add mappings for all string values so "D"->node, "E"->node, ... "L"->node. This is miles eaiser to do here, than when you are trying to match a records metadata ie matchin "D-L" to "Igloos are cool". Note that it is guarantee that the keys are all of the same length, ie "A-L", "MA-ML", "MMA-STF", "STFA-ZZZZ".
        else {
        String start = key.substring(0, key.indexOf("-"));
        String end = key.substring(key.indexOf("-") + 1);
        for(key = start; key != null && key.compareTo(end) <= 0; key = increment(key)) {
            mappings.put(key, node);    
        }
        }
        // Each iteration.
        pd.increase(1, separator_count, 25);
    }
    // Step 5: Recurse the entire tree, adding the appropriate values where necessary (overwriting any existing value for this element).
    pd.setText("Allocating metadata to records.");
    ///ystem.out.println("Allocating metadata to records.");
    int count = gatherer.c_man.getCollection().getCount();
    TreeModel record_tree = gatherer.c_man.getRecordSet();
    FileNode records[] = ArrayTools.add(null, (FileNode)record_tree.getRoot());
    while(records != null) {
        FileNode current_record = records[0];
        // There is no point in assigning hidden metadata to a file node we doesn't have any of that metadata set...
        ArrayList current_metadatum = Gatherer.c_man.getCollection().gdm.getMetadata(current_record.getFile());
        for(int z = 0; z < current_metadatum.size(); z++) {
        Metadata current_metadata = (Metadata) current_metadatum.get(z);
        if(current_metadata.getElement().equals(element) && current_metadata.isFileLevel()) {
            ///ystem.err.println("The file " + current_record + " has previous " + element + " metadata in: " + current_metadata);
            addMetadata(0L, current_record, element);
        }
        }
        if(!current_record.isLeaf()) {
        ///ystem.out.println("Add all children to records at once hopefully.");
        // Add all children to records at once hopefully.
        FileNode children[] = new FileNode[current_record.getChildCount()];
        for(int i = 0; i < children.length; i++) {
            children[i] = (FileNode) current_record.getChildAt(i);
        }
        records = ArrayTools.add(records, children);
        }
        records = ArrayTools.tail(records);
        pd.increase(1, count, 50);
    }
    is_processing = false;
    // Step 6: Done.
    pd.dispose();
    pd = null;
    }

    public boolean isProcessing() {
    return is_processing;
    }

    /** A dialog window used to show the progress of processing the file records in terms of adding hidden metadata. */
    private class ProgressDialog
    extends JDialog {
    /** The current value represented by the progress bar (where value is double and the progress bar shows an int). */
    private double value = 0.0;
    /** The default size of this dialog. */
    private Dimension dialog_size = new Dimension(500,100);
    /** The label explaining what action is currently happening (1 of 5 steps). */
    private JLabel label = new JLabel();
    /** The progress bar itself. */
    private JProgressBar bar = new JProgressBar();
    /** Constructor.
     * @param t The title for this dialog as a <strong>String</strong>.
     * @param l The initial label for the progress bar also a <strong>String</strong>.
     */
    public ProgressDialog(String t, String l) {
        super();
        setModal(false);
        setSize(dialog_size);
        setTitle(t);
        // Create
        JPanel content_pane = (JPanel) getContentPane();
        label.setText(l);
        bar.setMaximum(100);
        bar.setMinimum(0);
        bar.setValue(0);
        // Connect
        // Layout
        content_pane.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
        content_pane.setLayout(new BorderLayout());
        content_pane.add(label, BorderLayout.NORTH);
        content_pane.add(bar, BorderLayout.CENTER);
        // Display
        Dimension screen_size = Gatherer.config.screen_size;
        setLocation((screen_size.width - dialog_size.width) / 2, (screen_size.height - dialog_size.height) / 2);
        screen_size = null;
        show();
    }
    /** Increase the progress bar by a certain ammount.
     * @param item An <i>int</i> indicating what item number this is.
     * @param out_of An <i>int</i> detailing the number of items expected in total for this phase.
     * @param total The maximum value of the progress bar as an <i>int</i>.
     */
    public void increase(int item, int out_of, int total) {
        value = value + (((double) item / (double) out_of) * (double)total);
        int int_value = (int) value;
                ///ystem.err.println("Value is " + value + " which rounds to " + int_value);
        if(int_value != bar.getValue()) {
        bar.setValue(int_value);
        }
    }
    /** Set the message shown in the progress bar.
     * @param l The new progress bar label as a <strong>String</strong>.
     */
    public void setText(String l) {
        label.setText(l);
    }
    }
    /** The String equivelent of int++, this method increments the value of a String by one letter at a time.
      * @param str The <strong>String</strong> to be incremented.
      * @return A <strong>String</strong> whose 'checksum' value (adding the INT_VALUE[] of the letters together) is one greater than the initial String, while still containing only those values in STRING_VALUE[].
      */
    public String increment(String str) {
    ///ystem.err.print("Incrementing " + str + " -> ");
    char chars[] = str.toCharArray();
    boolean found = false;
    int pos = str.length() - 1;
    while(found == false && pos >= 0) {
        if((int)chars[pos] + 1 <= INT_VALUES[26]) {
        if((int)chars[pos] == INT_VALUES[0]) { // Anything else symbol
            chars[pos] = (char) INT_VALUES[1];
        }
        else {
            chars[pos] = (char)((int)chars[pos] + 1);
        }
        found = true;
        }  
        else {
        chars[pos] = (char)INT_VALUES[1];
        pos--;
        }
    }
    // If we haven't found it yet, return null.
    if(!found) {
        return null;
    }
    ///ystem.err.println(String.valueOf(chars));
    return String.valueOf(chars);
    }
}